No OneTemporary
Actions

Size

65 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/src/applications/differential/controller/DifferentialController.php b/src/applications/differential/controller/DifferentialController.php
	index 43252c07f6..1991580116 100644
	--- a/src/applications/differential/controller/DifferentialController.php
	+++ b/src/applications/differential/controller/DifferentialController.php
	@@ -1,228 +1,228 @@
	<?php

	abstract class DifferentialController extends PhabricatorController {

	public function buildSideNavView($for_app = false) {
	$viewer = $this->getRequest()->getUser();

	$nav = new AphrontSideNavFilterView();
	$nav->setBaseURI(new PhutilURI($this->getApplicationURI()));

	id(new DifferentialRevisionSearchEngine())
	->setViewer($viewer)
	->addNavigationItems($nav->getMenu());

	$nav->selectFilter(null);

	return $nav;
	}

	public function buildApplicationMenu() {
	return $this->buildSideNavView(true)->getMenu();
	}

	protected function buildTableOfContents(
	array $changesets,
	array $visible_changesets,
	array $coverage) {
	$viewer = $this->getViewer();

	$toc_view = id(new PHUIDiffTableOfContentsListView())
	- ->setUser($viewer)
	- ->setBackground(PHUIObjectBoxView::BLUE_PROPERTY);
	+ ->setViewer($viewer)
	+ ->setBare(true);

	$have_owners = PhabricatorApplication::isClassInstalledForViewer(
	'PhabricatorOwnersApplication',
	$viewer);
	if ($have_owners) {
	$repository_phid = null;
	if ($changesets) {
	$changeset = head($changesets);
	$diff = $changeset->getDiff();
	$repository_phid = $diff->getRepositoryPHID();
	}

	if (!$repository_phid) {
	$have_owners = false;
	} else {
	if ($viewer->getPHID()) {
	$packages = id(new PhabricatorOwnersPackageQuery())
	->setViewer($viewer)
	->withStatuses(array(PhabricatorOwnersPackage::STATUS_ACTIVE))
	->withAuthorityPHIDs(array($viewer->getPHID()))
	->execute();
	$toc_view->setAuthorityPackages($packages);
	}

	// TODO: For Subversion, we should adjust these paths to be relative to
	// the repository root where possible.
	$paths = mpull($changesets, 'getFilename');

	$control_query = id(new PhabricatorOwnersPackageQuery())
	->setViewer($viewer)
	->withStatuses(array(PhabricatorOwnersPackage::STATUS_ACTIVE))
	->withControl($repository_phid, $paths);
	$control_query->execute();
	}
	}

	foreach ($changesets as $changeset_id => $changeset) {
	$is_visible = isset($visible_changesets[$changeset_id]);
	$anchor = $changeset->getAnchorName();

	$filename = $changeset->getFilename();
	$coverage_id = 'differential-mcoverage-'.md5($filename);

	$item = id(new PHUIDiffTableOfContentsItemView())
	->setChangeset($changeset)
	->setIsVisible($is_visible)
	->setAnchor($anchor)
	->setCoverage(idx($coverage, $filename))
	->setCoverageID($coverage_id);

	if ($have_owners) {
	$packages = $control_query->getControllingPackagesForPath(
	$repository_phid,
	$changeset->getFilename());
	$item->setPackages($packages);
	}

	$toc_view->addItem($item);
	}

	return $toc_view;
	}

	protected function loadDiffProperties(array $diffs) {
	$diffs = mpull($diffs, null, 'getID');

	$properties = id(new DifferentialDiffProperty())->loadAllWhere(
	'diffID IN (%Ld)',
	array_keys($diffs));
	$properties = mgroup($properties, 'getDiffID');

	foreach ($diffs as $id => $diff) {
	$values = idx($properties, $id, array());
	$values = mpull($values, 'getData', 'getName');
	$diff->attachDiffProperties($values);
	}
	}


	protected function loadHarbormasterData(array $diffs) {
	$viewer = $this->getViewer();

	$diffs = mpull($diffs, null, 'getPHID');

	$buildables = id(new HarbormasterBuildableQuery())
	->setViewer($viewer)
	->withBuildablePHIDs(array_keys($diffs))
	->withManualBuildables(false)
	->needBuilds(true)
	->needTargets(true)
	->execute();

	$buildables = mpull($buildables, null, 'getBuildablePHID');
	foreach ($diffs as $phid => $diff) {
	$diff->attachBuildable(idx($buildables, $phid));
	}

	$target_map = array();
	foreach ($diffs as $phid => $diff) {
	$target_map[$phid] = $diff->getBuildTargetPHIDs();
	}
	$all_target_phids = array_mergev($target_map);

	if ($all_target_phids) {
	$unit_messages = id(new HarbormasterBuildUnitMessage())->loadAllWhere(
	'buildTargetPHID IN (%Ls)',
	$all_target_phids);
	$unit_messages = mgroup($unit_messages, 'getBuildTargetPHID');
	} else {
	$unit_messages = array();
	}

	foreach ($diffs as $phid => $diff) {
	$target_phids = idx($target_map, $phid, array());
	$messages = array_select_keys($unit_messages, $target_phids);
	$messages = array_mergev($messages);
	$diff->attachUnitMessages($messages);
	}

	// For diffs with no messages, look for legacy unit messages stored on the
	// diff itself.
	foreach ($diffs as $phid => $diff) {
	if ($diff->getUnitMessages()) {
	continue;
	}

	if (!$diff->hasDiffProperty('arc:unit')) {
	continue;
	}

	$legacy_messages = $diff->getProperty('arc:unit');
	if (!$legacy_messages) {
	continue;
	}

	// Show the top 100 legacy lint messages. Previously, we showed some
	// by default and let the user toggle the rest. With modern messages,
	// we can send the user to the Harbormaster detail page. Just show
	// "a lot" of messages in legacy cases to try to strike a balance
	// between implementation simplicitly and compatibility.
	$legacy_messages = array_slice($legacy_messages, 0, 100);

	$messages = array();
	foreach ($legacy_messages as $message) {
	$messages[] = HarbormasterBuildUnitMessage::newFromDictionary(
	new HarbormasterBuildTarget(),
	$this->getModernUnitMessageDictionary($message));
	}

	$diff->attachUnitMessages($messages);
	}
	}

	private function getModernUnitMessageDictionary(array $map) {
	// Strip out `null` values to satisfy stricter typechecks.
	foreach ($map as $key => $value) {
	if ($value === null) {
	unset($map[$key]);
	}
	}

	// Cast duration to a float since it used to be a string in some
	// cases.
	if (isset($map['duration'])) {
	$map['duration'] = (double)$map['duration'];
	}

	return $map;
	}

	protected function getDiffTabLabels(array $diffs) {
	// Make sure we're only going to render unique diffs.
	$diffs = mpull($diffs, null, 'getID');
	$labels = array(pht('Left'), pht('Right'));

	$results = array();

	foreach ($diffs as $diff) {
	if (count($diffs) == 2) {
	$label = array_shift($labels);
	$label = pht('%s (Diff %d)', $label, $diff->getID());
	} else {
	$label = pht('Diff %d', $diff->getID());
	}

	$results[] = array(
	$label,
	$diff,
	);
	}

	return $results;
	}


	}
	diff --git a/src/applications/differential/controller/DifferentialRevisionViewController.php b/src/applications/differential/controller/DifferentialRevisionViewController.php
	index f2078a57de..c66da78035 100644
	--- a/src/applications/differential/controller/DifferentialRevisionViewController.php
	+++ b/src/applications/differential/controller/DifferentialRevisionViewController.php
	@@ -1,1170 +1,1201 @@
	<?php

	final class DifferentialRevisionViewController extends DifferentialController {

	private $revisionID;

	public function shouldAllowPublic() {
	return true;
	}

	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($request->getUser())
	->needRelationships(true)
	->needReviewerStatus(true)
	->needReviewerAuthority(true)
	->executeOne();

	if (!$revision) {
	return new Aphront404Response();
	}

	$diffs = id(new DifferentialDiffQuery())
	->setViewer($request->getUser())
	->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);

	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();

	$object_phids = array_merge(
	$revision->getReviewers(),
	$revision->getCCPHIDs(),
	$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);

	$request_uri = $request->getRequestURI();

	$limit = 100;
	$large = $request->getStr('large');
	if (count($changesets) > $limit && !$large) {
	$count = count($changesets);
	$warning = new PHUIInfoView();
	$warning->setTitle(pht('Very Large Diff'));
	$warning->setSeverity(PHUIInfoView::SEVERITY_WARNING);
	$warning->appendChild(hsprintf(
	'%s <strong>%s</strong>',
	pht(
	'This diff is very large and affects %s files. '.
	'You may load each file individually or ',
	new PhutilNumber($count)),
	phutil_tag(
	'a',
	array(
	'class' => 'button grey',
	'href' => $request_uri
	->alter('large', 'true')
	->setFragment('toc'),
	),
	pht('Show All Files Inline'))));
	$warning = $warning->render();

	$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];
	}
	}
	} else {
	$warning = null;
	$visible_changesets = $changesets;
	}

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

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

	if (!$viewer_is_anonymous) {
	$comment_view->setQuoteRef('D'.$revision->getID());
	$comment_view->setQuoteTargetID('comment-content');
	}

	$changeset_view = id(new DifferentialChangesetListView())
	->setChangesets($changesets)
	->setVisibleChangesets($visible_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);

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

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

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

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

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

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

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

	+ $tab_group = id(new PHUITabGroupView())
	+ ->addTab(
	+ id(new PHUITabView())
	+ ->setName(pht('Files'))
	+ ->setKey('files')
	+ ->appendChild($toc_view))
	+ ->addTab(
	+ id(new PHUITabView())
	+ ->setName(pht('History'))
	+ ->setKey('history')
	+ ->appendChild($history))
	+ ->addTab(
	+ id(new PHUITabView())
	+ ->setName(pht('Commits'))
	+ ->setKey('commits')
	+ ->appendChild($local_table));
	+
	+ if ($other_view) {
	+ $tab_group->addTab(
	+ id(new PHUITabView())
	+ ->setName(pht('Similar'))
	+ ->setKey('similar')
	+ ->appendChild($other_view));
	+ }
	+
	+ $tab_view = id(new PHUIObjectBoxView())
	+ ->setHeaderText(pht('Revision Contents'))
	+ ->setBackground(PHUIObjectBoxView::BLUE_PROPERTY)
	+ ->addTabGroup($tab_group);
	+
	$comment_form = null;
	if (!$viewer_is_anonymous) {
	$comment_form = $this->buildCommentForm($revision, $field_list);
	}

	$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 {
	- $footer[] =
	- array(
	- $diff_history,
	- $warning,
	- $local_view,
	- $toc_view,
	- $other_view,
	- $changeset_view,
	- );
	+ $anchor = id(new PhabricatorAnchorView())
	+ ->setAnchorName('toc')
	+ ->setNavigationMarker(true);
	+
	+ $footer[] = array(
	+ $anchor,
	+ $warning,
	+ $tab_view,
	+ $changeset_view,
	+ );
	}

	if ($comment_form) {
	$footer[] = $comment_form;
	} else {
	// TODO: For now, just use this to get "Login to Comment".
	$footer[] = id(new PhabricatorApplicationTransactionCommentView())
	->setUser($viewer)
	->setRequestURI($request->getRequestURI());
	}

	$object_id = 'D'.$revision->getID();
	$operations_box = $this->buildOperationsBox($revision);

	$crumbs = $this->buildApplicationCrumbs();
	$crumbs->addTextCrumb($object_id, '/'.$object_id);
	$crumbs->setBorder(true);

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

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

	$nav = id(new DifferentialChangesetFileTreeSideNavBuilder())
	->setTitle('D'.$revision->getID())
	->setBaseURI(new PhutilURI('/D'.$revision->getID()))
	->setCollapsed((bool)$collapsed_value)
	->build($changesets);
	}

	// Haunt Mode
	$pane_id = celerity_generate_unique_node_id();
	Javelin::initBehavior(
	'differential-keyboard-navigation',
	array(
	'haunt' => $pane_id,
	));
	Javelin::initBehavior('differential-user-select');

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

	$page = $this->newPage()
	->setTitle($object_id.' '.$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 = $revision->getStatus();
	$status_name =
	DifferentialRevisionStatus::renderFullDescription($status);

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

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

	return $curtain;
	}

	private function buildCommentForm(
	DifferentialRevision $revision,
	$field_list) {

	$viewer = $this->getViewer();

	$draft = id(new PhabricatorDraft())->loadOneWhere(
	'authorPHID = %s AND draftKey = %s',
	$viewer->getPHID(),
	'differential-comment-'.$revision->getID());

	$reviewers = array();
	$ccs = array();
	if ($draft) {
	$reviewers = idx($draft->getMetadata(), 'reviewers', array());
	$ccs = idx($draft->getMetadata(), 'ccs', array());
	if ($reviewers \|\| $ccs) {
	$handles = $this->loadViewerHandles(array_merge($reviewers, $ccs));
	$reviewers = array_select_keys($handles, $reviewers);
	$ccs = array_select_keys($handles, $ccs);
	}
	}

	$comment_form = id(new DifferentialAddCommentView())
	->setRevision($revision);

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

	if ($review_warnings) {
	$review_warnings_panel = id(new PHUIInfoView())
	->setSeverity(PHUIInfoView::SEVERITY_WARNING)
	->setErrors($review_warnings);
	$comment_form->setInfoView($review_warnings_panel);
	}

	$action_uri = $this->getApplicationURI(
	'comment/save/'.$revision->getID().'/');

	$comment_form->setActions($this->getRevisionCommentActions($revision))
	->setActionURI($action_uri)
	->setUser($viewer)
	->setDraft($draft)
	->setReviewers(mpull($reviewers, 'getFullName', 'getPHID'))
	->setCCs(mpull($ccs, 'getFullName', 'getPHID'));

	// TODO: This just makes the "Z" key work. Generalize this and remove
	// it at some point.
	$comment_form = phutil_tag(
	'div',
	array(
	'class' => 'differential-add-comment-panel',
	),
	$comment_form);
	return $comment_form;
	}

	private function getRevisionCommentActions(DifferentialRevision $revision) {
	$actions = array(
	DifferentialAction::ACTION_COMMENT => true,
	);

	$viewer = $this->getViewer();
	$viewer_phid = $viewer->getPHID();
	$viewer_is_owner = ($viewer_phid == $revision->getAuthorPHID());
	$viewer_is_reviewer = in_array($viewer_phid, $revision->getReviewers());
	$status = $revision->getStatus();

	$viewer_has_accepted = false;
	$viewer_has_rejected = false;
	$status_accepted = DifferentialReviewerStatus::STATUS_ACCEPTED;
	$status_rejected = DifferentialReviewerStatus::STATUS_REJECTED;
	foreach ($revision->getReviewerStatus() as $reviewer) {
	if ($reviewer->getReviewerPHID() == $viewer_phid) {
	if ($reviewer->getStatus() == $status_accepted) {
	$viewer_has_accepted = true;
	}
	if ($reviewer->getStatus() == $status_rejected) {
	$viewer_has_rejected = true;
	}
	break;
	}
	}

	$allow_self_accept = PhabricatorEnv::getEnvConfig(
	'differential.allow-self-accept');
	$always_allow_abandon = PhabricatorEnv::getEnvConfig(
	'differential.always-allow-abandon');
	$always_allow_close = PhabricatorEnv::getEnvConfig(
	'differential.always-allow-close');
	$allow_reopen = PhabricatorEnv::getEnvConfig(
	'differential.allow-reopen');

	if ($viewer_is_owner) {
	switch ($status) {
	case ArcanistDifferentialRevisionStatus::NEEDS_REVIEW:
	$actions[DifferentialAction::ACTION_ACCEPT] = $allow_self_accept;
	$actions[DifferentialAction::ACTION_ABANDON] = true;
	$actions[DifferentialAction::ACTION_RETHINK] = true;
	break;
	case ArcanistDifferentialRevisionStatus::NEEDS_REVISION:
	case ArcanistDifferentialRevisionStatus::CHANGES_PLANNED:
	$actions[DifferentialAction::ACTION_ACCEPT] = $allow_self_accept;
	$actions[DifferentialAction::ACTION_ABANDON] = true;
	$actions[DifferentialAction::ACTION_REQUEST] = true;
	break;
	case ArcanistDifferentialRevisionStatus::ACCEPTED:
	$actions[DifferentialAction::ACTION_ABANDON] = true;
	$actions[DifferentialAction::ACTION_REQUEST] = true;
	$actions[DifferentialAction::ACTION_RETHINK] = true;
	$actions[DifferentialAction::ACTION_CLOSE] = true;
	break;
	case ArcanistDifferentialRevisionStatus::CLOSED:
	break;
	case ArcanistDifferentialRevisionStatus::ABANDONED:
	$actions[DifferentialAction::ACTION_RECLAIM] = true;
	break;
	}
	} else {
	switch ($status) {
	case ArcanistDifferentialRevisionStatus::NEEDS_REVIEW:
	$actions[DifferentialAction::ACTION_ABANDON] = $always_allow_abandon;
	$actions[DifferentialAction::ACTION_ACCEPT] = true;
	$actions[DifferentialAction::ACTION_REJECT] = true;
	$actions[DifferentialAction::ACTION_RESIGN] = $viewer_is_reviewer;
	break;
	case ArcanistDifferentialRevisionStatus::NEEDS_REVISION:
	case ArcanistDifferentialRevisionStatus::CHANGES_PLANNED:
	$actions[DifferentialAction::ACTION_ABANDON] = $always_allow_abandon;
	$actions[DifferentialAction::ACTION_ACCEPT] = true;
	$actions[DifferentialAction::ACTION_REJECT] = !$viewer_has_rejected;
	$actions[DifferentialAction::ACTION_RESIGN] = $viewer_is_reviewer;
	break;
	case ArcanistDifferentialRevisionStatus::ACCEPTED:
	$actions[DifferentialAction::ACTION_ABANDON] = $always_allow_abandon;
	$actions[DifferentialAction::ACTION_ACCEPT] = !$viewer_has_accepted;
	$actions[DifferentialAction::ACTION_REJECT] = true;
	$actions[DifferentialAction::ACTION_RESIGN] = $viewer_is_reviewer;
	break;
	case ArcanistDifferentialRevisionStatus::CLOSED:
	case ArcanistDifferentialRevisionStatus::ABANDONED:
	break;
	}
	if ($status != ArcanistDifferentialRevisionStatus::CLOSED) {
	$actions[DifferentialAction::ACTION_CLAIM] = true;
	$actions[DifferentialAction::ACTION_CLOSE] = $always_allow_close;
	}
	}

	$actions[DifferentialAction::ACTION_ADDREVIEWERS] = true;
	$actions[DifferentialAction::ACTION_ADDCCS] = true;
	$actions[DifferentialAction::ACTION_REOPEN] = $allow_reopen &&
	($status == ArcanistDifferentialRevisionStatus::CLOSED);

	$actions = array_keys(array_filter($actions));
	$actions_dict = array();
	foreach ($actions as $action) {
	$actions_dict[$action] = DifferentialAction::getActionVerb($action);
	}

	return $actions_dict;
	}

	private function loadChangesetsAndVsMap(
	DifferentialDiff $target,
	DifferentialDiff $diff_vs = null,
	PhabricatorRepository $repository = null) {

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

	$raw_changesets = id(new DifferentialChangesetQuery())
	->setViewer($this->getRequest()->getUser())
	->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();
	$vs_changesets = array();
	if ($diff_vs) {
	$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]);
	} 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';
	}
	} else {
	foreach ($changesets as $changeset) {
	$refs[$changeset->getID()] = $changeset->getID();
	}
	}

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

	return array($changesets, $vs_map, $vs_changesets, $refs);
	}

	private function buildSymbolIndexes(
	PhabricatorRepository $repository,
	array $visible_changesets) {
	assert_instances_of($visible_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) {
	$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())
	->withStatus(DifferentialRevisionQuery::STATUS_OPEN)
	->withUpdatedEpochBetween($recent, null)
	->setOrder(DifferentialRevisionQuery::ORDER_MODIFIED)
	->setLimit(10)
	->needFlags(true)
	->needDrafts(true)
	->needRelationships(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'));

	$view = id(new DifferentialRevisionListView())
	- ->setHeader($header)
	->setRevisions($revisions)
	->setBackground(PHUIObjectBoxView::BLUE_PROPERTY)
	+ ->setNoBox(true)
	->setUser($viewer);

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

	return $view;
	}


	/**
	* 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';

	$file = PhabricatorFile::buildFromFileDataOrHash(
	$raw_diff,
	array(
	'name' => $file_name,
	'ttl' => (60 * 60 * 24),
	'viewPolicy' => PhabricatorPolicies::POLICY_NOONE,
	));

	$unguarded = AphrontWriteGuard::beginScopedUnguardedWrites();
	$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/view/DifferentialLocalCommitsView.php b/src/applications/differential/view/DifferentialLocalCommitsView.php
	index 639b62fc4b..4ac2bc14b3 100644
	--- a/src/applications/differential/view/DifferentialLocalCommitsView.php
	+++ b/src/applications/differential/view/DifferentialLocalCommitsView.php
	@@ -1,154 +1,151 @@
	<?php

	final class DifferentialLocalCommitsView extends AphrontView {

	private $localCommits;
	private $commitsForLinks = array();

	public function setLocalCommits($local_commits) {
	$this->localCommits = $local_commits;
	return $this;
	}

	public function setCommitsForLinks(array $commits) {
	assert_instances_of($commits, 'PhabricatorRepositoryCommit');
	$this->commitsForLinks = $commits;
	return $this;
	}

	public function render() {
	$viewer = $this->getViewer();

	$local = $this->localCommits;
	if (!$local) {
	return null;
	}

	$has_tree = false;
	$has_local = false;

	foreach ($local as $commit) {
	if (idx($commit, 'tree')) {
	$has_tree = true;
	}
	if (idx($commit, 'local')) {
	$has_local = true;
	}
	}

	$rows = array();
	foreach ($local as $commit) {
	$row = array();
	if (idx($commit, 'commit')) {
	$commit_link = $this->buildCommitLink($commit['commit']);
	} else if (isset($commit['rev'])) {
	$commit_link = $this->buildCommitLink($commit['rev']);
	} else {
	$commit_link = null;
	}
	$row[] = $commit_link;

	if ($has_tree) {
	$row[] = $this->buildCommitLink($commit['tree']);
	}

	if ($has_local) {
	$row[] = $this->buildCommitLink($commit['local']);
	}

	$parents = idx($commit, 'parents', array());
	foreach ($parents as $k => $parent) {
	if (is_array($parent)) {
	$parent = idx($parent, 'rev');
	}
	$parents[$k] = $this->buildCommitLink($parent);
	}
	$parents = phutil_implode_html(phutil_tag('br'), $parents);
	$row[] = $parents;

	$author = nonempty(
	idx($commit, 'user'),
	idx($commit, 'author'));
	$row[] = $author;

	$message = idx($commit, 'message');

	$summary = idx($commit, 'summary');
	$summary = id(new PhutilUTF8StringTruncator())
	->setMaximumGlyphs(80)
	->truncateString($summary);

	$view = new AphrontMoreView();
	$view->setSome($summary);

	if ($message && (trim($summary) != trim($message))) {
	$view->setMore(phutil_escape_html_newlines($message));
	}

	$row[] = $view->render();

	$date = nonempty(
	idx($commit, 'date'),
	idx($commit, 'time'));
	if ($date) {
	$date = phabricator_datetime($date, $viewer);
	}
	$row[] = $date;

	$rows[] = $row;
	}

	$column_classes = array('');
	if ($has_tree) {
	$column_classes[] = '';
	}
	if ($has_local) {
	$column_classes[] = '';
	}
	$column_classes[] = '';
	$column_classes[] = '';
	$column_classes[] = 'wide';
	$column_classes[] = 'date';
	$table = id(new AphrontTableView($rows))
	->setColumnClasses($column_classes);
	$headers = array();
	$headers[] = pht('Commit');
	if ($has_tree) {
	$headers[] = pht('Tree');
	}
	if ($has_local) {
	$headers[] = pht('Local');
	}
	$headers[] = pht('Parents');
	$headers[] = pht('Author');
	$headers[] = pht('Summary');
	$headers[] = pht('Date');
	$table->setHeaders($headers);

	- return id(new PHUIObjectBoxView())
	- ->setHeaderText(pht('Local Commits'))
	- ->setBackground(PHUIObjectBoxView::BLUE_PROPERTY)
	- ->setTable($table);
	+ return $table;
	}

	private static function formatCommit($commit) {
	return substr($commit, 0, 12);
	}

	private function buildCommitLink($hash) {
	$commit_for_link = idx($this->commitsForLinks, $hash);
	$commit_hash = self::formatCommit($hash);
	if ($commit_for_link) {
	$link = phutil_tag(
	'a',
	array(
	'href' => $commit_for_link->getURI(),
	),
	$commit_hash);
	} else {
	$link = $commit_hash;
	}
	return $link;
	}

	}
	diff --git a/src/applications/differential/view/DifferentialRevisionUpdateHistoryView.php b/src/applications/differential/view/DifferentialRevisionUpdateHistoryView.php
	index 5ce766afb9..2d311fd0bd 100644
	--- a/src/applications/differential/view/DifferentialRevisionUpdateHistoryView.php
	+++ b/src/applications/differential/view/DifferentialRevisionUpdateHistoryView.php
	@@ -1,432 +1,429 @@
	<?php

	final class DifferentialRevisionUpdateHistoryView extends AphrontView {

	private $diffs = array();
	private $selectedVersusDiffID;
	private $selectedDiffID;
	private $selectedWhitespace;
	private $commitsForLinks = array();

	public function setDiffs(array $diffs) {
	assert_instances_of($diffs, 'DifferentialDiff');
	$this->diffs = $diffs;
	return $this;
	}

	public function setSelectedVersusDiffID($id) {
	$this->selectedVersusDiffID = $id;
	return $this;
	}

	public function setSelectedDiffID($id) {
	$this->selectedDiffID = $id;
	return $this;
	}

	public function setSelectedWhitespace($whitespace) {
	$this->selectedWhitespace = $whitespace;
	return $this;
	}

	public function setCommitsForLinks(array $commits) {
	assert_instances_of($commits, 'PhabricatorRepositoryCommit');
	$this->commitsForLinks = $commits;
	return $this;
	}

	public function render() {
	$this->requireResource('differential-core-view-css');
	$this->requireResource('differential-revision-history-css');

	$data = array(
	array(
	'name' => pht('Base'),
	'id' => null,
	'desc' => pht('Base'),
	'age' => null,
	'obj' => null,
	),
	);

	$seq = 0;
	foreach ($this->diffs as $diff) {
	$data[] = array(
	'name' => pht('Diff %d', ++$seq),
	'id' => $diff->getID(),
	'desc' => $diff->getDescription(),
	'age' => $diff->getDateCreated(),
	'obj' => $diff,
	);
	}

	$max_id = $diff->getID();
	$revision_id = $diff->getRevisionID();

	$idx = 0;
	$rows = array();
	$disable = false;
	$radios = array();
	$last_base = null;
	$rowc = array();
	foreach ($data as $row) {

	$diff = $row['obj'];
	$name = $row['name'];
	$id = $row['id'];

	$old_class = false;
	$new_class = false;

	if ($id) {
	$new_checked = ($this->selectedDiffID == $id);
	$new = javelin_tag(
	'input',
	array(
	'type' => 'radio',
	'name' => 'id',
	'value' => $id,
	'checked' => $new_checked ? 'checked' : null,
	'sigil' => 'differential-new-radio',
	));
	if ($new_checked) {
	$new_class = true;
	$disable = true;
	}
	$new = phutil_tag(
	'div',
	array(
	'class' => 'differential-update-history-radio',
	),
	$new);
	} else {
	$new = null;
	}

	if ($max_id != $id) {
	$uniq = celerity_generate_unique_node_id();
	$old_checked = ($this->selectedVersusDiffID == $id);
	$old = phutil_tag(
	'input',
	array(
	'type' => 'radio',
	'name' => 'vs',
	'value' => $id,
	'id' => $uniq,
	'checked' => $old_checked ? 'checked' : null,
	'disabled' => $disable ? 'disabled' : null,
	));
	$radios[] = $uniq;
	if ($old_checked) {
	$old_class = true;
	}
	$old = phutil_tag(
	'div',
	array(
	'class' => 'differential-update-history-radio',
	),
	$old);
	} else {
	$old = null;
	}

	$desc = $row['desc'];

	if ($row['age']) {
	$age = phabricator_datetime($row['age'], $this->getUser());
	} else {
	$age = null;
	}

	if ($diff) {
	$lint = self::renderDiffLintStar($row['obj']);
	$lint = phutil_tag(
	'div',
	array(
	'class' => 'lintunit-star',
	'title' => self::getDiffLintMessage($diff),
	),
	$lint);

	$unit = self::renderDiffUnitStar($row['obj']);
	$unit = phutil_tag(
	'div',
	array(
	'class' => 'lintunit-star',
	'title' => self::getDiffUnitMessage($diff),
	),
	$unit);

	$base = $this->renderBaseRevision($diff);
	} else {
	$lint = null;
	$unit = null;
	$base = null;
	}

	if ($last_base !== null && $base !== $last_base) {
	// TODO: Render some kind of notice about rebases.
	}
	$last_base = $base;

	if ($revision_id) {
	$id_link = phutil_tag(
	'a',
	array(
	'href' => '/D'.$revision_id.'?id='.$id,
	),
	$id);
	} else {
	$id_link = phutil_tag(
	'a',
	array(
	'href' => '/differential/diff/'.$id.'/',
	),
	$id);
	}

	$rows[] = array(
	$name,
	$id_link,
	$base,
	$desc,
	$age,
	$lint,
	$unit,
	$old,
	$new,
	);

	$classes = array();
	if ($old_class) {
	$classes[] = 'differential-update-history-old-now';
	}
	if ($new_class) {
	$classes[] = 'differential-update-history-new-now';
	}
	$rowc[] = nonempty(implode(' ', $classes), null);
	}

	Javelin::initBehavior(
	'differential-diff-radios',
	array(
	'radios' => $radios,
	));

	$options = array(
	DifferentialChangesetParser::WHITESPACE_IGNORE_ALL => pht('Ignore All'),
	DifferentialChangesetParser::WHITESPACE_IGNORE_MOST => pht('Ignore Most'),
	DifferentialChangesetParser::WHITESPACE_IGNORE_TRAILING =>
	pht('Ignore Trailing'),
	DifferentialChangesetParser::WHITESPACE_SHOW_ALL => pht('Show All'),
	);

	foreach ($options as $value => $label) {
	$options[$value] = phutil_tag(
	'option',
	array(
	'value' => $value,
	'selected' => ($value == $this->selectedWhitespace)
	? 'selected'
	: null,
	),
	$label);
	}
	$select = phutil_tag('select', array('name' => 'whitespace'), $options);


	$table = id(new AphrontTableView($rows));
	$table->setHeaders(
	array(
	pht('Diff'),
	pht('ID'),
	pht('Base'),
	pht('Description'),
	pht('Created'),
	pht('Lint'),
	pht('Unit'),
	'',
	'',
	));
	$table->setColumnClasses(
	array(
	'pri',
	'',
	'',
	'wide',
	'date',
	'center',
	'center',
	'center differential-update-history-old',
	'center differential-update-history-new',
	));
	$table->setRowClasses($rowc);
	$table->setDeviceVisibility(
	array(
	true,
	true,
	false,
	true,
	false,
	false,
	false,
	true,
	true,
	));

	$show_diff = phutil_tag(
	'div',
	array(
	'class' => 'differential-update-history-footer',
	),
	array(
	phutil_tag(
	'label',
	array(),
	array(
	pht('Whitespace Changes:'),
	$select,
	)),
	phutil_tag(
	'button',
	array(),
	pht('Show Diff')),
	));

	$content = phabricator_form(
	$this->getUser(),
	array(
	'action' => '#toc',
	),
	array(
	$table,
	$show_diff,
	));

	- return id(new PHUIObjectBoxView())
	- ->setHeaderText(pht('Revision Update History'))
	- ->setBackground(PHUIObjectBoxView::BLUE_PROPERTY)
	- ->setTable($content);
	+ return $content;
	}

	const STAR_NONE = 'none';
	const STAR_OKAY = 'okay';
	const STAR_WARN = 'warn';
	const STAR_FAIL = 'fail';
	const STAR_SKIP = 'skip';

	public static function renderDiffLintStar(DifferentialDiff $diff) {
	static $map = array(
	DifferentialLintStatus::LINT_NONE => self::STAR_NONE,
	DifferentialLintStatus::LINT_OKAY => self::STAR_OKAY,
	DifferentialLintStatus::LINT_WARN => self::STAR_WARN,
	DifferentialLintStatus::LINT_FAIL => self::STAR_FAIL,
	DifferentialLintStatus::LINT_SKIP => self::STAR_SKIP,
	DifferentialLintStatus::LINT_AUTO_SKIP => self::STAR_SKIP,
	);

	$star = idx($map, $diff->getLintStatus(), self::STAR_FAIL);

	return self::renderDiffStar($star);
	}

	public static function renderDiffUnitStar(DifferentialDiff $diff) {
	static $map = array(
	DifferentialUnitStatus::UNIT_NONE => self::STAR_NONE,
	DifferentialUnitStatus::UNIT_OKAY => self::STAR_OKAY,
	DifferentialUnitStatus::UNIT_WARN => self::STAR_WARN,
	DifferentialUnitStatus::UNIT_FAIL => self::STAR_FAIL,
	DifferentialUnitStatus::UNIT_SKIP => self::STAR_SKIP,
	DifferentialUnitStatus::UNIT_AUTO_SKIP => self::STAR_SKIP,
	);

	$star = idx($map, $diff->getUnitStatus(), self::STAR_FAIL);

	return self::renderDiffStar($star);
	}

	public static function getDiffLintMessage(DifferentialDiff $diff) {
	switch ($diff->getLintStatus()) {
	case DifferentialLintStatus::LINT_NONE:
	return pht('No Linters Available');
	case DifferentialLintStatus::LINT_OKAY:
	return pht('Lint OK');
	case DifferentialLintStatus::LINT_WARN:
	return pht('Lint Warnings');
	case DifferentialLintStatus::LINT_FAIL:
	return pht('Lint Errors');
	case DifferentialLintStatus::LINT_SKIP:
	return pht('Lint Skipped');
	case DifferentialLintStatus::LINT_AUTO_SKIP:
	return pht('Automatic diff as part of commit; lint not applicable.');
	}
	return pht('Unknown');
	}

	public static function getDiffUnitMessage(DifferentialDiff $diff) {
	switch ($diff->getUnitStatus()) {
	case DifferentialUnitStatus::UNIT_NONE:
	return pht('No Unit Test Coverage');
	case DifferentialUnitStatus::UNIT_OKAY:
	return pht('Unit Tests OK');
	case DifferentialUnitStatus::UNIT_WARN:
	return pht('Unit Test Warnings');
	case DifferentialUnitStatus::UNIT_FAIL:
	return pht('Unit Test Errors');
	case DifferentialUnitStatus::UNIT_SKIP:
	return pht('Unit Tests Skipped');
	case DifferentialUnitStatus::UNIT_AUTO_SKIP:
	return pht(
	'Automatic diff as part of commit; unit tests not applicable.');
	}
	return pht('Unknown');
	}

	private static function renderDiffStar($star) {
	$class = 'diff-star-'.$star;
	return phutil_tag(
	'span',
	array('class' => $class),
	"\xE2\x98\x85");
	}

	private function renderBaseRevision(DifferentialDiff $diff) {
	switch ($diff->getSourceControlSystem()) {
	case 'git':
	$base = $diff->getSourceControlBaseRevision();
	if (strpos($base, '@') === false) {
	$label = substr($base, 0, 7);
	} else {
	// The diff is from git-svn
	$base = explode('@', $base);
	$base = last($base);
	$label = $base;
	}
	break;
	case 'svn':
	$base = $diff->getSourceControlBaseRevision();
	$base = explode('@', $base);
	$base = last($base);
	$label = $base;
	break;
	default:
	$label = null;
	break;
	}
	$link = null;
	if ($label) {
	$commit_for_link = idx(
	$this->commitsForLinks,
	$diff->getSourceControlBaseRevision());
	if ($commit_for_link) {
	$link = phutil_tag(
	'a',
	array('href' => $commit_for_link->getURI()),
	$label);
	} else {
	$link = $label;
	}
	}
	return $link;
	}
	}
	diff --git a/src/infrastructure/diff/view/PHUIDiffTableOfContentsListView.php b/src/infrastructure/diff/view/PHUIDiffTableOfContentsListView.php
	index 3330620148..e6ca6cc53d 100644
	--- a/src/infrastructure/diff/view/PHUIDiffTableOfContentsListView.php
	+++ b/src/infrastructure/diff/view/PHUIDiffTableOfContentsListView.php
	@@ -1,183 +1,197 @@
	<?php

	final class PHUIDiffTableOfContentsListView extends AphrontView {

	private $items = array();
	private $authorityPackages;
	private $header;
	private $infoView;
	private $background;
	+ private $bare;

	public function addItem(PHUIDiffTableOfContentsItemView $item) {
	$this->items[] = $item;
	return $this;
	}

	public function setAuthorityPackages(array $authority_packages) {
	assert_instances_of($authority_packages, 'PhabricatorOwnersPackage');
	$this->authorityPackages = $authority_packages;
	return $this;
	}

	public function getAuthorityPackages() {
	return $this->authorityPackages;
	}

	public function setBackground($background) {
	$this->background = $background;
	return $this;
	}

	public function setHeader(PHUIHeaderView $header) {
	$this->header = $header;
	return $this;
	}

	public function setInfoView(PHUIInfoView $infoview) {
	$this->infoView = $infoview;
	return $this;
	}

	+ public function setBare($bare) {
	+ $this->bare = $bare;
	+ return $this;
	+ }
	+
	+ public function getBare() {
	+ return $this->bare;
	+ }
	+
	public function render() {
	$this->requireResource('differential-core-view-css');
	$this->requireResource('differential-table-of-contents-css');

	Javelin::initBehavior('phabricator-tooltips');

	if ($this->getAuthorityPackages()) {
	$authority = mpull($this->getAuthorityPackages(), null, 'getPHID');
	} else {
	$authority = array();
	}

	$items = $this->items;

	$rows = array();
	$rowc = array();
	foreach ($items as $item) {
	$item->setUser($this->getUser());
	$rows[] = $item->render();

	$have_authority = false;

	$packages = $item->getPackages();
	if ($packages) {
	if (array_intersect_key($packages, $authority)) {
	$have_authority = true;
	}
	}

	if ($have_authority) {
	$rowc[] = 'highlighted';
	} else {
	$rowc[] = null;
	}
	}

	// Check if any item has content in these columns. If no item does, we'll
	// just hide them.
	$any_coverage = false;
	$any_context = false;
	$any_packages = false;
	foreach ($items as $item) {
	if ($item->getContext() !== null) {
	$any_context = true;
	}

	if (strlen($item->getCoverage())) {
	$any_coverage = true;
	}

	if ($item->getPackages() !== null) {
	$any_packages = true;
	}
	}

	$reveal_link = javelin_tag(
	'a',
	array(
	'sigil' => 'differential-reveal-all',
	'mustcapture' => true,
	'class' => 'button differential-toc-reveal-all',
	),
	pht('Show All Context'));

	$buttons = phutil_tag(
	'div',
	array(
	'class' => 'differential-toc-buttons grouped',
	),
	$reveal_link);

	$table = id(new AphrontTableView($rows))
	->setRowClasses($rowc)
	->setHeaders(
	array(
	null,
	null,
	null,
	null,
	pht('Path'),
	pht('Coverage (All)'),
	pht('Coverage (Touched)'),
	pht('Packages'),
	))
	->setColumnClasses(
	array(
	null,
	'differential-toc-char center',
	'differential-toc-prop center',
	'differential-toc-ftype center',
	'differential-toc-file wide',
	'differential-toc-cov',
	'differential-toc-cov',
	null,
	))
	->setColumnVisibility(
	array(
	$any_context,
	true,
	true,
	true,
	true,
	$any_coverage,
	$any_coverage,
	$any_packages,
	))
	->setDeviceVisibility(
	array(
	true,
	true,
	true,
	true,
	true,
	false,
	false,
	true,
	));

	$anchor = id(new PhabricatorAnchorView())
	->setAnchorName('toc')
	->setNavigationMarker(true);

	+ if ($this->bare) {
	+ return $table;
	+ }
	+
	$header = id(new PHUIHeaderView())
	->setHeader(pht('Table of Contents'));

	if ($this->header) {
	$header = $this->header;
	}

	$box = id(new PHUIObjectBoxView())
	->setHeader($header)
	->setBackground($this->background)
	->setTable($table)
	->appendChild($anchor)
	->appendChild($buttons);

	if ($this->infoView) {
	$box->setInfoView($this->infoView);
	}
	return $box;
	}

	}

File Metadata

Mime Type: text/x-diff
Expires: Fri, Mar 14, 9:32 AM (21 h, 35 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 71748
Default Alt Text: (65 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions