No OneTemporary
Actions

Size

31 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/src/applications/audit/storage/PhabricatorAuditInlineComment.php b/src/applications/audit/storage/PhabricatorAuditInlineComment.php
	index 0c2bbd3cca..7d5336436f 100644
	--- a/src/applications/audit/storage/PhabricatorAuditInlineComment.php
	+++ b/src/applications/audit/storage/PhabricatorAuditInlineComment.php
	@@ -1,161 +1,168 @@
	<?php

	final class PhabricatorAuditInlineComment
	extends PhabricatorInlineComment {

	protected function newStorageObject() {
	return new PhabricatorAuditTransactionComment();
	}

	public function getControllerURI() {
	return urisprintf(
	'/diffusion/inline/edit/%s/',
	$this->getCommitPHID());
	}

	public function supportsHiding() {
	return false;
	}

	public function isHidden() {
	return false;
	}

	public function getTransactionCommentForSave() {
	$content_source = PhabricatorContentSource::newForSource(
	PhabricatorOldWorldContentSource::SOURCECONST);

	$this->getStorageObject()
	->setViewPolicy('public')
	->setEditPolicy($this->getAuthorPHID())
	->setContentSource($content_source)
	->setCommentVersion(1);

	return $this->getStorageObject();
	}

	public static function loadID($id) {
	$inlines = id(new PhabricatorAuditTransactionComment())->loadAllWhere(
	'id = %d',
	$id);
	if (!$inlines) {
	return null;
	}

	return head(self::buildProxies($inlines));
	}

	public static function loadPHID($phid) {
	$inlines = id(new PhabricatorAuditTransactionComment())->loadAllWhere(
	'phid = %s',
	$phid);
	if (!$inlines) {
	return null;
	}
	return head(self::buildProxies($inlines));
	}

	public static function loadDraftComments(
	PhabricatorUser $viewer,
	$commit_phid,
	$raw = false) {

	$inlines = id(new DiffusionDiffInlineCommentQuery())
	->setViewer($viewer)
	->withAuthorPHIDs(array($viewer->getPHID()))
	->withCommitPHIDs(array($commit_phid))
	->withHasTransaction(false)
	->withHasPath(true)
	->withIsDeleted(false)
	->needReplyToComments(true)
	->execute();

	if ($raw) {
	return $inlines;
	}

	return self::buildProxies($inlines);
	}

	public static function loadPublishedComments(
	PhabricatorUser $viewer,
	$commit_phid) {

	$inlines = id(new DiffusionDiffInlineCommentQuery())
	->setViewer($viewer)
	->withCommitPHIDs(array($commit_phid))
	->withHasTransaction(true)
	->withHasPath(true)
	->execute();

	return self::buildProxies($inlines);
	}

	public static function loadDraftAndPublishedComments(
	PhabricatorUser $viewer,
	$commit_phid,
	$path_id = null) {

	if ($path_id === null) {
	$inlines = id(new PhabricatorAuditTransactionComment())->loadAllWhere(
	'commitPHID = %s AND (transactionPHID IS NOT NULL OR authorPHID = %s)
	AND pathID IS NOT NULL',
	$commit_phid,
	$viewer->getPHID());
	} else {
	$inlines = id(new PhabricatorAuditTransactionComment())->loadAllWhere(
	'commitPHID = %s AND pathID = %d AND
	((authorPHID = %s AND isDeleted = 0) OR transactionPHID IS NOT NULL)',
	$commit_phid,
	$path_id,
	$viewer->getPHID());
	}

	+ foreach ($inlines as $key => $inline) {
	+ $is_draft = !$inline->getTransactionPHID();
	+ if ($is_draft && $inline->isEmptyInlineComment()) {
	+ unset($inlines[$key]);
	+ }
	+ }
	+
	return self::buildProxies($inlines);
	}

	private static function buildProxies(array $inlines) {
	$results = array();
	foreach ($inlines as $key => $inline) {
	$results[$key] = self::newFromModernComment(
	$inline);
	}
	return $results;
	}

	public static function newFromModernComment(
	PhabricatorAuditTransactionComment $comment) {

	$obj = new PhabricatorAuditInlineComment();
	$obj->setStorageObject($comment);

	return $obj;
	}

	public function setPathID($id) {
	$this->getStorageObject()->setPathID($id);
	return $this;
	}

	public function getPathID() {
	return $this->getStorageObject()->getPathID();
	}

	public function setCommitPHID($commit_phid) {
	$this->getStorageObject()->setCommitPHID($commit_phid);
	return $this;
	}

	public function getCommitPHID() {
	return $this->getStorageObject()->getCommitPHID();
	}

	public function setChangesetID($id) {
	return $this->setPathID($id);
	}

	public function getChangesetID() {
	return $this->getPathID();
	}

	}
	diff --git a/src/applications/differential/controller/DifferentialChangesetViewController.php b/src/applications/differential/controller/DifferentialChangesetViewController.php
	index 8f432a6e98..c66a25d950 100644
	--- a/src/applications/differential/controller/DifferentialChangesetViewController.php
	+++ b/src/applications/differential/controller/DifferentialChangesetViewController.php
	@@ -1,459 +1,460 @@
	<?php

	final class DifferentialChangesetViewController extends DifferentialController {

	public function shouldAllowPublic() {
	return true;
	}

	public function handleRequest(AphrontRequest $request) {
	$viewer = $this->getViewer();

	$rendering_reference = $request->getStr('ref');
	$parts = explode('/', $rendering_reference);
	if (count($parts) == 2) {
	list($id, $vs) = $parts;
	} else {
	$id = $parts[0];
	$vs = 0;
	}

	$id = (int)$id;
	$vs = (int)$vs;

	$load_ids = array($id);
	if ($vs && ($vs != -1)) {
	$load_ids[] = $vs;
	}

	$changesets = id(new DifferentialChangesetQuery())
	->setViewer($viewer)
	->withIDs($load_ids)
	->needHunks(true)
	->execute();
	$changesets = mpull($changesets, null, 'getID');

	$changeset = idx($changesets, $id);
	if (!$changeset) {
	return new Aphront404Response();
	}

	$vs_changeset = null;
	if ($vs && ($vs != -1)) {
	$vs_changeset = idx($changesets, $vs);
	if (!$vs_changeset) {
	return new Aphront404Response();
	}
	}

	$view = $request->getStr('view');
	if ($view) {
	$phid = idx($changeset->getMetadata(), "$view:binary-phid");
	if ($phid) {
	return id(new AphrontRedirectResponse())->setURI("/file/info/$phid/");
	}
	switch ($view) {
	case 'new':
	return $this->buildRawFileResponse($changeset, $is_new = true);
	case 'old':
	if ($vs_changeset) {
	return $this->buildRawFileResponse($vs_changeset, $is_new = true);
	}
	return $this->buildRawFileResponse($changeset, $is_new = false);
	default:
	return new Aphront400Response();
	}
	}

	$old = array();
	$new = array();
	if (!$vs) {
	$right = $changeset;
	$left = null;

	$right_source = $right->getID();
	$right_new = true;
	$left_source = $right->getID();
	$left_new = false;

	$render_cache_key = $right->getID();

	$old[] = $changeset;
	$new[] = $changeset;
	} else if ($vs == -1) {
	$right = null;
	$left = $changeset;

	$right_source = $left->getID();
	$right_new = false;
	$left_source = $left->getID();
	$left_new = true;

	$render_cache_key = null;

	$old[] = $changeset;
	$new[] = $changeset;
	} else {
	$right = $changeset;
	$left = $vs_changeset;

	$right_source = $right->getID();
	$right_new = true;
	$left_source = $left->getID();
	$left_new = true;

	$render_cache_key = null;

	$new[] = $left;
	$new[] = $right;
	}

	if ($left) {
	$changeset = $left->newComparisonChangeset($right);
	}

	if ($left_new \|\| $right_new) {
	$diff_map = array();
	if ($left) {
	$diff_map[] = $left->getDiff();
	}
	if ($right) {
	$diff_map[] = $right->getDiff();
	}
	$diff_map = mpull($diff_map, null, 'getPHID');

	$buildables = id(new HarbormasterBuildableQuery())
	->setViewer($viewer)
	->withBuildablePHIDs(array_keys($diff_map))
	->withManualBuildables(false)
	->needBuilds(true)
	->needTargets(true)
	->execute();
	$buildables = mpull($buildables, null, 'getBuildablePHID');
	foreach ($diff_map as $diff_phid => $changeset_diff) {
	$changeset_diff->attachBuildable(idx($buildables, $diff_phid));
	}
	}

	$coverage = null;
	if ($right_new) {
	$coverage = $this->loadCoverage($right);
	}

	$spec = $request->getStr('range');
	list($range_s, $range_e, $mask) =
	DifferentialChangesetParser::parseRangeSpecification($spec);

	$diff = $changeset->getDiff();
	$revision_id = $diff->getRevisionID();

	$can_mark = false;
	$object_owner_phid = null;
	$revision = null;
	if ($revision_id) {
	$revision = id(new DifferentialRevisionQuery())
	->setViewer($viewer)
	->withIDs(array($revision_id))
	->executeOne();
	if ($revision) {
	$can_mark = ($revision->getAuthorPHID() == $viewer->getPHID());
	$object_owner_phid = $revision->getAuthorPHID();
	}
	}

	if ($revision) {
	$container_phid = $revision->getPHID();
	} else {
	$container_phid = $diff->getPHID();
	}

	$viewstate_engine = id(new PhabricatorChangesetViewStateEngine())
	->setViewer($viewer)
	->setObjectPHID($container_phid)
	->setChangeset($changeset);

	$viewstate = $viewstate_engine->newViewStateFromRequest($request);

	if ($viewstate->getDiscardResponse()) {
	return new AphrontAjaxResponse();
	}

	$parser = id(new DifferentialChangesetParser())
	->setViewer($viewer)
	->setViewState($viewstate)
	->setCoverage($coverage)
	->setChangeset($changeset)
	->setRenderingReference($rendering_reference)
	->setRenderCacheKey($render_cache_key)
	->setRightSideCommentMapping($right_source, $right_new)
	->setLeftSideCommentMapping($left_source, $left_new);

	if ($left && $right) {
	$parser->setOriginals($left, $right);
	}

	// Load both left-side and right-side inline comments.
	if ($revision) {
	$query = id(new DifferentialInlineCommentQuery())
	->setViewer($viewer)
	->needHidden(true)
	+ ->withEmptyInlineComments(false)
	->withRevisionPHIDs(array($revision->getPHID()));
	$inlines = $query->execute();
	$inlines = $query->adjustInlinesForChangesets(
	$inlines,
	$old,
	$new,
	$revision);
	} else {
	$inlines = array();
	}

	if ($left_new) {
	$inlines = array_merge(
	$inlines,
	$this->buildLintInlineComments($left));
	}

	if ($right_new) {
	$inlines = array_merge(
	$inlines,
	$this->buildLintInlineComments($right));
	}

	$phids = array();
	foreach ($inlines as $inline) {
	$parser->parseInlineComment($inline);
	if ($inline->getAuthorPHID()) {
	$phids[$inline->getAuthorPHID()] = true;
	}
	}
	$phids = array_keys($phids);

	$handles = $this->loadViewerHandles($phids);
	$parser->setHandles($handles);

	$engine = new PhabricatorMarkupEngine();
	$engine->setViewer($viewer);

	foreach ($inlines as $inline) {
	$engine->addObject(
	$inline,
	PhabricatorInlineComment::MARKUP_FIELD_BODY);
	}

	$engine->process();

	$parser
	->setViewer($viewer)
	->setMarkupEngine($engine)
	->setShowEditAndReplyLinks(true)
	->setCanMarkDone($can_mark)
	->setObjectOwnerPHID($object_owner_phid)
	->setRange($range_s, $range_e)
	->setMask($mask);

	if ($request->isAjax()) {
	// NOTE: We must render the changeset before we render coverage
	// information, since it builds some caches.
	$response = $parser->newChangesetResponse();

	$mcov = $parser->renderModifiedCoverage();

	$coverage_data = array(
	'differential-mcoverage-'.md5($changeset->getFilename()) => $mcov,
	);

	$response->setCoverage($coverage_data);

	return $response;
	}

	$detail = id(new DifferentialChangesetListView())
	->setUser($this->getViewer())
	->setChangesets(array($changeset))
	->setVisibleChangesets(array($changeset))
	->setRenderingReferences(array($rendering_reference))
	->setRenderURI('/differential/changeset/')
	->setDiff($diff)
	->setTitle(pht('Standalone View'))
	->setBackground(PHUIObjectBoxView::BLUE_PROPERTY)
	->setIsStandalone(true)
	->setParser($parser);

	if ($revision_id) {
	$detail->setInlineCommentControllerURI(
	'/differential/comment/inline/edit/'.$revision_id.'/');
	}

	$crumbs = $this->buildApplicationCrumbs();

	if ($revision_id) {
	$crumbs->addTextCrumb('D'.$revision_id, '/D'.$revision_id);
	}

	$diff_id = $diff->getID();
	if ($diff_id) {
	$crumbs->addTextCrumb(
	pht('Diff %d', $diff_id),
	$this->getApplicationURI('diff/'.$diff_id));
	}

	$crumbs->addTextCrumb($changeset->getDisplayFilename());
	$crumbs->setBorder(true);

	$header = id(new PHUIHeaderView())
	->setHeader(pht('Changeset View'))
	->setHeaderIcon('fa-gear');

	$view = id(new PHUITwoColumnView())
	->setHeader($header)
	->setFooter($detail);

	return $this->newPage()
	->setTitle(pht('Changeset View'))
	->setCrumbs($crumbs)
	->appendChild($view);
	}

	private function buildRawFileResponse(
	DifferentialChangeset $changeset,
	$is_new) {

	$viewer = $this->getViewer();

	if ($is_new) {
	$key = 'raw:new:phid';
	} else {
	$key = 'raw:old:phid';
	}

	$metadata = $changeset->getMetadata();

	$file = null;
	$phid = idx($metadata, $key);
	if ($phid) {
	$file = id(new PhabricatorFileQuery())
	->setViewer($viewer)
	->withPHIDs(array($phid))
	->execute();
	if ($file) {
	$file = head($file);
	}
	}

	if (!$file) {
	// This is just building a cache of the changeset content in the file
	// tool, and is safe to run on a read pathway.
	$unguard = AphrontWriteGuard::beginScopedUnguardedWrites();

	if ($is_new) {
	$data = $changeset->makeNewFile();
	} else {
	$data = $changeset->makeOldFile();
	}

	$diff = $changeset->getDiff();

	$file = PhabricatorFile::newFromFileData(
	$data,
	array(
	'name' => $changeset->getFilename(),
	'mime-type' => 'text/plain',
	'ttl.relative' => phutil_units('24 hours in seconds'),
	'viewPolicy' => PhabricatorPolicies::POLICY_NOONE,
	));

	$file->attachToObject($diff->getPHID());

	$metadata[$key] = $file->getPHID();
	$changeset->setMetadata($metadata);
	$changeset->save();

	unset($unguard);
	}

	return $file->getRedirectResponse();
	}

	private function buildLintInlineComments($changeset) {
	$diff = $changeset->getDiff();

	$target_phids = $diff->getBuildTargetPHIDs();
	if (!$target_phids) {
	return array();
	}

	$messages = id(new HarbormasterBuildLintMessage())->loadAllWhere(
	'buildTargetPHID IN (%Ls) AND path = %s',
	$target_phids,
	$changeset->getFilename());

	if (!$messages) {
	return array();
	}

	$change_type = $changeset->getChangeType();
	if (DifferentialChangeType::isDeleteChangeType($change_type)) {
	// If this is a lint message on a deleted file, show it on the left
	// side of the UI because there are no source code lines on the right
	// side of the UI so inlines don't have anywhere to render. See PHI416.
	$is_new = 0;
	} else {
	$is_new = 1;
	}

	$template = id(new DifferentialInlineComment())
	->setChangesetID($changeset->getID())
	->setIsNewFile($is_new)
	->setLineLength(0);

	$inlines = array();
	foreach ($messages as $message) {
	$description = $message->getProperty('description');

	$inlines[] = id(clone $template)
	->setSyntheticAuthor(pht('Lint: %s', $message->getName()))
	->setLineNumber($message->getLine())
	->setContent($description);
	}

	return $inlines;
	}

	private function loadCoverage(DifferentialChangeset $changeset) {
	$viewer = $this->getViewer();

	$target_phids = $changeset->getDiff()->getBuildTargetPHIDs();
	if (!$target_phids) {
	return null;
	}

	$unit = id(new HarbormasterBuildUnitMessageQuery())
	->setViewer($viewer)
	->withBuildTargetPHIDs($target_phids)
	->execute();
	if (!$unit) {
	return null;
	}

	$coverage = array();
	foreach ($unit as $message) {
	$test_coverage = $message->getProperty('coverage');
	if ($test_coverage === null) {
	continue;
	}
	$coverage_data = idx($test_coverage, $changeset->getFileName());
	if (!strlen($coverage_data)) {
	continue;
	}
	$coverage[] = $coverage_data;
	}

	if (!$coverage) {
	return null;
	}

	return ArcanistUnitTestResult::mergeCoverage($coverage);
	}

	}
	diff --git a/src/applications/differential/query/DifferentialInlineCommentQuery.php b/src/applications/differential/query/DifferentialInlineCommentQuery.php
	index 38549cd933..21b2e39d7a 100644
	--- a/src/applications/differential/query/DifferentialInlineCommentQuery.php
	+++ b/src/applications/differential/query/DifferentialInlineCommentQuery.php
	@@ -1,483 +1,498 @@
	<?php

	/**
	* Temporary wrapper for transitioning Differential to ApplicationTransactions.
	*/
	final class DifferentialInlineCommentQuery
	extends PhabricatorOffsetPagedQuery {

	// TODO: Remove this when this query eventually moves to PolicyAware.
	private $viewer;

	private $ids;
	private $phids;
	private $drafts;
	private $authorPHIDs;
	private $revisionPHIDs;
	private $deletedDrafts;
	private $needHidden;
	+ private $withEmpty;

	public function setViewer(PhabricatorUser $viewer) {
	$this->viewer = $viewer;
	return $this;
	}

	public function getViewer() {
	return $this->viewer;
	}

	public function withIDs(array $ids) {
	$this->ids = $ids;
	return $this;
	}

	public function withPHIDs(array $phids) {
	$this->phids = $phids;
	return $this;
	}

	public function withDrafts($drafts) {
	$this->drafts = $drafts;
	return $this;
	}

	public function withAuthorPHIDs(array $author_phids) {
	$this->authorPHIDs = $author_phids;
	return $this;
	}

	public function withRevisionPHIDs(array $revision_phids) {
	$this->revisionPHIDs = $revision_phids;
	return $this;
	}

	public function withDeletedDrafts($deleted_drafts) {
	$this->deletedDrafts = $deleted_drafts;
	return $this;
	}

	public function needHidden($need) {
	$this->needHidden = $need;
	return $this;
	}

	+ public function withEmptyInlineComments($empty) {
	+ $this->withEmpty = $empty;
	+ return $this;
	+ }
	+
	public function execute() {
	$table = new DifferentialTransactionComment();
	$conn_r = $table->establishConnection('r');

	$data = queryfx_all(
	$conn_r,
	'SELECT * FROM %T %Q %Q',
	$table->getTableName(),
	$this->buildWhereClause($conn_r),
	$this->buildLimitClause($conn_r));

	$comments = $table->loadAllFromArray($data);

	+ if ($this->withEmpty !== null) {
	+ $want_empty = (bool)$this->withEmpty;
	+ foreach ($comments as $key => $value) {
	+ if ($value->isEmptyInlineComment() !== $want_empty) {
	+ unset($comments[$key]);
	+ }
	+ }
	+ }
	+
	if ($this->needHidden) {
	$viewer_phid = $this->getViewer()->getPHID();
	if ($viewer_phid && $comments) {
	$hidden = queryfx_all(
	$conn_r,
	'SELECT commentID FROM %T WHERE userPHID = %s
	AND commentID IN (%Ls)',
	id(new DifferentialHiddenComment())->getTableName(),
	$viewer_phid,
	mpull($comments, 'getID'));
	$hidden = array_fuse(ipull($hidden, 'commentID'));
	} else {
	$hidden = array();
	}

	foreach ($comments as $inline) {
	$inline->attachIsHidden(isset($hidden[$inline->getID()]));
	}
	}

	foreach ($comments as $key => $value) {
	$comments[$key] = DifferentialInlineComment::newFromModernComment(
	$value);
	}

	return $comments;
	}

	public function executeOne() {
	// TODO: Remove when this query moves to PolicyAware.
	return head($this->execute());
	}

	protected function buildWhereClause(AphrontDatabaseConnection $conn) {
	$where = array();

	// Only find inline comments.
	$where[] = qsprintf(
	$conn,
	'changesetID IS NOT NULL');

	if ($this->ids !== null) {
	$where[] = qsprintf(
	$conn,
	'id IN (%Ld)',
	$this->ids);
	}

	if ($this->phids !== null) {
	$where[] = qsprintf(
	$conn,
	'phid IN (%Ls)',
	$this->phids);
	}

	if ($this->revisionPHIDs !== null) {
	$where[] = qsprintf(
	$conn,
	'revisionPHID IN (%Ls)',
	$this->revisionPHIDs);
	}

	if ($this->drafts === null) {
	if ($this->deletedDrafts) {
	$where[] = qsprintf(
	$conn,
	'(authorPHID = %s) OR (transactionPHID IS NOT NULL)',
	$this->getViewer()->getPHID());
	} else {
	$where[] = qsprintf(
	$conn,
	'(authorPHID = %s AND isDeleted = 0)
	OR (transactionPHID IS NOT NULL)',
	$this->getViewer()->getPHID());
	}
	} else if ($this->drafts) {
	$where[] = qsprintf(
	$conn,
	'(authorPHID = %s AND isDeleted = 0) AND (transactionPHID IS NULL)',
	$this->getViewer()->getPHID());
	} else {
	$where[] = qsprintf(
	$conn,
	'transactionPHID IS NOT NULL');
	}

	return $this->formatWhereClause($conn, $where);
	}

	public function adjustInlinesForChangesets(
	array $inlines,
	array $old,
	array $new,
	DifferentialRevision $revision) {

	assert_instances_of($inlines, 'DifferentialInlineComment');
	assert_instances_of($old, 'DifferentialChangeset');
	assert_instances_of($new, 'DifferentialChangeset');

	$viewer = $this->getViewer();

	$no_ghosts = $viewer->compareUserSetting(
	PhabricatorOlderInlinesSetting::SETTINGKEY,
	PhabricatorOlderInlinesSetting::VALUE_GHOST_INLINES_DISABLED);
	if ($no_ghosts) {
	return $inlines;
	}

	$all = array_merge($old, $new);

	$changeset_ids = mpull($inlines, 'getChangesetID');
	$changeset_ids = array_unique($changeset_ids);

	$all_map = mpull($all, null, 'getID');

	// We already have at least some changesets, and we might not need to do
	// any more data fetching. Remove everything we already have so we can
	// tell if we need new stuff.
	foreach ($changeset_ids as $key => $id) {
	if (isset($all_map[$id])) {
	unset($changeset_ids[$key]);
	}
	}

	if ($changeset_ids) {
	$changesets = id(new DifferentialChangesetQuery())
	->setViewer($viewer)
	->withIDs($changeset_ids)
	->execute();
	$changesets = mpull($changesets, null, 'getID');
	} else {
	$changesets = array();
	}
	$changesets += $all_map;

	$id_map = array();
	foreach ($all as $changeset) {
	$id_map[$changeset->getID()] = $changeset->getID();
	}

	// Generate filename maps for older and newer comments. If we're bringing
	// an older comment forward in a diff-of-diffs, we want to put it on the
	// left side of the screen, not the right side. Both sides are "new" files
	// with the same name, so they're both appropriate targets, but the left
	// is a better target conceptually for users because it's more consistent
	// with the rest of the UI, which shows old information on the left and
	// new information on the right.
	$move_here = DifferentialChangeType::TYPE_MOVE_HERE;

	$name_map_old = array();
	$name_map_new = array();
	$move_map = array();
	foreach ($all as $changeset) {
	$changeset_id = $changeset->getID();

	$filenames = array();
	$filenames[] = $changeset->getFilename();

	// If this is the target of a move, also map comments on the old filename
	// to this changeset.
	if ($changeset->getChangeType() == $move_here) {
	$old_file = $changeset->getOldFile();
	$filenames[] = $old_file;
	$move_map[$changeset_id][$old_file] = true;
	}

	foreach ($filenames as $filename) {
	// We update the old map only if we don't already have an entry (oldest
	// changeset persists).
	if (empty($name_map_old[$filename])) {
	$name_map_old[$filename] = $changeset_id;
	}

	// We always update the new map (newest changeset overwrites).
	$name_map_new[$changeset->getFilename()] = $changeset_id;
	}
	}

	// Find the smallest "new" changeset ID. We'll consider everything
	// larger than this to be "newer", and everything smaller to be "older".
	$first_new_id = min(mpull($new, 'getID'));

	$results = array();
	foreach ($inlines as $inline) {
	$changeset_id = $inline->getChangesetID();
	if (isset($id_map[$changeset_id])) {
	// This inline is legitimately on one of the current changesets, so
	// we can include it in the result set unmodified.
	$results[] = $inline;
	continue;
	}

	$changeset = idx($changesets, $changeset_id);
	if (!$changeset) {
	// Just discard this inline, as it has bogus data.
	continue;
	}

	$target_id = null;

	if ($changeset_id >= $first_new_id) {
	$name_map = $name_map_new;
	$is_new = true;
	} else {
	$name_map = $name_map_old;
	$is_new = false;
	}

	$filename = $changeset->getFilename();
	if (isset($name_map[$filename])) {
	// This changeset is on a file with the same name as the current
	// changeset, so we're going to port it forward or backward.
	$target_id = $name_map[$filename];

	$is_move = isset($move_map[$target_id][$filename]);
	if ($is_new) {
	if ($is_move) {
	$reason = pht(
	'This comment was made on a file with the same name as the '.
	'file this file was moved from, but in a newer diff.');
	} else {
	$reason = pht(
	'This comment was made on a file with the same name, but '.
	'in a newer diff.');
	}
	} else {
	if ($is_move) {
	$reason = pht(
	'This comment was made on a file with the same name as the '.
	'file this file was moved from, but in an older diff.');
	} else {
	$reason = pht(
	'This comment was made on a file with the same name, but '.
	'in an older diff.');
	}
	}
	}


	// If we didn't find a target and this change is the target of a move,
	// look for a match against the old filename.
	if (!$target_id) {
	if ($changeset->getChangeType() == $move_here) {
	$filename = $changeset->getOldFile();
	if (isset($name_map[$filename])) {
	$target_id = $name_map[$filename];
	if ($is_new) {
	$reason = pht(
	'This comment was made on a file which this file was moved '.
	'to, but in a newer diff.');
	} else {
	$reason = pht(
	'This comment was made on a file which this file was moved '.
	'to, but in an older diff.');
	}
	}
	}
	}


	// If we found a changeset to port this comment to, bring it forward
	// or backward and mark it.
	if ($target_id) {
	$diff_id = $changeset->getDiffID();
	$inline_id = $inline->getID();
	$revision_id = $revision->getID();
	$href = "/D{$revision_id}?id={$diff_id}#inline-{$inline_id}";

	$inline
	->makeEphemeral(true)
	->setChangesetID($target_id)
	->setIsGhost(
	array(
	'new' => $is_new,
	'reason' => $reason,
	'href' => $href,
	'originalID' => $changeset->getID(),
	));

	$results[] = $inline;
	}
	}

	// Filter out the inlines we ported forward which won't be visible because
	// they appear on the wrong side of a file.
	$keep_map = array();
	foreach ($old as $changeset) {
	$keep_map[$changeset->getID()][0] = true;
	}
	foreach ($new as $changeset) {
	$keep_map[$changeset->getID()][1] = true;
	}

	foreach ($results as $key => $inline) {
	$is_new = (int)$inline->getIsNewFile();
	$changeset_id = $inline->getChangesetID();
	if (!isset($keep_map[$changeset_id][$is_new])) {
	unset($results[$key]);
	continue;
	}
	}

	// Adjust inline line numbers to account for content changes across
	// updates and rebases.
	$plan = array();
	$need = array();
	foreach ($results as $inline) {
	$ghost = $inline->getIsGhost();
	if (!$ghost) {
	// If this isn't a "ghost" inline, ignore it.
	continue;
	}

	$src_id = $ghost['originalID'];
	$dst_id = $inline->getChangesetID();

	$xforms = array();

	// If the comment is on the right, transform it through the inverse map
	// back to the left.
	if ($inline->getIsNewFile()) {
	$xforms[] = array($src_id, $src_id, true);
	}

	// Transform it across rebases.
	$xforms[] = array($src_id, $dst_id, false);

	// If the comment is on the right, transform it back onto the right.
	if ($inline->getIsNewFile()) {
	$xforms[] = array($dst_id, $dst_id, false);
	}

	$key = array();
	foreach ($xforms as $xform) {
	list($u, $v, $inverse) = $xform;

	$short = $u.'/'.$v;
	$need[$short] = array($u, $v);

	$part = $u.($inverse ? '<' : '>').$v;
	$key[] = $part;
	}
	$key = implode(',', $key);

	if (empty($plan[$key])) {
	$plan[$key] = array(
	'xforms' => $xforms,
	'inlines' => array(),
	);
	}

	$plan[$key]['inlines'][] = $inline;
	}

	if ($need) {
	$maps = DifferentialLineAdjustmentMap::loadMaps($need);
	} else {
	$maps = array();
	}

	foreach ($plan as $step) {
	$xforms = $step['xforms'];

	$chain = null;
	foreach ($xforms as $xform) {
	list($u, $v, $inverse) = $xform;
	$map = idx(idx($maps, $u, array()), $v);
	if (!$map) {
	continue 2;
	}

	if ($inverse) {
	$map = DifferentialLineAdjustmentMap::newInverseMap($map);
	} else {
	$map = clone $map;
	}

	if ($chain) {
	$chain->addMapToChain($map);
	} else {
	$chain = $map;
	}
	}

	foreach ($step['inlines'] as $inline) {
	$head_line = $inline->getLineNumber();
	$tail_line = ($head_line + $inline->getLineLength());

	$head_info = $chain->mapLine($head_line, false);
	$tail_info = $chain->mapLine($tail_line, true);

	list($head_deleted, $head_offset, $head_line) = $head_info;
	list($tail_deleted, $tail_offset, $tail_line) = $tail_info;

	if ($head_offset !== false) {
	$inline->setLineNumber($head_line + 1 + $head_offset);
	} else {
	$inline->setLineNumber($head_line);
	$inline->setLineLength($tail_line - $head_line);
	}
	}
	}

	return $results;
	}

	}

File Metadata

Mime Type: text/x-diff
Expires: Tue, Dec 2, 12:39 AM (1 d, 1 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 431477
Default Alt Text: (31 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions