2011-01-25 00:52:35 +01:00
|
|
|
<?php
|
|
|
|
|
2012-03-13 19:18:11 +01:00
|
|
|
final class DifferentialChangesetParser {
|
2011-01-25 00:52:35 +01:00
|
|
|
|
|
|
|
protected $visible = array();
|
|
|
|
protected $new = array();
|
|
|
|
protected $old = array();
|
|
|
|
protected $intra = array();
|
|
|
|
protected $newRender = null;
|
|
|
|
protected $oldRender = null;
|
|
|
|
|
|
|
|
protected $filename = null;
|
|
|
|
protected $missingOld = array();
|
|
|
|
protected $missingNew = array();
|
|
|
|
|
|
|
|
protected $comments = array();
|
|
|
|
protected $specialAttributes = array();
|
|
|
|
|
|
|
|
protected $changeset;
|
|
|
|
protected $whitespaceMode = null;
|
|
|
|
|
2011-05-05 16:08:10 +02:00
|
|
|
protected $renderCacheKey = null;
|
|
|
|
|
2012-12-08 03:08:27 +01:00
|
|
|
private $handles = array();
|
2011-02-02 19:10:25 +01:00
|
|
|
private $user;
|
2011-01-25 00:52:35 +01:00
|
|
|
|
2011-05-09 06:22:25 +02:00
|
|
|
private $leftSideChangesetID;
|
|
|
|
private $leftSideAttachesToNewFile;
|
|
|
|
|
|
|
|
private $rightSideChangesetID;
|
|
|
|
private $rightSideAttachesToNewFile;
|
|
|
|
|
2012-06-15 09:53:26 +02:00
|
|
|
private $originalLeft;
|
|
|
|
private $originalRight;
|
|
|
|
|
Move "Rendering References" to the DifferentialChangesetParser level
Summary:
Separates changeset IDs from rendering. Now each changeset has a "rendering
reference" which is basically a description of what the ajax endpoint should
render. For Differential, it's in the form "id/vs". For Diffusion,
"branch/path;commit".
I believe this fixes pretty much all of the bugs related to "show more" breaking
in various obscure ways, although I never got a great repro for T153.
Test Plan:
Clicked "show more" in diffusion change and commit views and differential diff,
diff-of-diff, standalone-diff, standalone-diff-of-diff views. Verified refs and
'whitespace' were always sent correctly.
Made inline comments on diffs and diffs-of-diffs. Used "Reply".
Reviewed By: tuomaspelkonen
Reviewers: tuomaspelkonen, jungejason, aran
CC: aran, tuomaspelkonen, epriestley
Differential Revision: 274
2011-05-12 06:46:29 +02:00
|
|
|
private $renderingReference;
|
2011-05-21 05:40:00 +02:00
|
|
|
private $isSubparser;
|
Move "Rendering References" to the DifferentialChangesetParser level
Summary:
Separates changeset IDs from rendering. Now each changeset has a "rendering
reference" which is basically a description of what the ajax endpoint should
render. For Differential, it's in the form "id/vs". For Diffusion,
"branch/path;commit".
I believe this fixes pretty much all of the bugs related to "show more" breaking
in various obscure ways, although I never got a great repro for T153.
Test Plan:
Clicked "show more" in diffusion change and commit views and differential diff,
diff-of-diff, standalone-diff, standalone-diff-of-diff views. Verified refs and
'whitespace' were always sent correctly.
Made inline comments on diffs and diffs-of-diffs. Used "Reply".
Reviewed By: tuomaspelkonen
Reviewers: tuomaspelkonen, jungejason, aran
CC: aran, tuomaspelkonen, epriestley
Differential Revision: 274
2011-05-12 06:46:29 +02:00
|
|
|
|
2011-06-20 22:49:17 +02:00
|
|
|
private $isTopLevel;
|
Show coverage information in Differential
Summary:
Render coverage information in the right gutter, if available.
We could render some kind of summary report deal too but this seems like a good
start.
Test Plan:
- Looked at diffs with coverage.
- Looked at diffs without coverage.
- Used inline comments, diff-of-diff, "show more", "show entire file", "show
generated file", "undo". Nothing seemed disrupted by the addition of a 5th
column.
Reviewers: btrahan, tuomaspelkonen, jungejason
Reviewed By: btrahan
CC: zeeg, aran, epriestley
Maniphest Tasks: T140
Differential Revision: https://secure.phabricator.com/D1527
2012-01-31 21:07:47 +01:00
|
|
|
private $coverage;
|
2012-03-20 03:17:59 +01:00
|
|
|
private $markupEngine;
|
2012-04-13 08:52:50 +02:00
|
|
|
private $highlightErrors;
|
2011-06-08 21:39:03 +02:00
|
|
|
|
2012-10-20 16:11:19 +02:00
|
|
|
const CACHE_VERSION = 8;
|
2012-08-27 22:08:58 +02:00
|
|
|
const CACHE_MAX_SIZE = 8e6;
|
2011-01-25 00:52:35 +01:00
|
|
|
|
|
|
|
const ATTR_GENERATED = 'attr:generated';
|
|
|
|
const ATTR_DELETED = 'attr:deleted';
|
|
|
|
const ATTR_UNCHANGED = 'attr:unchanged';
|
|
|
|
const ATTR_WHITELINES = 'attr:white';
|
|
|
|
|
|
|
|
const LINES_CONTEXT = 8;
|
|
|
|
|
|
|
|
const WHITESPACE_SHOW_ALL = 'show-all';
|
|
|
|
const WHITESPACE_IGNORE_TRAILING = 'ignore-trailing';
|
2012-03-13 01:06:36 +01:00
|
|
|
|
|
|
|
// TODO: This is now "Ignore Most" in the UI.
|
2011-01-25 00:52:35 +01:00
|
|
|
const WHITESPACE_IGNORE_ALL = 'ignore-all';
|
|
|
|
|
2012-03-13 01:06:36 +01:00
|
|
|
const WHITESPACE_IGNORE_FORCE = 'ignore-force';
|
|
|
|
|
2013-01-09 22:11:17 +01:00
|
|
|
public function setOldLines(array $lines) {
|
|
|
|
$this->old = $lines;
|
|
|
|
return $this;
|
|
|
|
}
|
|
|
|
|
|
|
|
public function setNewLines(array $lines) {
|
|
|
|
$this->new = $lines;
|
|
|
|
return $this;
|
|
|
|
}
|
|
|
|
|
|
|
|
public function setSpecialAttributes(array $attributes) {
|
|
|
|
$this->specialAttributes = $attributes;
|
|
|
|
return $this;
|
|
|
|
}
|
|
|
|
|
|
|
|
public function setMissingNewLineMarkerMap(array $map) {
|
|
|
|
$this->missingNew = $map;
|
|
|
|
return $this;
|
|
|
|
}
|
|
|
|
|
|
|
|
public function setMissingOldLineMarkerMap(array $map) {
|
|
|
|
$this->missingOld = $map;
|
|
|
|
return $this;
|
|
|
|
}
|
|
|
|
|
|
|
|
public function setIntraLineDiffs(array $diffs) {
|
|
|
|
$this->intra = $diffs;
|
|
|
|
return $this;
|
|
|
|
}
|
|
|
|
|
|
|
|
public function setVisibileLinesMask(array $mask) {
|
|
|
|
$this->visible = $mask;
|
|
|
|
return $this;
|
|
|
|
}
|
|
|
|
|
2011-05-09 06:22:25 +02:00
|
|
|
/**
|
|
|
|
* Configure which Changeset comments added to the right side of the visible
|
|
|
|
* diff will be attached to. The ID must be the ID of a real Differential
|
|
|
|
* Changeset.
|
|
|
|
*
|
|
|
|
* The complexity here is that we may show an arbitrary side of an arbitrary
|
|
|
|
* changeset as either the left or right part of a diff. This method allows
|
|
|
|
* the left and right halves of the displayed diff to be correctly mapped to
|
|
|
|
* storage changesets.
|
|
|
|
*
|
|
|
|
* @param id The Differential Changeset ID that comments added to the right
|
|
|
|
* side of the visible diff should be attached to.
|
|
|
|
* @param bool If true, attach new comments to the right side of the storage
|
|
|
|
* changeset. Note that this may be false, if the left side of
|
|
|
|
* some storage changeset is being shown as the right side of
|
|
|
|
* a display diff.
|
|
|
|
* @return this
|
|
|
|
*/
|
2011-02-04 00:41:58 +01:00
|
|
|
public function setRightSideCommentMapping($id, $is_new) {
|
2011-05-09 06:22:25 +02:00
|
|
|
$this->rightSideChangesetID = $id;
|
|
|
|
$this->rightSideAttachesToNewFile = $is_new;
|
|
|
|
return $this;
|
2011-02-04 00:41:58 +01:00
|
|
|
}
|
|
|
|
|
2011-05-09 06:22:25 +02:00
|
|
|
/**
|
|
|
|
* See setRightSideCommentMapping(), but this sets information for the left
|
|
|
|
* side of the display diff.
|
|
|
|
*/
|
2011-02-04 00:41:58 +01:00
|
|
|
public function setLeftSideCommentMapping($id, $is_new) {
|
2011-05-09 06:22:25 +02:00
|
|
|
$this->leftSideChangesetID = $id;
|
|
|
|
$this->leftSideAttachesToNewFile = $is_new;
|
|
|
|
return $this;
|
2011-02-04 00:41:58 +01:00
|
|
|
}
|
2011-01-25 00:52:35 +01:00
|
|
|
|
2012-06-15 09:53:26 +02:00
|
|
|
public function setOriginals(
|
|
|
|
DifferentialChangeset $left,
|
|
|
|
DifferentialChangeset $right) {
|
|
|
|
|
|
|
|
$this->originalLeft = $left;
|
|
|
|
$this->originalRight = $right;
|
|
|
|
}
|
|
|
|
|
|
|
|
public function diffOriginals() {
|
|
|
|
$engine = new PhabricatorDifferenceEngine();
|
|
|
|
$changeset = $engine->generateChangesetFromFileContent(
|
|
|
|
implode('', mpull($this->originalLeft->getHunks(), 'getChanges')),
|
|
|
|
implode('', mpull($this->originalRight->getHunks(), 'getChanges')));
|
|
|
|
|
2013-01-09 22:11:17 +01:00
|
|
|
$parser = new DifferentialHunkParser();
|
2012-06-15 09:53:26 +02:00
|
|
|
|
2013-01-09 22:11:17 +01:00
|
|
|
return $parser->parseHunksForHighlightMasks(
|
|
|
|
$changeset->getHunks(),
|
|
|
|
$this->originalLeft->getHunks(),
|
|
|
|
$this->originalRight->getHunks()
|
|
|
|
);
|
2012-06-15 09:53:26 +02:00
|
|
|
}
|
|
|
|
|
2011-05-05 16:08:10 +02:00
|
|
|
/**
|
|
|
|
* Set a key for identifying this changeset in the render cache. If set, the
|
|
|
|
* parser will attempt to use the changeset render cache, which can improve
|
|
|
|
* performance for frequently-viewed changesets.
|
|
|
|
*
|
|
|
|
* By default, there is no render cache key and parsers do not use the cache.
|
|
|
|
* This is appropriate for rarely-viewed changesets.
|
|
|
|
*
|
|
|
|
* NOTE: Currently, this key must be a valid Differential Changeset ID.
|
|
|
|
*
|
|
|
|
* @param string Key for identifying this changeset in the render cache.
|
|
|
|
* @return this
|
|
|
|
*/
|
|
|
|
public function setRenderCacheKey($key) {
|
|
|
|
$this->renderCacheKey = $key;
|
|
|
|
return $this;
|
|
|
|
}
|
|
|
|
|
|
|
|
private function getRenderCacheKey() {
|
|
|
|
return $this->renderCacheKey;
|
|
|
|
}
|
|
|
|
|
2012-12-08 01:19:57 +01:00
|
|
|
public function setChangeset(DifferentialChangeset $changeset) {
|
2011-01-25 00:52:35 +01:00
|
|
|
$this->changeset = $changeset;
|
2011-06-08 21:39:03 +02:00
|
|
|
|
2011-01-25 00:52:35 +01:00
|
|
|
$this->setFilename($changeset->getFilename());
|
|
|
|
|
|
|
|
return $this;
|
|
|
|
}
|
|
|
|
|
|
|
|
public function setWhitespaceMode($whitespace_mode) {
|
|
|
|
$this->whitespaceMode = $whitespace_mode;
|
|
|
|
return $this;
|
|
|
|
}
|
|
|
|
|
Move "Rendering References" to the DifferentialChangesetParser level
Summary:
Separates changeset IDs from rendering. Now each changeset has a "rendering
reference" which is basically a description of what the ajax endpoint should
render. For Differential, it's in the form "id/vs". For Diffusion,
"branch/path;commit".
I believe this fixes pretty much all of the bugs related to "show more" breaking
in various obscure ways, although I never got a great repro for T153.
Test Plan:
Clicked "show more" in diffusion change and commit views and differential diff,
diff-of-diff, standalone-diff, standalone-diff-of-diff views. Verified refs and
'whitespace' were always sent correctly.
Made inline comments on diffs and diffs-of-diffs. Used "Reply".
Reviewed By: tuomaspelkonen
Reviewers: tuomaspelkonen, jungejason, aran
CC: aran, tuomaspelkonen, epriestley
Differential Revision: 274
2011-05-12 06:46:29 +02:00
|
|
|
public function setRenderingReference($ref) {
|
|
|
|
$this->renderingReference = $ref;
|
2011-01-25 00:52:35 +01:00
|
|
|
return $this;
|
|
|
|
}
|
|
|
|
|
2012-12-08 01:19:57 +01:00
|
|
|
private function getRenderingReference() {
|
|
|
|
return $this->renderingReference;
|
|
|
|
}
|
|
|
|
|
2011-03-31 04:22:11 +02:00
|
|
|
public function getChangeset() {
|
|
|
|
return $this->changeset;
|
|
|
|
}
|
|
|
|
|
2011-01-25 00:52:35 +01:00
|
|
|
public function setFilename($filename) {
|
|
|
|
$this->filename = $filename;
|
2011-07-06 20:10:40 +02:00
|
|
|
return $this;
|
2011-01-25 00:52:35 +01:00
|
|
|
}
|
2011-02-02 22:48:52 +01:00
|
|
|
|
2011-02-02 01:42:36 +01:00
|
|
|
public function setHandles(array $handles) {
|
2012-04-04 22:13:08 +02:00
|
|
|
assert_instances_of($handles, 'PhabricatorObjectHandle');
|
2011-02-02 01:42:36 +01:00
|
|
|
$this->handles = $handles;
|
|
|
|
return $this;
|
|
|
|
}
|
2011-02-02 22:48:52 +01:00
|
|
|
|
2012-10-24 02:33:58 +02:00
|
|
|
public function setMarkupEngine(PhabricatorMarkupEngine $engine) {
|
2011-02-02 01:42:36 +01:00
|
|
|
$this->markupEngine = $engine;
|
|
|
|
return $this;
|
|
|
|
}
|
2011-01-25 00:52:35 +01:00
|
|
|
|
2011-02-02 19:10:25 +01:00
|
|
|
public function setUser(PhabricatorUser $user) {
|
|
|
|
$this->user = $user;
|
|
|
|
return $this;
|
|
|
|
}
|
|
|
|
|
Show coverage information in Differential
Summary:
Render coverage information in the right gutter, if available.
We could render some kind of summary report deal too but this seems like a good
start.
Test Plan:
- Looked at diffs with coverage.
- Looked at diffs without coverage.
- Used inline comments, diff-of-diff, "show more", "show entire file", "show
generated file", "undo". Nothing seemed disrupted by the addition of a 5th
column.
Reviewers: btrahan, tuomaspelkonen, jungejason
Reviewed By: btrahan
CC: zeeg, aran, epriestley
Maniphest Tasks: T140
Differential Revision: https://secure.phabricator.com/D1527
2012-01-31 21:07:47 +01:00
|
|
|
public function setCoverage($coverage) {
|
|
|
|
$this->coverage = $coverage;
|
|
|
|
return $this;
|
|
|
|
}
|
2012-12-12 02:16:11 +01:00
|
|
|
private function getCoverage() {
|
|
|
|
return $this->coverage;
|
|
|
|
}
|
Show coverage information in Differential
Summary:
Render coverage information in the right gutter, if available.
We could render some kind of summary report deal too but this seems like a good
start.
Test Plan:
- Looked at diffs with coverage.
- Looked at diffs without coverage.
- Used inline comments, diff-of-diff, "show more", "show entire file", "show
generated file", "undo". Nothing seemed disrupted by the addition of a 5th
column.
Reviewers: btrahan, tuomaspelkonen, jungejason
Reviewed By: btrahan
CC: zeeg, aran, epriestley
Maniphest Tasks: T140
Differential Revision: https://secure.phabricator.com/D1527
2012-01-31 21:07:47 +01:00
|
|
|
|
Add inline comments to Diffusion/Audit
Summary:
- Add inline comments to Audits, like Differential.
- Creates new storage for the comments in the Audits database.
- Creates a new PhabricatorAuditInlineComment class, similar to DifferentialInlineComment.
- Defines an Interface which Differential and Audit comments conform to.
- Makes consumers of DifferentialInlineComments consume objects which implement that interface instead.
- Adds save
NOTE: Some features are still missing! Wanted to cut this off before it got crazy:
- Inline comments aren't shown in the main comment list.
- Inline comments aren't shown in the emails.
- Inline comments aren't previewed.
I'll followup with those but this was getting pretty big.
@vrana, does the SQL change look correct?
Test Plan:
- Created, edited, deleted, replied to, reloaded and saved inline comments in Diffusion, on the left and right side of diffs.
- Created, edited, deleted, replied to, reloaded and saved inline comments in Differentila, on the left and right side of primary and diff-versus-diff diffs.
Reviewers: btrahan, vrana
Reviewed By: btrahan
CC: aran, epriestley
Maniphest Tasks: T904
Differential Revision: https://secure.phabricator.com/D1898
2012-03-14 20:56:01 +01:00
|
|
|
public function parseInlineComment(
|
|
|
|
PhabricatorInlineCommentInterface $comment) {
|
|
|
|
|
2011-05-09 06:22:25 +02:00
|
|
|
// Parse only comments which are actually visible.
|
|
|
|
if ($this->isCommentVisibleOnRenderedDiff($comment)) {
|
|
|
|
$this->comments[] = $comment;
|
|
|
|
}
|
2011-01-25 00:52:35 +01:00
|
|
|
return $this;
|
|
|
|
}
|
|
|
|
|
2013-01-09 22:11:17 +01:00
|
|
|
private function loadCache() {
|
2011-05-05 16:08:10 +02:00
|
|
|
$render_cache_key = $this->getRenderCacheKey();
|
|
|
|
if (!$render_cache_key) {
|
2011-01-25 00:52:35 +01:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
$data = null;
|
2011-01-26 01:10:36 +01:00
|
|
|
|
|
|
|
$changeset = new DifferentialChangeset();
|
|
|
|
$conn_r = $changeset->establishConnection('r');
|
2011-01-25 00:52:35 +01:00
|
|
|
$data = queryfx_one(
|
2011-01-26 01:10:36 +01:00
|
|
|
$conn_r,
|
|
|
|
'SELECT * FROM %T WHERE id = %d',
|
|
|
|
$changeset->getTableName().'_parse_cache',
|
2011-05-05 16:08:10 +02:00
|
|
|
$render_cache_key);
|
2011-01-25 00:52:35 +01:00
|
|
|
|
|
|
|
if (!$data) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
$data = json_decode($data['cache'], true);
|
|
|
|
if (!is_array($data) || !$data) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
foreach (self::getCacheableProperties() as $cache_key) {
|
|
|
|
if (!array_key_exists($cache_key, $data)) {
|
|
|
|
// If we're missing a cache key, assume we're looking at an old cache
|
|
|
|
// and ignore it.
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if ($data['cacheVersion'] !== self::CACHE_VERSION) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2012-05-01 07:31:26 +02:00
|
|
|
// Someone displays contents of a partially cached shielded file.
|
|
|
|
if (!isset($data['newRender']) && (!$this->isTopLevel || $this->comments)) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2011-01-25 00:52:35 +01:00
|
|
|
unset($data['cacheVersion'], $data['cacheHost']);
|
|
|
|
$cache_prop = array_select_keys($data, self::getCacheableProperties());
|
|
|
|
foreach ($cache_prop as $cache_key => $v) {
|
|
|
|
$this->$cache_key = $v;
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
protected static function getCacheableProperties() {
|
|
|
|
return array(
|
|
|
|
'visible',
|
|
|
|
'new',
|
|
|
|
'old',
|
|
|
|
'intra',
|
|
|
|
'newRender',
|
|
|
|
'oldRender',
|
|
|
|
'specialAttributes',
|
|
|
|
'missingOld',
|
|
|
|
'missingNew',
|
|
|
|
'cacheVersion',
|
|
|
|
'cacheHost',
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
|
|
|
public function saveCache() {
|
2012-04-13 08:52:50 +02:00
|
|
|
if ($this->highlightErrors) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2011-05-05 16:08:10 +02:00
|
|
|
$render_cache_key = $this->getRenderCacheKey();
|
|
|
|
if (!$render_cache_key) {
|
2011-01-25 00:52:35 +01:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
$cache = array();
|
|
|
|
foreach (self::getCacheableProperties() as $cache_key) {
|
|
|
|
switch ($cache_key) {
|
|
|
|
case 'cacheVersion':
|
|
|
|
$cache[$cache_key] = self::CACHE_VERSION;
|
|
|
|
break;
|
|
|
|
case 'cacheHost':
|
|
|
|
$cache[$cache_key] = php_uname('n');
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
$cache[$cache_key] = $this->$cache_key;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
$cache = json_encode($cache);
|
|
|
|
|
2012-08-27 22:08:58 +02:00
|
|
|
// We don't want to waste too much space by a single changeset.
|
|
|
|
if (strlen($cache) > self::CACHE_MAX_SIZE) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2011-01-25 00:52:35 +01:00
|
|
|
try {
|
2011-01-26 01:10:36 +01:00
|
|
|
$changeset = new DifferentialChangeset();
|
|
|
|
$conn_w = $changeset->establishConnection('w');
|
2011-08-16 23:44:13 +02:00
|
|
|
|
|
|
|
$unguarded = AphrontWriteGuard::beginScopedUnguardedWrites();
|
2011-01-25 00:52:35 +01:00
|
|
|
queryfx(
|
2011-01-26 01:10:36 +01:00
|
|
|
$conn_w,
|
2011-07-09 00:26:33 +02:00
|
|
|
'INSERT INTO %T (id, cache, dateCreated) VALUES (%d, %s, %d)
|
2011-01-25 00:52:35 +01:00
|
|
|
ON DUPLICATE KEY UPDATE cache = VALUES(cache)',
|
2011-07-09 00:26:33 +02:00
|
|
|
DifferentialChangeset::TABLE_CACHE,
|
2011-05-05 16:08:10 +02:00
|
|
|
$render_cache_key,
|
2011-07-09 00:26:33 +02:00
|
|
|
$cache,
|
|
|
|
time());
|
2011-02-27 05:57:21 +01:00
|
|
|
} catch (AphrontQueryException $ex) {
|
2011-01-25 00:52:35 +01:00
|
|
|
// TODO: uhoh
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-10-01 23:17:13 +02:00
|
|
|
private function markGenerated($new_corpus_block = '') {
|
|
|
|
$generated_guess = (strpos($new_corpus_block, '@'.'generated') !== false);
|
|
|
|
|
|
|
|
if (!$generated_guess) {
|
|
|
|
$config_key = 'differential.generated-paths';
|
|
|
|
$generated_path_regexps = PhabricatorEnv::getEnvConfig($config_key);
|
|
|
|
foreach ($generated_path_regexps as $regexp) {
|
|
|
|
if (preg_match($regexp, $this->changeset->getFilename())) {
|
|
|
|
$generated_guess = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
$event = new PhabricatorEvent(
|
|
|
|
PhabricatorEventType::TYPE_DIFFERENTIAL_WILLMARKGENERATED,
|
|
|
|
array(
|
|
|
|
'corpus' => $new_corpus_block,
|
|
|
|
'is_generated' => $generated_guess,
|
|
|
|
)
|
|
|
|
);
|
|
|
|
PhutilEventEngine::dispatchEvent($event);
|
|
|
|
|
|
|
|
$generated = $event->getValue('is_generated');
|
|
|
|
$this->specialAttributes[self::ATTR_GENERATED] = $generated;
|
|
|
|
}
|
|
|
|
|
2011-01-25 00:52:35 +01:00
|
|
|
public function isGenerated() {
|
|
|
|
return idx($this->specialAttributes, self::ATTR_GENERATED, false);
|
|
|
|
}
|
|
|
|
|
|
|
|
public function isDeleted() {
|
|
|
|
return idx($this->specialAttributes, self::ATTR_DELETED, false);
|
|
|
|
}
|
|
|
|
|
|
|
|
public function isUnchanged() {
|
|
|
|
return idx($this->specialAttributes, self::ATTR_UNCHANGED, false);
|
|
|
|
}
|
|
|
|
|
|
|
|
public function isWhitespaceOnly() {
|
|
|
|
return idx($this->specialAttributes, self::ATTR_WHITELINES, false);
|
|
|
|
}
|
|
|
|
|
2013-01-09 22:11:17 +01:00
|
|
|
private function applyIntraline(&$render, $intra, $corpus) {
|
2012-01-17 18:42:30 +01:00
|
|
|
|
2011-01-25 00:52:35 +01:00
|
|
|
foreach ($render as $key => $text) {
|
|
|
|
if (isset($intra[$key])) {
|
|
|
|
$render[$key] = ArcanistDiffUtils::applyIntralineDiff(
|
|
|
|
$text,
|
|
|
|
$intra[$key]);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-01-09 22:11:17 +01:00
|
|
|
private function getHighlightFuture($corpus) {
|
2012-10-20 16:11:19 +02:00
|
|
|
if (preg_match('/\r(?!\n)/', $corpus)) {
|
|
|
|
// TODO: Pygments converts "\r" newlines into "\n" newlines, so we can't
|
|
|
|
// use it on files with "\r" newlines. If we have "\r" not followed by
|
|
|
|
// "\n" in the file, skip highlighting.
|
|
|
|
$result = phutil_escape_html($corpus);
|
|
|
|
return new ImmediateFuture($result);
|
|
|
|
}
|
|
|
|
|
2011-05-21 06:15:00 +02:00
|
|
|
return $this->highlightEngine->getHighlightFuture(
|
2011-07-06 20:10:40 +02:00
|
|
|
$this->highlightEngine->getLanguageFromFilename($this->filename),
|
2011-01-25 02:39:14 +01:00
|
|
|
$corpus);
|
2011-05-21 06:15:00 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
protected function processHighlightedSource($data, $result) {
|
2011-01-26 01:10:36 +01:00
|
|
|
|
2012-10-20 16:11:19 +02:00
|
|
|
$result_lines = phutil_split_lines($result);
|
2011-01-25 00:52:35 +01:00
|
|
|
foreach ($data as $key => $info) {
|
|
|
|
if (!$info) {
|
|
|
|
unset($result_lines[$key]);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return $result_lines;
|
|
|
|
}
|
|
|
|
|
|
|
|
private function tryCacheStuff() {
|
|
|
|
$whitespace_mode = $this->whitespaceMode;
|
|
|
|
switch ($whitespace_mode) {
|
|
|
|
case self::WHITESPACE_SHOW_ALL:
|
|
|
|
case self::WHITESPACE_IGNORE_TRAILING:
|
2012-03-13 01:06:36 +01:00
|
|
|
case self::WHITESPACE_IGNORE_FORCE:
|
2011-01-25 00:52:35 +01:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
$whitespace_mode = self::WHITESPACE_IGNORE_ALL;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
$skip_cache = ($whitespace_mode != self::WHITESPACE_IGNORE_ALL);
|
|
|
|
$this->whitespaceMode = $whitespace_mode;
|
|
|
|
|
|
|
|
$changeset = $this->changeset;
|
|
|
|
|
2012-10-01 23:17:13 +02:00
|
|
|
if ($changeset->getFileType() != DifferentialChangeType::FILE_TEXT &&
|
|
|
|
$changeset->getFileType() != DifferentialChangeType::FILE_SYMLINK) {
|
2013-01-09 22:11:17 +01:00
|
|
|
|
2012-10-01 23:17:13 +02:00
|
|
|
$this->markGenerated();
|
|
|
|
|
|
|
|
} else {
|
2011-01-25 00:52:35 +01:00
|
|
|
if ($skip_cache || !$this->loadCache()) {
|
2013-01-09 22:11:17 +01:00
|
|
|
$this->process();
|
|
|
|
if (!$skip_cache) {
|
|
|
|
$this->saveCache();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
Don't use the "ignore all whitespace" algorithm on multi-hunk diffs
Summary:
Diffs with missing context don't render properly in the "ignore all whitespace"
algorith, so don't try to use it. These diffs can occur if someone creates a
diff via the web interface, for example, or if they muck around in their copy of
'arc'.
See D473, T246 (a problem with D473), rPe5bb756b5191720 (revert of D473) and
T231.
Test Plan:
Viewed a diff with missing context from the web interface. Verified normal diffs
still rendered with all whitespace ignored.
Reviewed By: fratrik
Reviewers: jungejason, aran, tuomaspelkonen, fratrik
Commenters: jungejason
CC: aran, epriestley, fratrik, jungejason
Differential Revision: 500
2011-06-23 01:12:09 +02:00
|
|
|
|
2013-01-09 22:11:17 +01:00
|
|
|
private function process() {
|
|
|
|
$whitespace_mode = $this->whitespaceMode;
|
|
|
|
$changeset = $this->changeset;
|
2012-03-13 01:06:36 +01:00
|
|
|
|
2013-01-09 22:11:17 +01:00
|
|
|
$ignore_all = (($whitespace_mode == self::WHITESPACE_IGNORE_ALL) ||
|
|
|
|
($whitespace_mode == self::WHITESPACE_IGNORE_FORCE));
|
2011-06-29 01:21:06 +02:00
|
|
|
|
2013-01-09 22:11:17 +01:00
|
|
|
$force_ignore = ($whitespace_mode == self::WHITESPACE_IGNORE_FORCE);
|
2011-07-22 22:15:11 +02:00
|
|
|
|
2013-01-09 22:11:17 +01:00
|
|
|
if (!$force_ignore) {
|
|
|
|
if ($ignore_all && $changeset->getWhitespaceMatters()) {
|
|
|
|
$ignore_all = false;
|
|
|
|
}
|
|
|
|
}
|
2011-06-29 01:21:06 +02:00
|
|
|
|
2013-01-09 22:11:17 +01:00
|
|
|
// The "ignore all whitespace" algorithm depends on rediffing the
|
|
|
|
// files, and we currently need complete representations of both
|
|
|
|
// files to do anything reasonable. If we only have parts of the files,
|
|
|
|
// don't use the "ignore all" algorithm.
|
|
|
|
if ($ignore_all) {
|
|
|
|
$hunks = $changeset->getHunks();
|
|
|
|
if (count($hunks) !== 1) {
|
|
|
|
$ignore_all = false;
|
|
|
|
} else {
|
|
|
|
$first_hunk = reset($hunks);
|
|
|
|
if ($first_hunk->getOldOffset() != 1 ||
|
|
|
|
$first_hunk->getNewOffset() != 1) {
|
2011-06-29 01:21:06 +02:00
|
|
|
$ignore_all = false;
|
Don't use the "ignore all whitespace" algorithm on multi-hunk diffs
Summary:
Diffs with missing context don't render properly in the "ignore all whitespace"
algorith, so don't try to use it. These diffs can occur if someone creates a
diff via the web interface, for example, or if they muck around in their copy of
'arc'.
See D473, T246 (a problem with D473), rPe5bb756b5191720 (revert of D473) and
T231.
Test Plan:
Viewed a diff with missing context from the web interface. Verified normal diffs
still rendered with all whitespace ignored.
Reviewed By: fratrik
Reviewers: jungejason, aran, tuomaspelkonen, fratrik
Commenters: jungejason
CC: aran, epriestley, fratrik, jungejason
Differential Revision: 500
2011-06-23 01:12:09 +02:00
|
|
|
}
|
2013-01-09 22:11:17 +01:00
|
|
|
}
|
|
|
|
}
|
Don't use the "ignore all whitespace" algorithm on multi-hunk diffs
Summary:
Diffs with missing context don't render properly in the "ignore all whitespace"
algorith, so don't try to use it. These diffs can occur if someone creates a
diff via the web interface, for example, or if they muck around in their copy of
'arc'.
See D473, T246 (a problem with D473), rPe5bb756b5191720 (revert of D473) and
T231.
Test Plan:
Viewed a diff with missing context from the web interface. Verified normal diffs
still rendered with all whitespace ignored.
Reviewed By: fratrik
Reviewers: jungejason, aran, tuomaspelkonen, fratrik
Commenters: jungejason
CC: aran, epriestley, fratrik, jungejason
Differential Revision: 500
2011-06-23 01:12:09 +02:00
|
|
|
|
2013-01-09 22:11:17 +01:00
|
|
|
if ($ignore_all) {
|
|
|
|
$old_file = $changeset->makeOldFile();
|
|
|
|
$new_file = $changeset->makeNewFile();
|
|
|
|
if ($old_file == $new_file) {
|
|
|
|
// If the old and new files are exactly identical, the synthetic
|
|
|
|
// diff below will give us nonsense and whitespace modes are
|
|
|
|
// irrelevant anyway. This occurs when you, e.g., copy a file onto
|
|
|
|
// itself in Subversion (see T271).
|
|
|
|
$ignore_all = false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
$old_text = array();
|
|
|
|
$new_text = array();
|
|
|
|
$is_unchanged = null;
|
|
|
|
$whitelines = null;
|
|
|
|
if ($ignore_all) {
|
|
|
|
|
|
|
|
// Huge mess. Generate a "-bw" (ignore all whitespace changes) diff,
|
|
|
|
// parse it out, and then play a shell game with the parsed format
|
|
|
|
// later so we highlight only changed lines but render
|
|
|
|
// whitespace differences. If we don't do this, we either fail to
|
|
|
|
// render whitespace changes (which is incredibly confusing,
|
|
|
|
// especially for python) or often produce a much larger set of
|
|
|
|
// differences than necessary.
|
|
|
|
|
|
|
|
$engine = new PhabricatorDifferenceEngine();
|
|
|
|
$engine->setIgnoreWhitespace(true);
|
|
|
|
$no_whitespace_changeset = $engine->generateChangesetFromFileContent(
|
|
|
|
$old_file,
|
|
|
|
$new_file);
|
|
|
|
|
|
|
|
$hunk_parser = new DifferentialHunkParser();
|
|
|
|
$hunk_parser->parseHunksForLineData($changeset->getHunks());
|
|
|
|
$hunk_parser->reparseHunksForSpecialAttributes();
|
|
|
|
$is_unchanged = $hunk_parser->getIsUnchanged();
|
|
|
|
$whitelines = $hunk_parser->getHasWhiteLines();
|
|
|
|
|
|
|
|
// While we aren't updating $this->changeset (since it has a bunch
|
|
|
|
// of metadata we need to preserve, so that headers like "this file
|
|
|
|
// was moved" render correctly), we're overwriting the local
|
|
|
|
// $changeset so that the block below will choose the synthetic
|
|
|
|
// hunks we've built instead of the original hunks.
|
|
|
|
$changeset = $no_whitespace_changeset;
|
|
|
|
|
|
|
|
// let the games continue - pull out the proper text so we can
|
|
|
|
// later accurately display the diff
|
|
|
|
$old_text = ipull($hunk_parser->getOldLines(), 'text', 'line');
|
|
|
|
$new_text = ipull($hunk_parser->getNewLines(), 'text', 'line');
|
|
|
|
}
|
|
|
|
|
|
|
|
// This either uses the real hunks, or synthetic hunks we built above.
|
|
|
|
// $is_unchanged, $whitelines, $old_text and $new_text are populated
|
|
|
|
// for synthetic hunks, otherwise they are default values.
|
|
|
|
$hunk_parser = new DifferentialHunkParser();
|
|
|
|
$hunk_parser->parseHunksForLineData($changeset->getHunks());
|
|
|
|
$hunk_parser->reparseHunksForSpecialAttributes();
|
|
|
|
|
|
|
|
$unchanged = false;
|
|
|
|
// i.e. if we didn't have to play horrendous games above
|
|
|
|
if ($is_unchanged === null) {
|
|
|
|
if ($hunk_parser->getIsUnchanged()) {
|
|
|
|
$filetype = $this->changeset->getFileType();
|
|
|
|
if ($filetype == DifferentialChangeType::FILE_TEXT ||
|
|
|
|
$filetype == DifferentialChangeType::FILE_SYMLINK) {
|
|
|
|
$unchanged = true;
|
2011-01-25 00:52:35 +01:00
|
|
|
}
|
2013-01-09 22:11:17 +01:00
|
|
|
}
|
|
|
|
$whitelines = $hunk_parser->getHasWhiteLines();
|
|
|
|
} else {
|
|
|
|
$unchanged = $is_unchanged;
|
|
|
|
}
|
|
|
|
$changetype = $this->changeset->getChangeType();
|
|
|
|
if ($changetype == DifferentialChangeType::TYPE_MOVE_AWAY) {
|
|
|
|
// sometimes we show moved files as unchanged, sometimes deleted,
|
|
|
|
// and sometimes inconsistent with what actually happened at the
|
|
|
|
// destination of the move. Rather than make a false claim,
|
|
|
|
// omit the 'not changed' notice if this is the source of a move
|
|
|
|
$unchanged = false;
|
|
|
|
}
|
|
|
|
$this->setSpecialAttributes(array(
|
|
|
|
self::ATTR_UNCHANGED => $unchanged,
|
|
|
|
self::ATTR_DELETED => $hunk_parser->getIsDeleted(),
|
|
|
|
self::ATTR_WHITELINES => $whitelines
|
|
|
|
));
|
|
|
|
|
|
|
|
$hunk_parser->updateParsedHunksText($old_text, $new_text);
|
|
|
|
$hunk_parser->generateIntraLineDiffs();
|
|
|
|
$hunk_parser->generateVisibileLinesMask();
|
|
|
|
|
|
|
|
$this->setOldLines($hunk_parser->getOldLines());
|
|
|
|
$this->setNewLines($hunk_parser->getNewLines());
|
|
|
|
$this->setIntraLineDiffs($hunk_parser->getIntraLineDiffs());
|
|
|
|
$this->setVisibileLinesMask($hunk_parser->getVisibleLinesMask());
|
|
|
|
|
|
|
|
$new_corpus = $hunk_parser->getNewCorpus();
|
|
|
|
$new_corpus_block = implode('', $new_corpus);
|
|
|
|
$this->markGenerated($new_corpus_block);
|
|
|
|
|
|
|
|
if ($this->isTopLevel &&
|
|
|
|
!$this->comments &&
|
|
|
|
($this->isGenerated() ||
|
|
|
|
$this->isUnchanged() ||
|
|
|
|
$this->isDeleted())) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
$old_corpus = $hunk_parser->getOldCorpus();
|
|
|
|
$old_corpus_block = implode('', $old_corpus);
|
|
|
|
$old_future = $this->getHighlightFuture($old_corpus_block);
|
|
|
|
$new_future = $this->getHighlightFuture($new_corpus_block);
|
|
|
|
$futures = array(
|
|
|
|
'old' => $old_future,
|
|
|
|
'new' => $new_future,
|
|
|
|
);
|
|
|
|
$corpus_blocks = array(
|
|
|
|
'old' => $old_corpus_block,
|
|
|
|
'new' => $new_corpus_block,
|
|
|
|
);
|
2011-05-21 05:40:00 +02:00
|
|
|
|
2013-01-09 22:11:17 +01:00
|
|
|
$this->highlightErrors = false;
|
|
|
|
foreach (Futures($futures) as $key => $future) {
|
|
|
|
try {
|
|
|
|
try {
|
|
|
|
$highlighted = $future->resolve();
|
|
|
|
} catch (PhutilSyntaxHighlighterException $ex) {
|
|
|
|
$this->highlightErrors = true;
|
|
|
|
$highlighted = id(new PhutilDefaultSyntaxHighlighter())
|
|
|
|
->getHighlightFuture($corpus_blocks[$key])
|
|
|
|
->resolve();
|
2011-01-25 00:52:35 +01:00
|
|
|
}
|
2013-01-09 22:11:17 +01:00
|
|
|
switch ($key) {
|
|
|
|
case 'old':
|
|
|
|
$this->oldRender = $this->processHighlightedSource(
|
|
|
|
$this->old,
|
|
|
|
$highlighted);
|
|
|
|
break;
|
|
|
|
case 'new':
|
|
|
|
$this->newRender = $this->processHighlightedSource(
|
|
|
|
$this->new,
|
|
|
|
$highlighted);
|
|
|
|
break;
|
2011-01-25 00:52:35 +01:00
|
|
|
}
|
2013-01-09 22:11:17 +01:00
|
|
|
} catch (Exception $ex) {
|
|
|
|
phlog($ex);
|
|
|
|
throw $ex;
|
2011-01-25 00:52:35 +01:00
|
|
|
}
|
|
|
|
}
|
2013-01-09 22:11:17 +01:00
|
|
|
|
|
|
|
$this->applyIntraline(
|
|
|
|
$this->oldRender,
|
|
|
|
ipull($this->intra, 0),
|
|
|
|
$old_corpus);
|
|
|
|
$this->applyIntraline(
|
|
|
|
$this->newRender,
|
|
|
|
ipull($this->intra, 1),
|
|
|
|
$new_corpus);
|
2011-01-25 00:52:35 +01:00
|
|
|
}
|
|
|
|
|
2012-12-08 01:19:57 +01:00
|
|
|
private function shouldRenderPropertyChangeHeader($changeset) {
|
|
|
|
if (!$this->isTopLevel) {
|
|
|
|
// We render properties only at top level; otherwise we get multiple
|
|
|
|
// copies of them when a user clicks "Show More".
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
$old = $changeset->getOldProperties();
|
|
|
|
$new = $changeset->getNewProperties();
|
|
|
|
|
|
|
|
if ($old === $new) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
if ($changeset->getChangeType() == DifferentialChangeType::TYPE_ADD &&
|
|
|
|
$new == array('unix:filemode' => '100644')) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
if ($changeset->getChangeType() == DifferentialChangeType::TYPE_DELETE &&
|
|
|
|
$old == array('unix:filemode' => '100644')) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2011-01-25 00:52:35 +01:00
|
|
|
public function render(
|
|
|
|
$range_start = null,
|
|
|
|
$range_len = null,
|
|
|
|
$mask_force = array()) {
|
|
|
|
|
2011-06-20 22:49:17 +02:00
|
|
|
// "Top level" renders are initial requests for the whole file, versus
|
|
|
|
// requests for a specific range generated by clicking "show more". We
|
|
|
|
// generate property changes and "shield" UI elements only for toplevel
|
|
|
|
// requests.
|
|
|
|
$this->isTopLevel = (($range_start === null) && ($range_len === null));
|
2011-07-06 21:12:17 +02:00
|
|
|
$this->highlightEngine = PhabricatorSyntaxHighlighter::newEngine();
|
2012-07-26 22:24:43 +02:00
|
|
|
$this->tryCacheStuff();
|
2012-12-08 01:19:57 +01:00
|
|
|
$render_pch = $this->shouldRenderPropertyChangeHeader($this->changeset);
|
|
|
|
|
2012-12-19 19:56:00 +01:00
|
|
|
$rows = max(
|
|
|
|
count($this->old),
|
|
|
|
count($this->new));
|
|
|
|
|
2012-12-08 01:19:57 +01:00
|
|
|
$renderer = id(new DifferentialChangesetTwoUpRenderer())
|
|
|
|
->setChangeset($this->changeset)
|
|
|
|
->setRenderPropertyChangeHeader($render_pch)
|
2012-12-19 19:56:00 +01:00
|
|
|
->setLineCount($rows)
|
2012-12-08 01:19:57 +01:00
|
|
|
->setOldRender($this->oldRender)
|
|
|
|
->setNewRender($this->newRender)
|
|
|
|
->setMissingOldLines($this->missingOld)
|
|
|
|
->setMissingNewLines($this->missingNew)
|
|
|
|
->setOldChangesetID($this->leftSideChangesetID)
|
|
|
|
->setNewChangesetID($this->rightSideChangesetID)
|
|
|
|
->setOldAttachesToNewFile($this->leftSideAttachesToNewFile)
|
|
|
|
->setNewAttachesToNewFile($this->rightSideAttachesToNewFile)
|
2012-12-12 02:16:11 +01:00
|
|
|
->setCodeCoverage($this->getCoverage())
|
2012-12-08 01:19:57 +01:00
|
|
|
->setRenderingReference($this->getRenderingReference())
|
|
|
|
->setMarkupEngine($this->markupEngine)
|
|
|
|
->setHandles($this->handles);
|
2012-07-26 22:24:43 +02:00
|
|
|
|
2012-12-11 00:12:32 +01:00
|
|
|
if ($this->user) {
|
|
|
|
$renderer->setUser($this->user);
|
|
|
|
}
|
|
|
|
|
2012-05-01 07:31:26 +02:00
|
|
|
$shield = null;
|
2012-07-26 22:24:43 +02:00
|
|
|
if ($this->isTopLevel && !$this->comments) {
|
|
|
|
if ($this->isGenerated()) {
|
2012-12-08 01:19:57 +01:00
|
|
|
$shield = $renderer->renderShield(
|
|
|
|
pht(
|
|
|
|
'This file contains generated code, which does not normally '.
|
|
|
|
'need to be reviewed.'),
|
2012-07-26 22:24:43 +02:00
|
|
|
true);
|
|
|
|
} else if ($this->isUnchanged()) {
|
|
|
|
if ($this->isWhitespaceOnly()) {
|
2012-12-08 01:19:57 +01:00
|
|
|
$shield = $renderer->renderShield(
|
|
|
|
pht(
|
|
|
|
'This file was changed only by adding or removing trailing '.
|
|
|
|
'whitespace.'),
|
2012-07-26 22:24:43 +02:00
|
|
|
false);
|
|
|
|
} else {
|
2012-12-08 01:19:57 +01:00
|
|
|
$shield = $renderer->renderShield(
|
|
|
|
pht("The contents of this file were not changed."),
|
2012-07-26 22:24:43 +02:00
|
|
|
false);
|
2012-05-01 07:31:26 +02:00
|
|
|
}
|
2012-07-26 22:24:43 +02:00
|
|
|
} else if ($this->isDeleted()) {
|
2012-12-08 01:19:57 +01:00
|
|
|
$shield = $renderer->renderShield(
|
|
|
|
pht("This file was completely deleted."),
|
2012-07-26 22:24:43 +02:00
|
|
|
true);
|
|
|
|
} else if ($this->changeset->getAffectedLineCount() > 2500) {
|
|
|
|
$lines = number_format($this->changeset->getAffectedLineCount());
|
2012-12-08 01:19:57 +01:00
|
|
|
$shield = $renderer->renderShield(
|
|
|
|
pht(
|
|
|
|
'This file has a very large number of changes ({%s} lines).',
|
|
|
|
$lines),
|
2012-07-26 22:24:43 +02:00
|
|
|
true);
|
2012-05-01 07:31:26 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if ($shield) {
|
2012-12-08 01:19:57 +01:00
|
|
|
return $renderer->renderChangesetTable($shield);
|
2012-05-01 07:31:26 +02:00
|
|
|
}
|
2011-01-25 00:52:35 +01:00
|
|
|
|
2012-12-08 01:19:57 +01:00
|
|
|
$old_comments = array();
|
|
|
|
$new_comments = array();
|
|
|
|
$old_mask = array();
|
|
|
|
$new_mask = array();
|
2011-01-25 00:52:35 +01:00
|
|
|
$feedback_mask = array();
|
|
|
|
|
2012-12-08 01:19:57 +01:00
|
|
|
if ($this->comments) {
|
|
|
|
foreach ($this->comments as $comment) {
|
|
|
|
$start = max($comment->getLineNumber() - self::LINES_CONTEXT, 0);
|
|
|
|
$end = $comment->getLineNumber() +
|
|
|
|
$comment->getLineLength() +
|
|
|
|
self::LINES_CONTEXT;
|
|
|
|
$new_side = $this->isCommentOnRightSideWhenDisplayed($comment);
|
|
|
|
for ($ii = $start; $ii <= $end; $ii++) {
|
|
|
|
if ($new_side) {
|
|
|
|
$new_mask[$ii] = true;
|
|
|
|
} else {
|
|
|
|
$old_mask[$ii] = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
foreach ($this->old as $ii => $old) {
|
|
|
|
if (isset($old['line']) && isset($old_mask[$old['line']])) {
|
|
|
|
$feedback_mask[$ii] = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
foreach ($this->new as $ii => $new) {
|
|
|
|
if (isset($new['line']) && isset($new_mask[$new['line']])) {
|
|
|
|
$feedback_mask[$ii] = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
$this->comments = msort($this->comments, 'getID');
|
|
|
|
foreach ($this->comments as $comment) {
|
|
|
|
$final = $comment->getLineNumber() +
|
|
|
|
$comment->getLineLength();
|
|
|
|
$final = max(1, $final);
|
|
|
|
if ($this->isCommentOnRightSideWhenDisplayed($comment)) {
|
|
|
|
$new_comments[$final][] = $comment;
|
|
|
|
} else {
|
|
|
|
$old_comments[$final][] = $comment;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
$renderer
|
|
|
|
->setOldComments($old_comments)
|
|
|
|
->setNewComments($new_comments);
|
|
|
|
|
2011-01-25 00:52:35 +01:00
|
|
|
switch ($this->changeset->getFileType()) {
|
|
|
|
case DifferentialChangeType::FILE_IMAGE:
|
|
|
|
$old = null;
|
2012-12-13 18:48:28 +01:00
|
|
|
$new = null;
|
2011-09-19 08:04:03 +02:00
|
|
|
// TODO: Improve the architectural issue as discussed in D955
|
|
|
|
// https://secure.phabricator.com/D955
|
2012-12-08 01:19:57 +01:00
|
|
|
$reference = $this->getRenderingReference();
|
2011-09-19 08:04:03 +02:00
|
|
|
$parts = explode('/', $reference);
|
|
|
|
if (count($parts) == 2) {
|
|
|
|
list($id, $vs) = $parts;
|
|
|
|
} else {
|
|
|
|
$id = $parts[0];
|
|
|
|
$vs = 0;
|
|
|
|
}
|
|
|
|
$id = (int)$id;
|
|
|
|
$vs = (int)$vs;
|
|
|
|
|
|
|
|
if (!$vs) {
|
|
|
|
$metadata = $this->changeset->getMetadata();
|
|
|
|
$data = idx($metadata, 'attachment-data');
|
2011-01-25 00:52:35 +01:00
|
|
|
|
2011-09-19 08:04:03 +02:00
|
|
|
$old_phid = idx($metadata, 'old:binary-phid');
|
|
|
|
$new_phid = idx($metadata, 'new:binary-phid');
|
|
|
|
} else {
|
|
|
|
$vs_changeset = id(new DifferentialChangeset())->load($vs);
|
|
|
|
$vs_metadata = $vs_changeset->getMetadata();
|
|
|
|
$old_phid = idx($vs_metadata, 'new:binary-phid');
|
|
|
|
|
|
|
|
$changeset = id(new DifferentialChangeset())->load($id);
|
|
|
|
$metadata = $changeset->getMetadata();
|
|
|
|
$new_phid = idx($metadata, 'new:binary-phid');
|
|
|
|
}
|
2011-01-25 00:52:35 +01:00
|
|
|
|
|
|
|
if ($old_phid || $new_phid) {
|
2012-01-10 23:48:55 +01:00
|
|
|
// grab the files, (micro) optimization for 1 query not 2
|
|
|
|
$file_phids = array();
|
2011-01-25 00:52:35 +01:00
|
|
|
if ($old_phid) {
|
2012-01-10 23:48:55 +01:00
|
|
|
$file_phids[] = $old_phid;
|
2011-01-25 00:52:35 +01:00
|
|
|
}
|
|
|
|
if ($new_phid) {
|
2012-01-10 23:48:55 +01:00
|
|
|
$file_phids[] = $new_phid;
|
|
|
|
}
|
|
|
|
|
|
|
|
$files = id(new PhabricatorFile())->loadAllWhere(
|
|
|
|
'phid IN (%Ls)',
|
|
|
|
$file_phids);
|
|
|
|
foreach ($files as $file) {
|
|
|
|
if (empty($file)) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if ($file->getPHID() == $old_phid) {
|
2012-12-08 01:19:57 +01:00
|
|
|
$old = $file;
|
|
|
|
} else if ($file->getPHID() == $new_phid) {
|
|
|
|
$new = $file;
|
2012-01-10 23:48:55 +01:00
|
|
|
}
|
2011-01-25 00:52:35 +01:00
|
|
|
}
|
|
|
|
}
|
2012-12-13 18:48:28 +01:00
|
|
|
|
2012-12-08 01:19:57 +01:00
|
|
|
return $renderer->renderFileChange($old, $new, $id, $vs);
|
2011-01-25 00:52:35 +01:00
|
|
|
case DifferentialChangeType::FILE_DIRECTORY:
|
|
|
|
case DifferentialChangeType::FILE_BINARY:
|
2012-12-08 01:19:57 +01:00
|
|
|
$output = $renderer->renderChangesetTable(null);
|
2011-01-25 00:52:35 +01:00
|
|
|
return $output;
|
|
|
|
}
|
|
|
|
|
2012-12-10 10:47:58 +01:00
|
|
|
if ($this->originalLeft && $this->originalRight) {
|
2012-12-08 01:19:57 +01:00
|
|
|
list($highlight_old, $highlight_new) = $this->diffOriginals();
|
|
|
|
$highlight_old = array_flip($highlight_old);
|
|
|
|
$highlight_new = array_flip($highlight_new);
|
|
|
|
$renderer
|
|
|
|
->setHighlightOld($highlight_old)
|
|
|
|
->setHighlightNew($highlight_new);
|
2011-01-25 00:52:35 +01:00
|
|
|
}
|
2012-12-08 01:19:57 +01:00
|
|
|
$renderer
|
|
|
|
->setOriginalOld($this->originalLeft)
|
|
|
|
->setOriginalNew($this->originalRight);
|
2011-01-25 00:52:35 +01:00
|
|
|
|
2012-12-12 02:16:11 +01:00
|
|
|
if ($range_start === null) {
|
|
|
|
$range_start = 0;
|
|
|
|
}
|
|
|
|
if ($range_len === null) {
|
|
|
|
$range_len = $rows;
|
|
|
|
}
|
|
|
|
$range_len = min($range_len, $rows - $range_start);
|
|
|
|
|
|
|
|
list($gaps, $mask, $depths) = $this->calculateGapsMaskAndDepths(
|
|
|
|
$mask_force,
|
|
|
|
$feedback_mask,
|
|
|
|
$range_start,
|
|
|
|
$range_len
|
|
|
|
);
|
|
|
|
|
|
|
|
$renderer
|
|
|
|
->setOldLines($this->old)
|
|
|
|
->setNewLines($this->new)
|
|
|
|
->setGaps($gaps)
|
|
|
|
->setMask($mask)
|
|
|
|
->setDepths($depths);
|
|
|
|
|
2012-12-08 01:19:57 +01:00
|
|
|
$html = $renderer->renderTextChange(
|
2011-01-25 00:52:35 +01:00
|
|
|
$range_start,
|
|
|
|
$range_len,
|
2012-12-12 02:16:11 +01:00
|
|
|
$rows
|
2012-12-08 01:19:57 +01:00
|
|
|
);
|
2011-01-25 00:52:35 +01:00
|
|
|
|
2012-12-08 01:19:57 +01:00
|
|
|
return $renderer->renderChangesetTable($html);
|
2011-01-25 00:52:35 +01:00
|
|
|
}
|
|
|
|
|
2012-12-12 02:16:11 +01:00
|
|
|
/**
|
|
|
|
* This function calculates a lot of stuff we need to know to display
|
|
|
|
* the diff:
|
|
|
|
*
|
|
|
|
* Gaps - compute gaps in the visible display diff, where we will render
|
|
|
|
* "Show more context" spacers. If a gap is smaller than the context size,
|
|
|
|
* we just display it. Otherwise, we record it into $gaps and will render a
|
|
|
|
* "show more context" element instead of diff text below. A given $gap
|
|
|
|
* is a tuple of $gap_line_number_start and $gap_length.
|
|
|
|
*
|
|
|
|
* Mask - compute the actual lines that need to be shown (because they
|
|
|
|
* are near changes lines, near inline comments, or the request has
|
|
|
|
* explicitly asked for them, i.e. resulting from the user clicking
|
|
|
|
* "show more"). The $mask returned is a sparesely populated dictionary
|
|
|
|
* of $visible_line_number => true.
|
|
|
|
*
|
|
|
|
* Depths - compute how indented any given line is. The $depths returned
|
|
|
|
* is a sparesely populated dictionary of $visible_line_number => $depth.
|
|
|
|
*
|
|
|
|
* This function also has the side effect of modifying member variable
|
|
|
|
* new such that tabs are normalized to spaces for each line of the diff.
|
|
|
|
*
|
|
|
|
* @return array($gaps, $mask, $depths)
|
|
|
|
*/
|
|
|
|
private function calculateGapsMaskAndDepths($mask_force,
|
|
|
|
$feedback_mask,
|
|
|
|
$range_start,
|
|
|
|
$range_len) {
|
|
|
|
|
|
|
|
// Calculate gaps and mask first
|
|
|
|
$gaps = array();
|
|
|
|
$gap_start = 0;
|
|
|
|
$in_gap = false;
|
|
|
|
$base_mask = $this->visible + $mask_force + $feedback_mask;
|
|
|
|
$base_mask[$range_start + $range_len] = true;
|
|
|
|
for ($ii = $range_start; $ii <= $range_start + $range_len; $ii++) {
|
|
|
|
if (isset($base_mask[$ii])) {
|
|
|
|
if ($in_gap) {
|
|
|
|
$gap_length = $ii - $gap_start;
|
|
|
|
if ($gap_length <= self::LINES_CONTEXT) {
|
|
|
|
for ($jj = $gap_start; $jj <= $gap_start + $gap_length; $jj++) {
|
|
|
|
$base_mask[$jj] = true;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
$gaps[] = array($gap_start, $gap_length);
|
|
|
|
}
|
|
|
|
$in_gap = false;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
if (!$in_gap) {
|
|
|
|
$gap_start = $ii;
|
|
|
|
$in_gap = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
$gaps = array_reverse($gaps);
|
|
|
|
$mask = $base_mask;
|
|
|
|
|
|
|
|
// Time to calculate depth.
|
|
|
|
// We need to go backwards to properly indent whitespace in this code:
|
|
|
|
//
|
|
|
|
// 0: class C {
|
|
|
|
// 1:
|
|
|
|
// 1: function f() {
|
|
|
|
// 2:
|
|
|
|
// 2: return;
|
|
|
|
// 3:
|
|
|
|
// 3: }
|
|
|
|
// 4:
|
|
|
|
// 4: }
|
|
|
|
//
|
|
|
|
$depths = array();
|
|
|
|
$last_depth = 0;
|
|
|
|
$range_end = $range_start + $range_len;
|
|
|
|
if (!isset($this->new[$range_end])) {
|
|
|
|
$range_end--;
|
|
|
|
}
|
|
|
|
for ($ii = $range_end; $ii >= $range_start; $ii--) {
|
|
|
|
// We need to expand tabs to process mixed indenting and to round
|
|
|
|
// correctly later.
|
|
|
|
$line = str_replace("\t", " ", $this->new[$ii]['text']);
|
|
|
|
$trimmed = ltrim($line);
|
|
|
|
if ($trimmed != '') {
|
|
|
|
// We round down to flatten "/**" and " *".
|
|
|
|
$last_depth = floor((strlen($line) - strlen($trimmed)) / 2);
|
|
|
|
}
|
|
|
|
$depths[$ii] = $last_depth;
|
|
|
|
}
|
|
|
|
|
|
|
|
return array($gaps, $mask, $depths);
|
|
|
|
}
|
|
|
|
|
2011-05-09 06:22:25 +02:00
|
|
|
/**
|
|
|
|
* Determine if an inline comment will appear on the rendered diff,
|
|
|
|
* taking into consideration which halves of which changesets will actually
|
|
|
|
* be shown.
|
|
|
|
*
|
Add inline comments to Diffusion/Audit
Summary:
- Add inline comments to Audits, like Differential.
- Creates new storage for the comments in the Audits database.
- Creates a new PhabricatorAuditInlineComment class, similar to DifferentialInlineComment.
- Defines an Interface which Differential and Audit comments conform to.
- Makes consumers of DifferentialInlineComments consume objects which implement that interface instead.
- Adds save
NOTE: Some features are still missing! Wanted to cut this off before it got crazy:
- Inline comments aren't shown in the main comment list.
- Inline comments aren't shown in the emails.
- Inline comments aren't previewed.
I'll followup with those but this was getting pretty big.
@vrana, does the SQL change look correct?
Test Plan:
- Created, edited, deleted, replied to, reloaded and saved inline comments in Diffusion, on the left and right side of diffs.
- Created, edited, deleted, replied to, reloaded and saved inline comments in Differentila, on the left and right side of primary and diff-versus-diff diffs.
Reviewers: btrahan, vrana
Reviewed By: btrahan
CC: aran, epriestley
Maniphest Tasks: T904
Differential Revision: https://secure.phabricator.com/D1898
2012-03-14 20:56:01 +01:00
|
|
|
* @param PhabricatorInlineCommentInterface Comment to test for visibility.
|
2011-05-09 06:22:25 +02:00
|
|
|
* @return bool True if the comment is visible on the rendered diff.
|
|
|
|
*/
|
|
|
|
private function isCommentVisibleOnRenderedDiff(
|
Add inline comments to Diffusion/Audit
Summary:
- Add inline comments to Audits, like Differential.
- Creates new storage for the comments in the Audits database.
- Creates a new PhabricatorAuditInlineComment class, similar to DifferentialInlineComment.
- Defines an Interface which Differential and Audit comments conform to.
- Makes consumers of DifferentialInlineComments consume objects which implement that interface instead.
- Adds save
NOTE: Some features are still missing! Wanted to cut this off before it got crazy:
- Inline comments aren't shown in the main comment list.
- Inline comments aren't shown in the emails.
- Inline comments aren't previewed.
I'll followup with those but this was getting pretty big.
@vrana, does the SQL change look correct?
Test Plan:
- Created, edited, deleted, replied to, reloaded and saved inline comments in Diffusion, on the left and right side of diffs.
- Created, edited, deleted, replied to, reloaded and saved inline comments in Differentila, on the left and right side of primary and diff-versus-diff diffs.
Reviewers: btrahan, vrana
Reviewed By: btrahan
CC: aran, epriestley
Maniphest Tasks: T904
Differential Revision: https://secure.phabricator.com/D1898
2012-03-14 20:56:01 +01:00
|
|
|
PhabricatorInlineCommentInterface $comment) {
|
2011-05-09 06:22:25 +02:00
|
|
|
|
2012-12-08 01:19:57 +01:00
|
|
|
$changeset_id = $comment->getChangesetID();
|
|
|
|
$is_new = $comment->getIsNewFile();
|
2011-05-09 06:22:25 +02:00
|
|
|
|
2012-12-08 01:19:57 +01:00
|
|
|
if ($changeset_id == $this->rightSideChangesetID &&
|
2011-05-09 06:22:25 +02:00
|
|
|
$is_new == $this->rightSideAttachesToNewFile) {
|
2012-12-08 01:19:57 +01:00
|
|
|
return true;
|
|
|
|
}
|
2011-05-09 06:22:25 +02:00
|
|
|
|
2012-12-08 01:19:57 +01:00
|
|
|
if ($changeset_id == $this->leftSideChangesetID &&
|
2011-05-09 06:22:25 +02:00
|
|
|
$is_new == $this->leftSideAttachesToNewFile) {
|
2012-12-08 01:19:57 +01:00
|
|
|
return true;
|
|
|
|
}
|
2011-05-09 06:22:25 +02:00
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Determine if a comment will appear on the right side of the display diff.
|
|
|
|
* Note that the comment must appear somewhere on the rendered changeset, as
|
|
|
|
* per isCommentVisibleOnRenderedDiff().
|
|
|
|
*
|
Add inline comments to Diffusion/Audit
Summary:
- Add inline comments to Audits, like Differential.
- Creates new storage for the comments in the Audits database.
- Creates a new PhabricatorAuditInlineComment class, similar to DifferentialInlineComment.
- Defines an Interface which Differential and Audit comments conform to.
- Makes consumers of DifferentialInlineComments consume objects which implement that interface instead.
- Adds save
NOTE: Some features are still missing! Wanted to cut this off before it got crazy:
- Inline comments aren't shown in the main comment list.
- Inline comments aren't shown in the emails.
- Inline comments aren't previewed.
I'll followup with those but this was getting pretty big.
@vrana, does the SQL change look correct?
Test Plan:
- Created, edited, deleted, replied to, reloaded and saved inline comments in Diffusion, on the left and right side of diffs.
- Created, edited, deleted, replied to, reloaded and saved inline comments in Differentila, on the left and right side of primary and diff-versus-diff diffs.
Reviewers: btrahan, vrana
Reviewed By: btrahan
CC: aran, epriestley
Maniphest Tasks: T904
Differential Revision: https://secure.phabricator.com/D1898
2012-03-14 20:56:01 +01:00
|
|
|
* @param PhabricatorInlineCommentInterface Comment to test for display
|
|
|
|
* location.
|
2011-05-09 06:22:25 +02:00
|
|
|
* @return bool True for right, false for left.
|
|
|
|
*/
|
|
|
|
private function isCommentOnRightSideWhenDisplayed(
|
Add inline comments to Diffusion/Audit
Summary:
- Add inline comments to Audits, like Differential.
- Creates new storage for the comments in the Audits database.
- Creates a new PhabricatorAuditInlineComment class, similar to DifferentialInlineComment.
- Defines an Interface which Differential and Audit comments conform to.
- Makes consumers of DifferentialInlineComments consume objects which implement that interface instead.
- Adds save
NOTE: Some features are still missing! Wanted to cut this off before it got crazy:
- Inline comments aren't shown in the main comment list.
- Inline comments aren't shown in the emails.
- Inline comments aren't previewed.
I'll followup with those but this was getting pretty big.
@vrana, does the SQL change look correct?
Test Plan:
- Created, edited, deleted, replied to, reloaded and saved inline comments in Diffusion, on the left and right side of diffs.
- Created, edited, deleted, replied to, reloaded and saved inline comments in Differentila, on the left and right side of primary and diff-versus-diff diffs.
Reviewers: btrahan, vrana
Reviewed By: btrahan
CC: aran, epriestley
Maniphest Tasks: T904
Differential Revision: https://secure.phabricator.com/D1898
2012-03-14 20:56:01 +01:00
|
|
|
PhabricatorInlineCommentInterface $comment) {
|
2011-05-09 06:22:25 +02:00
|
|
|
|
|
|
|
if (!$this->isCommentVisibleOnRenderedDiff($comment)) {
|
|
|
|
throw new Exception("Comment is not visible on changeset!");
|
|
|
|
}
|
|
|
|
|
|
|
|
$changeset_id = $comment->getChangesetID();
|
|
|
|
$is_new = $comment->getIsNewFile();
|
|
|
|
|
|
|
|
if ($changeset_id == $this->rightSideChangesetID &&
|
|
|
|
$is_new == $this->rightSideAttachesToNewFile) {
|
|
|
|
return true;
|
2011-01-25 00:52:35 +01:00
|
|
|
}
|
2011-05-09 06:22:25 +02:00
|
|
|
|
|
|
|
return false;
|
2011-01-25 00:52:35 +01:00
|
|
|
}
|
|
|
|
|
2011-07-17 20:06:02 +02:00
|
|
|
/**
|
|
|
|
* Parse the 'range' specification that this class and the client-side JS
|
|
|
|
* emit to indicate that a user clicked "Show more..." on a diff. Generally,
|
|
|
|
* use is something like this:
|
|
|
|
*
|
|
|
|
* $spec = $request->getStr('range');
|
|
|
|
* $parsed = DifferentialChangesetParser::parseRangeSpecification($spec);
|
|
|
|
* list($start, $end, $mask) = $parsed;
|
|
|
|
* $parser->render($start, $end, $mask);
|
|
|
|
*
|
|
|
|
* @param string Range specification, indicating the range of the diff that
|
|
|
|
* should be rendered.
|
|
|
|
* @return tuple List of <start, end, mask> suitable for passing to
|
|
|
|
* @{method:render}.
|
|
|
|
*/
|
|
|
|
public static function parseRangeSpecification($spec) {
|
|
|
|
$range_s = null;
|
|
|
|
$range_e = null;
|
|
|
|
$mask = array();
|
|
|
|
|
|
|
|
if ($spec) {
|
|
|
|
$match = null;
|
|
|
|
if (preg_match('@^(\d+)-(\d+)(?:/(\d+)-(\d+))?$@', $spec, $match)) {
|
|
|
|
$range_s = (int)$match[1];
|
|
|
|
$range_e = (int)$match[2];
|
|
|
|
if (count($match) > 3) {
|
|
|
|
$start = (int)$match[3];
|
|
|
|
$len = (int)$match[4];
|
|
|
|
for ($ii = $start; $ii < $start + $len; $ii++) {
|
|
|
|
$mask[$ii] = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return array($range_s, $range_e, $mask);
|
|
|
|
}
|
|
|
|
|
2012-03-13 01:06:55 +01:00
|
|
|
/**
|
|
|
|
* Render "modified coverage" information; test coverage on modified lines.
|
|
|
|
* This synthesizes diff information with unit test information into a useful
|
|
|
|
* indicator of how well tested a change is.
|
|
|
|
*/
|
|
|
|
public function renderModifiedCoverage() {
|
|
|
|
$na = '<em>-</em>';
|
|
|
|
|
2012-12-12 02:16:11 +01:00
|
|
|
$coverage = $this->getCoverage();
|
|
|
|
if (!$coverage) {
|
2012-03-13 01:06:55 +01:00
|
|
|
return $na;
|
|
|
|
}
|
|
|
|
|
|
|
|
$covered = 0;
|
|
|
|
$not_covered = 0;
|
|
|
|
|
|
|
|
foreach ($this->new as $k => $new) {
|
|
|
|
if (!$new['line']) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!$new['type']) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2012-12-12 02:16:11 +01:00
|
|
|
if (empty($coverage[$new['line'] - 1])) {
|
2012-03-13 01:06:55 +01:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2012-12-12 02:16:11 +01:00
|
|
|
switch ($coverage[$new['line'] - 1]) {
|
2012-03-13 01:06:55 +01:00
|
|
|
case 'C':
|
|
|
|
$covered++;
|
|
|
|
break;
|
|
|
|
case 'U':
|
|
|
|
$not_covered++;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!$covered && !$not_covered) {
|
|
|
|
return $na;
|
|
|
|
}
|
|
|
|
|
|
|
|
return sprintf('%d%%', 100 * ($covered / ($covered + $not_covered)));
|
|
|
|
}
|
|
|
|
|
2013-01-09 22:11:17 +01:00
|
|
|
public function detectCopiedCode(
|
|
|
|
array $changesets,
|
|
|
|
$min_width = 30,
|
|
|
|
$min_lines = 3) {
|
|
|
|
|
|
|
|
assert_instances_of($changesets, 'DifferentialChangeset');
|
|
|
|
|
|
|
|
$map = array();
|
|
|
|
$files = array();
|
|
|
|
$types = array();
|
|
|
|
foreach ($changesets as $changeset) {
|
|
|
|
$file = $changeset->getFilename();
|
|
|
|
foreach ($changeset->getHunks() as $hunk) {
|
|
|
|
$line = $hunk->getOldOffset();
|
|
|
|
foreach (explode("\n", $hunk->getChanges()) as $code) {
|
|
|
|
$type = (isset($code[0]) ? $code[0] : '');
|
|
|
|
if ($type == '-' || $type == ' ') {
|
|
|
|
$code = trim(substr($code, 1));
|
|
|
|
$files[$file][$line] = $code;
|
|
|
|
$types[$file][$line] = $type;
|
|
|
|
if (strlen($code) >= $min_width) {
|
|
|
|
$map[$code][] = array($file, $line);
|
|
|
|
}
|
|
|
|
$line++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
foreach ($changesets as $changeset) {
|
|
|
|
$copies = array();
|
|
|
|
foreach ($changeset->getHunks() as $hunk) {
|
|
|
|
$added = array_map('trim', $hunk->getAddedLines());
|
|
|
|
for (reset($added); list($line, $code) = each($added); ) {
|
|
|
|
if (isset($map[$code])) { // We found a long matching line.
|
|
|
|
$best_length = 0;
|
|
|
|
foreach ($map[$code] as $val) { // Explore all candidates.
|
|
|
|
list($file, $orig_line) = $val;
|
|
|
|
$length = 1;
|
|
|
|
// Search also backwards for short lines.
|
|
|
|
foreach (array(-1, 1) as $direction) {
|
|
|
|
$offset = $direction;
|
|
|
|
while (!isset($copies[$line + $offset]) &&
|
|
|
|
isset($added[$line + $offset]) &&
|
|
|
|
idx($files[$file], $orig_line + $offset) ===
|
|
|
|
$added[$line + $offset]) {
|
|
|
|
$length++;
|
|
|
|
$offset += $direction;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if ($length > $best_length ||
|
|
|
|
($length == $best_length && // Prefer moves.
|
|
|
|
idx($types[$file], $orig_line) == '-')) {
|
|
|
|
$best_length = $length;
|
|
|
|
// ($offset - 1) contains number of forward matching lines.
|
|
|
|
$best_offset = $offset - 1;
|
|
|
|
$best_file = $file;
|
|
|
|
$best_line = $orig_line;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
$file = ($best_file == $changeset->getFilename() ? '' : $best_file);
|
|
|
|
for ($i = $best_length; $i--; ) {
|
|
|
|
$type = idx($types[$best_file], $best_line + $best_offset - $i);
|
|
|
|
$copies[$line + $best_offset - $i] = ($best_length < $min_lines
|
|
|
|
? array() // Ignore short blocks.
|
|
|
|
: array($file, $best_line + $best_offset - $i, $type));
|
|
|
|
}
|
|
|
|
for ($i = 0; $i < $best_offset; $i++) {
|
|
|
|
next($added);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
$copies = array_filter($copies);
|
|
|
|
if ($copies) {
|
|
|
|
$metadata = $changeset->getMetadata();
|
|
|
|
$metadata['copy:lines'] = $copies;
|
|
|
|
$changeset->setMetadata($metadata);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return $changesets;
|
|
|
|
}
|
|
|
|
|
2011-01-25 00:52:35 +01:00
|
|
|
}
|