No OneTemporary
Actions

Size

63 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/src/applications/differential/controller/DifferentialRevisionViewController.php b/src/applications/differential/controller/DifferentialRevisionViewController.php
	index 6b13e893d5..cd71c62a1e 100644
	--- a/src/applications/differential/controller/DifferentialRevisionViewController.php
	+++ b/src/applications/differential/controller/DifferentialRevisionViewController.php
	@@ -1,1254 +1,1315 @@
	<?php

	final class DifferentialRevisionViewController
	extends DifferentialController {

	private $revisionID;
	private $changesetCount;
	+ private $hiddenChangesets;

	public function shouldAllowPublic() {
	return true;
	}

	public function isLargeDiff() {
	return ($this->getChangesetCount() > $this->getLargeDiffLimit());
	}

	public function isVeryLargeDiff() {
	return ($this->getChangesetCount() > $this->getVeryLargeDiffLimit());
	}

	public function getLargeDiffLimit() {
	return 100;
	}

	public function getVeryLargeDiffLimit() {
	return 1000;
	}

	public function getChangesetCount() {
	if ($this->changesetCount === null) {
	throw new PhutilInvalidStateException('setChangesetCount');
	}
	return $this->changesetCount;
	}

	public function setChangesetCount($count) {
	$this->changesetCount = $count;
	return $this;
	}

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

	$viewer_is_anonymous = !$viewer->isLoggedIn();

	$revision = id(new DifferentialRevisionQuery())
	->withIDs(array($this->revisionID))
	->setViewer($viewer)
	->needReviewers(true)
	->needReviewerAuthority(true)
	->executeOne();
	if (!$revision) {
	return new Aphront404Response();
	}

	$diffs = id(new DifferentialDiffQuery())
	->setViewer($viewer)
	->withRevisionIDs(array($this->revisionID))
	->execute();
	$diffs = array_reverse($diffs, $preserve_keys = true);

	if (!$diffs) {
	throw new Exception(
	pht('This revision has no diffs. Something has gone quite wrong.'));
	}

	$revision->attachActiveDiff(last($diffs));

	$diff_vs = $request->getInt('vs');
	$target_id = $request->getInt('id');
	$target = idx($diffs, $target_id, end($diffs));

	$target_manual = $target;
	if (!$target_id) {
	foreach ($diffs as $diff) {
	if ($diff->getCreationMethod() != 'commit') {
	$target_manual = $diff;
	}
	}
	}

	if (empty($diffs[$diff_vs])) {
	$diff_vs = null;
	}

	$repository = null;
	$repository_phid = $target->getRepositoryPHID();
	if ($repository_phid) {
	if ($repository_phid == $revision->getRepositoryPHID()) {
	$repository = $revision->getRepository();
	} else {
	$repository = id(new PhabricatorRepositoryQuery())
	->setViewer($viewer)
	->withPHIDs(array($repository_phid))
	->executeOne();
	}
	}

	list($changesets, $vs_map, $vs_changesets, $rendering_references) =
	$this->loadChangesetsAndVsMap(
	$target,
	idx($diffs, $diff_vs),
	$repository);

	$this->setChangesetCount(count($rendering_references));

	if ($request->getExists('download')) {
	return $this->buildRawDiffResponse(
	$revision,
	$changesets,
	$vs_changesets,
	$vs_map,
	$repository);
	}

	$map = $vs_map;
	if (!$map) {
	$map = array_fill_keys(array_keys($changesets), 0);
	}

	$old_ids = array();
	$new_ids = array();
	foreach ($map as $id => $vs) {
	if ($vs <= 0) {
	$old_ids[] = $id;
	$new_ids[] = $id;
	} else {
	$new_ids[] = $id;
	$new_ids[] = $vs;
	}
	}

	$this->loadDiffProperties($diffs);
	$props = $target_manual->getDiffProperties();

	$subscriber_phids = PhabricatorSubscribersQuery::loadSubscribersForPHID(
	$revision->getPHID());

	$object_phids = array_merge(
	$revision->getReviewerPHIDs(),
	$subscriber_phids,
	$revision->loadCommitPHIDs(),
	array(
	$revision->getAuthorPHID(),
	$viewer->getPHID(),
	));

	foreach ($revision->getAttached() as $type => $phids) {
	foreach ($phids as $phid => $info) {
	$object_phids[] = $phid;
	}
	}

	$field_list = PhabricatorCustomField::getObjectFields(
	$revision,
	PhabricatorCustomField::ROLE_VIEW);

	$field_list->setViewer($viewer);
	$field_list->readFieldsFromStorage($revision);

	$warning_handle_map = array();
	foreach ($field_list->getFields() as $key => $field) {
	$req = $field->getRequiredHandlePHIDsForRevisionHeaderWarnings();
	foreach ($req as $phid) {
	$warning_handle_map[$key][] = $phid;
	$object_phids[] = $phid;
	}
	}

	$handles = $this->loadViewerHandles($object_phids);
	+ $warnings = array();

	$request_uri = $request->getRequestURI();

	$large = $request->getStr('large');

	$large_warning =
	($this->isLargeDiff()) &&
	(!$this->isVeryLargeDiff()) &&
	(!$large);

	if ($large_warning) {
	$count = $this->getChangesetCount();

	$expand_uri = $request_uri
	->alter('large', 'true')
	->setFragment('toc');

	$message = array(
	pht(
	'This large diff affects %s files. Files without inline '.
	'comments have been collapsed.',
	new PhutilNumber($count)),
	' ',
	phutil_tag(
	'strong',
	array(),
	phutil_tag(
	'a',
	array(
	'href' => $expand_uri,
	),
	pht('Expand All Files'))),
	);

	- $warning = id(new PHUIInfoView())
	+ $warnings[] = id(new PHUIInfoView())
	->setTitle(pht('Large Diff'))
	->setSeverity(PHUIInfoView::SEVERITY_WARNING)
	->appendChild($message);

	+ $folded_changesets = $changesets;
	+ } else {
	+ $folded_changesets = array();
	+ }
	+
	+ // Don't hide or fold changesets which have inline comments.
	+ $hidden_changesets = $this->hiddenChangesets;
	+ if ($hidden_changesets \|\| $folded_changesets) {
	$old = array_select_keys($changesets, $old_ids);
	$new = array_select_keys($changesets, $new_ids);

	$query = id(new DifferentialInlineCommentQuery())
	->setViewer($viewer)
	->needHidden(true)
	->withRevisionPHIDs(array($revision->getPHID()));
	$inlines = $query->execute();
	$inlines = $query->adjustInlinesForChangesets(
	$inlines,
	$old,
	$new,
	$revision);

	- $visible_changesets = array();
	foreach ($inlines as $inline) {
	$changeset_id = $inline->getChangesetID();
	- if (isset($changesets[$changeset_id])) {
	- $visible_changesets[$changeset_id] = $changesets[$changeset_id];
	+ if (!isset($changesets[$changeset_id])) {
	+ continue;
	}
	+
	+ unset($hidden_changesets[$changeset_id]);
	+ unset($folded_changesets[$changeset_id]);
	}
	- } else {
	- $warning = null;
	- $visible_changesets = $changesets;
	+ }
	+
	+ // If we would hide only one changeset, don't hide anything. The notice
	+ // we'd render about it is about the same size as the changeset.
	+ if (count($hidden_changesets) < 2) {
	+ $hidden_changesets = array();
	+ }
	+
	+ // Update the set of hidden changesets, since we may have just un-hidden
	+ // some of them.
	+ if ($hidden_changesets) {
	+ $warnings[] = id(new PHUIInfoView())
	+ ->setTitle(pht('Showing Only Differences'))
	+ ->setSeverity(PHUIInfoView::SEVERITY_NOTICE)
	+ ->appendChild(
	+ pht(
	+ 'This revision modifies %s more files that are hidden because '.
	+ 'they were not modified between selected diffs and they have no '.
	+ 'inline comments.',
	+ phutil_count($hidden_changesets)));
	+ }
	+
	+ // Compute the unfolded changesets. By default, everything is unfolded.
	+ $unfolded_changesets = $changesets;
	+ foreach ($folded_changesets as $changeset_id => $changeset) {
	+ unset($unfolded_changesets[$changeset_id]);
	+ }
	+
	+ // Throw away any hidden changesets.
	+ foreach ($hidden_changesets as $changeset_id => $changeset) {
	+ unset($changesets[$changeset_id]);
	+ unset($unfolded_changesets[$changeset_id]);
	}

	$commit_hashes = mpull($diffs, 'getSourceControlBaseRevision');
	$local_commits = idx($props, 'local:commits', array());
	foreach ($local_commits as $local_commit) {
	$commit_hashes[] = idx($local_commit, 'tree');
	$commit_hashes[] = idx($local_commit, 'local');
	}
	$commit_hashes = array_unique(array_filter($commit_hashes));
	if ($commit_hashes) {
	$commits_for_links = id(new DiffusionCommitQuery())
	->setViewer($viewer)
	->withIdentifiers($commit_hashes)
	->execute();
	$commits_for_links = mpull(
	$commits_for_links,
	null,
	'getCommitIdentifier');
	} else {
	$commits_for_links = array();
	}

	$header = $this->buildHeader($revision);
	$subheader = $this->buildSubheaderView($revision);
	$details = $this->buildDetails($revision, $field_list);
	$curtain = $this->buildCurtain($revision);

	$whitespace = $request->getStr(
	'whitespace',
	DifferentialChangesetParser::WHITESPACE_IGNORE_MOST);

	$repository = $revision->getRepository();
	if ($repository) {
	$symbol_indexes = $this->buildSymbolIndexes(
	$repository,
	- $visible_changesets);
	+ $unfolded_changesets);
	} else {
	$symbol_indexes = array();
	}

	$revision_warnings = $this->buildRevisionWarnings(
	$revision,
	$field_list,
	$warning_handle_map,
	$handles);
	$info_view = null;
	if ($revision_warnings) {
	$info_view = id(new PHUIInfoView())
	->setSeverity(PHUIInfoView::SEVERITY_WARNING)
	->setErrors($revision_warnings);
	}

	$detail_diffs = array_select_keys(
	$diffs,
	array($diff_vs, $target->getID()));
	$detail_diffs = mpull($detail_diffs, null, 'getPHID');

	$this->loadHarbormasterData($detail_diffs);

	$diff_detail_box = $this->buildDiffDetailView(
	$detail_diffs,
	$revision,
	$field_list);

	$unit_box = $this->buildUnitMessagesView(
	$target,
	$revision);

	$timeline = $this->buildTransactions(
	$revision,
	$diff_vs ? $diffs[$diff_vs] : $target,
	$target,
	$old_ids,
	$new_ids);

	$timeline->setQuoteRef($revision->getMonogram());

	if ($this->isVeryLargeDiff()) {
	$messages = array();

	$messages[] = pht(
	'This very large diff affects more than %s files. Use the %s to '.
	'browse changes.',
	new PhutilNumber($this->getVeryLargeDiffLimit()),
	phutil_tag(
	'a',
	array(
	'href' => '/differential/diff/'.$target->getID().'/changesets/',
	),
	phutil_tag('strong', array(), pht('Changeset List'))));

	$changeset_view = id(new PHUIInfoView())
	->setErrors($messages);
	} else {
	$changeset_view = id(new DifferentialChangesetListView())
	->setChangesets($changesets)
	- ->setVisibleChangesets($visible_changesets)
	+ ->setVisibleChangesets($unfolded_changesets)
	->setStandaloneURI('/differential/changeset/')
	->setRawFileURIs(
	'/differential/changeset/?view=old',
	'/differential/changeset/?view=new')
	->setUser($viewer)
	->setDiff($target)
	->setRenderingReferences($rendering_references)
	->setVsMap($vs_map)
	->setWhitespace($whitespace)
	->setSymbolIndexes($symbol_indexes)
	->setTitle(pht('Diff %s', $target->getID()))
	->setBackground(PHUIObjectBoxView::BLUE_PROPERTY);


	$revision_id = $revision->getID();
	$inline_list_uri = "/revision/inlines/{$revision_id}/";
	$inline_list_uri = $this->getApplicationURI($inline_list_uri);
	$changeset_view->setInlineListURI($inline_list_uri);

	if ($repository) {
	$changeset_view->setRepository($repository);
	}

	if (!$viewer_is_anonymous) {
	$changeset_view->setInlineCommentControllerURI(
	'/differential/comment/inline/edit/'.$revision->getID().'/');
	}
	}

	$broken_diffs = $this->loadHistoryDiffStatus($diffs);

	$history = id(new DifferentialRevisionUpdateHistoryView())
	->setUser($viewer)
	->setDiffs($diffs)
	->setDiffUnitStatuses($broken_diffs)
	->setSelectedVersusDiffID($diff_vs)
	->setSelectedDiffID($target->getID())
	->setSelectedWhitespace($whitespace)
	->setCommitsForLinks($commits_for_links);

	$local_table = id(new DifferentialLocalCommitsView())
	->setUser($viewer)
	->setLocalCommits(idx($props, 'local:commits'))
	->setCommitsForLinks($commits_for_links);

	if ($repository && !$this->isVeryLargeDiff()) {
	$other_revisions = $this->loadOtherRevisions(
	$changesets,
	$target,
	$repository);
	} else {
	$other_revisions = array();
	}

	$other_view = null;
	if ($other_revisions) {
	$other_view = $this->renderOtherRevisions($other_revisions);
	}

	if ($this->isVeryLargeDiff()) {
	$toc_view = null;

	// When rendering a "very large" diff, we skip computation of owners
	// that own no files because it is significantly expensive and not very
	// valuable.
	foreach ($revision->getReviewers() as $reviewer) {
	// Give each reviewer a dummy nonempty value so the UI does not render
	// the "(Owns No Changed Paths)" note. If that behavior becomes more
	// sophisticated in the future, this behavior might also need to.
	$reviewer->attachChangesets($changesets);
	}
	} else {
	$this->buildPackageMaps($changesets);

	$toc_view = $this->buildTableOfContents(
	$changesets,
	- $visible_changesets,
	+ $unfolded_changesets,
	$target->loadCoverageMap($viewer));

	// Attach changesets to each reviewer so we can show which Owners package
	// reviewers own no files.
	foreach ($revision->getReviewers() as $reviewer) {
	$reviewer_phid = $reviewer->getReviewerPHID();
	$reviewer_changesets = $this->getPackageChangesets($reviewer_phid);
	$reviewer->attachChangesets($reviewer_changesets);
	}
	}

	$tab_group = id(new PHUITabGroupView());

	if ($toc_view) {
	$tab_group->addTab(
	id(new PHUITabView())
	->setName(pht('Files'))
	->setKey('files')
	->appendChild($toc_view));
	}

	$tab_group
	->addTab(
	id(new PHUITabView())
	->setName(pht('History'))
	->setKey('history')
	->appendChild($history))
	->addTab(
	id(new PHUITabView())
	->setName(pht('Commits'))
	->setKey('commits')
	->appendChild($local_table));

	$stack_graph = id(new DifferentialRevisionGraph())
	->setViewer($viewer)
	->setSeedPHID($revision->getPHID())
	->setLoadEntireGraph(true)
	->loadGraph();
	if (!$stack_graph->isEmpty()) {
	$stack_table = $stack_graph->newGraphTable();

	$parent_type = DifferentialRevisionDependsOnRevisionEdgeType::EDGECONST;
	$reachable = $stack_graph->getReachableObjects($parent_type);

	foreach ($reachable as $key => $reachable_revision) {
	if ($reachable_revision->isClosed()) {
	unset($reachable[$key]);
	}
	}

	if ($reachable) {
	$stack_name = pht('Stack (%s Open)', phutil_count($reachable));
	$stack_color = PHUIListItemView::STATUS_FAIL;
	} else {
	$stack_name = pht('Stack');
	$stack_color = null;
	}

	$tab_group->addTab(
	id(new PHUITabView())
	->setName($stack_name)
	->setKey('stack')
	->setColor($stack_color)
	->appendChild($stack_table));
	}

	if ($other_view) {
	$tab_group->addTab(
	id(new PHUITabView())
	->setName(pht('Similar'))
	->setKey('similar')
	->appendChild($other_view));
	}

	$view_button = id(new PHUIButtonView())
	->setTag('a')
	->setText(pht('Changeset List'))
	->setHref('/differential/diff/'.$target->getID().'/changesets/')
	->setIcon('fa-align-left');

	$tab_header = id(new PHUIHeaderView())
	->setHeader(pht('Revision Contents'))
	->addActionLink($view_button);

	$tab_view = id(new PHUIObjectBoxView())
	->setHeader($tab_header)
	->setBackground(PHUIObjectBoxView::BLUE_PROPERTY)
	->addTabGroup($tab_group);

	$signatures = DifferentialRequiredSignaturesField::loadForRevision(
	$revision);
	$missing_signatures = false;
	foreach ($signatures as $phid => $signed) {
	if (!$signed) {
	$missing_signatures = true;
	}
	}

	$footer = array();
	$signature_message = null;
	if ($missing_signatures) {
	$signature_message = id(new PHUIInfoView())
	->setTitle(pht('Content Hidden'))
	->appendChild(
	pht(
	'The content of this revision is hidden until the author has '.
	'signed all of the required legal agreements.'));
	} else {
	$anchor = id(new PhabricatorAnchorView())
	->setAnchorName('toc')
	->setNavigationMarker(true);

	$footer[] = array(
	$anchor,
	- $warning,
	+ $warnings,
	$tab_view,
	$changeset_view,
	);
	}

	$comment_view = id(new DifferentialRevisionEditEngine())
	->setViewer($viewer)
	->buildEditEngineCommentView($revision);

	$comment_view->setTransactionTimeline($timeline);

	$review_warnings = array();
	foreach ($field_list->getFields() as $field) {
	$review_warnings[] = $field->getWarningsForDetailView();
	}
	$review_warnings = array_mergev($review_warnings);

	if ($review_warnings) {
	$warnings_view = id(new PHUIInfoView())
	->setSeverity(PHUIInfoView::SEVERITY_WARNING)
	->setErrors($review_warnings);

	$comment_view->setInfoView($warnings_view);
	}

	$footer[] = $comment_view;

	$monogram = $revision->getMonogram();
	$operations_box = $this->buildOperationsBox($revision);

	$crumbs = $this->buildApplicationCrumbs();
	$crumbs->addTextCrumb($monogram);
	$crumbs->setBorder(true);

	$filetree_on = $viewer->compareUserSetting(
	PhabricatorShowFiletreeSetting::SETTINGKEY,
	PhabricatorShowFiletreeSetting::VALUE_ENABLE_FILETREE);

	$nav = null;
	if ($filetree_on && !$this->isVeryLargeDiff()) {
	$collapsed_key = PhabricatorFiletreeVisibleSetting::SETTINGKEY;
	$collapsed_value = $viewer->getUserSetting($collapsed_key);

	$width_key = PhabricatorFiletreeWidthSetting::SETTINGKEY;
	$width_value = $viewer->getUserSetting($width_key);

	$nav = id(new DifferentialChangesetFileTreeSideNavBuilder())
	->setTitle($monogram)
	->setBaseURI(new PhutilURI($revision->getURI()))
	->setCollapsed((bool)$collapsed_value)
	->setWidth((int)$width_value)
	->build($changesets);
	}

	Javelin::initBehavior('differential-user-select');

	$view = id(new PHUITwoColumnView())
	->setHeader($header)
	->setSubheader($subheader)
	->setCurtain($curtain)
	->setMainColumn(
	array(
	$operations_box,
	$info_view,
	$details,
	$diff_detail_box,
	$unit_box,
	$timeline,
	$signature_message,
	))
	->setFooter($footer);

	$page = $this->newPage()
	->setTitle($monogram.' '.$revision->getTitle())
	->setCrumbs($crumbs)
	->setPageObjectPHIDs(array($revision->getPHID()))
	->appendChild($view);

	if ($nav) {
	$page->setNavigation($nav);
	}

	return $page;
	}

	private function buildHeader(DifferentialRevision $revision) {
	$view = id(new PHUIHeaderView())
	->setHeader($revision->getTitle($revision))
	->setUser($this->getViewer())
	->setPolicyObject($revision)
	->setHeaderIcon('fa-cog');

	$status_tag = id(new PHUITagView())
	->setName($revision->getStatusDisplayName())
	->setIcon($revision->getStatusIcon())
	->setColor($revision->getStatusTagColor())
	->setType(PHUITagView::TYPE_SHADE);

	$view->addProperty(PHUIHeaderView::PROPERTY_STATUS, $status_tag);

	// If the revision is in a status other than "Draft", but not broadcasting,
	// add an additional "Draft" tag to the header to make it clear that this
	// revision hasn't promoted yet.
	if (!$revision->getShouldBroadcast() && !$revision->isDraft()) {
	$draft_status = DifferentialRevisionStatus::newForStatus(
	DifferentialRevisionStatus::DRAFT);

	$draft_tag = id(new PHUITagView())
	->setName($draft_status->getDisplayName())
	->setIcon($draft_status->getIcon())
	->setColor($draft_status->getTagColor())
	->setType(PHUITagView::TYPE_SHADE);

	$view->addTag($draft_tag);
	}

	return $view;
	}

	private function buildSubheaderView(DifferentialRevision $revision) {
	$viewer = $this->getViewer();

	$author_phid = $revision->getAuthorPHID();

	$author = $viewer->renderHandle($author_phid)->render();
	$date = phabricator_datetime($revision->getDateCreated(), $viewer);
	$author = phutil_tag('strong', array(), $author);

	$handles = $viewer->loadHandles(array($author_phid));
	$image_uri = $handles[$author_phid]->getImageURI();
	$image_href = $handles[$author_phid]->getURI();

	$content = pht('Authored by %s on %s.', $author, $date);

	return id(new PHUIHeadThingView())
	->setImage($image_uri)
	->setImageHref($image_href)
	->setContent($content);
	}

	private function buildDetails(
	DifferentialRevision $revision,
	$custom_fields) {
	$viewer = $this->getViewer();
	$properties = id(new PHUIPropertyListView())
	->setUser($viewer);

	if ($custom_fields) {
	$custom_fields->appendFieldsToPropertyList(
	$revision,
	$viewer,
	$properties);
	}

	$header = id(new PHUIHeaderView())
	->setHeader(pht('Details'));

	return id(new PHUIObjectBoxView())
	->setHeader($header)
	->setBackground(PHUIObjectBoxView::BLUE_PROPERTY)
	->appendChild($properties);
	}

	private function buildCurtain(DifferentialRevision $revision) {
	$viewer = $this->getViewer();
	$revision_id = $revision->getID();
	$revision_phid = $revision->getPHID();
	$curtain = $this->newCurtainView($revision);

	$can_edit = PhabricatorPolicyFilter::hasCapability(
	$viewer,
	$revision,
	PhabricatorPolicyCapability::CAN_EDIT);

	$curtain->addAction(
	id(new PhabricatorActionView())
	->setIcon('fa-pencil')
	->setHref("/differential/revision/edit/{$revision_id}/")
	->setName(pht('Edit Revision'))
	->setDisabled(!$can_edit)
	->setWorkflow(!$can_edit));

	$curtain->addAction(
	id(new PhabricatorActionView())
	->setIcon('fa-upload')
	->setHref("/differential/revision/update/{$revision_id}/")
	->setName(pht('Update Diff'))
	->setDisabled(!$can_edit)
	->setWorkflow(!$can_edit));

	$request_uri = $this->getRequest()->getRequestURI();
	$curtain->addAction(
	id(new PhabricatorActionView())
	->setIcon('fa-download')
	->setName(pht('Download Raw Diff'))
	->setHref($request_uri->alter('download', 'true')));

	$relationship_list = PhabricatorObjectRelationshipList::newForObject(
	$viewer,
	$revision);

	$revision_actions = array(
	DifferentialRevisionHasParentRelationship::RELATIONSHIPKEY,
	DifferentialRevisionHasChildRelationship::RELATIONSHIPKEY,
	);

	$revision_submenu = $relationship_list->newActionSubmenu($revision_actions)
	->setName(pht('Edit Related Revisions...'))
	->setIcon('fa-cog');

	$curtain->addAction($revision_submenu);

	$relationship_submenu = $relationship_list->newActionMenu();
	if ($relationship_submenu) {
	$curtain->addAction($relationship_submenu);
	}

	$repository = $revision->getRepository();
	if ($repository && $repository->canPerformAutomation()) {
	$revision_id = $revision->getID();

	$op = new DrydockLandRepositoryOperation();
	$barrier = $op->getBarrierToLanding($viewer, $revision);

	if ($barrier) {
	$can_land = false;
	} else {
	$can_land = true;
	}

	$action = id(new PhabricatorActionView())
	->setName(pht('Land Revision'))
	->setIcon('fa-fighter-jet')
	->setHref("/differential/revision/operation/{$revision_id}/")
	->setWorkflow(true)
	->setDisabled(!$can_land);

	$curtain->addAction($action);
	}

	return $curtain;
	}

	private function loadHistoryDiffStatus(array $diffs) {
	assert_instances_of($diffs, 'DifferentialDiff');

	$diff_phids = mpull($diffs, 'getPHID');
	$bad_unit_status = array(
	ArcanistUnitTestResult::RESULT_FAIL,
	ArcanistUnitTestResult::RESULT_BROKEN,
	);

	$message = new HarbormasterBuildUnitMessage();
	$target = new HarbormasterBuildTarget();
	$build = new HarbormasterBuild();
	$buildable = new HarbormasterBuildable();

	$broken_diffs = queryfx_all(
	$message->establishConnection('r'),
	'SELECT distinct a.buildablePHID
	FROM %T m
	JOIN %T t ON m.buildTargetPHID = t.phid
	JOIN %T b ON t.buildPHID = b.phid
	JOIN %T a ON b.buildablePHID = a.phid
	WHERE a.buildablePHID IN (%Ls)
	AND m.result in (%Ls)',
	$message->getTableName(),
	$target->getTableName(),
	$build->getTableName(),
	$buildable->getTableName(),
	$diff_phids,
	$bad_unit_status);

	$unit_status = array();
	foreach ($broken_diffs as $broken) {
	$phid = $broken['buildablePHID'];
	$unit_status[$phid] = DifferentialUnitStatus::UNIT_FAIL;
	}

	return $unit_status;
	}

	private function loadChangesetsAndVsMap(
	DifferentialDiff $target,
	DifferentialDiff $diff_vs = null,
	PhabricatorRepository $repository = null) {
	+ $viewer = $this->getViewer();

	$load_diffs = array($target);
	if ($diff_vs) {
	$load_diffs[] = $diff_vs;
	}

	$raw_changesets = id(new DifferentialChangesetQuery())
	- ->setViewer($this->getRequest()->getUser())
	+ ->setViewer($viewer)
	->withDiffs($load_diffs)
	->execute();
	$changeset_groups = mgroup($raw_changesets, 'getDiffID');

	$changesets = idx($changeset_groups, $target->getID(), array());
	$changesets = mpull($changesets, null, 'getID');

	- $refs = array();
	- $vs_map = array();
	+ $refs = array();
	+ $vs_map = array();
	$vs_changesets = array();
	+ $must_compare = array();
	if ($diff_vs) {
	- $vs_id = $diff_vs->getID();
	+ $vs_id = $diff_vs->getID();
	$vs_changesets_path_map = array();
	foreach (idx($changeset_groups, $vs_id, array()) as $changeset) {
	$path = $changeset->getAbsoluteRepositoryPath($repository, $diff_vs);
	$vs_changesets_path_map[$path] = $changeset;
	$vs_changesets[$changeset->getID()] = $changeset;
	}
	+
	foreach ($changesets as $key => $changeset) {
	$path = $changeset->getAbsoluteRepositoryPath($repository, $target);
	if (isset($vs_changesets_path_map[$path])) {
	$vs_map[$changeset->getID()] =
	$vs_changesets_path_map[$path]->getID();
	$refs[$changeset->getID()] =
	$changeset->getID().'/'.$vs_changesets_path_map[$path]->getID();
	unset($vs_changesets_path_map[$path]);
	+
	+ $must_compare[] = $changeset->getID();
	+
	} else {
	$refs[$changeset->getID()] = $changeset->getID();
	}
	}
	+
	foreach ($vs_changesets_path_map as $path => $changeset) {
	$changesets[$changeset->getID()] = $changeset;
	- $vs_map[$changeset->getID()] = -1;
	- $refs[$changeset->getID()] = $changeset->getID().'/-1';
	+ $vs_map[$changeset->getID()] = -1;
	+ $refs[$changeset->getID()] = $changeset->getID().'/-1';
	}
	+
	} else {
	foreach ($changesets as $changeset) {
	$refs[$changeset->getID()] = $changeset->getID();
	}
	}

	$changesets = msort($changesets, 'getSortKey');

	+ // See T13137. When displaying the diff between two updates, hide any
	+ // changesets which haven't actually changed.
	+ $this->hiddenChangesets = array();
	+ foreach ($must_compare as $changeset_id) {
	+ $changeset = $changesets[$changeset_id];
	+ $vs_changeset = $vs_changesets[$vs_map[$changeset_id]];
	+
	+ if ($changeset->hasSameEffectAs($vs_changeset)) {
	+ $this->hiddenChangesets[$changeset_id] = $changesets[$changeset_id];
	+ }
	+ }
	+
	return array($changesets, $vs_map, $vs_changesets, $refs);
	}

	private function buildSymbolIndexes(
	PhabricatorRepository $repository,
	- array $visible_changesets) {
	- assert_instances_of($visible_changesets, 'DifferentialChangeset');
	+ array $unfolded_changesets) {
	+ assert_instances_of($unfolded_changesets, 'DifferentialChangeset');

	$engine = PhabricatorSyntaxHighlighter::newEngine();

	$langs = $repository->getSymbolLanguages();
	$langs = nonempty($langs, array());

	$sources = $repository->getSymbolSources();
	$sources = nonempty($sources, array());

	$symbol_indexes = array();

	if ($langs && $sources) {
	$have_symbols = id(new DiffusionSymbolQuery())
	->existsSymbolsInRepository($repository->getPHID());
	if (!$have_symbols) {
	return $symbol_indexes;
	}
	}

	$repository_phids = array_merge(
	array($repository->getPHID()),
	$sources);

	$indexed_langs = array_fill_keys($langs, true);
	- foreach ($visible_changesets as $key => $changeset) {
	+ foreach ($unfolded_changesets as $key => $changeset) {
	$lang = $engine->getLanguageFromFilename($changeset->getFilename());
	if (empty($indexed_langs) \|\| isset($indexed_langs[$lang])) {
	$symbol_indexes[$key] = array(
	'lang' => $lang,
	'repositories' => $repository_phids,
	);
	}
	}

	return $symbol_indexes;
	}

	private function loadOtherRevisions(
	array $changesets,
	DifferentialDiff $target,
	PhabricatorRepository $repository) {
	assert_instances_of($changesets, 'DifferentialChangeset');

	$paths = array();
	foreach ($changesets as $changeset) {
	$paths[] = $changeset->getAbsoluteRepositoryPath(
	$repository,
	$target);
	}

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

	$path_map = id(new DiffusionPathIDQuery($paths))->loadPathIDs();

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

	$recent = (PhabricatorTime::getNow() - phutil_units('30 days in seconds'));

	$query = id(new DifferentialRevisionQuery())
	->setViewer($this->getRequest()->getUser())
	->withIsOpen(true)
	->withUpdatedEpochBetween($recent, null)
	->setOrder(DifferentialRevisionQuery::ORDER_MODIFIED)
	->setLimit(10)
	->needFlags(true)
	->needDrafts(true)
	->needReviewers(true);

	foreach ($path_map as $path => $path_id) {
	$query->withPath($repository->getID(), $path_id);
	}

	$results = $query->execute();

	// Strip out this revision.
	foreach ($results as $key => $result) {
	if ($result->getID() == $this->revisionID) {
	unset($results[$key]);
	}
	}

	return $results;
	}

	private function renderOtherRevisions(array $revisions) {
	assert_instances_of($revisions, 'DifferentialRevision');
	$viewer = $this->getViewer();

	$header = id(new PHUIHeaderView())
	->setHeader(pht('Recent Similar Revisions'));

	return id(new DifferentialRevisionListView())
	->setViewer($viewer)
	->setRevisions($revisions)
	->setBackground(PHUIObjectBoxView::BLUE_PROPERTY)
	->setNoBox(true);
	}


	/**
	* Note this code is somewhat similar to the buildPatch method in
	* @{class:DifferentialReviewRequestMail}.
	*
	* @return @{class:AphrontRedirectResponse}
	*/
	private function buildRawDiffResponse(
	DifferentialRevision $revision,
	array $changesets,
	array $vs_changesets,
	array $vs_map,
	PhabricatorRepository $repository = null) {

	assert_instances_of($changesets, 'DifferentialChangeset');
	assert_instances_of($vs_changesets, 'DifferentialChangeset');

	$viewer = $this->getViewer();

	id(new DifferentialHunkQuery())
	->setViewer($viewer)
	->withChangesets($changesets)
	->needAttachToChangesets(true)
	->execute();

	$diff = new DifferentialDiff();
	$diff->attachChangesets($changesets);
	$raw_changes = $diff->buildChangesList();
	$changes = array();
	foreach ($raw_changes as $changedict) {
	$changes[] = ArcanistDiffChange::newFromDictionary($changedict);
	}

	$loader = id(new PhabricatorFileBundleLoader())
	->setViewer($viewer);

	$bundle = ArcanistBundle::newFromChanges($changes);
	$bundle->setLoadFileDataCallback(array($loader, 'loadFileData'));

	$vcs = $repository ? $repository->getVersionControlSystem() : null;
	switch ($vcs) {
	case PhabricatorRepositoryType::REPOSITORY_TYPE_GIT:
	case PhabricatorRepositoryType::REPOSITORY_TYPE_MERCURIAL:
	$raw_diff = $bundle->toGitPatch();
	break;
	case PhabricatorRepositoryType::REPOSITORY_TYPE_SVN:
	default:
	$raw_diff = $bundle->toUnifiedDiff();
	break;
	}

	$request_uri = $this->getRequest()->getRequestURI();

	// this ends up being something like
	// D123.diff
	// or the verbose
	// D123.vs123.id123.whitespaceignore-all.diff
	// lame but nice to include these options
	$file_name = ltrim($request_uri->getPath(), '/').'.';
	foreach ($request_uri->getQueryParams() as $key => $value) {
	if ($key == 'download') {
	continue;
	}
	$file_name .= $key.$value.'.';
	}
	$file_name .= 'diff';

	$unguarded = AphrontWriteGuard::beginScopedUnguardedWrites();
	$file = PhabricatorFile::newFromFileData(
	$raw_diff,
	array(
	'name' => $file_name,
	'ttl.relative' => phutil_units('24 hours in seconds'),
	'viewPolicy' => PhabricatorPolicies::POLICY_NOONE,
	));

	$file->attachToObject($revision->getPHID());
	unset($unguarded);

	return $file->getRedirectResponse();
	}

	private function buildTransactions(
	DifferentialRevision $revision,
	DifferentialDiff $left_diff,
	DifferentialDiff $right_diff,
	array $old_ids,
	array $new_ids) {

	$timeline = $this->buildTransactionTimeline(
	$revision,
	new DifferentialTransactionQuery(),
	$engine = null,
	array(
	'left' => $left_diff->getID(),
	'right' => $right_diff->getID(),
	'old' => implode(',', $old_ids),
	'new' => implode(',', $new_ids),
	));

	return $timeline;
	}

	private function buildRevisionWarnings(
	DifferentialRevision $revision,
	PhabricatorCustomFieldList $field_list,
	array $warning_handle_map,
	array $handles) {

	$warnings = array();
	foreach ($field_list->getFields() as $key => $field) {
	$phids = idx($warning_handle_map, $key, array());
	$field_handles = array_select_keys($handles, $phids);
	$field_warnings = $field->getWarningsForRevisionHeader($field_handles);
	foreach ($field_warnings as $warning) {
	$warnings[] = $warning;
	}
	}

	return $warnings;
	}

	private function buildDiffDetailView(
	array $diffs,
	DifferentialRevision $revision,
	PhabricatorCustomFieldList $field_list) {
	$viewer = $this->getViewer();

	$fields = array();
	foreach ($field_list->getFields() as $field) {
	if ($field->shouldAppearInDiffPropertyView()) {
	$fields[] = $field;
	}
	}

	if (!$fields) {
	return null;
	}

	$property_lists = array();
	foreach ($this->getDiffTabLabels($diffs) as $tab) {
	list($label, $diff) = $tab;

	$property_lists[] = array(
	$label,
	$this->buildDiffPropertyList($diff, $revision, $fields),
	);
	}

	$tab_group = id(new PHUITabGroupView())
	->setHideSingleTab(true);

	foreach ($property_lists as $key => $property_list) {
	list($tab_name, $list_view) = $property_list;

	$tab = id(new PHUITabView())
	->setKey($key)
	->setName($tab_name)
	->appendChild($list_view);

	$tab_group->addTab($tab);
	$tab_group->selectTab($key);
	}

	return id(new PHUIObjectBoxView())
	->setHeaderText(pht('Diff Detail'))
	->setBackground(PHUIObjectBoxView::BLUE_PROPERTY)
	->setUser($viewer)
	->addTabGroup($tab_group);
	}

	private function buildDiffPropertyList(
	DifferentialDiff $diff,
	DifferentialRevision $revision,
	array $fields) {
	$viewer = $this->getViewer();

	$view = id(new PHUIPropertyListView())
	->setUser($viewer)
	->setObject($diff);

	foreach ($fields as $field) {
	$label = $field->renderDiffPropertyViewLabel($diff);
	$value = $field->renderDiffPropertyViewValue($diff);
	if ($value !== null) {
	$view->addProperty($label, $value);
	}
	}

	return $view;
	}

	private function buildOperationsBox(DifferentialRevision $revision) {
	$viewer = $this->getViewer();

	// Save a query if we can't possibly have pending operations.
	$repository = $revision->getRepository();
	if (!$repository \|\| !$repository->canPerformAutomation()) {
	return null;
	}

	$operations = id(new DrydockRepositoryOperationQuery())
	->setViewer($viewer)
	->withObjectPHIDs(array($revision->getPHID()))
	->withIsDismissed(false)
	->withOperationTypes(
	array(
	DrydockLandRepositoryOperation::OPCONST,
	))
	->execute();
	if (!$operations) {
	return null;
	}

	$state_fail = DrydockRepositoryOperation::STATE_FAIL;

	// We're going to show the oldest operation which hasn't failed, or the
	// most recent failure if they're all failures.
	$operations = msort($operations, 'getID');
	foreach ($operations as $operation) {
	if ($operation->getOperationState() != $state_fail) {
	break;
	}
	}

	// If we found a completed operation, don't render anything. We don't want
	// to show an older error after the thing worked properly.
	if ($operation->isDone()) {
	return null;
	}

	$box_view = id(new PHUIObjectBoxView())
	->setHeaderText(pht('Active Operations'))
	->setBackground(PHUIObjectBoxView::BLUE_PROPERTY);

	return id(new DrydockRepositoryOperationStatusView())
	->setUser($viewer)
	->setBoxView($box_view)
	->setOperation($operation);
	}

	private function buildUnitMessagesView(
	$diff,
	DifferentialRevision $revision) {
	$viewer = $this->getViewer();

	if (!$diff->getBuildable()) {
	return null;
	}

	if (!$diff->getUnitMessages()) {
	return null;
	}

	$interesting_messages = array();
	foreach ($diff->getUnitMessages() as $message) {
	switch ($message->getResult()) {
	case ArcanistUnitTestResult::RESULT_PASS:
	case ArcanistUnitTestResult::RESULT_SKIP:
	break;
	default:
	$interesting_messages[] = $message;
	break;
	}
	}

	if (!$interesting_messages) {
	return null;
	}

	$excuse = null;
	if ($diff->hasDiffProperty('arc:unit-excuse')) {
	$excuse = $diff->getProperty('arc:unit-excuse');
	}

	return id(new HarbormasterUnitSummaryView())
	->setUser($viewer)
	->setExcuse($excuse)
	->setBuildable($diff->getBuildable())
	->setUnitMessages($diff->getUnitMessages())
	->setLimit(5)
	->setShowViewAll(true);
	}

	}
	diff --git a/src/applications/differential/engine/DifferentialChangesetEngine.php b/src/applications/differential/engine/DifferentialChangesetEngine.php
	index ccb4381e43..e8a55a1b0e 100644
	--- a/src/applications/differential/engine/DifferentialChangesetEngine.php
	+++ b/src/applications/differential/engine/DifferentialChangesetEngine.php
	@@ -1,223 +1,248 @@
	<?php

	final class DifferentialChangesetEngine extends Phobject {

	public function rebuildChangesets(array $changesets) {
	assert_instances_of($changesets, 'DifferentialChangeset');

	foreach ($changesets as $changeset) {
	$this->detectGeneratedCode($changeset);
	+ $this->computeHashes($changeset);
	}

	$this->detectCopiedCode($changesets);
	}


	/* -( Generated Code )----------------------------------------------------- */


	private function detectGeneratedCode(DifferentialChangeset $changeset) {
	$is_generated_trusted = $this->isTrustedGeneratedCode($changeset);
	if ($is_generated_trusted) {
	$changeset->setTrustedChangesetAttribute(
	DifferentialChangeset::ATTRIBUTE_GENERATED,
	$is_generated_trusted);
	}

	$is_generated_untrusted = $this->isUntrustedGeneratedCode($changeset);
	if ($is_generated_untrusted) {
	$changeset->setUntrustedChangesetAttribute(
	DifferentialChangeset::ATTRIBUTE_GENERATED,
	$is_generated_untrusted);
	}
	}

	private function isTrustedGeneratedCode(DifferentialChangeset $changeset) {

	$filename = $changeset->getFilename();

	$paths = PhabricatorEnv::getEnvConfig('differential.generated-paths');
	foreach ($paths as $regexp) {
	if (preg_match($regexp, $filename)) {
	return true;
	}
	}

	return false;
	}

	private function isUntrustedGeneratedCode(DifferentialChangeset $changeset) {

	if ($changeset->getHunks()) {
	$new_data = $changeset->makeNewFile();
	if (strpos($new_data, '@'.'generated') !== false) {
	return true;
	}
	}

	return false;
	}


	+/* -( Content Hashes )----------------------------------------------------- */
	+
	+
	+ private function computeHashes(DifferentialChangeset $changeset) {
	+
	+ $effect_key = DifferentialChangeset::METADATA_EFFECT_HASH;
	+
	+ $effect_hash = $this->newEffectHash($changeset);
	+ if ($effect_hash !== null) {
	+ $changeset->setChangesetMetadata($effect_key, $effect_hash);
	+ }
	+ }
	+
	+ private function newEffectHash(DifferentialChangeset $changeset) {
	+
	+ if ($changeset->getHunks()) {
	+ $new_data = $changeset->makeNewFile();
	+ return PhabricatorHash::digestForIndex($new_data);
	+ }
	+
	+ return null;
	+ }
	+
	+
	/* -( Copied Code )-------------------------------------------------------- */


	private function detectCopiedCode(array $changesets) {
	$min_width = 30;
	$min_lines = 3;

	$map = array();
	$files = array();
	$types = array();
	foreach ($changesets as $changeset) {
	$file = $changeset->getFilename();
	foreach ($changeset->getHunks() as $hunk) {
	$lines = $hunk->getStructuredOldFile();
	foreach ($lines as $line => $info) {
	$type = $info['type'];
	if ($type == '\\') {
	continue;
	}
	$types[$file][$line] = $type;

	$text = $info['text'];
	$text = trim($text);
	$files[$file][$line] = $text;

	if (strlen($text) >= $min_width) {
	$map[$text][] = array($file, $line);
	}
	}
	}
	}

	foreach ($changesets as $changeset) {
	$copies = array();
	foreach ($changeset->getHunks() as $hunk) {
	$added = $hunk->getStructuredNewFile();
	$atype = array();

	foreach ($added as $line => $info) {
	$atype[$line] = $info['type'];
	$added[$line] = trim($info['text']);
	}

	$skip_lines = 0;
	foreach ($added as $line => $code) {
	if ($skip_lines) {
	// We're skipping lines that we already processed because we
	// extended a block above them downward to include them.
	$skip_lines--;
	continue;
	}

	if ($atype[$line] !== '+') {
	// This line hasn't been changed in the new file, so don't try
	// to figure out where it came from.
	continue;
	}

	if (empty($map[$code])) {
	// This line was too short to trigger copy/move detection.
	continue;
	}

	if (count($map[$code]) > 16) {
	// If there are a large number of identical lines in this diff,
	// don't try to figure out where this block came from: the analysis
	// is O(N^2), since we need to compare every line against every
	// other line. Even if we arrive at a result, it is unlikely to be
	// meaningful. See T5041.
	continue;
	}

	$best_length = 0;

	// Explore all candidates.
	foreach ($map[$code] as $val) {
	list($file, $orig_line) = $val;
	$length = 1;

	// Search backward and forward to find all of the adjacent lines
	// which match.
	foreach (array(-1, 1) as $direction) {
	$offset = $direction;
	while (true) {
	if (isset($copies[$line + $offset])) {
	// If we run into a block above us which we've already
	// attributed to a move or copy from elsewhere, stop
	// looking.
	break;
	}

	if (!isset($added[$line + $offset])) {
	// If we've run off the beginning or end of the new file,
	// stop looking.
	break;
	}

	if (!isset($files[$file][$orig_line + $offset])) {
	// If we've run off the beginning or end of the original
	// file, we also stop looking.
	break;
	}

	$old = $files[$file][$orig_line + $offset];
	$new = $added[$line + $offset];
	if ($old !== $new) {
	// If the old line doesn't match the new line, stop
	// looking.
	break;
	}

	$length++;
	$offset += $direction;
	}
	}

	if ($length < $best_length) {
	// If we already know of a better source (more matching lines)
	// for this move/copy, stick with that one. We prefer long
	// copies/moves which match a lot of context over short ones.
	continue;
	}

	if ($length == $best_length) {
	if (idx($types[$file], $orig_line) != '-') {
	// If we already know of an equally good source (same number
	// of matching lines) and this isn't a move, stick with the
	// other one. We prefer moves over copies.
	continue;
	}
	}

	$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));
	}

	$skip_lines = $best_offset;
	}
	}

	$copies = array_filter($copies);
	if ($copies) {
	$metadata = $changeset->getMetadata();
	$metadata['copy:lines'] = $copies;
	$changeset->setMetadata($metadata);
	}
	}

	}

	}
	diff --git a/src/applications/differential/management/PhabricatorDifferentialRebuildChangesetsWorkflow.php b/src/applications/differential/management/PhabricatorDifferentialRebuildChangesetsWorkflow.php
	index 29b116fc3c..068771284b 100644
	--- a/src/applications/differential/management/PhabricatorDifferentialRebuildChangesetsWorkflow.php
	+++ b/src/applications/differential/management/PhabricatorDifferentialRebuildChangesetsWorkflow.php
	@@ -1,92 +1,96 @@
	<?php

	final class PhabricatorDifferentialRebuildChangesetsWorkflow
	extends PhabricatorDifferentialManagementWorkflow {

	protected function didConstruct() {
	$this
	->setName('rebuild-changesets')
	->setExamples('rebuild-changesets --revision __revision__')
	->setSynopsis(pht('Rebuild changesets for a revision.'))
	->setArguments(
	array(
	array(
	'name' => 'revision',
	'param' => 'revision',
	'help' => pht('Revision to rebuild changesets for.'),
	),
	));
	}

	public function execute(PhutilArgumentParser $args) {
	$viewer = $this->getViewer();

	$revision_identifier = $args->getArg('revision');
	if (!$revision_identifier) {
	throw new PhutilArgumentUsageException(
	pht('Specify a revision to rebuild changesets for with "--revision".'));
	}

	$revision = id(new PhabricatorObjectQuery())
	->setViewer($viewer)
	->withNames(array($revision_identifier))
	->executeOne();
	if ($revision) {
	if (!($revision instanceof DifferentialRevision)) {
	throw new PhutilArgumentUsageException(
	pht(
	'Object "%s" specified by "--revision" must be a Differential '.
	'revision.'));
	}
	} else {
	$revision = id(new DifferentialRevisionQuery())
	->setViewer($viewer)
	->withIDs(array($revision_identifier))
	->executeOne();
	}

	if (!$revision) {
	throw new PhutilArgumentUsageException(
	pht(
	'No revision "%s" exists.',
	$revision_identifier));
	}

	$diffs = id(new DifferentialDiffQuery())
	->setViewer($viewer)
	->withRevisionIDs(array($revision->getID()))
	->execute();

	$changesets = id(new DifferentialChangesetQuery())
	->setViewer($viewer)
	->withDiffs($diffs)
	->needHunks(true)
	->execute();

	$changeset_groups = mgroup($changesets, 'getDiffID');

	foreach ($changeset_groups as $diff_id => $changesets) {
	echo tsprintf(
	"%s\n",
	pht(
	'Rebuilding %s changeset(s) for diff ID %d.',
	phutil_count($changesets),
	$diff_id));

	foreach ($changesets as $changeset) {
	echo tsprintf(
	" %s\n",
	$changeset->getFilename());
	}

	id(new DifferentialChangesetEngine())
	->rebuildChangesets($changesets);

	+ foreach ($changesets as $changeset) {
	+ $changeset->save();
	+ }
	+
	echo tsprintf(
	"%s\n",
	pht('Done.'));
	}
	}


	}
	diff --git a/src/applications/differential/storage/DifferentialChangeset.php b/src/applications/differential/storage/DifferentialChangeset.php
	index 27d3ad4d64..00af84bc4e 100644
	--- a/src/applications/differential/storage/DifferentialChangeset.php
	+++ b/src/applications/differential/storage/DifferentialChangeset.php
	@@ -1,397 +1,440 @@
	<?php

	final class DifferentialChangeset
	extends DifferentialDAO
	implements
	PhabricatorPolicyInterface,
	PhabricatorDestructibleInterface {

	protected $diffID;
	protected $oldFile;
	protected $filename;
	protected $awayPaths;
	protected $changeType;
	protected $fileType;
	protected $metadata = array();
	protected $oldProperties;
	protected $newProperties;
	protected $addLines;
	protected $delLines;

	private $unsavedHunks = array();
	private $hunks = self::ATTACHABLE;
	private $diff = self::ATTACHABLE;

	const TABLE_CACHE = 'differential_changeset_parse_cache';

	const METADATA_TRUSTED_ATTRIBUTES = 'attributes.trusted';
	const METADATA_UNTRUSTED_ATTRIBUTES = 'attributes.untrusted';
	+ const METADATA_EFFECT_HASH = 'hash.effect';

	const ATTRIBUTE_GENERATED = 'generated';

	protected function getConfiguration() {
	return array(
	self::CONFIG_SERIALIZATION => array(
	'metadata' => self::SERIALIZATION_JSON,
	'oldProperties' => self::SERIALIZATION_JSON,
	'newProperties' => self::SERIALIZATION_JSON,
	'awayPaths' => self::SERIALIZATION_JSON,
	),
	self::CONFIG_COLUMN_SCHEMA => array(
	'oldFile' => 'bytes?',
	'filename' => 'bytes',
	'changeType' => 'uint32',
	'fileType' => 'uint32',
	'addLines' => 'uint32',
	'delLines' => 'uint32',

	// T6203/NULLABILITY
	// These should all be non-nullable, and store reasonable default
	// JSON values if empty.
	'awayPaths' => 'text?',
	'metadata' => 'text?',
	'oldProperties' => 'text?',
	'newProperties' => 'text?',
	),
	self::CONFIG_KEY_SCHEMA => array(
	'diffID' => array(
	'columns' => array('diffID'),
	),
	),
	) + parent::getConfiguration();
	}

	public function getAffectedLineCount() {
	return $this->getAddLines() + $this->getDelLines();
	}

	public function attachHunks(array $hunks) {
	assert_instances_of($hunks, 'DifferentialHunk');
	$this->hunks = $hunks;
	return $this;
	}

	public function getHunks() {
	return $this->assertAttached($this->hunks);
	}

	public function getDisplayFilename() {
	$name = $this->getFilename();
	if ($this->getFileType() == DifferentialChangeType::FILE_DIRECTORY) {
	$name .= '/';
	}
	return $name;
	}

	public function getOwnersFilename() {
	// TODO: For Subversion, we should adjust these paths to be relative to
	// the repository root where possible.

	$path = $this->getFilename();

	if (!isset($path[0])) {
	return '/';
	}

	if ($path[0] != '/') {
	$path = '/'.$path;
	}

	return $path;
	}

	public function addUnsavedHunk(DifferentialHunk $hunk) {
	if ($this->hunks === self::ATTACHABLE) {
	$this->hunks = array();
	}
	$this->hunks[] = $hunk;
	$this->unsavedHunks[] = $hunk;
	return $this;
	}

	public function save() {
	$this->openTransaction();
	$ret = parent::save();
	foreach ($this->unsavedHunks as $hunk) {
	$hunk->setChangesetID($this->getID());
	$hunk->save();
	}
	$this->saveTransaction();
	return $ret;
	}

	public function delete() {
	$this->openTransaction();

	$hunks = id(new DifferentialHunk())->loadAllWhere(
	'changesetID = %d',
	$this->getID());
	foreach ($hunks as $hunk) {
	$hunk->delete();
	}

	$this->unsavedHunks = array();

	queryfx(
	$this->establishConnection('w'),
	'DELETE FROM %T WHERE id = %d',
	self::TABLE_CACHE,
	$this->getID());

	$ret = parent::delete();
	$this->saveTransaction();
	return $ret;
	}

	+ /**
	+ * Test if this changeset and some other changeset put the affected file in
	+ * the same state.
	+ *
	+ * @param DifferentialChangeset Changeset to compare against.
	+ * @return bool True if the two changesets have the same effect.
	+ */
	+ public function hasSameEffectAs(DifferentialChangeset $other) {
	+ if ($this->getFilename() !== $other->getFilename()) {
	+ return false;
	+ }
	+
	+ $hash_key = self::METADATA_EFFECT_HASH;
	+
	+ $u_hash = $this->getChangesetMetadata($hash_key);
	+ if ($u_hash === null) {
	+ return false;
	+ }
	+
	+ $v_hash = $other->getChangesetMetadata($hash_key);
	+ if ($v_hash === null) {
	+ return false;
	+ }
	+
	+ if ($u_hash !== $v_hash) {
	+ return false;
	+ }
	+
	+ // Make sure the final states for the file properties (like the "+x"
	+ // executable bit) match one another.
	+ $u_props = $this->getNewProperties();
	+ $v_props = $other->getNewProperties();
	+ ksort($u_props);
	+ ksort($v_props);
	+
	+ if ($u_props !== $v_props) {
	+ return false;
	+ }
	+
	+ return true;
	+ }
	+
	public function getSortKey() {
	$sort_key = $this->getFilename();
	// Sort files with ".h" in them first, so headers (.h, .hpp) come before
	// implementations (.c, .cpp, .cs).
	$sort_key = str_replace('.h', '.!h', $sort_key);
	return $sort_key;
	}

	public function makeNewFile() {
	$file = mpull($this->getHunks(), 'makeNewFile');
	return implode('', $file);
	}

	public function makeOldFile() {
	$file = mpull($this->getHunks(), 'makeOldFile');
	return implode('', $file);
	}

	public function makeChangesWithContext($num_lines = 3) {
	$with_context = array();
	foreach ($this->getHunks() as $hunk) {
	$context = array();
	$changes = explode("\n", $hunk->getChanges());
	foreach ($changes as $l => $line) {
	$type = substr($line, 0, 1);
	if ($type == '+' \|\| $type == '-') {
	$context += array_fill($l - $num_lines, 2 * $num_lines + 1, true);
	}
	}
	$with_context[] = array_intersect_key($changes, $context);
	}
	return array_mergev($with_context);
	}

	public function getAnchorName() {
	return 'change-'.PhabricatorHash::digestForAnchor($this->getFilename());
	}

	public function getAbsoluteRepositoryPath(
	PhabricatorRepository $repository = null,
	DifferentialDiff $diff = null) {

	$base = '/';
	if ($diff && $diff->getSourceControlPath()) {
	$base = id(new PhutilURI($diff->getSourceControlPath()))->getPath();
	}

	$path = $this->getFilename();
	$path = rtrim($base, '/').'/'.ltrim($path, '/');

	$svn = PhabricatorRepositoryType::REPOSITORY_TYPE_SVN;
	if ($repository && $repository->getVersionControlSystem() == $svn) {
	$prefix = $repository->getDetail('remote-uri');
	$prefix = id(new PhutilURI($prefix))->getPath();
	if (!strncmp($path, $prefix, strlen($prefix))) {
	$path = substr($path, strlen($prefix));
	}
	$path = '/'.ltrim($path, '/');
	}

	return $path;
	}

	public function getWhitespaceMatters() {
	$config = PhabricatorEnv::getEnvConfig('differential.whitespace-matters');
	foreach ($config as $regexp) {
	if (preg_match($regexp, $this->getFilename())) {
	return true;
	}
	}

	return false;
	}

	public function attachDiff(DifferentialDiff $diff) {
	$this->diff = $diff;
	return $this;
	}

	public function getDiff() {
	return $this->assertAttached($this->diff);
	}

	public function newFileTreeIcon() {
	$file_type = $this->getFileType();
	$change_type = $this->getChangeType();

	$change_icons = array(
	DifferentialChangeType::TYPE_DELETE => 'fa-file-o',
	);

	if (isset($change_icons[$change_type])) {
	$icon = $change_icons[$change_type];
	} else {
	$icon = DifferentialChangeType::getIconForFileType($file_type);
	}

	$change_colors = array(
	DifferentialChangeType::TYPE_ADD => 'green',
	DifferentialChangeType::TYPE_DELETE => 'red',
	DifferentialChangeType::TYPE_MOVE_AWAY => 'orange',
	DifferentialChangeType::TYPE_MOVE_HERE => 'orange',
	DifferentialChangeType::TYPE_COPY_HERE => 'orange',
	DifferentialChangeType::TYPE_MULTICOPY => 'orange',
	);

	$color = idx($change_colors, $change_type, 'bluetext');

	return id(new PHUIIconView())
	->setIcon($icon.' '.$color);
	}

	public function getFileTreeClass() {
	switch ($this->getChangeType()) {
	case DifferentialChangeType::TYPE_ADD:
	return 'filetree-added';
	case DifferentialChangeType::TYPE_DELETE:
	return 'filetree-deleted';
	case DifferentialChangeType::TYPE_MOVE_AWAY:
	case DifferentialChangeType::TYPE_MOVE_HERE:
	case DifferentialChangeType::TYPE_COPY_HERE:
	case DifferentialChangeType::TYPE_MULTICOPY:
	return 'filetree-movecopy';
	}

	return null;
	}

	public function setChangesetMetadata($key, $value) {
	if (!is_array($this->metadata)) {
	$this->metadata = array();
	}

	$this->metadata[$key] = $value;

	return $this;
	}

	public function getChangesetMetadata($key, $default = null) {
	if (!is_array($this->metadata)) {
	return $default;
	}

	return idx($this->metadata, $key, $default);
	}

	private function setInternalChangesetAttribute($trusted, $key, $value) {
	if ($trusted) {
	$meta_key = self::METADATA_TRUSTED_ATTRIBUTES;
	} else {
	$meta_key = self::METADATA_UNTRUSTED_ATTRIBUTES;
	}

	$attributes = $this->getChangesetMetadata($meta_key, array());
	$attributes[$key] = $value;
	$this->setChangesetMetadata($meta_key, $attributes);

	return $this;
	}

	private function getInternalChangesetAttributes($trusted) {
	if ($trusted) {
	$meta_key = self::METADATA_TRUSTED_ATTRIBUTES;
	} else {
	$meta_key = self::METADATA_UNTRUSTED_ATTRIBUTES;
	}

	return $this->getChangesetMetadata($meta_key, array());
	}

	public function setTrustedChangesetAttribute($key, $value) {
	return $this->setInternalChangesetAttribute(true, $key, $value);
	}

	public function getTrustedChangesetAttributes() {
	return $this->getInternalChangesetAttributes(true);
	}

	public function getTrustedChangesetAttribute($key, $default = null) {
	$map = $this->getTrustedChangesetAttributes();
	return idx($map, $key, $default);
	}

	public function setUntrustedChangesetAttribute($key, $value) {
	return $this->setInternalChangesetAttribute(false, $key, $value);
	}

	public function getUntrustedChangesetAttributes() {
	return $this->getInternalChangesetAttributes(false);
	}

	public function getUntrustedChangesetAttribute($key, $default = null) {
	$map = $this->getUntrustedChangesetAttributes();
	return idx($map, $key, $default);
	}

	public function getChangesetAttributes() {
	// Prefer trusted values over untrusted values when both exist.
	return
	$this->getTrustedChangesetAttributes() +
	$this->getUntrustedChangesetAttributes();
	}

	public function getChangesetAttribute($key, $default = null) {
	$map = $this->getChangesetAttributes();
	return idx($map, $key, $default);
	}

	public function isGeneratedChangeset() {
	return $this->getChangesetAttribute(self::ATTRIBUTE_GENERATED);
	}


	/* -( PhabricatorPolicyInterface )----------------------------------------- */


	public function getCapabilities() {
	return array(
	PhabricatorPolicyCapability::CAN_VIEW,
	);
	}

	public function getPolicy($capability) {
	return $this->getDiff()->getPolicy($capability);
	}

	public function hasAutomaticCapability($capability, PhabricatorUser $viewer) {
	return $this->getDiff()->hasAutomaticCapability($capability, $viewer);
	}


	/* -( PhabricatorDestructibleInterface )----------------------------------- */


	public function destroyObjectPermanently(
	PhabricatorDestructionEngine $engine) {
	$this->openTransaction();

	$hunks = id(new DifferentialHunk())->loadAllWhere(
	'changesetID = %d',
	$this->getID());
	foreach ($hunks as $hunk) {
	$engine->destroyObject($hunk);
	}

	$this->delete();

	$this->saveTransaction();
	}


	}

File Metadata

Mime Type: text/x-diff
Expires: Jan 19 2025, 21:36 (6 w, 1 d ago)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1129020
Default Alt Text: (63 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions