No OneTemporary
Actions

Size

100 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 bc0ccaeedb..ee0e13f6eb 100644
	--- a/src/applications/differential/controller/DifferentialRevisionViewController.php
	+++ b/src/applications/differential/controller/DifferentialRevisionViewController.php
	@@ -1,1008 +1,959 @@
	<?php

	final class DifferentialRevisionViewController extends DifferentialController {

	private $revisionID;

	public function shouldRequireLogin() {
	if ($this->allowsAnonymousAccess()) {
	return false;
	}
	return parent::shouldRequireLogin();
	}

	public function shouldAllowPublic() {
	return true;
	}

	public function willProcessRequest(array $data) {
	$this->revisionID = $data['id'];
	}

	public function processRequest() {

	$request = $this->getRequest();
	$user = $request->getUser();
	$viewer_is_anonymous = !$user->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(
	"This revision has no diffs. Something has gone quite wrong.");
	}

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

	$arc_project = $target->loadArcanistProject();
	$repository = ($arc_project ? $arc_project->loadRepository() : null);

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

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

	$props = id(new DifferentialDiffProperty())->loadAllWhere(
	'diffID = %d',
	$target_manual->getID());
	$props = mpull($props, 'getData', 'getName');

	$aux_fields = $this->loadAuxiliaryFields($revision);

	$comments = $revision->loadComments();
	- $comments = array_merge(
	- $this->getImplicitComments($revision, reset($diffs)),
	- $comments);

	$all_changesets = $changesets;
	$inlines = $this->loadInlineComments(
	$revision,
	$all_changesets);

	$object_phids = array_merge(
	$revision->getReviewers(),
	$revision->getCCPHIDs(),
	$revision->loadCommitPHIDs(),
	array(
	$revision->getAuthorPHID(),
	$user->getPHID(),
	),
	mpull($comments, 'getAuthorPHID'));

	foreach ($comments as $comment) {
	- $metadata = $comment->getMetadata();
	- $added_reviewers = idx(
	- $metadata,
	- DifferentialComment::METADATA_ADDED_REVIEWERS);
	- if ($added_reviewers) {
	- foreach ($added_reviewers as $phid) {
	- $object_phids[] = $phid;
	- }
	- }
	- $added_ccs = idx(
	- $metadata,
	- DifferentialComment::METADATA_ADDED_CCS);
	- if ($added_ccs) {
	- foreach ($added_ccs as $phid) {
	- $object_phids[] = $phid;
	- }
	+ foreach ($comment->getRequiredHandlePHIDs() as $phid) {
	+ $object_phids[] = $phid;
	}
	}

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

	$aux_phids = array();
	foreach ($aux_fields as $key => $aux_field) {
	$aux_field->setDiff($target);
	$aux_field->setManualDiff($target_manual);
	$aux_field->setDiffProperties($props);
	$aux_phids[$key] = $aux_field->getRequiredHandlePHIDsForRevisionView();
	}
	$object_phids = array_merge($object_phids, array_mergev($aux_phids));
	$object_phids = array_unique($object_phids);

	$handles = $this->loadViewerHandles($object_phids);

	foreach ($aux_fields as $key => $aux_field) {
	// Make sure each field only has access to handles it specifically
	// requested, not all handles. Otherwise you can get a field which works
	// only in the presence of other fields.
	$aux_field->setHandles(array_select_keys($handles, $aux_phids[$key]));
	}

	$reviewer_warning = null;
	if ($revision->getStatus() ==
	ArcanistDifferentialRevisionStatus::NEEDS_REVIEW) {
	$has_live_reviewer = false;
	foreach ($revision->getReviewers() as $reviewer) {
	if (!$handles[$reviewer]->isDisabled()) {
	$has_live_reviewer = true;
	break;
	}
	}
	if (!$has_live_reviewer) {
	$reviewer_warning = new AphrontErrorView();
	$reviewer_warning->setSeverity(AphrontErrorView::SEVERITY_WARNING);
	$reviewer_warning->setTitle(pht('No Active Reviewers'));
	if ($revision->getReviewers()) {
	$reviewer_warning->appendChild(
	phutil_tag(
	'p',
	array(),
	pht('All specified reviewers are disabled and this revision '.
	'needs review. You may want to add some new reviewers.')));
	} else {
	$reviewer_warning->appendChild(
	phutil_tag(
	'p',
	array(),
	pht('This revision has no specified reviewers and needs '.
	'review. You may want to add some reviewers.')));
	}
	}
	}

	$request_uri = $request->getRequestURI();

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

	$my_inlines = id(new DifferentialInlineCommentQuery())
	->withDraftComments($user->getPHID(), $this->revisionID)
	->execute();

	$visible_changesets = array();
	foreach ($inlines + $my_inlines as $inline) {
	$changeset_id = $inline->getChangesetID();
	if (isset($changesets[$changeset_id])) {
	$visible_changesets[$changeset_id] = $changesets[$changeset_id];
	}
	}

	if (!empty($props['arc:lint'])) {
	$changeset_paths = mpull($changesets, null, 'getFilename');
	foreach ($props['arc:lint'] as $lint) {
	$changeset = idx($changeset_paths, $lint['path']);
	if ($changeset) {
	$visible_changesets[$changeset->getID()] = $changeset;
	}
	}
	}

	} else {
	$warning = null;
	$visible_changesets = $changesets;
	}

	$revision_detail = id(new DifferentialRevisionDetailView())
	->setUser($user)
	->setRevision($revision)
	->setDiff(end($diffs))
	->setAuxiliaryFields($aux_fields)
	->setURI($request->getRequestURI());

	$actions = $this->getRevisionActions($revision);

	$custom_renderer_class = PhabricatorEnv::getEnvConfig(
	'differential.revision-custom-detail-renderer');
	if ($custom_renderer_class) {

	// TODO: build a better version of the action links and deprecate the
	// whole DifferentialRevisionDetailRenderer class.
	$custom_renderer = newv($custom_renderer_class, array());
	$custom_renderer->setUser($user);
	$custom_renderer->setDiff($target);
	if ($diff_vs) {
	$custom_renderer->setVSDiff($diffs[$diff_vs]);
	}
	$actions = array_merge(
	$actions,
	$custom_renderer->generateActionLinks($revision, $target_manual));
	}

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

	if ($arc_project) {
	list($symbol_indexes, $project_phids) = $this->buildSymbolIndexes(
	$arc_project,
	$visible_changesets);
	} else {
	$symbol_indexes = array();
	$project_phids = null;
	}

	$revision_detail->setActions($actions);
	$revision_detail->setUser($user);

	$comment_view = new DifferentialRevisionCommentListView();
	$comment_view->setComments($comments);
	$comment_view->setHandles($handles);
	$comment_view->setInlineComments($inlines);
	$comment_view->setChangesets($all_changesets);
	$comment_view->setUser($user);
	$comment_view->setTargetDiff($target);
	$comment_view->setVersusDiffID($diff_vs);

	if ($arc_project) {
	Javelin::initBehavior(
	'repository-crossreference',
	array(
	'section' => $comment_view->getID(),
	'projects' => $project_phids,
	));
	}

	$changeset_view = new DifferentialChangesetListView();
	$changeset_view->setChangesets($changesets);
	$changeset_view->setVisibleChangesets($visible_changesets);

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

	$changeset_view->setStandaloneURI('/differential/changeset/');
	$changeset_view->setRawFileURIs(
	'/differential/changeset/?view=old',
	'/differential/changeset/?view=new');

	$changeset_view->setUser($user);
	$changeset_view->setDiff($target);
	$changeset_view->setRenderingReferences($rendering_references);
	$changeset_view->setVsMap($vs_map);
	$changeset_view->setWhitespace($whitespace);
	if ($repository) {
	$changeset_view->setRepository($repository);
	}
	$changeset_view->setSymbolIndexes($symbol_indexes);
	$changeset_view->setTitle('Diff '.$target->getID());

	$diff_history = new DifferentialRevisionUpdateHistoryView();
	$diff_history->setDiffs($diffs);
	$diff_history->setSelectedVersusDiffID($diff_vs);
	$diff_history->setSelectedDiffID($target->getID());
	$diff_history->setSelectedWhitespace($whitespace);
	$diff_history->setUser($user);

	$local_view = new DifferentialLocalCommitsView();
	$local_view->setUser($user);
	$local_view->setLocalCommits(idx($props, 'local:commits'));

	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 = new DifferentialDiffTableOfContentsView();
	$toc_view->setChangesets($changesets);
	$toc_view->setVisibleChangesets($visible_changesets);
	$toc_view->setRenderingReferences($rendering_references);
	$toc_view->setUnitTestData(idx($props, 'arc:unit', array()));
	if ($repository) {
	$toc_view->setRepository($repository);
	}
	$toc_view->setDiff($target);
	$toc_view->setUser($user);
	$toc_view->setRevisionID($revision->getID());
	$toc_view->setWhitespace($whitespace);

	$comment_form = null;
	if (!$viewer_is_anonymous) {
	$draft = id(new PhabricatorDraft())->loadOneWhere(
	'authorPHID = %s AND draftKey = %s',
	$user->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 = new DifferentialAddCommentView();
	$comment_form->setRevision($revision);
	$comment_form->setAuxFields($aux_fields);
	$comment_form->setActions($this->getRevisionCommentActions($revision));
	$comment_form->setActionURI('/differential/comment/save/');
	$comment_form->setUser($user);
	$comment_form->setDraft($draft);
	$comment_form->setReviewers(mpull($reviewers, 'getFullName', 'getPHID'));
	$comment_form->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);
	}

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

	$page_pane = id(new DifferentialPrimaryPaneView())
	->setID($pane_id)
	->appendChild(array(
	$comment_view,
	$diff_history,
	$warning,
	$local_view,
	$toc_view,
	$other_view,
	$changeset_view,
	));
	if ($comment_form) {
	$page_pane->appendChild($comment_form);
	} else {
	// TODO: For now, just use this to get "Login to Comment".
	$page_pane->appendChild(
	id(new PhabricatorApplicationTransactionCommentView())
	->setUser($user)
	->setRequestURI($request->getRequestURI()));
	}


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

	$top_anchor = id(new PhabricatorAnchorView())
	->setAnchorName('top')
	->setNavigationMarker(true);

	$content = array(
	$reviewer_warning,
	$top_anchor,
	$revision_detail,
	$page_pane,
	);

	$crumbs = $this->buildApplicationCrumbs();
	$crumbs->addCrumb(
	id(new PhabricatorCrumbView())
	->setName($object_id)
	->setHref('/'.$object_id));

	$prefs = $user->loadPreferences();

	$pref_filetree = PhabricatorUserPreferences::PREFERENCE_DIFF_FILETREE;
	if ($prefs->getPreference($pref_filetree)) {
	$collapsed = $prefs->getPreference(
	PhabricatorUserPreferences::PREFERENCE_NAV_COLLAPSED,
	false);

	$nav = id(new DifferentialChangesetFileTreeSideNavBuilder())
	->setAnchorName('top')
	->setTitle('D'.$revision->getID())
	->setBaseURI(new PhutilURI('/D'.$revision->getID()))
	->setCollapsed((bool)$collapsed)
	->build($changesets);
	$nav->appendChild($content);
	$nav->setCrumbs($crumbs);
	$content = $nav;
	} else {
	array_unshift($content, $crumbs);
	}

	return $this->buildApplicationPage(
	$content,
	array(
	'title' => $object_id.' '.$revision->getTitle(),
	'pageObjects' => array($revision->getPHID()),
	));
	}

	- private function getImplicitComments(
	- DifferentialRevision $revision,
	- DifferentialDiff $diff) {
	-
	- $author_phid = nonempty(
	- $diff->getAuthorPHID(),
	- $revision->getAuthorPHID());
	-
	- $template = new DifferentialComment();
	- $template->setAuthorPHID($author_phid);
	- $template->setRevisionID($revision->getID());
	- $template->setDateCreated($revision->getDateCreated());
	-
	- $comments = array();
	-
	- if (strlen($revision->getSummary())) {
	- $summary_comment = clone $template;
	- $summary_comment->setContent($revision->getSummary());
	- $summary_comment->setAction(DifferentialAction::ACTION_SUMMARIZE);
	- $comments[] = $summary_comment;
	- }
	-
	- if (strlen($revision->getTestPlan())) {
	- $testplan_comment = clone $template;
	- $testplan_comment->setContent($revision->getTestPlan());
	- $testplan_comment->setAction(DifferentialAction::ACTION_TESTPLAN);
	- $comments[] = $testplan_comment;
	- }
	-
	- return $comments;
	- }
	-
	private function getRevisionActions(DifferentialRevision $revision) {
	$user = $this->getRequest()->getUser();
	$viewer_phid = $user->getPHID();
	$viewer_is_owner = ($revision->getAuthorPHID() == $viewer_phid);
	$viewer_is_reviewer = in_array($viewer_phid, $revision->getReviewers());
	$viewer_is_cc = in_array($viewer_phid, $revision->getCCPHIDs());
	$logged_in = $this->getRequest()->getUser()->isLoggedIn();
	$status = $revision->getStatus();
	$revision_id = $revision->getID();
	$revision_phid = $revision->getPHID();

	$links = array();

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

	$links[] = array(
	'icon' => 'edit',
	'href' => "/differential/revision/edit/{$revision_id}/",
	'name' => pht('Edit Revision'),
	'disabled' => !$can_edit,
	'sigil' => $can_edit ? null : 'workflow',
	);

	if (!$viewer_is_owner && !$viewer_is_reviewer) {
	$action = $viewer_is_cc ? 'rem' : 'add';
	$links[] = array(
	'icon' => $viewer_is_cc ? 'disable' : 'check',
	'href' => "/differential/subscribe/{$action}/{$revision_id}/",
	'name' => $viewer_is_cc ? pht('Unsubscribe') : pht('Subscribe'),
	'instant' => $logged_in,
	'disabled' => !$logged_in,
	'sigil' => $can_edit ? null : 'workflow',
	);
	} else {
	$links[] = array(
	'icon' => 'enable',
	'name' => pht('Automatically Subscribed'),
	'disabled' => true,
	);
	}

	require_celerity_resource('phabricator-object-selector-css');
	require_celerity_resource('javelin-behavior-phabricator-object-selector');

	$links[] = array(
	'icon' => 'link',
	'name' => pht('Edit Dependencies'),
	'href' => "/search/attach/{$revision_phid}/DREV/dependencies/",
	'sigil' => 'workflow',
	'disabled' => !$can_edit,
	);

	$maniphest = 'PhabricatorApplicationManiphest';
	if (PhabricatorApplication::isClassInstalled($maniphest)) {
	$links[] = array(
	'icon' => 'attach',
	'name' => pht('Edit Maniphest Tasks'),
	'href' => "/search/attach/{$revision_phid}/TASK/",
	'sigil' => 'workflow',
	'disabled' => !$can_edit,
	);
	}

	$request_uri = $this->getRequest()->getRequestURI();
	$links[] = array(
	'icon' => 'download',
	'name' => pht('Download Raw Diff'),
	'href' => $request_uri->alter('download', 'true')
	);

	return $links;
	}

	private function getRevisionCommentActions(DifferentialRevision $revision) {

	$actions = array(
	DifferentialAction::ACTION_COMMENT => true,
	);

	$viewer = $this->getRequest()->getUser();
	$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_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:
	$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_ACCEPT] = true;
	$actions[DifferentialAction::ACTION_REJECT] = true;
	$actions[DifferentialAction::ACTION_RESIGN] = $viewer_is_reviewer;
	break;
	case ArcanistDifferentialRevisionStatus::NEEDS_REVISION:
	$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_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 loadInlineComments(
	DifferentialRevision $revision,
	array &$changesets) {
	assert_instances_of($changesets, 'DifferentialChangeset');

	$inline_comments = array();

	$inline_comments = id(new DifferentialInlineCommentQuery())
	->withRevisionIDs(array($revision->getID()))
	->withNotDraft(true)
	->execute();

	$load_changesets = array();
	foreach ($inline_comments as $inline) {
	$changeset_id = $inline->getChangesetID();
	if (isset($changesets[$changeset_id])) {
	continue;
	}
	$load_changesets[$changeset_id] = true;
	}

	$more_changesets = array();
	if ($load_changesets) {
	$changeset_ids = array_keys($load_changesets);
	$more_changesets += id(new DifferentialChangeset())
	->loadAllWhere(
	'id IN (%Ld)',
	$changeset_ids);
	}

	if ($more_changesets) {
	$changesets += $more_changesets;
	$changesets = msort($changesets, 'getSortKey');
	}

	return $inline_comments;
	}

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

	$load_ids = array();
	if ($diff_vs) {
	$load_ids[] = $diff_vs->getID();
	}
	$load_ids[] = $target->getID();

	$raw_changesets = id(new DifferentialChangeset())
	->loadAllWhere(
	'diffID IN (%Ld)',
	$load_ids);
	$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 loadAuxiliaryFields(DifferentialRevision $revision) {

	$aux_fields = DifferentialFieldSelector::newSelector()
	->getFieldSpecifications();
	foreach ($aux_fields as $key => $aux_field) {
	if (!$aux_field->shouldAppearOnRevisionView()) {
	unset($aux_fields[$key]);
	} else {
	$aux_field->setUser($this->getRequest()->getUser());
	}
	}

	$aux_fields = DifferentialAuxiliaryField::loadFromStorage(
	$revision,
	$aux_fields);

	return $aux_fields;
	}

	private function buildSymbolIndexes(
	PhabricatorRepositoryArcanistProject $arc_project,
	array $visible_changesets) {
	assert_instances_of($visible_changesets, 'DifferentialChangeset');

	$engine = PhabricatorSyntaxHighlighter::newEngine();

	$langs = $arc_project->getSymbolIndexLanguages();
	if (!$langs) {
	return array(array(), array());
	}

	$symbol_indexes = array();

	$project_phids = array_merge(
	array($arc_project->getPHID()),
	nonempty($arc_project->getSymbolIndexProjects(), array()));

	$indexed_langs = array_fill_keys($langs, true);
	foreach ($visible_changesets as $key => $changeset) {
	$lang = $engine->getLanguageFromFilename($changeset->getFilename());
	if (isset($indexed_langs[$lang])) {
	$symbol_indexes[$key] = array(
	'lang' => $lang,
	'projects' => $project_phids,
	);
	}
	}

	return array($symbol_indexes, $project_phids);
	}

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

	$query = id(new DifferentialRevisionQuery())
	->setViewer($this->getRequest()->getUser())
	->withStatus(DifferentialRevisionQuery::STATUS_OPEN)
	->setOrder(DifferentialRevisionQuery::ORDER_PATH_MODIFIED)
	->setLimit(10)
	->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');

	$user = $this->getRequest()->getUser();

	$view = id(new DifferentialRevisionListView())
	->setRevisions($revisions)
	->setFields(DifferentialRevisionListView::getDefaultFields($user))
	->setUser($user)
	->loadAssets();

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

	return id(new PHUIObjectBoxView())
	->setHeaderText(pht('Open Revisions Affecting These Files'))
	->appendChild($view);
	}


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

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

	$viewer = $this->getRequest()->getUser();

	$engine = new PhabricatorDifferenceEngine();
	$generated_changesets = array();
	foreach ($changesets as $changeset) {
	$changeset->attachHunks($changeset->loadHunks());
	$right = $changeset->makeNewFile();
	$choice = $changeset;
	$vs = idx($vs_map, $changeset->getID());
	if ($vs == -1) {
	$left = $right;
	$right = $changeset->makeOldFile();
	} else if ($vs) {
	$choice = $vs_changeset = $vs_changesets[$vs];
	$vs_changeset->attachHunks($vs_changeset->loadHunks());
	$left = $vs_changeset->makeNewFile();
	} else {
	$left = $changeset->makeOldFile();
	}

	$synthetic = $engine->generateChangesetFromFileContent(
	$left,
	$right);

	if (!$synthetic->getAffectedLineCount()) {
	$filetype = $choice->getFileType();
	if ($filetype == DifferentialChangeType::FILE_TEXT \|\|
	$filetype == DifferentialChangeType::FILE_SYMLINK) {
	continue;
	}
	}

	$choice->attachHunks($synthetic->getHunks());

	$generated_changesets[] = $choice;
	}

	$diff = new DifferentialDiff();
	$diff->attachChangesets($generated_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,
	));

	return id(new AphrontRedirectResponse())->setURI($file->getBestURI());

	}
	}
	diff --git a/src/applications/differential/editor/DifferentialCommentEditor.php b/src/applications/differential/editor/DifferentialCommentEditor.php
	index 36d38bc58b..0fef83eb2d 100644
	--- a/src/applications/differential/editor/DifferentialCommentEditor.php
	+++ b/src/applications/differential/editor/DifferentialCommentEditor.php
	@@ -1,771 +1,771 @@
	<?php

	final class DifferentialCommentEditor extends PhabricatorEditor {

	protected $revision;
	protected $action;

	protected $attachInlineComments;
	protected $message;
	protected $changedByCommit;
	protected $addedReviewers = array();
	protected $removedReviewers = array();
	private $addedCCs = array();

	private $parentMessageID;
	private $contentSource;
	private $noEmail;

	private $isDaemonWorkflow;

	public function __construct(
	DifferentialRevision $revision,
	$action) {

	$this->revision = $revision;
	$this->action = $action;
	}

	public function setParentMessageID($parent_message_id) {
	$this->parentMessageID = $parent_message_id;
	return $this;
	}

	public function setMessage($message) {
	$this->message = $message;
	return $this;
	}

	public function setAttachInlineComments($attach) {
	$this->attachInlineComments = $attach;
	return $this;
	}

	public function setChangedByCommit($changed_by_commit) {
	$this->changedByCommit = $changed_by_commit;
	return $this;
	}

	public function getChangedByCommit() {
	return $this->changedByCommit;
	}

	public function setAddedReviewers(array $added_reviewers) {
	$this->addedReviewers = $added_reviewers;
	return $this;
	}

	public function getAddedReviewers() {
	return $this->addedReviewers;
	}

	public function setRemovedReviewers(array $removeded_reviewers) {
	$this->removedReviewers = $removeded_reviewers;
	return $this;
	}

	public function getRemovedReviewers() {
	return $this->removedReviewers;
	}

	public function setAddedCCs($added_ccs) {
	$this->addedCCs = $added_ccs;
	return $this;
	}

	public function getAddedCCs() {
	return $this->addedCCs;
	}

	public function setContentSource(PhabricatorContentSource $content_source) {
	$this->contentSource = $content_source;
	return $this;
	}

	public function setIsDaemonWorkflow($is_daemon) {
	$this->isDaemonWorkflow = $is_daemon;
	return $this;
	}

	public function setNoEmail($no_email) {
	$this->noEmail = $no_email;
	return $this;
	}

	public function save() {
	$actor = $this->requireActor();

	// Reload the revision to pick up reviewer status, until we can lift this
	// out of here.
	$this->revision = id(new DifferentialRevisionQuery())
	->setViewer($actor)
	->withIDs(array($this->revision->getID()))
	->needRelationships(true)
	->needReviewerStatus(true)
	->needReviewerAuthority(true)
	->executeOne();

	$revision = $this->revision;
	$action = $this->action;
	$actor_phid = $actor->getPHID();
	$actor_is_author = ($actor_phid == $revision->getAuthorPHID());
	$allow_self_accept = PhabricatorEnv::getEnvConfig(
	'differential.allow-self-accept');
	$always_allow_close = PhabricatorEnv::getEnvConfig(
	'differential.always-allow-close');
	$allow_reopen = PhabricatorEnv::getEnvConfig(
	'differential.allow-reopen');
	$revision_status = $revision->getStatus();
	$update_accepted_status = false;

	$reviewer_phids = $revision->getReviewers();
	if ($reviewer_phids) {
	$reviewer_phids = array_fuse($reviewer_phids);
	}

	$metadata = array();

	$inline_comments = array();
	if ($this->attachInlineComments) {
	$inline_comments = id(new DifferentialInlineCommentQuery())
	->withDraftComments($actor_phid, $revision->getID())
	->execute();
	}

	switch ($action) {
	case DifferentialAction::ACTION_COMMENT:
	if (!$this->message && !$inline_comments) {
	throw new DifferentialActionHasNoEffectException(
	"You are submitting an empty comment with no action: ".
	"you must act on the revision or post a comment.");
	}

	// If the actor is a reviewer, and their status is "added" (that is,
	// they haven't accepted or requested changes to the revision),
	// upgrade their status to "commented". If they have a stronger status
	// already, don't overwrite it.
	if (isset($reviewer_phids[$actor_phid])) {
	$status_added = DifferentialReviewerStatus::STATUS_ADDED;
	$reviewer_status = $revision->getReviewerStatus();
	foreach ($reviewer_status as $reviewer) {
	if ($reviewer->getReviewerPHID() == $actor_phid) {
	if ($reviewer->getStatus() == $status_added) {
	DifferentialRevisionEditor::updateReviewerStatus(
	$revision,
	$actor,
	$actor_phid,
	DifferentialReviewerStatus::STATUS_COMMENTED);
	}
	}
	}
	}

	break;

	case DifferentialAction::ACTION_RESIGN:
	if ($actor_is_author) {
	throw new Exception('You can not resign from your own revision!');
	}
	if (empty($reviewer_phids[$actor_phid])) {
	throw new DifferentialActionHasNoEffectException(
	"You can not resign from this revision because you are not ".
	"a reviewer.");
	}

	list($added_reviewers, $ignored) = $this->alterReviewers();
	if ($added_reviewers) {
	$key = DifferentialComment::METADATA_ADDED_REVIEWERS;
	$metadata[$key] = $added_reviewers;
	}

	DifferentialRevisionEditor::updateReviewers(
	$revision,
	$actor,
	array(),
	array($actor_phid));

	// If you are a blocking reviewer, your presence as a reviewer may be
	// the only thing keeping a revision from transitioning to "accepted".
	// Recalculate state after removing the resigning reviewer.
	switch ($revision_status) {
	case ArcanistDifferentialRevisionStatus::NEEDS_REVISION:
	case ArcanistDifferentialRevisionStatus::NEEDS_REVIEW:
	$update_accepted_status = true;
	break;
	}

	break;

	case DifferentialAction::ACTION_ABANDON:
	if (!$actor_is_author) {
	throw new Exception('You can only abandon your own revisions.');
	}

	if ($revision_status == ArcanistDifferentialRevisionStatus::CLOSED) {
	throw new DifferentialActionHasNoEffectException(
	"You can not abandon this revision because it has already ".
	"been closed.");
	}

	if ($revision_status == ArcanistDifferentialRevisionStatus::ABANDONED) {
	throw new DifferentialActionHasNoEffectException(
	"You can not abandon this revision because it has already ".
	"been abandoned.");
	}

	$revision->setStatus(ArcanistDifferentialRevisionStatus::ABANDONED);
	break;

	case DifferentialAction::ACTION_ACCEPT:
	if ($actor_is_author && !$allow_self_accept) {
	throw new Exception('You can not accept your own revision.');
	}

	switch ($revision_status) {
	case ArcanistDifferentialRevisionStatus::ABANDONED:
	throw new DifferentialActionHasNoEffectException(
	"You can not accept this revision because it has been ".
	"abandoned.");
	case ArcanistDifferentialRevisionStatus::CLOSED:
	throw new DifferentialActionHasNoEffectException(
	"You can not accept this revision because it has already ".
	"been closed.");
	case ArcanistDifferentialRevisionStatus::NEEDS_REVIEW:
	case ArcanistDifferentialRevisionStatus::NEEDS_REVISION:
	case ArcanistDifferentialRevisionStatus::ACCEPTED:
	// We expect "Accept" from these states.
	break;
	default:
	throw new Exception(
	"Unexpected revision state '{$revision_status}'!");
	}

	$was_reviewer_already = false;
	foreach ($revision->getReviewerStatus() as $reviewer) {
	if ($reviewer->hasAuthority($actor)) {
	DifferentialRevisionEditor::updateReviewerStatus(
	$revision,
	$actor,
	$reviewer->getReviewerPHID(),
	DifferentialReviewerStatus::STATUS_ACCEPTED);
	if ($reviewer->getReviewerPHID() == $actor_phid) {
	$was_reviewer_already = true;
	}
	}
	}

	if (!$was_reviewer_already) {
	DifferentialRevisionEditor::updateReviewerStatus(
	$revision,
	$actor,
	$actor_phid,
	DifferentialReviewerStatus::STATUS_ACCEPTED);
	}

	$update_accepted_status = true;
	break;

	case DifferentialAction::ACTION_REQUEST:
	if (!$actor_is_author) {
	throw new Exception('You must own a revision to request review.');
	}

	switch ($revision_status) {
	case ArcanistDifferentialRevisionStatus::ACCEPTED:
	case ArcanistDifferentialRevisionStatus::NEEDS_REVISION:
	$revision->setStatus(
	ArcanistDifferentialRevisionStatus::NEEDS_REVIEW);
	break;
	case ArcanistDifferentialRevisionStatus::NEEDS_REVIEW:
	throw new DifferentialActionHasNoEffectException(
	"You can not request review of this revision because it has ".
	"been abandoned.");
	case ArcanistDifferentialRevisionStatus::ABANDONED:
	throw new DifferentialActionHasNoEffectException(
	"You can not request review of this revision because it has ".
	"been abandoned.");
	case ArcanistDifferentialRevisionStatus::CLOSED:
	throw new DifferentialActionHasNoEffectException(
	"You can not request review of this revision because it has ".
	"already been closed.");
	default:
	throw new Exception(
	"Unexpected revision state '{$revision_status}'!");
	}

	list($added_reviewers, $ignored) = $this->alterReviewers();
	if ($added_reviewers) {
	$key = DifferentialComment::METADATA_ADDED_REVIEWERS;
	$metadata[$key] = $added_reviewers;
	}

	break;

	case DifferentialAction::ACTION_REJECT:
	if ($actor_is_author) {
	throw new Exception(
	'You can not request changes to your own revision.');
	}

	switch ($revision_status) {
	case ArcanistDifferentialRevisionStatus::ACCEPTED:
	case ArcanistDifferentialRevisionStatus::NEEDS_REVISION:
	case ArcanistDifferentialRevisionStatus::NEEDS_REVIEW:
	// We expect rejects from these states.
	break;
	case ArcanistDifferentialRevisionStatus::ABANDONED:
	throw new DifferentialActionHasNoEffectException(
	"You can not request changes to this revision because it has ".
	"been abandoned.");
	case ArcanistDifferentialRevisionStatus::CLOSED:
	throw new DifferentialActionHasNoEffectException(
	"You can not request changes to this revision because it has ".
	"already been closed.");
	default:
	throw new Exception(
	"Unexpected revision state '{$revision_status}'!");
	}

	DifferentialRevisionEditor::updateReviewerStatus(
	$revision,
	$actor,
	$actor_phid,
	DifferentialReviewerStatus::STATUS_REJECTED);

	$revision
	->setStatus(ArcanistDifferentialRevisionStatus::NEEDS_REVISION);
	break;

	case DifferentialAction::ACTION_RETHINK:
	if (!$actor_is_author) {
	throw new Exception(
	"You can not plan changes to somebody else's revision");
	}

	switch ($revision_status) {
	case ArcanistDifferentialRevisionStatus::ACCEPTED:
	case ArcanistDifferentialRevisionStatus::NEEDS_REVISION:
	case ArcanistDifferentialRevisionStatus::NEEDS_REVIEW:
	// We expect accepts from these states.
	break;
	case ArcanistDifferentialRevisionStatus::ABANDONED:
	throw new DifferentialActionHasNoEffectException(
	"You can not plan changes to this revision because it has ".
	"been abandoned.");
	case ArcanistDifferentialRevisionStatus::CLOSED:
	throw new DifferentialActionHasNoEffectException(
	"You can not plan changes to this revision because it has ".
	"already been closed.");
	default:
	throw new Exception(
	"Unexpected revision state '{$revision_status}'!");
	}

	$revision
	->setStatus(ArcanistDifferentialRevisionStatus::NEEDS_REVISION);
	break;

	case DifferentialAction::ACTION_RECLAIM:
	if (!$actor_is_author) {
	throw new Exception('You can not reclaim a revision you do not own.');
	}


	if ($revision_status != ArcanistDifferentialRevisionStatus::ABANDONED) {
	throw new DifferentialActionHasNoEffectException(
	"You can not reclaim this revision because it is not abandoned.");
	}

	$revision
	->setStatus(ArcanistDifferentialRevisionStatus::NEEDS_REVIEW);

	$update_accepted_status = true;
	break;

	case DifferentialAction::ACTION_CLOSE:

	// NOTE: The daemons can mark things closed from any state. We treat
	// them as completely authoritative.

	if (!$this->isDaemonWorkflow) {
	if (!$actor_is_author && !$always_allow_close) {
	throw new Exception(
	"You can not mark a revision you don't own as closed.");
	}

	$status_closed = ArcanistDifferentialRevisionStatus::CLOSED;
	$status_accepted = ArcanistDifferentialRevisionStatus::ACCEPTED;

	if ($revision_status == $status_closed) {
	throw new DifferentialActionHasNoEffectException(
	"You can not mark this revision as closed because it has ".
	"already been marked as closed.");
	}

	if ($revision_status != $status_accepted) {
	throw new DifferentialActionHasNoEffectException(
	"You can not mark this revision as closed because it is ".
	"has not been accepted.");
	}
	}

	if (!$revision->getDateCommitted()) {
	$revision->setDateCommitted(time());
	}

	$revision->setStatus(ArcanistDifferentialRevisionStatus::CLOSED);
	break;

	case DifferentialAction::ACTION_REOPEN:
	if (!$allow_reopen) {
	throw new Exception(
	"You cannot reopen a revision when this action is disabled.");
	}

	if ($revision_status != ArcanistDifferentialRevisionStatus::CLOSED) {
	throw new Exception(
	"You cannot reopen a revision that is not currently closed.");
	}

	$revision->setStatus(ArcanistDifferentialRevisionStatus::NEEDS_REVIEW);

	break;

	case DifferentialAction::ACTION_ADDREVIEWERS:
	list($added_reviewers, $ignored) = $this->alterReviewers();

	if ($added_reviewers) {
	$key = DifferentialComment::METADATA_ADDED_REVIEWERS;
	$metadata[$key] = $added_reviewers;
	} else {
	$user_tried_to_add = count($this->getAddedReviewers());
	if ($user_tried_to_add == 0) {
	throw new DifferentialActionHasNoEffectException(
	"You can not add reviewers, because you did not specify any ".
	"reviewers.");
	} else if ($user_tried_to_add == 1) {
	throw new DifferentialActionHasNoEffectException(
	"You can not add that reviewer, because they are already an ".
	"author or reviewer.");
	} else {
	throw new DifferentialActionHasNoEffectException(
	"You can not add those reviewers, because they are all already ".
	"authors or reviewers.");
	}
	}

	break;
	case DifferentialAction::ACTION_ADDCCS:
	$added_ccs = $this->getAddedCCs();
	$user_tried_to_add = count($added_ccs);

	$added_ccs = $this->filterAddedCCs($added_ccs);

	if ($added_ccs) {
	foreach ($added_ccs as $cc) {
	DifferentialRevisionEditor::addCC(
	$revision,
	$cc,
	$actor_phid);
	}

	$key = DifferentialComment::METADATA_ADDED_CCS;
	$metadata[$key] = $added_ccs;

	} else {
	if ($user_tried_to_add == 0) {
	throw new DifferentialActionHasNoEffectException(
	"You can not add CCs, because you did not specify any ".
	"CCs.");
	} else if ($user_tried_to_add == 1) {
	throw new DifferentialActionHasNoEffectException(
	"You can not add that CC, because they are already an ".
	"author, reviewer or CC.");
	} else {
	throw new DifferentialActionHasNoEffectException(
	"You can not add those CCs, because they are all already ".
	"authors, reviewers or CCs.");
	}
	}
	break;
	case DifferentialAction::ACTION_CLAIM:
	if ($actor_is_author) {
	throw new Exception("You can not commandeer your own revision.");
	}

	switch ($revision_status) {
	case ArcanistDifferentialRevisionStatus::CLOSED:
	throw new DifferentialActionHasNoEffectException(
	"You can not commandeer this revision because it has ".
	"already been closed.");
	break;
	}

	$this->setAddedReviewers(array($revision->getAuthorPHID()));
	$this->setRemovedReviewers(array($actor_phid));

	// NOTE: Set the new author PHID before calling addReviewers(), since it
	// doesn't permit the author to become a reviewer.
	$revision->setAuthorPHID($actor_phid);

	list($added_reviewers, $removed_reviewers) = $this->alterReviewers();
	if ($added_reviewers) {
	$key = DifferentialComment::METADATA_ADDED_REVIEWERS;
	$metadata[$key] = $added_reviewers;
	}

	if ($removed_reviewers) {
	$key = DifferentialComment::METADATA_REMOVED_REVIEWERS;
	$metadata[$key] = $removed_reviewers;
	}

	break;
	default:
	throw new Exception('Unsupported action.');
	}

	// Update information about reviewer in charge.
	if ($action == DifferentialAction::ACTION_ACCEPT \|\|
	$action == DifferentialAction::ACTION_REJECT) {
	$revision->setLastReviewerPHID($actor_phid);
	}

	// TODO: Call beginReadLocking() prior to loading the revision.
	$revision->openTransaction();

	// Always save the revision (even if we didn't actually change any of its
	// properties) so that it jumps to the top of the revision list when sorted
	// by "updated". Notably, this allows "ping" comments to push it to the
	// top of the action list.
	$revision->save();

	if ($update_accepted_status) {
	$revision = DifferentialRevisionEditor::updateAcceptedStatus(
	$actor,
	$revision);
	}

	if ($action != DifferentialAction::ACTION_RESIGN) {
	DifferentialRevisionEditor::addCC(
	$revision,
	$actor_phid,
	$actor_phid);
	}

	$is_new = !$revision->getID();

	$event = new PhabricatorEvent(
	PhabricatorEventType::TYPE_DIFFERENTIAL_WILLEDITREVISION,
	array(
	'revision' => $revision,
	'new' => $is_new,
	));

	$event->setUser($actor);
	PhutilEventEngine::dispatchEvent($event);

	$comment = id(new DifferentialComment())
	->setAuthorPHID($actor_phid)
	- ->setRevisionID($revision->getID())
	+ ->setRevision($revision)
	->setAction($action)
	->setContent((string)$this->message)
	->setMetadata($metadata);

	if ($this->contentSource) {
	$comment->setContentSource($this->contentSource);
	}

	$comment->save();

	$changesets = array();
	if ($inline_comments) {
	$load_ids = mpull($inline_comments, 'getChangesetID');
	if ($load_ids) {
	$load_ids = array_unique($load_ids);
	$changesets = id(new DifferentialChangeset())->loadAllWhere(
	'id in (%Ld)',
	$load_ids);
	}
	foreach ($inline_comments as $inline) {
	$inline->setCommentID($comment->getID());
	$inline->save();
	}
	}

	// Find any "@mentions" in the comment blocks.
	$content_blocks = array($comment->getContent());
	foreach ($inline_comments as $inline) {
	$content_blocks[] = $inline->getContent();
	}
	$mention_ccs = PhabricatorMarkupEngine::extractPHIDsFromMentions(
	$content_blocks);
	if ($mention_ccs) {
	$mention_ccs = $this->filterAddedCCs($mention_ccs);
	if ($mention_ccs) {
	$metadata = $comment->getMetadata();
	$metacc = idx(
	$metadata,
	DifferentialComment::METADATA_ADDED_CCS,
	array());
	foreach ($mention_ccs as $cc_phid) {
	DifferentialRevisionEditor::addCC(
	$revision,
	$cc_phid,
	$actor_phid);
	$metacc[] = $cc_phid;
	}
	$metadata[DifferentialComment::METADATA_ADDED_CCS] = $metacc;

	$comment->setMetadata($metadata);
	$comment->save();

	$event = new PhabricatorEvent(
	PhabricatorEventType::TYPE_DIFFERENTIAL_DIDEDITREVISION,
	array(
	'revision' => $revision,
	'new' => $is_new,
	));
	$event->setUser($actor);
	PhutilEventEngine::dispatchEvent($event);
	}
	}

	$revision->saveTransaction();

	$phids = array($actor_phid);
	$handles = id(new PhabricatorHandleQuery())
	->setViewer($actor)
	->withPHIDs($phids)
	->execute();
	$actor_handle = $handles[$actor_phid];

	$xherald_header = HeraldTranscript::loadXHeraldRulesHeader(
	$revision->getPHID());

	$mailed_phids = array();
	if (!$this->noEmail) {
	$mail = id(new DifferentialCommentMail(
	$revision,
	$actor_handle,
	$comment,
	$changesets,
	$inline_comments))
	->setActor($actor)
	->setExcludeMailRecipientPHIDs($this->getExcludeMailRecipientPHIDs())
	->setToPHIDs(
	array_merge(
	$revision->getReviewers(),
	array($revision->getAuthorPHID())))
	->setCCPHIDs($revision->getCCPHIDs())
	->setChangedByCommit($this->getChangedByCommit())
	->setXHeraldRulesHeader($xherald_header)
	->setParentMessageID($this->parentMessageID)
	->send();

	$mailed_phids = $mail->getRawMail()->buildRecipientList();
	}

	$event_data = array(
	'revision_id' => $revision->getID(),
	'revision_phid' => $revision->getPHID(),
	'revision_name' => $revision->getTitle(),
	'revision_author_phid' => $revision->getAuthorPHID(),
	'action' => $comment->getAction(),
	'feedback_content' => $comment->getContent(),
	'actor_phid' => $actor_phid,

	// NOTE: Don't use this, it will be removed after ApplicationTransactions.
	// For now, it powers inline comment rendering over the Asana brdige.
	'temporaryCommentID' => $comment->getID(),
	);

	id(new PhabricatorFeedStoryPublisher())
	->setStoryType('PhabricatorFeedStoryDifferential')
	->setStoryData($event_data)
	->setStoryTime(time())
	->setStoryAuthorPHID($actor_phid)
	->setRelatedPHIDs(
	array(
	$revision->getPHID(),
	$actor_phid,
	$revision->getAuthorPHID(),
	))
	->setPrimaryObjectPHID($revision->getPHID())
	->setSubscribedPHIDs(
	array_merge(
	array($revision->getAuthorPHID()),
	$revision->getReviewers(),
	$revision->getCCPHIDs()))
	->setMailRecipientPHIDs($mailed_phids)
	->publish();

	id(new PhabricatorSearchIndexer())
	->indexDocumentByPHID($revision->getPHID());

	return $comment;
	}

	private function filterAddedCCs(array $ccs) {
	$revision = $this->revision;

	$current_ccs = $revision->getCCPHIDs();
	$current_ccs = array_fill_keys($current_ccs, true);

	$reviewer_phids = $revision->getReviewers();
	$reviewer_phids = array_fill_keys($reviewer_phids, true);

	foreach ($ccs as $key => $cc) {
	if (isset($current_ccs[$cc])) {
	unset($ccs[$key]);
	}
	if (isset($reviewer_phids[$cc])) {
	unset($ccs[$key]);
	}
	if ($cc == $revision->getAuthorPHID()) {
	unset($ccs[$key]);
	}
	}

	return $ccs;
	}

	private function alterReviewers() {
	$actor_phid = $this->getActor()->getPHID();
	$revision = $this->revision;
	$added_reviewers = $this->getAddedReviewers();
	$removed_reviewers = $this->getRemovedReviewers();
	$reviewer_phids = $revision->getReviewers();
	$allow_self_accept = PhabricatorEnv::getEnvConfig(
	'differential.allow-self-accept');

	$reviewer_phids_map = array_fill_keys($reviewer_phids, true);
	foreach ($added_reviewers as $k => $user_phid) {
	if (!$allow_self_accept && $user_phid == $revision->getAuthorPHID()) {
	unset($added_reviewers[$k]);
	}
	if (isset($reviewer_phids_map[$user_phid])) {
	unset($added_reviewers[$k]);
	}
	}

	foreach ($removed_reviewers as $k => $user_phid) {
	if (!isset($reviewer_phids_map[$user_phid])) {
	unset($removed_reviewers[$k]);
	}
	}

	$added_reviewers = array_unique($added_reviewers);
	$removed_reviewers = array_unique($removed_reviewers);

	if ($added_reviewers) {
	DifferentialRevisionEditor::updateReviewers(
	$revision,
	$this->getActor(),
	$added_reviewers,
	$removed_reviewers);
	}

	return array($added_reviewers, $removed_reviewers);
	}

	}
	diff --git a/src/applications/differential/editor/DifferentialRevisionEditor.php b/src/applications/differential/editor/DifferentialRevisionEditor.php
	index e5418ecab2..028948d32b 100644
	--- a/src/applications/differential/editor/DifferentialRevisionEditor.php
	+++ b/src/applications/differential/editor/DifferentialRevisionEditor.php
	@@ -1,1109 +1,1108 @@
	<?php

	/**
	* Handle major edit operations to DifferentialRevision -- adding and removing
	* reviewers, diffs, and CCs. Unlike simple edits, these changes trigger
	* complicated email workflows.
	*/
	final class DifferentialRevisionEditor extends PhabricatorEditor {

	protected $revision;

	protected $cc = null;
	protected $reviewers = null;
	protected $diff;
	protected $comments;
	protected $silentUpdate;

	private $auxiliaryFields = array();
	private $contentSource;
	private $isCreate;
	private $aphrontRequestForEventDispatch;


	public function setAphrontRequestForEventDispatch(AphrontRequest $request) {
	$this->aphrontRequestForEventDispatch = $request;
	return $this;
	}

	public function getAphrontRequestForEventDispatch() {
	return $this->aphrontRequestForEventDispatch;
	}

	public function __construct(DifferentialRevision $revision) {
	$this->revision = $revision;
	$this->isCreate = !($revision->getID());
	}

	public static function newRevisionFromConduitWithDiff(
	array $fields,
	DifferentialDiff $diff,
	PhabricatorUser $actor) {

	$revision = DifferentialRevision::initializeNewRevision($actor);
	$revision->setPHID($revision->generatePHID());

	$editor = new DifferentialRevisionEditor($revision);
	$editor->setActor($actor);
	$editor->addDiff($diff, null);
	$editor->copyFieldsFromConduit($fields);

	$editor->save();

	return $revision;
	}

	public function copyFieldsFromConduit(array $fields) {

	$actor = $this->getActor();
	$revision = $this->revision;
	$revision->loadRelationships();

	$all_fields = DifferentialFieldSelector::newSelector()
	->getFieldSpecifications();

	$aux_fields = array();
	foreach ($all_fields as $aux_field) {
	$aux_field->setRevision($revision);
	$aux_field->setDiff($this->diff);
	$aux_field->setUser($actor);
	if ($aux_field->shouldAppearOnCommitMessage()) {
	$aux_fields[$aux_field->getCommitMessageKey()] = $aux_field;
	}
	}

	foreach ($fields as $field => $value) {
	if (empty($aux_fields[$field])) {
	throw new Exception(
	"Parsed commit message contains unrecognized field '{$field}'.");
	}
	$aux_fields[$field]->setValueFromParsedCommitMessage($value);
	}

	foreach ($aux_fields as $aux_field) {
	$aux_field->validateField();
	}

	$this->setAuxiliaryFields($all_fields);
	}

	public function setAuxiliaryFields(array $auxiliary_fields) {
	assert_instances_of($auxiliary_fields, 'DifferentialFieldSpecification');
	$this->auxiliaryFields = $auxiliary_fields;
	return $this;
	}

	public function getRevision() {
	return $this->revision;
	}

	public function setReviewers(array $reviewers) {
	$this->reviewers = $reviewers;
	return $this;
	}

	public function setCCPHIDs(array $cc) {
	$this->cc = $cc;
	return $this;
	}

	public function setContentSource(PhabricatorContentSource $content_source) {
	$this->contentSource = $content_source;
	return $this;
	}

	public function addDiff(DifferentialDiff $diff, $comments) {
	if ($diff->getRevisionID() &&
	$diff->getRevisionID() != $this->getRevision()->getID()) {
	$diff_id = (int)$diff->getID();
	$targ_id = (int)$this->getRevision()->getID();
	$real_id = (int)$diff->getRevisionID();
	throw new Exception(
	"Can not attach diff #{$diff_id} to Revision D{$targ_id}, it is ".
	"already attached to D{$real_id}.");
	}
	$this->diff = $diff;
	$this->comments = $comments;

	$repository = id(new DifferentialRepositoryLookup())
	->setViewer($this->getActor())
	->setDiff($diff)
	->lookupRepository();

	if ($repository) {
	$this->getRevision()->setRepositoryPHID($repository->getPHID());
	}

	return $this;
	}

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

	protected function getComments() {
	return $this->comments;
	}

	protected function getActorPHID() {
	return $this->getActor()->getPHID();
	}

	public function isNewRevision() {
	return !$this->getRevision()->getID();
	}

	/**
	* A silent update does not trigger Herald rules or send emails. This is used
	* for auto-amends at commit time.
	*/
	public function setSilentUpdate($silent) {
	$this->silentUpdate = $silent;
	return $this;
	}

	public function save() {
	$revision = $this->getRevision();

	$is_new = $this->isNewRevision();

	$revision->loadRelationships();

	$this->willWriteRevision();

	if ($this->reviewers === null) {
	$this->reviewers = $revision->getReviewers();
	}

	if ($this->cc === null) {
	$this->cc = $revision->getCCPHIDs();
	}

	if ($is_new) {
	$content_blocks = array();
	foreach ($this->auxiliaryFields as $field) {
	if ($field->shouldExtractMentions()) {
	$content_blocks[] = $field->renderValueForCommitMessage(false);
	}
	}
	$phids = PhabricatorMarkupEngine::extractPHIDsFromMentions(
	$content_blocks);
	$this->cc = array_unique(array_merge($this->cc, $phids));
	}

	$diff = $this->getDiff();
	if ($diff) {
	$revision->setLineCount($diff->getLineCount());
	}

	// Save the revision, to generate its ID and PHID if it is new. We need
	// the ID/PHID in order to record them in Herald transcripts, but don't
	// want to hold a transaction open while running Herald because it is
	// potentially somewhat slow. The downside is that we may end up with a
	// saved revision/diff pair without appropriate CCs. We could be better
	// about this -- for example:
	//
	// - Herald can't affect reviewers, so we could compute them before
	// opening the transaction and then save them in the transaction.
	// - Herald doesn't really need PHIDs to compute its effects, we could
	// run it before saving these objects and then hand over the PHIDs later.
	//
	// But this should address the problem of orphaned revisions, which is
	// currently the only problem we experience in practice.

	$revision->openTransaction();

	if ($diff) {
	$revision->setBranchName($diff->getBranch());
	$revision->setArcanistProjectPHID($diff->getArcanistProjectPHID());
	}

	$revision->save();

	if ($diff) {
	$diff->setRevisionID($revision->getID());
	$diff->save();
	}

	$revision->saveTransaction();


	// We're going to build up three dictionaries: $add, $rem, and $stable. The
	// $add dictionary has added reviewers/CCs. The $rem dictionary has
	// reviewers/CCs who have been removed, and the $stable array is
	// reviewers/CCs who haven't changed. We're going to send new reviewers/CCs
	// a different ("welcome") email than we send stable reviewers/CCs.

	$old = array(
	'rev' => array_fill_keys($revision->getReviewers(), true),
	'ccs' => array_fill_keys($revision->getCCPHIDs(), true),
	);

	$xscript_header = null;
	$xscript_uri = null;

	$new = array(
	'rev' => array_fill_keys($this->reviewers, true),
	'ccs' => array_fill_keys($this->cc, true),
	);

	$rem_ccs = array();
	$xscript_phid = null;
	if ($diff) {
	$adapter = HeraldDifferentialRevisionAdapter::newLegacyAdapter(
	$revision,
	$diff);
	$adapter->setExplicitCCs($new['ccs']);
	$adapter->setExplicitReviewers($new['rev']);
	$adapter->setForbiddenCCs($revision->loadUnsubscribedPHIDs());

	$xscript = HeraldEngine::loadAndApplyRules($adapter);
	$xscript_uri = '/herald/transcript/'.$xscript->getID().'/';
	$xscript_phid = $xscript->getPHID();
	$xscript_header = $xscript->getXHeraldRulesHeader();

	$xscript_header = HeraldTranscript::saveXHeraldRulesHeader(
	$revision->getPHID(),
	$xscript_header);

	$sub = array(
	'rev' => $adapter->getReviewersAddedByHerald(),
	'ccs' => $adapter->getCCsAddedByHerald(),
	);
	$rem_ccs = $adapter->getCCsRemovedByHerald();
	$blocking_reviewers = array_keys(
	$adapter->getBlockingReviewersAddedByHerald());
	} else {
	$sub = array(
	'rev' => array(),
	'ccs' => array(),
	);
	$blocking_reviewers = array();
	}

	// Remove any CCs which are prevented by Herald rules.
	$sub['ccs'] = array_diff_key($sub['ccs'], $rem_ccs);
	$new['ccs'] = array_diff_key($new['ccs'], $rem_ccs);

	$add = array();
	$rem = array();
	$stable = array();
	foreach (array('rev', 'ccs') as $key) {
	$add[$key] = array();
	if ($new[$key] !== null) {
	$add[$key] += array_diff_key($new[$key], $old[$key]);
	}
	$add[$key] += array_diff_key($sub[$key], $old[$key]);

	$combined = $sub[$key];
	if ($new[$key] !== null) {
	$combined += $new[$key];
	}
	$rem[$key] = array_diff_key($old[$key], $combined);

	$stable[$key] = array_diff_key($old[$key], $add[$key] + $rem[$key]);
	}

	// Prevent Herald rules from adding a revision's owner as a reviewer.
	unset($add['rev'][$revision->getAuthorPHID()]);

	self::updateReviewers(
	$revision,
	$this->getActor(),
	array_keys($add['rev']),
	array_keys($rem['rev']),
	$blocking_reviewers);

	// We want to attribute new CCs to a "reasonPHID", representing the reason
	// they were added. This is either a user (if some user explicitly CCs
	// them, or uses "Add CCs...") or a Herald transcript PHID, indicating that
	// they were added by a Herald rule.

	if ($add['ccs'] \|\| $rem['ccs']) {
	$reasons = array();
	foreach ($add['ccs'] as $phid => $ignored) {
	if (empty($new['ccs'][$phid])) {
	$reasons[$phid] = $xscript_phid;
	} else {
	$reasons[$phid] = $this->getActorPHID();
	}
	}
	foreach ($rem['ccs'] as $phid => $ignored) {
	if (empty($new['ccs'][$phid])) {
	$reasons[$phid] = $this->getActorPHID();
	} else {
	$reasons[$phid] = $xscript_phid;
	}
	}
	} else {
	$reasons = $this->getActorPHID();
	}

	self::alterCCs(
	$revision,
	$this->cc,
	array_keys($rem['ccs']),
	array_keys($add['ccs']),
	$reasons);

	$this->updateAuxiliaryFields();

	// Add the author and users included from Herald rules to the relevant set
	// of users so they get a copy of the email.
	if (!$this->silentUpdate) {
	if ($is_new) {
	$add['rev'][$this->getActorPHID()] = true;
	if ($diff) {
	$add['rev'] += $adapter->getEmailPHIDsAddedByHerald();
	}
	} else {
	$stable['rev'][$this->getActorPHID()] = true;
	if ($diff) {
	$stable['rev'] += $adapter->getEmailPHIDsAddedByHerald();
	}
	}
	}

	$mail = array();

	$phids = array($this->getActorPHID());

	$handles = id(new PhabricatorHandleQuery())
	->setViewer($this->getActor())
	->withPHIDs($phids)
	->execute();
	$actor_handle = $handles[$this->getActorPHID()];

	$changesets = null;
	$comment = null;
	$old_status = $revision->getStatus();

	if ($diff) {
	$changesets = $diff->loadChangesets();
	// TODO: This should probably be in DifferentialFeedbackEditor?
	if (!$is_new) {
	$comment = $this->createComment();
	}
	if ($comment) {
	$mail[] = id(new DifferentialNewDiffMail(
	$revision,
	$actor_handle,
	$changesets))
	->setActor($this->getActor())
	->setIsFirstMailAboutRevision($is_new)
	->setIsFirstMailToRecipients($is_new)
	->setComments($this->getComments())
	->setToPHIDs(array_keys($stable['rev']))
	->setCCPHIDs(array_keys($stable['ccs']));
	}

	// Save the changes we made above.

	$diff->setDescription(preg_replace('/\n.*/s', '', $this->getComments()));
	$diff->save();

	$this->updateAffectedPathTable($revision, $diff, $changesets);
	$this->updateRevisionHashTable($revision, $diff);

	// An updated diff should require review, as long as it's not closed
	// or accepted. The "accepted" status is "sticky" to encourage courtesy
	// re-diffs after someone accepts with minor changes/suggestions.

	$status = $revision->getStatus();
	if ($status != ArcanistDifferentialRevisionStatus::CLOSED &&
	$status != ArcanistDifferentialRevisionStatus::ACCEPTED) {
	$revision->setStatus(ArcanistDifferentialRevisionStatus::NEEDS_REVIEW);
	}

	} else {
	$diff = $revision->loadActiveDiff();
	if ($diff) {
	$changesets = $diff->loadChangesets();
	} else {
	$changesets = array();
	}
	}

	$revision->save();

	// If the actor just deleted all the blocking/rejected reviewers, we may
	// be able to put the revision into "accepted".
	switch ($revision->getStatus()) {
	case ArcanistDifferentialRevisionStatus::NEEDS_REVISION:
	case ArcanistDifferentialRevisionStatus::NEEDS_REVIEW:
	$revision = self::updateAcceptedStatus(
	$this->getActor(),
	$revision);
	break;
	}

	$this->didWriteRevision();

	$event_data = array(
	'revision_id' => $revision->getID(),
	'revision_phid' => $revision->getPHID(),
	'revision_name' => $revision->getTitle(),
	'revision_author_phid' => $revision->getAuthorPHID(),
	'action' => $is_new
	? DifferentialAction::ACTION_CREATE
	: DifferentialAction::ACTION_UPDATE,
	'feedback_content' => $is_new
	? phutil_utf8_shorten($revision->getSummary(), 140)
	: $this->getComments(),
	'actor_phid' => $revision->getAuthorPHID(),
	);

	$mailed_phids = array();
	if (!$this->silentUpdate) {
	$revision->loadRelationships();

	if ($add['rev']) {
	$message = id(new DifferentialNewDiffMail(
	$revision,
	$actor_handle,
	$changesets))
	->setActor($this->getActor())
	->setIsFirstMailAboutRevision($is_new)
	->setIsFirstMailToRecipients(true)
	->setToPHIDs(array_keys($add['rev']));

	if ($is_new) {
	// The first time we send an email about a revision, put the CCs in
	// the "CC:" field of the same "Review Requested" email that reviewers
	// get, so you don't get two initial emails if you're on a list that
	// is CC'd.
	$message->setCCPHIDs(array_keys($add['ccs']));
	}

	$mail[] = $message;
	}

	// If we added CCs, we want to send them an email, but only if they were
	// not already a reviewer and were not added as one (in these cases, they
	// got a "NewDiff" mail, either in the past or just a moment ago). You can
	// still get two emails, but only if a revision is updated and you are
	// added as a reviewer at the same time a list you are on is added as a
	// CC, which is rare and reasonable.

	$implied_ccs = self::getImpliedCCs($revision);
	$implied_ccs = array_fill_keys($implied_ccs, true);
	$add['ccs'] = array_diff_key($add['ccs'], $implied_ccs);

	if (!$is_new && $add['ccs']) {
	$mail[] = id(new DifferentialCCWelcomeMail(
	$revision,
	$actor_handle,
	$changesets))
	->setActor($this->getActor())
	->setIsFirstMailToRecipients(true)
	->setToPHIDs(array_keys($add['ccs']));
	}

	foreach ($mail as $message) {
	$message->setHeraldTranscriptURI($xscript_uri);
	$message->setXHeraldRulesHeader($xscript_header);
	$message->send();

	$mailed_phids[] = $message->getRawMail()->buildRecipientList();
	}
	$mailed_phids = array_mergev($mailed_phids);
	}

	id(new PhabricatorFeedStoryPublisher())
	->setStoryType('PhabricatorFeedStoryDifferential')
	->setStoryData($event_data)
	->setStoryTime(time())
	->setStoryAuthorPHID($revision->getAuthorPHID())
	->setRelatedPHIDs(
	array(
	$revision->getPHID(),
	$revision->getAuthorPHID(),
	))
	->setPrimaryObjectPHID($revision->getPHID())
	->setSubscribedPHIDs(
	array_merge(
	array($revision->getAuthorPHID()),
	$revision->getReviewers(),
	$revision->getCCPHIDs()))
	->setMailRecipientPHIDs($mailed_phids)
	->publish();

	id(new PhabricatorSearchIndexer())
	->indexDocumentByPHID($revision->getPHID());
	}

	public static function addCCAndUpdateRevision(
	$revision,
	$phid,
	PhabricatorUser $actor) {

	self::addCC($revision, $phid, $actor->getPHID());

	$type = PhabricatorEdgeConfig::TYPE_OBJECT_HAS_UNSUBSCRIBER;
	id(new PhabricatorEdgeEditor())
	->setActor($actor)
	->removeEdge($revision->getPHID(), $type, $phid)
	->save();
	}

	public static function removeCCAndUpdateRevision(
	$revision,
	$phid,
	PhabricatorUser $actor) {

	self::removeCC($revision, $phid, $actor->getPHID());

	$type = PhabricatorEdgeConfig::TYPE_OBJECT_HAS_UNSUBSCRIBER;
	id(new PhabricatorEdgeEditor())
	->setActor($actor)
	->addEdge($revision->getPHID(), $type, $phid)
	->save();
	}

	public static function addCC(
	DifferentialRevision $revision,
	$phid,
	$reason) {
	return self::alterCCs(
	$revision,
	$revision->getCCPHIDs(),
	$rem = array(),
	$add = array($phid),
	$reason);
	}

	public static function removeCC(
	DifferentialRevision $revision,
	$phid,
	$reason) {
	return self::alterCCs(
	$revision,
	$revision->getCCPHIDs(),
	$rem = array($phid),
	$add = array(),
	$reason);
	}

	protected static function alterCCs(
	DifferentialRevision $revision,
	array $stable_phids,
	array $rem_phids,
	array $add_phids,
	$reason_phid) {

	$dont_add = self::getImpliedCCs($revision);
	$add_phids = array_diff($add_phids, $dont_add);

	return self::alterRelationships(
	$revision,
	$stable_phids,
	$rem_phids,
	$add_phids,
	$reason_phid,
	DifferentialRevision::RELATION_SUBSCRIBED);
	}

	private static function getImpliedCCs(DifferentialRevision $revision) {
	return array_merge(
	$revision->getReviewers(),
	array($revision->getAuthorPHID()));
	}

	public static function updateReviewers(
	DifferentialRevision $revision,
	PhabricatorUser $actor,
	array $add_phids,
	array $remove_phids,
	array $blocking_phids = array()) {

	$reviewers = $revision->getReviewers();

	$editor = id(new PhabricatorEdgeEditor())
	->setActor($actor);

	$reviewer_phids_map = array_fill_keys($reviewers, true);

	$blocking_phids = array_fuse($blocking_phids);
	foreach ($add_phids as $phid) {

	// Adding an already existing edge again would have cause memory loss
	// That is, the previous state for that reviewer would be lost
	if (isset($reviewer_phids_map[$phid])) {
	// TODO: If we're writing a blocking edge, we should overwrite an
	// existing weaker edge (like "added" or "commented"), just not a
	// stronger existing edge.
	continue;
	}

	if (isset($blocking_phids[$phid])) {
	$status = DifferentialReviewerStatus::STATUS_BLOCKING;
	} else {
	$status = DifferentialReviewerStatus::STATUS_ADDED;
	}

	$options = array(
	'data' => array(
	'status' => $status,
	)
	);

	$editor->addEdge(
	$revision->getPHID(),
	PhabricatorEdgeConfig::TYPE_DREV_HAS_REVIEWER,
	$phid,
	$options);
	}

	foreach ($remove_phids as $phid) {
	$editor->removeEdge(
	$revision->getPHID(),
	PhabricatorEdgeConfig::TYPE_DREV_HAS_REVIEWER,
	$phid);
	}

	$editor->save();
	}

	public static function updateReviewerStatus(
	DifferentialRevision $revision,
	PhabricatorUser $actor,
	$reviewer_phid,
	$status) {

	$options = array(
	'data' => array(
	'status' => $status
	)
	);

	$active_diff = $revision->loadActiveDiff();
	if ($active_diff) {
	$options['data']['diff'] = $active_diff->getID();
	}

	id(new PhabricatorEdgeEditor())
	->setActor($actor)
	->addEdge(
	$revision->getPHID(),
	PhabricatorEdgeConfig::TYPE_DREV_HAS_REVIEWER,
	$reviewer_phid,
	$options)
	->save();
	}

	private static function alterRelationships(
	DifferentialRevision $revision,
	array $stable_phids,
	array $rem_phids,
	array $add_phids,
	$reason_phid,
	$relation_type) {

	$rem_map = array_fill_keys($rem_phids, true);
	$add_map = array_fill_keys($add_phids, true);

	$seq_map = array_values($stable_phids);
	$seq_map = array_flip($seq_map);
	foreach ($rem_map as $phid => $ignored) {
	if (!isset($seq_map[$phid])) {
	$seq_map[$phid] = count($seq_map);
	}
	}
	foreach ($add_map as $phid => $ignored) {
	if (!isset($seq_map[$phid])) {
	$seq_map[$phid] = count($seq_map);
	}
	}

	$raw = $revision->getRawRelations($relation_type);
	$raw = ipull($raw, null, 'objectPHID');

	$sequence = count($seq_map);
	foreach ($raw as $phid => $ignored) {
	if (isset($seq_map[$phid])) {
	$raw[$phid]['sequence'] = $seq_map[$phid];
	} else {
	$raw[$phid]['sequence'] = $sequence++;
	}
	}
	$raw = isort($raw, 'sequence');

	foreach ($raw as $phid => $ignored) {
	if (isset($rem_map[$phid])) {
	unset($raw[$phid]);
	}
	}

	foreach ($add_phids as $add) {
	$reason = is_array($reason_phid)
	? idx($reason_phid, $add)
	: $reason_phid;

	$raw[$add] = array(
	'objectPHID' => $add,
	'sequence' => idx($seq_map, $add, $sequence++),
	'reasonPHID' => $reason,
	);
	}

	$conn_w = $revision->establishConnection('w');

	$sql = array();
	foreach ($raw as $relation) {
	$sql[] = qsprintf(
	$conn_w,
	'(%d, %s, %s, %d, %s)',
	$revision->getID(),
	$relation_type,
	$relation['objectPHID'],
	$relation['sequence'],
	$relation['reasonPHID']);
	}

	$conn_w->openTransaction();
	queryfx(
	$conn_w,
	'DELETE FROM %T WHERE revisionID = %d AND relation = %s',
	DifferentialRevision::RELATIONSHIP_TABLE,
	$revision->getID(),
	$relation_type);
	if ($sql) {
	queryfx(
	$conn_w,
	'INSERT INTO %T
	(revisionID, relation, objectPHID, sequence, reasonPHID)
	VALUES %Q',
	DifferentialRevision::RELATIONSHIP_TABLE,
	implode(', ', $sql));
	}
	$conn_w->saveTransaction();

	$revision->loadRelationships();
	}


	private function createComment() {
	- $revision_id = $this->revision->getID();
	$comment = id(new DifferentialComment())
	->setAuthorPHID($this->getActorPHID())
	- ->setRevisionID($revision_id)
	+ ->setRevision($this->revision)
	->setContent($this->getComments())
	->setAction(DifferentialAction::ACTION_UPDATE)
	->setMetadata(
	array(
	DifferentialComment::METADATA_DIFF_ID => $this->getDiff()->getID(),
	));

	if ($this->contentSource) {
	$comment->setContentSource($this->contentSource);
	}

	$comment->save();

	return $comment;
	}

	private function updateAuxiliaryFields() {
	$aux_map = array();
	foreach ($this->auxiliaryFields as $aux_field) {
	$key = $aux_field->getStorageKey();
	if ($key !== null) {
	$val = $aux_field->getValueForStorage();
	$aux_map[$key] = $val;
	}
	}

	if (!$aux_map) {
	return;
	}

	$revision = $this->revision;

	$fields = id(new DifferentialAuxiliaryField())->loadAllWhere(
	'revisionPHID = %s AND name IN (%Ls)',
	$revision->getPHID(),
	array_keys($aux_map));
	$fields = mpull($fields, null, 'getName');

	foreach ($aux_map as $key => $val) {
	$obj = idx($fields, $key);
	if (!strlen($val)) {
	// If the new value is empty, just delete the old row if one exists and
	// don't add a new row if it doesn't.
	if ($obj) {
	$obj->delete();
	}
	} else {
	if (!$obj) {
	$obj = new DifferentialAuxiliaryField();
	$obj->setRevisionPHID($revision->getPHID());
	$obj->setName($key);
	}

	if ($obj->getValue() !== $val) {
	$obj->setValue($val);
	$obj->save();
	}
	}
	}
	}

	private function willWriteRevision() {
	foreach ($this->auxiliaryFields as $aux_field) {
	$aux_field->willWriteRevision($this);
	}

	$this->dispatchEvent(
	PhabricatorEventType::TYPE_DIFFERENTIAL_WILLEDITREVISION);
	}

	private function didWriteRevision() {
	foreach ($this->auxiliaryFields as $aux_field) {
	$aux_field->didWriteRevision($this);
	}

	$this->dispatchEvent(
	PhabricatorEventType::TYPE_DIFFERENTIAL_DIDEDITREVISION);
	}

	private function dispatchEvent($type) {
	$event = new PhabricatorEvent(
	$type,
	array(
	'revision' => $this->revision,
	'new' => $this->isCreate,
	));

	$event->setUser($this->getActor());

	$request = $this->getAphrontRequestForEventDispatch();
	if ($request) {
	$event->setAphrontRequest($request);
	}

	PhutilEventEngine::dispatchEvent($event);
	}

	/**
	* Update the table which links Differential revisions to paths they affect,
	* so Diffusion can efficiently find pending revisions for a given file.
	*/
	private function updateAffectedPathTable(
	DifferentialRevision $revision,
	DifferentialDiff $diff,
	array $changesets) {
	assert_instances_of($changesets, 'DifferentialChangeset');

	$project = $diff->loadArcanistProject();
	if (!$project) {
	// Probably an old revision from before projects.
	return;
	}

	$repository = $project->loadRepository();
	if (!$repository) {
	// Probably no project <-> repository link, or the repository where the
	// project lives is untracked.
	return;
	}

	$path_prefix = null;

	$local_root = $diff->getSourceControlPath();
	if ($local_root) {
	// We're in a working copy which supports subdirectory checkouts (e.g.,
	// SVN) so we need to figure out what prefix we should add to each path
	// (e.g., trunk/projects/example/) to get the absolute path from the
	// root of the repository. DVCS systems like Git and Mercurial are not
	// affected.

	// Normalize both paths and check if the repository root is a prefix of
	// the local root. If so, throw it away. Note that this correctly handles
	// the case where the remote path is "/".
	$local_root = id(new PhutilURI($local_root))->getPath();
	$local_root = rtrim($local_root, '/');

	$repo_root = id(new PhutilURI($repository->getRemoteURI()))->getPath();
	$repo_root = rtrim($repo_root, '/');

	if (!strncmp($repo_root, $local_root, strlen($repo_root))) {
	$path_prefix = substr($local_root, strlen($repo_root));
	}
	}

	$paths = array();
	foreach ($changesets as $changeset) {
	$paths[] = $path_prefix.'/'.$changeset->getFilename();
	}

	// Mark this as also touching all parent paths, so you can see all pending
	// changes to any file within a directory.
	$all_paths = array();
	foreach ($paths as $local) {
	foreach (DiffusionPathIDQuery::expandPathToRoot($local) as $path) {
	$all_paths[$path] = true;
	}
	}
	$all_paths = array_keys($all_paths);

	$path_ids =
	PhabricatorRepositoryCommitChangeParserWorker::lookupOrCreatePaths(
	$all_paths);

	$table = new DifferentialAffectedPath();
	$conn_w = $table->establishConnection('w');

	$sql = array();
	foreach ($path_ids as $path_id) {
	$sql[] = qsprintf(
	$conn_w,
	'(%d, %d, %d, %d)',
	$repository->getID(),
	$path_id,
	time(),
	$revision->getID());
	}

	queryfx(
	$conn_w,
	'DELETE FROM %T WHERE revisionID = %d',
	$table->getTableName(),
	$revision->getID());
	foreach (array_chunk($sql, 256) as $chunk) {
	queryfx(
	$conn_w,
	'INSERT INTO %T (repositoryID, pathID, epoch, revisionID) VALUES %Q',
	$table->getTableName(),
	implode(', ', $chunk));
	}
	}


	/**
	* Update the table connecting revisions to DVCS local hashes, so we can
	* identify revisions by commit/tree hashes.
	*/
	private function updateRevisionHashTable(
	DifferentialRevision $revision,
	DifferentialDiff $diff) {

	$vcs = $diff->getSourceControlSystem();
	if ($vcs == DifferentialRevisionControlSystem::SVN) {
	// Subversion has no local commit or tree hash information, so we don't
	// have to do anything.
	return;
	}

	$property = id(new DifferentialDiffProperty())->loadOneWhere(
	'diffID = %d AND name = %s',
	$diff->getID(),
	'local:commits');
	if (!$property) {
	return;
	}

	$hashes = array();

	$data = $property->getData();
	switch ($vcs) {
	case DifferentialRevisionControlSystem::GIT:
	foreach ($data as $commit) {
	$hashes[] = array(
	ArcanistDifferentialRevisionHash::HASH_GIT_COMMIT,
	$commit['commit'],
	);
	$hashes[] = array(
	ArcanistDifferentialRevisionHash::HASH_GIT_TREE,
	$commit['tree'],
	);
	}
	break;
	case DifferentialRevisionControlSystem::MERCURIAL:
	foreach ($data as $commit) {
	$hashes[] = array(
	ArcanistDifferentialRevisionHash::HASH_MERCURIAL_COMMIT,
	$commit['rev'],
	);
	}
	break;
	}

	$conn_w = $revision->establishConnection('w');

	$sql = array();
	foreach ($hashes as $info) {
	list($type, $hash) = $info;
	$sql[] = qsprintf(
	$conn_w,
	'(%d, %s, %s)',
	$revision->getID(),
	$type,
	$hash);
	}

	queryfx(
	$conn_w,
	'DELETE FROM %T WHERE revisionID = %d',
	ArcanistDifferentialRevisionHash::TABLE_NAME,
	$revision->getID());

	if ($sql) {
	queryfx(
	$conn_w,
	'INSERT INTO %T (revisionID, type, hash) VALUES %Q',
	ArcanistDifferentialRevisionHash::TABLE_NAME,
	implode(', ', $sql));
	}
	}

	/**
	* Try to move a revision to "accepted". We look for:
	*
	* - at least one accepting reviewer who is a user; and
	* - no rejects; and
	* - no blocking reviewers.
	*/
	public static function updateAcceptedStatus(
	PhabricatorUser $viewer,
	DifferentialRevision $revision) {

	$revision = id(new DifferentialRevisionQuery())
	->setViewer($viewer)
	->withIDs(array($revision->getID()))
	->needRelationships(true)
	->needReviewerStatus(true)
	->needReviewerAuthority(true)
	->executeOne();

	$has_user_accept = false;
	foreach ($revision->getReviewerStatus() as $reviewer) {
	$status = $reviewer->getStatus();
	if ($status == DifferentialReviewerStatus::STATUS_BLOCKING) {
	// We have a blocking reviewer, so just leave the revision in its
	// existing state.
	return $revision;
	}

	if ($status == DifferentialReviewerStatus::STATUS_REJECTED) {
	// We have a rejecting reviewer, so leave the revisoin as is.
	return $revision;
	}

	if ($reviewer->isUser()) {
	if ($status == DifferentialReviewerStatus::STATUS_ACCEPTED) {
	$has_user_accept = true;
	}
	}
	}

	if ($has_user_accept) {
	$revision
	->setStatus(ArcanistDifferentialRevisionStatus::ACCEPTED)
	->save();
	}

	return $revision;
	}

	}

	diff --git a/src/applications/differential/storage/DifferentialComment.php b/src/applications/differential/storage/DifferentialComment.php
	index 401b291b51..8d56afdf01 100644
	--- a/src/applications/differential/storage/DifferentialComment.php
	+++ b/src/applications/differential/storage/DifferentialComment.php
	@@ -1,87 +1,96 @@
	<?php

	final class DifferentialComment extends DifferentialDAO
	implements PhabricatorMarkupInterface {

	const METADATA_ADDED_REVIEWERS = 'added-reviewers';
	const METADATA_REMOVED_REVIEWERS = 'removed-reviewers';
	const METADATA_ADDED_CCS = 'added-ccs';
	const METADATA_DIFF_ID = 'diff-id';

	const MARKUP_FIELD_BODY = 'markup:body';

	protected $authorPHID;
	protected $revisionID;
	protected $action;
	protected $content;
	protected $cache;
	protected $metadata = array();
	protected $contentSource;

	private $arbitraryDiffForFacebook;

	+ public function setRevision(DifferentialRevision $revision) {
	+ return $this->setRevisionID($revision->getID());
	+ }
	+
	public function giveFacebookSomeArbitraryDiff(DifferentialDiff $diff) {
	$this->arbitraryDiffForFacebook = $diff;
	return $this;
	}

	+ public function getRequiredHandlePHIDs() {
	+ $phids = array();
	+
	+ $metadata = $this->getMetadata();
	+ $added_reviewers = idx(
	+ $metadata,
	+ self::METADATA_ADDED_REVIEWERS);
	+ if ($added_reviewers) {
	+ foreach ($added_reviewers as $phid) {
	+ $phids[] = $phid;
	+ }
	+ }
	+ $added_ccs = idx(
	+ $metadata,
	+ self::METADATA_ADDED_CCS);
	+ if ($added_ccs) {
	+ foreach ($added_ccs as $phid) {
	+ $phids[] = $phid;
	+ }
	+ }
	+
	+ return $phids;
	+ }
	+
	public function getConfiguration() {
	return array(
	self::CONFIG_SERIALIZATION => array(
	'metadata' => self::SERIALIZATION_JSON,
	),
	) + parent::getConfiguration();
	}

	public function setContentSource(PhabricatorContentSource $content_source) {
	$this->contentSource = $content_source->serialize();
	return $this;
	}

	public function getContentSource() {
	return PhabricatorContentSource::newFromSerialized($this->contentSource);
	}

	-
	public function getMarkupFieldKey($field) {
	- if ($this->getID()) {
	- return 'DC:'.$this->getID();
	- }
	-
	- // The summary and test plan render as comments, but do not have IDs.
	- // They are also mutable. Build keys using content hashes.
	- $hash = PhabricatorHash::digest($this->getMarkupText($field));
	- return 'DC:'.$hash;
	+ return 'DC:'.$this->getID();
	}

	public function newMarkupEngine($field) {
	return PhabricatorMarkupEngine::newDifferentialMarkupEngine(
	array(
	'differential.diff' => $this->arbitraryDiffForFacebook,
	));
	}

	public function getMarkupText($field) {
	return $this->getContent();
	}

	public function didMarkupText($field, $output, PhutilMarkupEngine $engine) {
	return $output;
	}

	public function shouldUseMarkupCache($field) {
	- if ($this->getID()) {
	- return true;
	- }
	-
	- $action = $this->getAction();
	- switch ($action) {
	- case DifferentialAction::ACTION_SUMMARIZE:
	- case DifferentialAction::ACTION_TESTPLAN:
	- return true;
	- }
	-
	- return false;
	+ return (bool)$this->getID();
	}

	}
	diff --git a/src/applications/differential/view/DifferentialRevisionDetailView.php b/src/applications/differential/view/DifferentialRevisionDetailView.php
	index f965acaf92..47d021a033 100644
	--- a/src/applications/differential/view/DifferentialRevisionDetailView.php
	+++ b/src/applications/differential/view/DifferentialRevisionDetailView.php
	@@ -1,149 +1,171 @@
	<?php

	final class DifferentialRevisionDetailView extends AphrontView {

	private $revision;
	private $actions;
	private $auxiliaryFields = array();
	private $diff;
	private $uri;

	public function setURI($uri) {
	$this->uri = $uri;
	return $this;
	}
	public function getURI() {
	return $this->uri;
	}

	public function setDiff(DifferentialDiff $diff) {
	$this->diff = $diff;
	return $this;
	}
	private function getDiff() {
	return $this->diff;
	}

	public function setRevision(DifferentialRevision $revision) {
	$this->revision = $revision;
	return $this;
	}

	public function setActions(array $actions) {
	$this->actions = $actions;
	return $this;
	}
	private function getActions() {
	return $this->actions;
	}

	public function setAuxiliaryFields(array $fields) {
	assert_instances_of($fields, 'DifferentialFieldSpecification');
	$this->auxiliaryFields = $fields;
	return $this;
	}

	public function render() {

	require_celerity_resource('differential-core-view-css');

	$revision = $this->revision;
	$user = $this->getUser();

	$header = $this->renderHeader($revision);

	$actions = id(new PhabricatorActionListView())
	->setUser($user)
	->setObject($revision)
	->setObjectURI($this->getURI());
	foreach ($this->getActions() as $action) {
	$obj = id(new PhabricatorActionView())
	->setIcon(idx($action, 'icon', 'edit'))
	->setName($action['name'])
	->setHref(idx($action, 'href'))
	->setWorkflow(idx($action, 'sigil') == 'workflow')
	->setRenderAsForm(!empty($action['instant']))
	->setUser($user)
	->setDisabled(idx($action, 'disabled', false));
	$actions->addAction($obj);
	}

	$properties = id(new PHUIPropertyListView())
	->setUser($user)
	->setObject($revision);

	$status = $revision->getStatus();
	$local_vcs = $this->getDiff()->getSourceControlSystem();

	$next_step = null;
	if ($status == ArcanistDifferentialRevisionStatus::ACCEPTED) {
	switch ($local_vcs) {
	case PhabricatorRepositoryType::REPOSITORY_TYPE_MERCURIAL:
	$bookmark = $this->getDiff()->getBookmark();
	$next_step = ($bookmark != ''
	? csprintf('arc land %s', $bookmark)
	: 'arc land');
	break;

	case PhabricatorRepositoryType::REPOSITORY_TYPE_GIT:
	$branch = $this->getDiff()->getBranch();
	$next_step = ($branch != ''
	? csprintf('arc land %s', $branch)
	: 'arc land');
	break;

	case PhabricatorRepositoryType::REPOSITORY_TYPE_SVN:
	$next_step = 'arc commit';
	break;
	}
	}
	if ($next_step) {
	$next_step = phutil_tag('tt', array(), $next_step);
	$properties->addProperty(pht('Next Step'), $next_step);
	}

	foreach ($this->auxiliaryFields as $field) {
	$value = $field->renderValueForRevisionView();
	if ($value !== null) {
	$label = rtrim($field->renderLabelForRevisionView(), ':');
	$properties->addProperty($label, $value);
	}
	}
	$properties->setHasKeyboardShortcuts(true);
	$properties->setActionList($actions);

	+ $properties->invokeWillRenderEvent();
	+
	+ if (strlen($revision->getSummary())) {
	+ $properties->addSectionHeader(pht('Summary'));
	+ $properties->addTextContent(
	+ PhabricatorMarkupEngine::renderOneObject(
	+ id(new PhabricatorMarkupOneOff())->setContent(
	+ $revision->getSummary()),
	+ 'default',
	+ $user));
	+ }
	+
	+ if (strlen($revision->getTestPlan())) {
	+ $properties->addSectionHeader(pht('Test Plan'));
	+ $properties->addTextContent(
	+ PhabricatorMarkupEngine::renderOneObject(
	+ id(new PhabricatorMarkupOneOff())->setContent(
	+ $revision->getTestPlan()),
	+ 'default',
	+ $user));
	+ }
	+
	$object_box = id(new PHUIObjectBoxView())
	->setHeader($header)
	->addPropertyList($properties);

	return $object_box;
	}

	private function renderHeader(DifferentialRevision $revision) {
	$view = id(new PHUIHeaderView())
	->setHeader($revision->getTitle($revision))
	->setUser($this->getUser())
	->setPolicyObject($revision);

	$status = $revision->getStatus();
	$status_name =
	DifferentialRevisionStatus::renderFullDescription($status);

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

	return $view;
	}

	public static function renderTagForRevision(
	DifferentialRevision $revision) {

	$status = $revision->getStatus();
	$status_name =
	ArcanistDifferentialRevisionStatus::getNameForRevisionStatus($status);

	return id(new PhabricatorTagView())
	->setType(PhabricatorTagView::TYPE_STATE)
	->setName($status_name);
	}

	}

File Metadata

Mime Type: text/x-diff
Expires: Sat, Nov 15, 6:37 PM (7 h, 33 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 338294
Default Alt Text: (100 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions