No OneTemporary
Actions

Size

145 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/src/applications/differential/editor/DifferentialRevisionEditor.php b/src/applications/differential/editor/DifferentialRevisionEditor.php
	index e128699645..5c156d04be 100644
	--- a/src/applications/differential/editor/DifferentialRevisionEditor.php
	+++ b/src/applications/differential/editor/DifferentialRevisionEditor.php
	@@ -1,950 +1,910 @@
	<?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();
	}


	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) {
	$unsubscribed_phids = PhabricatorEdgeQuery::loadDestinationPHIDs(
	$revision->getPHID(),
	PhabricatorEdgeConfig::TYPE_OBJECT_HAS_UNSUBSCRIBER);

	$adapter = HeraldDifferentialRevisionAdapter::newLegacyAdapter(
	$revision,
	$diff);
	$adapter->setExplicitCCs($new['ccs']);
	$adapter->setExplicitReviewers($new['rev']);
	$adapter->setForbiddenCCs($unsubscribed_phids);
	$adapter->setIsNewObject($is_new);

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

	HarbormasterBuildable::applyBuildPlans(
	$diff->getPHID(),
	$revision->getPHID(),
	$adapter->getBuildPlans());
	} 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;
	$old_status = $revision->getStatus();

	if ($diff) {
	$changesets = $diff->loadChangesets();
	// TODO: This should probably be in DifferentialFeedbackEditor?
	if (!$is_new) {
	$this->createComment();
	$mail[] = id(new DifferentialNewDiffMail(
	$revision,
	$actor_handle,
	$changesets))
	->setActor($this->getActor())
	->setIsFirstMailAboutRevision(false)
	->setIsFirstMailToRecipients(false)
	->setCommentText($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::CHANGES_PLANNED:
	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())
	->queueDocumentForIndexing($revision->getPHID());
	}

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

	id(new PhabricatorSubscriptionsEditor())
	->setActor(PhabricatorUser::getOmnipotentUser())
	->setObject($revision)
	->subscribeExplicit($add_phids)
	->unsubscribe($rem_phids)
	->save();
	}

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

	private function createComment() {
	$template = id(new DifferentialComment())
	->setAuthorPHID($this->getActorPHID())
	->setRevision($this->revision);

	if ($this->contentSource) {
	$content_source = $this->contentSource;
	} else {
	$content_source = PhabricatorContentSource::newForSource(
	PhabricatorContentSource::SOURCE_LEGACY,
	array());
	}

	$template->setContentSource($content_source);


	// Write the "update active diff" transaction.
	id(clone $template)
	->setAction(DifferentialAction::ACTION_UPDATE)
	->setMetadata(
	array(
	DifferentialComment::METADATA_DIFF_ID => $this->getDiff()->getID(),
	))
	->save();

	// If we have a comment, write the "add a comment" transaction.
	if (strlen($this->getComments())) {
	id(clone $template)
	->setAction(DifferentialAction::ACTION_COMMENT)
	->setContent($this->getComments())
	->save();
	}
	}

	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 DifferentialCustomFieldStorage())->loadAllWhere(
	'objectPHID = %s',
	$revision->getPHID());
	$fields = mpull($fields, null, 'getFieldIndex');

	foreach ($aux_map as $key => $val) {
	$index = PhabricatorHash::digestForIndex($key);
	$obj = idx($fields, $index);
	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 DifferentialCustomFieldStorage();
	$obj->setObjectPHID($revision->getPHID());
	$obj->setFieldIndex($index);
	}

	if ($obj->getFieldValue() !== $val) {
	$obj->setFieldValue($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/editor/DifferentialTransactionEditor.php b/src/applications/differential/editor/DifferentialTransactionEditor.php
	index cefe319ff9..0e094255db 100644
	--- a/src/applications/differential/editor/DifferentialTransactionEditor.php
	+++ b/src/applications/differential/editor/DifferentialTransactionEditor.php
	@@ -1,1269 +1,1303 @@
	<?php

	final class DifferentialTransactionEditor
	extends PhabricatorApplicationTransactionEditor {

	private $heraldEmailPHIDs;
	private $changedPriorToCommitURI;
	private $isCloseByCommit;

	public function setIsCloseByCommit($is_close_by_commit) {
	$this->isCloseByCommit = $is_close_by_commit;
	return $this;
	}

	public function getIsCloseByCommit() {
	return $this->isCloseByCommit;
	}

	public function setChangedPriorToCommitURI($uri) {
	$this->changedPriorToCommitURI = $uri;
	return $this;
	}

	public function getChangedPriorToCommitURI() {
	return $this->changedPriorToCommitURI;
	}

	public function getTransactionTypes() {
	$types = parent::getTransactionTypes();

	$types[] = PhabricatorTransactions::TYPE_COMMENT;
	$types[] = PhabricatorTransactions::TYPE_EDGE;
	$types[] = PhabricatorTransactions::TYPE_VIEW_POLICY;
	$types[] = PhabricatorTransactions::TYPE_EDIT_POLICY;

	$types[] = DifferentialTransaction::TYPE_ACTION;
	$types[] = DifferentialTransaction::TYPE_INLINE;
	$types[] = DifferentialTransaction::TYPE_STATUS;
	$types[] = DifferentialTransaction::TYPE_UPDATE;

	return $types;
	}

	protected function getCustomTransactionOldValue(
	PhabricatorLiskDAO $object,
	PhabricatorApplicationTransaction $xaction) {

	switch ($xaction->getTransactionType()) {
	case PhabricatorTransactions::TYPE_VIEW_POLICY:
	return $object->getViewPolicy();
	case PhabricatorTransactions::TYPE_EDIT_POLICY:
	return $object->getEditPolicy();
	case DifferentialTransaction::TYPE_ACTION:
	return null;
	case DifferentialTransaction::TYPE_INLINE:
	return null;
	case DifferentialTransaction::TYPE_UPDATE:
	if ($this->getIsNewObject()) {
	return null;
	} else {
	return $object->getActiveDiff()->getPHID();
	}
	}

	return parent::getCustomTransactionOldValue($object, $xaction);
	}

	protected function getCustomTransactionNewValue(
	PhabricatorLiskDAO $object,
	PhabricatorApplicationTransaction $xaction) {

	switch ($xaction->getTransactionType()) {
	case PhabricatorTransactions::TYPE_VIEW_POLICY:
	case PhabricatorTransactions::TYPE_EDIT_POLICY:
	case DifferentialTransaction::TYPE_ACTION:
	case DifferentialTransaction::TYPE_UPDATE:
	return $xaction->getNewValue();
	case DifferentialTransaction::TYPE_INLINE:
	return null;
	}

	return parent::getCustomTransactionNewValue($object, $xaction);
	}

	protected function transactionHasEffect(
	PhabricatorLiskDAO $object,
	PhabricatorApplicationTransaction $xaction) {

	switch ($xaction->getTransactionType()) {
	case DifferentialTransaction::TYPE_INLINE:
	return $xaction->hasComment();
	case DifferentialTransaction::TYPE_ACTION:
	$status_closed = ArcanistDifferentialRevisionStatus::CLOSED;
	$status_abandoned = ArcanistDifferentialRevisionStatus::ABANDONED;
	$status_review = ArcanistDifferentialRevisionStatus::NEEDS_REVIEW;
	$status_revision = ArcanistDifferentialRevisionStatus::NEEDS_REVISION;
	$status_plan = ArcanistDifferentialRevisionStatus::CHANGES_PLANNED;

	$action_type = $xaction->getNewValue();
	switch ($action_type) {
	case DifferentialAction::ACTION_ACCEPT:
	case DifferentialAction::ACTION_REJECT:
	if ($action_type == DifferentialAction::ACTION_ACCEPT) {
	$new_status = DifferentialReviewerStatus::STATUS_ACCEPTED;
	} else {
	$new_status = DifferentialReviewerStatus::STATUS_REJECTED;
	}

	$actor = $this->getActor();
	$actor_phid = $actor->getPHID();

	// These transactions can cause effects in two ways: by altering the
	// status of an existing reviewer; or by adding the actor as a new
	// reviewer.

	$will_add_reviewer = true;
	foreach ($object->getReviewerStatus() as $reviewer) {
	if ($reviewer->hasAuthority($actor)) {
	if ($reviewer->getStatus() != $new_status) {
	return true;
	}
	}
	if ($reviewer->getReviewerPHID() == $actor_phid) {
	$will_add_reviwer = false;
	}
	}

	return $will_add_reviewer;
	case DifferentialAction::ACTION_CLOSE:
	return ($object->getStatus() != $status_closed);
	case DifferentialAction::ACTION_ABANDON:
	return ($object->getStatus() != $status_abandoned);
	case DifferentialAction::ACTION_RECLAIM:
	return ($object->getStatus() == $status_abandoned);
	case DifferentialAction::ACTION_REOPEN:
	return ($object->getStatus() == $status_closed);
	case DifferentialAction::ACTION_RETHINK:
	return ($object->getStatus() != $status_plan);
	case DifferentialAction::ACTION_REQUEST:
	return ($object->getStatus() != $status_review);
	case DifferentialAction::ACTION_RESIGN:
	$actor_phid = $this->getActor()->getPHID();
	foreach ($object->getReviewerStatus() as $reviewer) {
	if ($reviewer->getReviewerPHID() == $actor_phid) {
	return true;
	}
	}
	return false;
	case DifferentialAction::ACTION_CLAIM:
	$actor_phid = $this->getActor()->getPHID();
	return ($actor_phid != $object->getAuthorPHID());
	}
	}

	return parent::transactionHasEffect($object, $xaction);
	}


	protected function applyCustomInternalTransaction(
	PhabricatorLiskDAO $object,
	PhabricatorApplicationTransaction $xaction) {

	$status_review = ArcanistDifferentialRevisionStatus::NEEDS_REVIEW;
	$status_revision = ArcanistDifferentialRevisionStatus::NEEDS_REVISION;
	$status_plan = ArcanistDifferentialRevisionStatus::CHANGES_PLANNED;

	switch ($xaction->getTransactionType()) {
	case PhabricatorTransactions::TYPE_VIEW_POLICY:
	$object->setViewPolicy($xaction->getNewValue());
	return;
	case PhabricatorTransactions::TYPE_EDIT_POLICY:
	$object->setEditPolicy($xaction->getNewValue());
	return;
	case PhabricatorTransactions::TYPE_SUBSCRIBERS:
	case PhabricatorTransactions::TYPE_COMMENT:
	case DifferentialTransaction::TYPE_INLINE:
	return;
	case PhabricatorTransactions::TYPE_EDGE:
	return;
	case DifferentialTransaction::TYPE_UPDATE:
	if (!$this->getIsCloseByCommit()) {
	$object->setStatus($status_review);
	}
	// TODO: Update the `diffPHID` once we add that.
	return;
	case DifferentialTransaction::TYPE_ACTION:
	switch ($xaction->getNewValue()) {
	case DifferentialAction::ACTION_RESIGN:
	case DifferentialAction::ACTION_ACCEPT:
	case DifferentialAction::ACTION_REJECT:
	// These have no direct effects, and affect review status only
	// indirectly by altering reviewers with TYPE_EDGE transactions.
	return;
	case DifferentialAction::ACTION_ABANDON:
	$object->setStatus(ArcanistDifferentialRevisionStatus::ABANDONED);
	return;
	case DifferentialAction::ACTION_RETHINK:
	$object->setStatus($status_plan);
	return;
	case DifferentialAction::ACTION_RECLAIM:
	$object->setStatus($status_review);
	return;
	case DifferentialAction::ACTION_REOPEN:
	$object->setStatus($status_review);
	return;
	case DifferentialAction::ACTION_REQUEST:
	$object->setStatus($status_review);
	return;
	case DifferentialAction::ACTION_CLOSE:
	$object->setStatus(ArcanistDifferentialRevisionStatus::CLOSED);
	return;
	case DifferentialAction::ACTION_CLAIM:
	$object->setAuthorPHID($this->getActor()->getPHID());
	return;
	}
	break;
	}

	return parent::applyCustomInternalTransaction($object, $xaction);
	}

	protected function expandTransaction(
	PhabricatorLiskDAO $object,
	PhabricatorApplicationTransaction $xaction) {

	$actor = $this->getActor();
	$actor_phid = $actor->getPHID();
	$type_edge = PhabricatorTransactions::TYPE_EDGE;
	+
	$edge_reviewer = PhabricatorEdgeConfig::TYPE_DREV_HAS_REVIEWER;
	+ $edge_ref_task = PhabricatorEdgeConfig::TYPE_DREV_HAS_RELATED_TASK;

	$results = parent::expandTransaction($object, $xaction);
	switch ($xaction->getTransactionType()) {
	case DifferentialTransaction::TYPE_UPDATE:
	if ($this->getIsCloseByCommit()) {
	// Don't bother with any of this if this update is a side effect of
	// commit detection.
	break;
	}

	$new_accept = DifferentialReviewerStatus::STATUS_ACCEPTED;
	$new_reject = DifferentialReviewerStatus::STATUS_REJECTED;
	$old_accept = DifferentialReviewerStatus::STATUS_ACCEPTED_OLDER;
	$old_reject = DifferentialReviewerStatus::STATUS_REJECTED_OLDER;

	// When a revision is updated, change all "reject" to "rejected older
	// revision". This means we won't immediately push the update back into
	// "needs review", but outstanding rejects will still block it from
	// moving to "accepted".
	$edits = array();
	foreach ($object->getReviewerStatus() as $reviewer) {
	if ($reviewer->getStatus() == $new_reject) {
	$edits[$reviewer->getReviewerPHID()] = array(
	'data' => array(
	'status' => $old_reject,
	),
	);
	}

	// TODO: If sticky accept is off, do a similar update for accepts.
	}

	if ($edits) {
	$results[] = id(new DifferentialTransaction())
	->setTransactionType($type_edge)
	->setMetadataValue('edge:type', $edge_reviewer)
	->setIgnoreOnNoEffect(true)
	->setNewValue(array('+' => $edits));
	}
	+
	+ // When a revision is updated and the diff comes from a branch named
	+ // "T123" or similar, automatically associate the commit with the
	+ // task that the branch names.
	+
	+ $maniphest = 'PhabricatorApplicationManiphest';
	+ if (PhabricatorApplication::isClassInstalled($maniphest)) {
	+ $diff = $this->loadDiff($xaction->getNewValue());
	+ if ($diff) {
	+ $branch = $diff->getBranch();
	+
	+ // No "$", to allow for branches like T123_demo.
	+ $match = null;
	+ if (preg_match('/^T(\d+)/i', $branch, $match)) {
	+ $task_id = $match[1];
	+ $tasks = id(new ManiphestTaskQuery())
	+ ->setViewer($this->getActor())
	+ ->withIDs(array($task_id))
	+ ->execute();
	+ if ($tasks) {
	+ $task = head($tasks);
	+ $task_phid = $task->getPHID();
	+
	+ $results[] = id(new DifferentialTransaction())
	+ ->setTransactionType($type_edge)
	+ ->setMetadataValue('edge:type', $edge_ref_task)
	+ ->setIgnoreOnNoEffect(true)
	+ ->setNewValue(array('+' => array($task_phid => $task_phid)));
	+ }
	+ }
	+ }
	+ }
	break;

	case PhabricatorTransactions::TYPE_COMMENT:
	// When a user leaves a comment, upgrade their reviewer status from
	// "added" to "commented" if they're also a reviewer. We may further
	// upgrade this based on other actions in the transaction group.

	$status_added = DifferentialReviewerStatus::STATUS_ADDED;
	$status_commented = DifferentialReviewerStatus::STATUS_COMMENTED;

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

	$edits = array();
	foreach ($object->getReviewerStatus() as $reviewer) {
	if ($reviewer->getReviewerPHID() == $actor_phid) {
	if ($reviewer->getStatus() == $status_added) {
	$edits[$actor_phid] = array(
	'data' => $data,
	);
	}
	}
	}

	if ($edits) {
	$results[] = id(new DifferentialTransaction())
	->setTransactionType($type_edge)
	->setMetadataValue('edge:type', $edge_reviewer)
	->setIgnoreOnNoEffect(true)
	->setNewValue(array('+' => $edits));
	}
	break;

	case DifferentialTransaction::TYPE_ACTION:
	$action_type = $xaction->getNewValue();

	switch ($action_type) {
	case DifferentialAction::ACTION_ACCEPT:
	case DifferentialAction::ACTION_REJECT:
	if ($action_type == DifferentialAction::ACTION_ACCEPT) {
	$data = array(
	'status' => DifferentialReviewerStatus::STATUS_ACCEPTED,
	);
	} else {
	$data = array(
	'status' => DifferentialReviewerStatus::STATUS_REJECTED,
	);
	}

	$edits = array();

	foreach ($object->getReviewerStatus() as $reviewer) {
	if ($reviewer->hasAuthority($actor)) {
	$edits[$reviewer->getReviewerPHID()] = array(
	'data' => $data,
	);
	}
	}

	// Also either update or add the actor themselves as a reviewer.
	$edits[$actor_phid] = array(
	'data' => $data,
	);

	$results[] = id(new DifferentialTransaction())
	->setTransactionType($type_edge)
	->setMetadataValue('edge:type', $edge_reviewer)
	->setIgnoreOnNoEffect(true)
	->setNewValue(array('+' => $edits));
	break;

	case DifferentialAction::ACTION_CLAIM:
	// If the user is commandeering, add the previous owner as a
	// reviewer and remove the actor.

	$edits = array(
	'-' => array(
	$actor_phid => $actor_phid,
	),
	);

	$owner_phid = $object->getAuthorPHID();
	if ($owner_phid) {
	$reviewer = new DifferentialReviewer(
	$owner_phid,
	array(
	'status' => DifferentialReviewerStatus::STATUS_ADDED,
	));

	$edits['+'] = array(
	$owner_phid => array(
	'data' => $reviewer->getEdgeData(),
	),
	);
	}

	$results[] = id(new DifferentialTransaction())
	->setTransactionType($type_edge)
	->setMetadataValue('edge:type', $edge_reviewer)
	->setIgnoreOnNoEffect(true)
	->setNewValue($edits);

	break;
	case DifferentialAction::ACTION_RESIGN:
	// If the user is resigning, add a separate reviewer edit
	// transaction which removes them as a reviewer.

	$results[] = id(new DifferentialTransaction())
	->setTransactionType($type_edge)
	->setMetadataValue('edge:type', $edge_reviewer)
	->setIgnoreOnNoEffect(true)
	->setNewValue(
	array(
	'-' => array(
	$actor_phid => $actor_phid,
	),
	));

	break;
	}
	break;
	}

	return $results;
	}

	protected function applyCustomExternalTransaction(
	PhabricatorLiskDAO $object,
	PhabricatorApplicationTransaction $xaction) {

	switch ($xaction->getTransactionType()) {
	case PhabricatorTransactions::TYPE_VIEW_POLICY:
	case PhabricatorTransactions::TYPE_EDIT_POLICY:
	return;
	case PhabricatorTransactions::TYPE_SUBSCRIBERS:
	case PhabricatorTransactions::TYPE_EDGE:
	case PhabricatorTransactions::TYPE_COMMENT:
	case DifferentialTransaction::TYPE_ACTION:
	case DifferentialTransaction::TYPE_INLINE:
	return;
	case DifferentialTransaction::TYPE_UPDATE:
	// Now that we're inside the transaction, do a final check.
	$diff = $this->loadDiff($xaction->getNewValue());

	// TODO: It would be slightly cleaner to just revalidate this
	// transaction somehow using the same validation code, but that's
	// not easy to do at the moment.

	if (!$diff) {
	throw new Exception(pht('Diff does not exist!'));
	} else {
	$revision_id = $diff->getRevisionID();
	if ($revision_id && ($revision_id != $object->getID())) {
	throw new Exception(
	pht(
	'Diff is already attached to another revision. You lost '.
	'a race?'));
	}
	}

	$diff->setRevisionID($object->getID());
	$diff->save();

	$object->setLineCount($diff->getLineCount());
	$object->setRepositoryPHID($diff->getRepositoryPHID());

	return;
	}

	return parent::applyCustomExternalTransaction($object, $xaction);
	}

	protected function mergeEdgeData($type, array $u, array $v) {
	$result = parent::mergeEdgeData($type, $u, $v);

	switch ($type) {
	case PhabricatorEdgeConfig::TYPE_DREV_HAS_REVIEWER:
	// When the same reviewer has their status updated by multiple
	// transactions, we want the strongest status to win. An example of
	// this is when a user adds a comment and also accepts a revision which
	// they are a reviewer on. The comment creates a "commented" status,
	// while the accept creates an "accepted" status. Since accept is
	// stronger, it should win and persist.

	$u_status = idx($u, 'status');
	$v_status = idx($v, 'status');
	$u_str = DifferentialReviewerStatus::getStatusStrength($u_status);
	$v_str = DifferentialReviewerStatus::getStatusStrength($v_status);
	if ($u_str > $v_str) {
	$result['status'] = $u_status;
	} else {
	$result['status'] = $v_status;
	}
	break;
	}

	return $result;
	}



	protected function applyFinalEffects(
	PhabricatorLiskDAO $object,
	array $xactions) {

	$status_accepted = ArcanistDifferentialRevisionStatus::ACCEPTED;
	$status_revision = ArcanistDifferentialRevisionStatus::NEEDS_REVISION;
	$status_review = ArcanistDifferentialRevisionStatus::NEEDS_REVIEW;

	$old_status = $object->getStatus();
	switch ($old_status) {
	case $status_accepted:
	case $status_revision:
	case $status_review:
	// Load the most up-to-date version of the revision and its reviewers,
	// so we don't need to try to deduce the state of reviewers by examining
	// all the changes made by the transactions.
	$new_revision = id(new DifferentialRevisionQuery())
	->setViewer($this->getActor())
	->needReviewerStatus(true)
	->withIDs(array($object->getID()))
	->executeOne();
	if (!$new_revision) {
	throw new Exception(
	pht('Failed to load revision from transaction finalization.'));
	}

	// Try to move a revision to "accepted". We look for:
	//
	// - at least one accepting reviewer who is a user; and
	// - no rejects; and
	// - no rejects of older diffs; and
	// - no blocking reviewers.

	$has_accepting_user = false;
	$has_rejecting_reviewer = false;
	$has_rejecting_older_reviewer = false;
	$has_blocking_reviewer = false;
	foreach ($new_revision->getReviewerStatus() as $reviewer) {
	$reviewer_status = $reviewer->getStatus();
	switch ($reviewer_status) {
	case DifferentialReviewerStatus::STATUS_REJECTED:
	$has_rejecting_reviewer = true;
	break;
	case DifferentialReviewerStatus::STATUS_REJECTED_OLDER:
	$has_rejecting_older_reviewer = true;
	break;
	case DifferentialReviewerStatus::STATUS_BLOCKING:
	$has_blocking_reviewer = true;
	break;
	case DifferentialReviewerStatus::STATUS_ACCEPTED:
	if ($reviewer->isUser()) {
	$has_accepting_user = true;
	}
	break;
	}
	}

	$new_status = null;
	if ($has_accepting_user &&
	!$has_rejecting_reviewer &&
	!$has_rejecting_older_reviewer &&
	!$has_blocking_reviewer) {
	$new_status = $status_accepted;
	} else if ($has_rejecting_reviewer) {
	// This isn't accepted, and there's at least one rejecting reviewer,
	// so the revision needs changes. This usually happens after a
	// "reject".
	$new_status = $status_revision;
	} else if ($old_status == $status_accepted) {
	// This revision was accepted, but it no longer satisfies the
	// conditions for acceptance. This usually happens after an accepting
	// reviewer resigns or is removed.
	$new_status = $status_review;
	}

	if ($new_status !== null && $new_status != $old_status) {
	$xaction = id(new DifferentialTransaction())
	->setTransactionType(DifferentialTransaction::TYPE_STATUS)
	->setOldValue($old_status)
	->setNewValue($new_status);

	$xaction = $this->populateTransaction($object, $xaction)->save();

	$xactions[] = $xaction;

	$object->setStatus($new_status)->save();
	}
	break;
	default:
	// Revisions can't transition out of other statuses (like closed or
	// abandoned) as a side effect of reviewer status changes.
	break;
	}

	return $xactions;
	}


	protected function validateTransaction(
	PhabricatorLiskDAO $object,
	$type,
	array $xactions) {

	$errors = parent::validateTransaction($object, $type, $xactions);

	foreach ($xactions as $xaction) {
	switch ($type) {
	case DifferentialTransaction::TYPE_UPDATE:
	$diff = $this->loadDiff($xaction->getNewValue());
	if (!$diff) {
	$errors[] = new PhabricatorApplicationTransactionValidationError(
	$type,
	pht('Invalid'),
	pht('The specified diff does not exist.'),
	$xaction);
	} else if (($diff->getRevisionID()) &&
	($diff->getRevisionID() != $object->getID())) {
	$errors[] = new PhabricatorApplicationTransactionValidationError(
	$type,
	pht('Invalid'),
	pht(
	'You can not update this revision to the specified diff, '.
	'because the diff is already attached to another revision.'),
	$xaction);
	}
	break;
	case DifferentialTransaction::TYPE_ACTION:
	$error = $this->validateDifferentialAction(
	$object,
	$type,
	$xaction,
	$xaction->getNewValue());
	if ($error) {
	$errors[] = new PhabricatorApplicationTransactionValidationError(
	$type,
	pht('Invalid'),
	$error,
	$xaction);
	}
	break;
	}
	}

	return $errors;
	}

	private function validateDifferentialAction(
	DifferentialRevision $revision,
	$type,
	DifferentialTransaction $xaction,
	$action) {

	$author_phid = $revision->getAuthorPHID();
	$actor_phid = $this->getActor()->getPHID();
	$actor_is_author = ($author_phid == $actor_phid);

	$config_close_key = 'differential.always-allow-close';
	$always_allow_close = PhabricatorEnv::getEnvConfig($config_close_key);

	$config_reopen_key = 'differential.allow-reopen';
	$allow_reopen = PhabricatorEnv::getEnvConfig($config_reopen_key);

	$config_self_accept_key = 'differential.allow-self-accept';
	$allow_self_accept = PhabricatorEnv::getEnvConfig($config_self_accept_key);

	$revision_status = $revision->getStatus();

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

	switch ($action) {
	case DifferentialAction::ACTION_ACCEPT:
	if ($actor_is_author && !$allow_self_accept) {
	return pht(
	'You can not accept this revision because you are the owner.');
	}

	if ($revision_status == $status_abandoned) {
	return pht(
	'You can not accept this revision because it has been '.
	'abandoned.');
	}

	if ($revision_status == $status_closed) {
	return pht(
	'You can not accept this revision because it has already been '.
	'closed.');
	}
	break;

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

	if ($revision_status == $status_abandoned) {
	return pht(
	'You can not request changes to this revision because it has been '.
	'abandoned.');
	}

	if ($revision_status == $status_closed) {
	return pht(
	'You can not request changes to this revision because it has '.
	'already been closed.');
	}
	break;

	case DifferentialAction::ACTION_RESIGN:
	// You can always resign from a revision if you're a reviewer. If you
	// aren't, this is a no-op rather than invalid.
	break;

	case DifferentialAction::ACTION_CLAIM:
	// You can claim a revision if you're not the owner. If you are, this
	// is a no-op rather than invalid.

	if ($revision_status == $status_closed) {
	return pht(
	"You can not commandeer this revision because it has already been ".
	"closed.");
	}
	break;

	case DifferentialAction::ACTION_ABANDON:
	if (!$actor_is_author) {
	return pht(
	"You can not abandon this revision because you do not own it. ".
	"You can only abandon revisions you own.");
	}

	if ($revision_status == $status_closed) {
	return pht(
	"You can not abandon this revision because it has already been ".
	"closed.");
	}

	// NOTE: Abandons of already-abandoned revisions are treated as no-op
	// instead of invalid. Other abandons are OK.

	break;

	case DifferentialAction::ACTION_RECLAIM:
	if (!$actor_is_author) {
	return pht(
	"You can not reclaim this revision because you do not own ".
	"it. You can only reclaim revisions you own.");
	}

	if ($revision_status == $status_closed) {
	return pht(
	"You can not reclaim this revision because it has already been ".
	"closed.");
	}

	// NOTE: Reclaims of other non-abandoned revisions are treated as no-op
	// instead of invalid.

	break;

	case DifferentialAction::ACTION_REOPEN:
	if (!$allow_reopen) {
	return pht(
	'The reopen action is not enabled on this Phabricator install. '.
	'Adjust your configuration to enable it.');
	}

	// NOTE: If the revision is not closed, this is caught as a no-op
	// instead of an invalid transaction.

	break;

	case DifferentialAction::ACTION_RETHINK:
	if (!$actor_is_author) {
	return pht(
	"You can not plan changes to this revision because you do not ".
	"own it. To plan changes to a revision, you must be its owner.");
	}

	switch ($revision_status) {
	case ArcanistDifferentialRevisionStatus::ACCEPTED:
	case ArcanistDifferentialRevisionStatus::NEEDS_REVISION:
	case ArcanistDifferentialRevisionStatus::NEEDS_REVIEW:
	// These are OK.
	break;
	case ArcanistDifferentialRevisionStatus::CHANGES_PLANNED:
	// Let this through, it's a no-op.
	break;
	case ArcanistDifferentialRevisionStatus::ABANDONED:
	return pht(
	"You can not plan changes to this revision because it has ".
	"been abandoned.");
	case ArcanistDifferentialRevisionStatus::CLOSED:
	return pht(
	"You can not plan changes to this revision because it has ".
	"already been closed.");
	default:
	throw new Exception(
	pht(
	'Encountered unexpected revision status ("%s") when '.
	'validating "%s" action.',
	$revision_status,
	$action));
	}
	break;

	case DifferentialAction::ACTION_REQUEST:
	if (!$actor_is_author) {
	return pht(
	"You can not request review of this revision because you do ".
	"not own it. To request review of a revision, you must be its ".
	"owner.");
	}

	switch ($revision_status) {
	case ArcanistDifferentialRevisionStatus::ACCEPTED:
	case ArcanistDifferentialRevisionStatus::NEEDS_REVISION:
	case ArcanistDifferentialRevisionStatus::CHANGES_PLANNED:
	// These are OK.
	break;
	case ArcanistDifferentialRevisionStatus::NEEDS_REVIEW:
	// This will be caught as "no effect" later on.
	break;
	case ArcanistDifferentialRevisionStatus::ABANDONED:
	return pht(
	"You can not request review of this revision because it has ".
	"been abandoned. Instead, reclaim it.");
	case ArcanistDifferentialRevisionStatus::CLOSED:
	return pht(
	"You can not request review of this revision because it has ".
	"already been closed.");
	default:
	throw new Exception(
	pht(
	'Encountered unexpected revision status ("%s") when '.
	'validating "%s" action.',
	$revision_status,
	$action));
	}
	break;

	case DifferentialAction::ACTION_CLOSE:
	// We force revisions closed when we discover a corresponding commit.
	// In this case, revisions are allowed to transition to closed from
	// any state. This is an automated action taken by the daemons.

	if (!$this->getIsCloseByCommit()) {
	if (!$actor_is_author && !$always_allow_close) {
	return pht(
	"You can not close this revision because you do not own it. To ".
	"close a revision, you must be its owner.");
	}

	if ($revision_status != $status_accepted) {
	return pht(
	"You can not close this revision because it has not been ".
	"accepted. You can only close accepted revisions.");
	}
	}
	break;
	}

	return null;
	}

	protected function sortTransactions(array $xactions) {
	$xactions = parent::sortTransactions($xactions);

	$head = array();
	$tail = array();

	foreach ($xactions as $xaction) {
	$type = $xaction->getTransactionType();
	if ($type == DifferentialTransaction::TYPE_INLINE) {
	$tail[] = $xaction;
	} else {
	$head[] = $xaction;
	}
	}

	return array_values(array_merge($head, $tail));
	}

	protected function requireCapabilities(
	PhabricatorLiskDAO $object,
	PhabricatorApplicationTransaction $xaction) {

	switch ($xaction->getTransactionType()) {
	}

	return parent::requireCapabilities($object, $xaction);
	}

	protected function shouldPublishFeedStory(
	PhabricatorLiskDAO $object,
	array $xactions) {
	return true;
	}

	protected function shouldSendMail(
	PhabricatorLiskDAO $object,
	array $xactions) {
	return true;
	}

	protected function getMailTo(PhabricatorLiskDAO $object) {
	$phids = array();
	$phids[] = $object->getAuthorPHID();
	foreach ($object->getReviewerStatus() as $reviewer) {
	$phids[] = $reviewer->getReviewerPHID();
	}
	return $phids;
	}

	protected function getMailCC(PhabricatorLiskDAO $object) {
	$phids = parent::getMailCC($object);

	if ($this->heraldEmailPHIDs) {
	foreach ($this->heraldEmailPHIDs as $phid) {
	$phids[] = $phid;
	}
	}

	return $phids;
	}

	protected function getMailAction(
	PhabricatorLiskDAO $object,
	array $xactions) {
	$action = parent::getMailAction($object, $xactions);

	$strongest = $this->getStrongestAction($object, $xactions);
	switch ($strongest->getTransactionType()) {
	case DifferentialTransaction::TYPE_UPDATE:
	$count = new PhutilNumber($object->getLineCount());
	- $action = pht('%s, %s line(s)', $action, $count);
	+ $action = pht('%s, %d line(s)', $action, $count);
	break;
	}

	return $action;
	}

	protected function getMailSubjectPrefix() {
	return PhabricatorEnv::getEnvConfig('metamta.differential.subject-prefix');
	}

	protected function getMailThreadID(PhabricatorLiskDAO $object) {
	// This is nonstandard, but retains threading with older messages.
	$phid = $object->getPHID();
	return "differential-rev-{$phid}-req";
	}

	protected function buildReplyHandler(PhabricatorLiskDAO $object) {
	return id(new DifferentialReplyHandler())
	->setMailReceiver($object);
	}

	protected function buildMailTemplate(PhabricatorLiskDAO $object) {
	$id = $object->getID();
	$title = $object->getTitle();

	$original_title = $object->getOriginalTitle();

	$subject = "D{$id}: {$title}";
	$thread_topic = "D{$id}: {$original_title}";

	return id(new PhabricatorMetaMTAMail())
	->setSubject($subject)
	->addHeader('Thread-Topic', $thread_topic);
	}

	protected function buildMailBody(
	PhabricatorLiskDAO $object,
	array $xactions) {

	$body = parent::buildMailBody($object, $xactions);

	$type_inline = DifferentialTransaction::TYPE_INLINE;

	$inlines = array();
	foreach ($xactions as $xaction) {
	if ($xaction->getTransactionType() == $type_inline) {
	$inlines[] = $xaction;
	}
	}

	$changed_uri = $this->getChangedPriorToCommitURI();
	if ($changed_uri) {
	$body->addTextSection(
	pht('CHANGED PRIOR TO COMMIT'),
	$changed_uri);
	}

	if ($inlines) {
	$body->addTextSection(
	pht('INLINE COMMENTS'),
	$this->renderInlineCommentsForMail($object, $inlines));
	}

	$body->addTextSection(
	pht('REVISION DETAIL'),
	PhabricatorEnv::getProductionURI('/D'.$object->getID()));


	return $body;
	}

	protected function supportsSearch() {
	return true;
	}

	protected function extractFilePHIDsFromCustomTransaction(
	PhabricatorLiskDAO $object,
	PhabricatorApplicationTransaction $xaction) {

	switch ($xaction->getTransactionType()) {
	}

	return parent::extractFilePHIDsFromCustomTransaction($object, $xaction);
	}

	protected function expandCustomRemarkupBlockTransactions(
	PhabricatorLiskDAO $object,
	array $xactions,
	$blocks,
	PhutilMarkupEngine $engine) {


	$flat_blocks = array_mergev($blocks);
	$huge_block = implode("\n\n", $flat_blocks);

	$task_map = array();
	$task_refs = id(new ManiphestCustomFieldStatusParser())
	->parseCorpus($huge_block);
	foreach ($task_refs as $match) {
	foreach ($match['monograms'] as $monogram) {
	$task_id = (int)trim($monogram, 'tT');
	$task_map[$task_id] = true;
	}
	}

	$rev_map = array();
	$rev_refs = id(new DifferentialCustomFieldDependsOnParser())
	->parseCorpus($huge_block);
	foreach ($rev_refs as $match) {
	foreach ($match['monograms'] as $monogram) {
	$rev_id = (int)trim($monogram, 'dD');
	$rev_map[$rev_id] = true;
	}
	}

	$edges = array();

	if ($task_map) {
	$tasks = id(new ManiphestTaskQuery())
	->setViewer($this->getActor())
	->withIDs(array_keys($task_map))
	->execute();

	if ($tasks) {
	$edge_related = PhabricatorEdgeConfig::TYPE_DREV_HAS_RELATED_TASK;
	$edges[$edge_related] = mpull($tasks, 'getPHID', 'getPHID');
	}
	}

	if ($rev_map) {
	$revs = id(new DifferentialRevisionQuery())
	->setViewer($this->getActor())
	->withIDs(array_keys($rev_map))
	->execute();
	$rev_phids = mpull($revs, 'getPHID', 'getPHID');

	// NOTE: Skip any write attempts if a user cleverly implies a revision
	// depends upon itself.
	unset($rev_phids[$object->getPHID()]);

	if ($revs) {
	$edge_depends = PhabricatorEdgeConfig::TYPE_DREV_DEPENDS_ON_DREV;
	$edges[$edge_depends] = $rev_phids;
	}
	}

	$result = array();
	foreach ($edges as $type => $specs) {
	$result[] = id(new DifferentialTransaction())
	->setTransactionType(PhabricatorTransactions::TYPE_EDGE)
	->setMetadataValue('edge:type', $type)
	->setNewValue(array('+' => $specs));
	}

	return $result;
	}

	private function renderInlineCommentsForMail(
	PhabricatorLiskDAO $object,
	array $inlines) {

	$context_key = 'metamta.differential.unified-comment-context';
	$show_context = PhabricatorEnv::getEnvConfig($context_key);

	$changeset_ids = array();
	foreach ($inlines as $inline) {
	$id = $inline->getComment()->getChangesetID();
	$changeset_ids[$id] = $id;
	}

	// TODO: We should write a proper Query class for this eventually.
	$changesets = id(new DifferentialChangeset())->loadAllWhere(
	'id IN (%Ld)',
	$changeset_ids);
	if ($show_context) {
	$hunk_parser = new DifferentialHunkParser();
	foreach ($changesets as $changeset) {
	$changeset->attachHunks($changeset->loadHunks());
	}
	}

	$inline_groups = DifferentialTransactionComment::sortAndGroupInlines(
	$inlines,
	$changesets);

	$result = array();
	foreach ($inline_groups as $changeset_id => $group) {
	$changeset = idx($changesets, $changeset_id);
	if (!$changeset) {
	continue;
	}

	foreach ($group as $inline) {
	$comment = $inline->getComment();
	$file = $changeset->getFilename();
	$start = $comment->getLineNumber();
	$len = $comment->getLineLength();
	if ($len) {
	$range = $start.'-'.($start + $len);
	} else {
	$range = $start;
	}

	$inline_content = $comment->getContent();

	if (!$show_context) {
	$result[] = "{$file}:{$range} {$inline_content}";
	} else {
	$result[] = "================";
	$result[] = "Comment at: " . $file . ":" . $range;
	$result[] = $hunk_parser->makeContextDiff(
	$changeset->getHunks(),
	$comment->getIsNewFile(),
	$comment->getLineNumber(),
	$comment->getLineLength(),
	1);
	$result[] = "----------------";

	$result[] = $inline_content;
	$result[] = null;
	}
	}
	}

	return implode("\n", $result);
	}

	private function loadDiff($phid) {
	return id(new DifferentialDiffQuery())
	->withPHIDs(array($phid))
	->setViewer($this->getActor())
	->executeOne();
	}

	/* -( Herald Integration )------------------------------------------------- */

	protected function shouldApplyHeraldRules(
	PhabricatorLiskDAO $object,
	array $xactions) {

	if ($this->getIsNewObject()) {
	return true;
	}

	foreach ($xactions as $xaction) {
	switch ($xaction->getTransactionType()) {
	case DifferentialTransaction::TYPE_UPDATE:
	if (!$this->getIsCloseByCommit()) {
	return true;
	}
	}
	}

	return parent::shouldApplyHeraldRules($object, $xactions);
	}

	protected function buildHeraldAdapter(
	PhabricatorLiskDAO $object,
	array $xactions) {

	$unsubscribed_phids = PhabricatorEdgeQuery::loadDestinationPHIDs(
	$object->getPHID(),
	PhabricatorEdgeConfig::TYPE_OBJECT_HAS_UNSUBSCRIBER);

	$subscribed_phids = PhabricatorSubscribersQuery::loadSubscribersForPHID(
	$object->getPHID());

	$revision = id(new DifferentialRevisionQuery())
	->setViewer($this->getActor())
	->withPHIDs(array($object->getPHID()))
	->needActiveDiffs(true)
	->needReviewerStatus(true)
	->executeOne();
	if (!$revision) {
	throw new Exception(
	pht(
	'Failed to load revision for Herald adapter construction!'));
	}

	$adapter = HeraldDifferentialRevisionAdapter::newLegacyAdapter(
	$revision,
	$revision->getActiveDiff());

	$reviewers = $revision->getReviewerStatus();
	$reviewer_phids = mpull($reviewers, 'getReviewerPHID');

	$adapter->setExplicitCCs($subscribed_phids);
	$adapter->setExplicitReviewers($reviewer_phids);
	$adapter->setForbiddenCCs($unsubscribed_phids);

	$adapter->setIsNewObject($this->getIsNewObject());

	return $adapter;
	}

	protected function didApplyHeraldRules(
	PhabricatorLiskDAO $object,
	HeraldAdapter $adapter,
	HeraldTranscript $transcript) {

	$xactions = array();

	// Build a transaction to adjust CCs.
	$ccs = array(
	'+' => array_keys($adapter->getCCsAddedByHerald()),
	'-' => array_keys($adapter->getCCsRemovedByHerald()),
	);
	$value = array();
	foreach ($ccs as $type => $phids) {
	foreach ($phids as $phid) {
	$value[$type][$phid] = $phid;
	}
	}

	if ($value) {
	$xactions[] = id(new DifferentialTransaction())
	->setTransactionType(PhabricatorTransactions::TYPE_SUBSCRIBERS)
	->setNewValue($value);
	}

	// Build a transaction to adjust reviewers.
	$reviewers = array(
	DifferentialReviewerStatus::STATUS_ADDED =>
	array_keys($adapter->getReviewersAddedByHerald()),
	DifferentialReviewerStatus::STATUS_BLOCKING =>
	array_keys($adapter->getBlockingReviewersAddedByHerald()),
	);

	$value = array();
	foreach ($reviewers as $status => $phids) {
	foreach ($phids as $phid) {
	$value['+'][$phid] = array(
	'data' => array(
	'status' => $status,
	),
	);
	}
	}

	if ($value) {
	$edge_reviewer = PhabricatorEdgeConfig::TYPE_DREV_HAS_REVIEWER;

	$xactions[] = id(new DifferentialTransaction())
	->setTransactionType(PhabricatorTransactions::TYPE_EDGE)
	->setMetadataValue('edge:type', $edge_reviewer)
	->setNewValue($value);
	}

	// Save extra email PHIDs for later.
	$this->heraldEmailPHIDs = $adapter->getEmailPHIDsAddedByHerald();

	// Apply build plans.
	HarbormasterBuildable::applyBuildPlans(
	$adapter->getDiff(),
	$adapter->getPHID(),
	$adapter->getBuildPlans());

	return $xactions;
	}

	}
	diff --git a/src/applications/differential/field/specification/DifferentialBranchFieldSpecification.php b/src/applications/differential/field/specification/DifferentialBranchFieldSpecification.php
	index d5fbcf2b49..af427fe34c 100644
	--- a/src/applications/differential/field/specification/DifferentialBranchFieldSpecification.php
	+++ b/src/applications/differential/field/specification/DifferentialBranchFieldSpecification.php
	@@ -1,78 +1,52 @@
	<?php

	final class DifferentialBranchFieldSpecification
	extends DifferentialFieldSpecification {

	public function shouldAppearOnRevisionView() {
	return true;
	}

	public function renderLabelForRevisionView() {
	return 'Branch:';
	}

	private function getBranchOrBookmarkDescription(DifferentialDiff $diff) {
	$branch = $diff->getBranch();
	$bookmark = $diff->getBookmark();
	$has_branch = ($branch != '');
	$has_bookmark = ($bookmark != '');
	if ($has_branch && $has_bookmark) {
	return "{$bookmark} bookmark on {$branch} branch";
	} else if ($has_bookmark) {
	return "{$bookmark} bookmark";
	} else if ($has_branch) {
	return $branch;
	}
	return null;
	}

	public function renderValueForRevisionView() {
	$diff = $this->getManualDiff();
	return $this->getBranchOrBookmarkDescription($diff);
	}

	public function renderValueForMail($phase) {
	$diff = $this->getRevision()->loadActiveDiff();
	if ($diff) {
	$description = $this->getBranchOrBookmarkDescription($diff);
	if ($description) {
	return "BRANCH\n {$description}";
	}
	}

	return null;
	}

	- public function didWriteRevision(DifferentialRevisionEditor $editor) {
	- $maniphest = 'PhabricatorApplicationManiphest';
	- if (!PhabricatorApplication::isClassInstalled($maniphest)) {
	- return;
	- }
	-
	- $branch = $this->getDiff()->getBranch();
	- $match = null;
	- if (preg_match('/^T(\d+)/i', $branch, $match)) { // No $ to allow T123_demo.
	- list(, $task_id) = $match;
	- $task = id(new ManiphestTaskQuery())
	- ->setViewer($editor->requireActor())
	- ->withIDs(array($task_id))
	- ->executeOne();
	- if ($task) {
	- id(new PhabricatorEdgeEditor())
	- ->setActor($this->getUser())
	- ->addEdge(
	- $this->getRevision()->getPHID(),
	- PhabricatorEdgeConfig::TYPE_DREV_HAS_RELATED_TASK,
	- $task->getPHID())
	- ->save();
	- }
	- }
	- }
	-
	public function getCommitMessageTips() {
	return array(
	'Name branch "T123" to attach the diff to a task.',
	);
	}

	}
	diff --git a/src/applications/differential/field/specification/DifferentialCCsFieldSpecification.php b/src/applications/differential/field/specification/DifferentialCCsFieldSpecification.php
	index 92c3106345..ed2e7e9a2f 100644
	--- a/src/applications/differential/field/specification/DifferentialCCsFieldSpecification.php
	+++ b/src/applications/differential/field/specification/DifferentialCCsFieldSpecification.php
	@@ -1,110 +1,106 @@
	<?php

	final class DifferentialCCsFieldSpecification
	extends DifferentialFieldSpecification {

	private $ccs = array();

	public function shouldAppearOnRevisionView() {
	return true;
	}

	public function getRequiredHandlePHIDsForRevisionView() {
	return $this->getCCPHIDs();
	}

	public function renderLabelForRevisionView() {
	return 'CCs:';
	}

	public function renderValueForRevisionView() {
	return $this->renderUserList($this->getCCPHIDs());
	}

	private function getCCPHIDs() {
	$revision = $this->getRevision();
	return $revision->getCCPHIDs();
	}

	public function shouldAppearOnEdit() {
	return true;
	}

	protected function didSetRevision() {
	$this->ccs = $this->getCCPHIDs();
	}

	public function getRequiredHandlePHIDsForRevisionEdit() {
	return $this->ccs;
	}

	public function getRequiredHandlePHIDsForCommitMessage() {
	return $this->ccs;
	}

	public function setValueFromRequest(AphrontRequest $request) {
	$this->ccs = $request->getArr('cc');
	return $this;
	}

	public function renderEditControl() {
	$cc_map = array();
	foreach ($this->ccs as $phid) {
	$cc_map[] = $this->getHandle($phid);
	}
	return id(new AphrontFormTokenizerControl())
	->setLabel('CC')
	->setName('cc')
	->setUser($this->getUser())
	->setDatasource('/typeahead/common/mailable/')
	->setValue($cc_map);
	}

	- public function willWriteRevision(DifferentialRevisionEditor $editor) {
	- $editor->setCCPHIDs($this->ccs);
	- }
	-
	public function shouldAppearOnCommitMessage() {
	return true;
	}

	public function getCommitMessageKey() {
	return 'ccPHIDs';
	}

	public function setValueFromParsedCommitMessage($value) {
	$this->ccs = array_unique(nonempty($value, array()));
	return $this;
	}

	public function renderLabelForCommitMessage() {
	return 'CC';
	}

	public function renderValueForCommitMessage($is_edit) {
	if (!$this->ccs) {
	return null;
	}

	$names = array();
	foreach ($this->ccs as $phid) {
	$handle = $this->getHandle($phid);
	if ($handle->isComplete()) {
	$names[] = $handle->getObjectName();
	}
	}
	return implode(', ', $names);
	}

	public function getSupportedCommitMessageLabels() {
	return array(
	'CC',
	'CCs',
	);
	}

	public function parseValueFromCommitMessage($value) {
	return $this->parseCommitMessageMailableList($value);
	}

	}
	diff --git a/src/applications/differential/field/specification/DifferentialEditPolicyFieldSpecification.php b/src/applications/differential/field/specification/DifferentialEditPolicyFieldSpecification.php
	index 62963e3d67..50cf1beecf 100644
	--- a/src/applications/differential/field/specification/DifferentialEditPolicyFieldSpecification.php
	+++ b/src/applications/differential/field/specification/DifferentialEditPolicyFieldSpecification.php
	@@ -1,42 +1,38 @@
	<?php

	final class DifferentialEditPolicyFieldSpecification
	extends DifferentialFieldSpecification {

	private $value;

	public function shouldAppearOnEdit() {
	return true;
	}

	protected function didSetRevision() {
	$this->value = $this->getRevision()->getEditPolicy();
	}

	public function setValueFromRequest(AphrontRequest $request) {
	$this->value = $request->getStr('editPolicy');
	return $this;
	}

	public function renderEditControl() {
	$viewer = $this->getUser();
	$revision = $this->getRevision();

	$policies = id(new PhabricatorPolicyQuery())
	->setViewer($viewer)
	->setObject($revision)
	->execute();

	return id(new AphrontFormPolicyControl())
	->setUser($viewer)
	->setCapability(PhabricatorPolicyCapability::CAN_EDIT)
	->setPolicyObject($revision)
	->setPolicies($policies)
	->setName('editPolicy');
	}

	- public function willWriteRevision(DifferentialRevisionEditor $editor) {
	- $this->getRevision()->setEditPolicy($this->value);
	- }
	-
	}
	diff --git a/src/applications/differential/field/specification/DifferentialFieldSpecification.php b/src/applications/differential/field/specification/DifferentialFieldSpecification.php
	index a7d45ab2f9..7ef49e7aed 100644
	--- a/src/applications/differential/field/specification/DifferentialFieldSpecification.php
	+++ b/src/applications/differential/field/specification/DifferentialFieldSpecification.php
	@@ -1,1004 +1,972 @@
	<?php

	/**
	* Describes and implements the behavior for a custom field on Differential
	* revisions. Along with other configuration, you can extend this class to add
	* custom fields to Differential revisions and commit messages.
	*
	* Generally, you should implement all methods from the storage task and then
	* the methods from one or more interface tasks.
	*
	* @task storage Field Storage
	* @task edit Extending the Revision Edit Interface
	* @task view Extending the Revision View Interface
	* @task list Extending the Revision List Interface
	* @task mail Extending the E-mail Interface
	* @task conduit Extending the Conduit View Interface
	* @task commit Extending Commit Messages
	* @task load Loading Additional Data
	* @task context Contextual Data
	*/
	abstract class DifferentialFieldSpecification {

	private $revision;
	private $diff;
	private $manualDiff;
	private $handles;
	private $diffProperties;
	private $user;


	/* -( Storage )------------------------------------------------------------ */


	/**
	* Return a unique string used to key storage of this field's value, like
	* "mycompany.fieldname" or similar. You can return null (the default) to
	* indicate that this field does not use any storage. This is appropriate for
	* display fields, like @{class:DifferentialLinesFieldSpecification}. If you
	* implement this, you must also implement @{method:getValueForStorage} and
	* @{method:setValueFromStorage}.
	*
	* @return string\|null Unique key which identifies this field in auxiliary
	* field storage. Maximum length is 32. Alternatively,
	* null (default) to indicate that this field does not
	* use auxiliary field storage.
	* @task storage
	*/
	public function getStorageKey() {
	return null;
	}


	/**
	* Return a serialized representation of the field value, appropriate for
	* storing in auxiliary field storage. You must implement this method if
	* you implement @{method:getStorageKey}.
	*
	* @return string Serialized field value.
	* @task storage
	*/
	public function getValueForStorage() {
	throw new DifferentialFieldSpecificationIncompleteException($this);
	}


	/**
	* Set the field's value given a serialized storage value. This is called
	* when the field is loaded; if no data is available, the value will be
	* null. You must implement this method if you implement
	* @{method:getStorageKey}.
	*
	* @param string\|null Serialized field representation (from
	* @{method:getValueForStorage}) or null if no value has
	* ever been stored.
	* @return this
	* @task storage
	*/
	public function setValueFromStorage($value) {
	throw new DifferentialFieldSpecificationIncompleteException($this);
	}


	/* -( Extending the Revision Edit Interface )------------------------------ */


	/**
	* Determine if this field should appear on the "Edit Revision" interface. If
	* you return true from this method, you must implement
	* @{method:setValueFromRequest}, @{method:renderEditControl} and
	* @{method:validateField}.
	*
	* For a concrete example of a field which implements an edit interface, see
	* @{class:DifferentialRevertPlanFieldSpecification}.
	*
	* @return bool True to indicate that this field implements an edit interface.
	* @task edit
	*/
	public function shouldAppearOnEdit() {
	return false;
	}


	/**
	* Set the field's value from an HTTP request. Generally, you should read
	* the value of some field name you emitted in @{method:renderEditControl}
	* and save it into the object, e.g.:
	*
	* $this->value = $request->getStr('my-custom-field');
	*
	* If you have some particularly complicated field, you may need to read
	* more data; this is why you have access to the entire request.
	*
	* You must implement this if you implement @{method:shouldAppearOnEdit}.
	*
	* You should not perform field validation here; instead, you should implement
	* @{method:validateField}.
	*
	* @param AphrontRequest HTTP request representing a user submitting a form
	* with this field in it.
	* @return this
	* @task edit
	*/
	public function setValueFromRequest(AphrontRequest $request) {
	throw new DifferentialFieldSpecificationIncompleteException($this);
	}


	/**
	* Build a renderable object (generally, some @{class:AphrontFormControl})
	* which can be appended to a @{class:AphrontFormView} and represents the
	* interface the user sees on the "Edit Revision" screen when interacting
	* with this field.
	*
	* For example:
	*
	* return id(new AphrontFormTextControl())
	* ->setLabel('Custom Field')
	* ->setName('my-custom-key')
	* ->setValue($this->value);
	*
	* You must implement this if you implement @{method:shouldAppearOnEdit}.
	*
	* @return AphrontView\|string Something renderable.
	* @task edit
	*/
	public function renderEditControl() {
	throw new DifferentialFieldSpecificationIncompleteException($this);
	}


	/**
	* Optionally, build a preview panel for the field which will appear on the
	* edit interface. This is used for the "Summary" field, but custom fields
	* generally need not implement it.
	*
	* @return AphrontView\|string Something renderable.
	* @task edit
	*/
	public function renderEditPreview() {
	return null;
	}


	/**
	* This method will be called after @{method:setValueFromRequest} but before
	* the field is saved. It gives you an opportunity to inspect the field value
	* and throw a @{class:DifferentialFieldValidationException} if there is a
	* problem with the value the user has provided (for example, the value the
	* user entered is not correctly formatted). This method is also called after
	* @{method:setValueFromParsedCommitMessage} before the revision is saved.
	*
	* By default, fields are not validated.
	*
	* @return void
	* @task edit
	*/
	public function validateField() {
	return;
	}

	/**
	* Determine if user mentions should be extracted from the value and added to
	* CC when creating revision. Mentions are then extracted from the string
	* returned by @{method:renderValueForCommitMessage}.
	*
	* By default, mentions are not extracted.
	*
	* @return bool
	* @task edit
	*/
	public function shouldExtractMentions() {
	return false;
	}

	- /**
	- * Hook for applying revision changes via the editor. Normally, you should
	- * not implement this, but a number of builtin fields use the revision object
	- * itself as storage. If you need to do something similar for whatever reason,
	- * this method gives you an opportunity to interact with the editor or
	- * revision before changes are saved (for example, you can write the field's
	- * value into some property of the revision).
	- *
	- * @param DifferentialRevisionEditor Active editor which is applying changes
	- * to the revision.
	- * @return void
	- * @task edit
	- */
	- public function willWriteRevision(DifferentialRevisionEditor $editor) {
	- return;
	- }
	-
	- /**
	- * Hook after an edit operation has completed. This allows you to update
	- * link tables or do other write operations which should happen after the
	- * revision is saved. Normally you don't need to implement this.
	- *
	- *
	- * @param DifferentialRevisionEditor Active editor which has just applied
	- * changes to the revision.
	- * @return void
	- * @task edit
	- */
	- public function didWriteRevision(DifferentialRevisionEditor $editor) {
	- return;
	- }
	-

	/* -( Extending the Revision View Interface )------------------------------ */


	/**
	* Determine if this field should appear on the revision detail view
	* interface. One use of this interface is to add purely informational
	* fields to the revision view, without any sort of backing storage.
	*
	* If you return true from this method, you must implement the methods
	* @{method:renderLabelForRevisionView} and
	* @{method:renderValueForRevisionView}.
	*
	* @return bool True if this field should appear when viewing a revision.
	* @task view
	*/
	public function shouldAppearOnRevisionView() {
	return false;
	}


	/**
	* Return a string field label which will appear in the revision detail
	* table.
	*
	* You must implement this method if you return true from
	* @{method:shouldAppearOnRevisionView}.
	*
	* @return string Label for field in revision detail view.
	* @task view
	*/
	public function renderLabelForRevisionView() {
	throw new DifferentialFieldSpecificationIncompleteException($this);
	}


	/**
	* Return a markup block representing the field for the revision detail
	* view. Note that you can return null to suppress display (for instance,
	* if the field shows related objects of some type and the revision doesn't
	* have any related objects).
	*
	* You must implement this method if you return true from
	* @{method:shouldAppearOnRevisionView}.
	*
	* @return string\|null Display markup for field value, or null to suppress
	* field rendering.
	* @task view
	*/
	public function renderValueForRevisionView() {
	throw new DifferentialFieldSpecificationIncompleteException($this);
	}


	/**
	* Load users, their current statuses and return a markup with links to the
	* user profiles and information about their current status.
	*
	* @return string Display markup.
	* @task view
	*/
	public function renderUserList(array $user_phids) {
	if (!$user_phids) {
	return phutil_tag('em', array(), pht('None'));
	}

	return implode_selected_handle_links(', ',
	$this->getLoadedHandles(), $user_phids);
	}


	/**
	* Return a markup block representing a warning to display with the comment
	* box when preparing to accept a diff. A return value of null indicates no
	* warning box should be displayed for this field.
	*
	* @return string\|null Display markup for warning box, or null for no warning
	*/
	public function renderWarningBoxForRevisionAccept() {
	return null;
	}


	/* -( Extending the Revision List Interface )------------------------------ */


	/**
	* Determine if this field should appear in the table on the revision list
	* interface.
	*
	* @return bool True if this field should appear in the table.
	*
	* @task list
	*/
	public function shouldAppearOnRevisionList() {
	return false;
	}


	/**
	* Return a column header for revision list tables.
	*
	* @return string Column header.
	*
	* @task list
	*/
	public function renderHeaderForRevisionList() {
	throw new DifferentialFieldSpecificationIncompleteException($this);
	}


	/**
	* Optionally, return a column class for revision list tables.
	*
	* @return string CSS class for table cells.
	*
	* @task list
	*/
	public function getColumnClassForRevisionList() {
	return null;
	}


	/**
	* Return a table cell value for revision list tables.
	*
	* @param DifferentialRevision The revision to render a value for.
	* @return string Table cell value.
	*
	* @task list
	*/
	public function renderValueForRevisionList(DifferentialRevision $revision) {
	throw new DifferentialFieldSpecificationIncompleteException($this);
	}


	/* -( Extending the Diff View Interface )------------------------------ */


	/**
	* Determine if this field should appear on the diff detail view
	* interface. One use of this interface is to add purely informational
	* fields to the diff view, without any sort of backing storage.
	*
	* NOTE: These diffs are not necessarily attached yet to a revision.
	* As such, a field on the diff view can not rely on the existence of a
	* revision or use storage attached to the revision.
	*
	* If you return true from this method, you must implement the methods
	* @{method:renderLabelForDiffView} and
	* @{method:renderValueForDiffView}.
	*
	* @return bool True if this field should appear when viewing a diff.
	* @task view
	*/
	public function shouldAppearOnDiffView() {
	return false;
	}


	/**
	* Return a string field label which will appear in the diff detail
	* table.
	*
	* You must implement this method if you return true from
	* @{method:shouldAppearOnDiffView}.
	*
	* @return string Label for field in revision detail view.
	* @task view
	*/
	public function renderLabelForDiffView() {
	throw new DifferentialFieldSpecificationIncompleteException($this);
	}


	/**
	* Return a markup block representing the field for the diff detail
	* view. Note that you can return null to suppress display (for instance,
	* if the field shows related objects of some type and the revision doesn't
	* have any related objects).
	*
	* You must implement this method if you return true from
	* @{method:shouldAppearOnDiffView}.
	*
	* @return string\|null Display markup for field value, or null to suppress
	* field rendering.
	* @task view
	*/
	public function renderValueForDiffView() {
	throw new DifferentialFieldSpecificationIncompleteException($this);
	}


	/* -( Extending the E-mail Interface )------------------------------------- */


	/**
	* Return plain text to render in e-mail messages. The text may span
	* multiple lines.
	*
	* @return int One of DifferentialMailPhase constants.
	* @return string\|null Plain text, or null for no message.
	*
	* @task mail
	*/
	public function renderValueForMail($phase) {
	return null;
	}


	/* -( Extending the Conduit Interface )------------------------------------ */


	/**
	* @task conduit
	*/
	public function shouldAppearOnConduitView() {
	return false;
	}

	/**
	* @task conduit
	*/
	public function getValueForConduit() {
	throw new DifferentialFieldSpecificationIncompleteException($this);
	}

	/**
	* @task conduit
	*/
	public function getKeyForConduit() {
	$key = $this->getStorageKey();
	if ($key === null) {
	throw new DifferentialFieldSpecificationIncompleteException($this);
	}
	return $key;
	}

	/* -( Extending the Search Interface )------------------------------------ */

	/**
	* @task search
	*/
	public function shouldAddToSearchIndex() {
	return false;
	}

	/**
	* @task search
	*/
	public function getValueForSearchIndex() {
	throw new DifferentialFieldSpecificationIncompleteException($this);
	}

	/**
	* NOTE: Keys must be 4 characters for
	* @{class:PhabricatorSearchEngineMySQL}.
	*
	* @task search
	*/
	public function getKeyForSearchIndex() {
	throw new DifferentialFieldSpecificationIncompleteException($this);
	}

	/* -( Extending Commit Messages )------------------------------------------ */


	/**
	* Determine if this field should appear in commit messages. You should return
	* true if this field participates in any part of the commit message workflow,
	* even if it is not rendered by default.
	*
	* If you implement this method, you must implement
	* @{method:getCommitMessageKey} and
	* @{method:setValueFromParsedCommitMessage}.
	*
	* @return bool True if this field appears in commit messages in any capacity.
	* @task commit
	*/
	public function shouldAppearOnCommitMessage() {
	return false;
	}

	/**
	* Key which identifies this field in parsed commit messages. Commit messages
	* exist in two forms: raw textual commit messages and parsed dictionaries of
	* fields. This method must return a unique string which identifies this field
	* in dictionaries. Principally, this dictionary is shipped to and from arc
	* over Conduit. Keys should be appropriate property names, like "testPlan"
	* (not "Test Plan") and must be globally unique.
	*
	* You must implement this method if you return true from
	* @{method:shouldAppearOnCommitMessage}.
	*
	* @return string Key which identifies the field in dictionaries.
	* @task commit
	*/
	public function getCommitMessageKey() {
	throw new DifferentialFieldSpecificationIncompleteException($this);
	}

	/**
	* Set this field's value from a value in a parsed commit message dictionary.
	* Afterward, this field will go through the normal write workflows and the
	* change will be permanently stored via either the storage mechanisms (if
	* your field implements them), revision write hooks (if your field implements
	* them) or discarded (if your field implements neither, e.g. is just a
	* display field).
	*
	* The value you receive will either be null or something you originally
	* returned from @{method:parseValueFromCommitMessage}.
	*
	* You must implement this method if you return true from
	* @{method:shouldAppearOnCommitMessage}.
	*
	* @param mixed Field value from a parsed commit message dictionary.
	* @return this
	* @task commit
	*/
	public function setValueFromParsedCommitMessage($value) {
	throw new DifferentialFieldSpecificationIncompleteException($this);
	}

	/**
	* In revision control systems which read revision information from the
	* working copy, the user may edit the commit message outside of invoking
	* "arc diff --edit". When they do this, only some fields (those fields which
	* can not be edited by other users) are safe to overwrite. For instance, it
	* is fine to overwrite "Summary" because no one else can edit it, but not
	* to overwrite "Reviewers" because reviewers may have been added or removed
	* via the web interface.
	*
	* If a field is safe to overwrite when edited in a working copy commit
	* message, return true. If the authoritative value should always be used,
	* return false. By default, fields can not be overwritten.
	*
	* arc will only attempt to overwrite field values if run with "--verbatim".
	*
	* @return bool True to indicate the field is save to overwrite.
	* @task commit
	*/
	public function shouldOverwriteWhenCommitMessageIsEdited() {
	return false;
	}

	/**
	* Return true if this field should be suggested to the user during
	* "arc diff --edit". Basicially, return true if the field is something the
	* user might want to fill out (like "Summary"), and false if it's a
	* system/display/readonly field (like "Differential Revision"). If this
	* method returns true, the field will be rendered even if it has no value
	* during edit and update operations.
	*
	* @return bool True to indicate the field should appear in the edit template.
	* @task commit
	*/
	public function shouldAppearOnCommitMessageTemplate() {
	return true;
	}

	/**
	* Render a human-readable label for this field, like "Summary" or
	* "Test Plan". This is distinct from the commit message key, but generally
	* they should be similar.
	*
	* @return string Human-readable field label for commit messages.
	* @task commit
	*/
	public function renderLabelForCommitMessage() {
	throw new DifferentialFieldSpecificationIncompleteException($this);
	}

	/**
	* Render a human-readable value for this field when it appears in commit
	* messages (for instance, lists of users should be rendered as user names).
	*
	* The ##$is_edit## parameter allows you to distinguish between commit
	* messages being rendered for editing and those being rendered for amending
	* or commit. Some fields may decline to render a value in one mode (for
	* example, "Reviewed By" appears only when doing commit/amend, not while
	* editing).
	*
	* @param bool True if the message is being edited.
	* @return string Human-readable field value.
	* @task commit
	*/
	public function renderValueForCommitMessage($is_edit) {
	throw new DifferentialFieldSpecificationIncompleteException($this);
	}

	/**
	* Return one or more labels which this field parses in commit messages. For
	* example, you might parse all of "Task", "Tasks" and "Task Numbers" or
	* similar. This is just to make it easier to get commit messages to parse
	* when users are typing in the fields manually as opposed to using a
	* template, by accepting alternate spellings / pluralizations / etc. By
	* default, only the label returned from @{method:renderLabelForCommitMessage}
	* is parsed.
	*
	* @return list List of supported labels that this field can parse from commit
	* messages.
	* @task commit
	*/
	public function getSupportedCommitMessageLabels() {
	return array($this->renderLabelForCommitMessage());
	}

	/**
	* Parse a raw text block from a commit message into a canonical
	* representation of the field value. For example, the "CC" field accepts a
	* comma-delimited list of usernames and emails and parses them into valid
	* PHIDs, emitting a PHID list.
	*
	* If you encounter errors (like a nonexistent username) while parsing,
	* you should throw a @{class:DifferentialFieldParseException}.
	*
	* Generally, this method should accept whatever you return from
	* @{method:renderValueForCommitMessage} and parse it back into a sensible
	* representation.
	*
	* You must implement this method if you return true from
	* @{method:shouldAppearOnCommitMessage}.
	*
	* @param string
	* @return mixed The canonical representation of the field value. For example,
	* you should lookup usernames and object references.
	* @task commit
	*/
	public function parseValueFromCommitMessage($value) {
	throw new DifferentialFieldSpecificationIncompleteException($this);
	}


	/**
	* This method allows you to take action when a commit appears in a tracked
	* branch (for example, by closing tasks associated with the commit).
	*
	* @param PhabricatorRepository The repository the commit appeared in.
	* @param PhabricatorRepositoryCommit The commit itself.
	* @param PhabricatorRepostioryCommitData Commit data.
	* @return void
	*
	* @task commit
	*/
	public function didParseCommit(
	PhabricatorRepository $repo,
	PhabricatorRepositoryCommit $commit,
	PhabricatorRepositoryCommitData $data) {
	return;
	}

	public function getCommitMessageTips() {
	return array();
	}


	/* -( Loading Additional Data )-------------------------------------------- */


	/**
	* Specify which @{class:PhabricatorObjectHandle}s need to be loaded for your
	* field to render correctly.
	*
	* This is a convenience method which makes the handles available on all
	* interfaces where the field appears. If your field needs handles on only
	* some interfaces (or needs different handles on different interfaces) you
	* can overload the more specific methods to customize which interfaces you
	* retrieve handles for. Requesting only the handles you need will improve
	* the performance of your field.
	*
	* You can later retrieve these handles by calling @{method:getHandle}.
	*
	* @return list List of PHIDs to load handles for.
	* @task load
	*/
	protected function getRequiredHandlePHIDs() {
	return array();
	}


	/**
	* Specify which @{class:PhabricatorObjectHandle}s need to be loaded for your
	* field to render correctly on the view interface.
	*
	* This is a more specific version of @{method:getRequiredHandlePHIDs} which
	* can be overridden to improve field performance by loading only data you
	* need.
	*
	* @return list List of PHIDs to load handles for.
	* @task load
	*/
	public function getRequiredHandlePHIDsForRevisionView() {
	return $this->getRequiredHandlePHIDs();
	}


	/**
	* Specify which @{class:PhabricatorObjectHandle}s need to be loaded for your
	* field to render correctly on the list interface.
	*
	* This is a more specific version of @{method:getRequiredHandlePHIDs} which
	* can be overridden to improve field performance by loading only data you
	* need.
	*
	* @param DifferentialRevision The revision to pull PHIDs for.
	* @return list List of PHIDs to load handles for.
	* @task load
	*/
	public function getRequiredHandlePHIDsForRevisionList(
	DifferentialRevision $revision) {
	return array();
	}


	/**
	* Specify which @{class:PhabricatorObjectHandle}s need to be loaded for your
	* field to render correctly on the edit interface.
	*
	* This is a more specific version of @{method:getRequiredHandlePHIDs} which
	* can be overridden to improve field performance by loading only data you
	* need.
	*
	* @return list List of PHIDs to load handles for.
	* @task load
	*/
	public function getRequiredHandlePHIDsForRevisionEdit() {
	return $this->getRequiredHandlePHIDs();
	}

	/**
	* Specify which @{class:PhabricatorObjectHandle}s need to be loaded for your
	* field to render correctly on the commit message interface.
	*
	* This is a more specific version of @{method:getRequiredHandlePHIDs} which
	* can be overridden to improve field performance by loading only data you
	* need.
	*
	* @return list List of PHIDs to load handles for.
	* @task load
	*/
	public function getRequiredHandlePHIDsForCommitMessage() {
	return $this->getRequiredHandlePHIDs();
	}

	/**
	* Parse a list of users into a canonical PHID list.
	*
	* @param string Raw list of comma-separated user names.
	* @return list List of corresponding PHIDs.
	* @task load
	*/
	protected function parseCommitMessageUserList($value) {
	return $this->parseCommitMessageObjectList($value, $mailables = false);
	}

	protected function parseCommitMessageUserOrProjectList($value) {
	return $this->parseCommitMessageObjectList(
	$value,
	$mailables = false,
	$allow_partial = false);
	}

	/**
	* Parse a list of mailable objects into a canonical PHID list.
	*
	* @param string Raw list of comma-separated mailable names.
	* @return list List of corresponding PHIDs.
	* @task load
	*/
	protected function parseCommitMessageMailableList($value) {
	return $this->parseCommitMessageObjectList($value, $mailables = true);
	}


	/**
	* Parse and lookup a list of object names, converting them to PHIDs.
	*
	* @param string Raw list of comma-separated object names.
	* @param bool True to include mailing lists.
	* @param bool True to make a best effort. By default, an exception is
	* thrown if any item is invalid.
	* @return list List of corresponding PHIDs.
	* @task load
	*/
	public static function parseCommitMessageObjectList(
	$value,
	$include_mailables,
	$allow_partial = false) {

	$types = array(
	PhabricatorPeoplePHIDTypeUser::TYPECONST,
	PhabricatorProjectPHIDTypeProject::TYPECONST,
	);

	if ($include_mailables) {
	$types[] = PhabricatorMailingListPHIDTypeList::TYPECONST;
	}

	return id(new PhabricatorObjectListQuery())
	->setViewer(PhabricatorUser::getOmnipotentUser())
	->setAllowPartialResults($allow_partial)
	->setAllowedTypes($types)
	->setObjectList($value)
	->execute();
	}


	/* -( Contextual Data )---------------------------------------------------- */


	/**
	* @task context
	*/
	final public function setRevision(DifferentialRevision $revision) {
	$this->revision = $revision;
	$this->didSetRevision();
	return $this;
	}

	/**
	* @task context
	*/
	protected function didSetRevision() {
	return;
	}


	/**
	* @task context
	*/
	final public function setDiff(DifferentialDiff $diff) {
	$this->diff = $diff;
	return $this;
	}

	/**
	* @task context
	*/
	final public function setManualDiff(DifferentialDiff $diff) {
	$this->manualDiff = $diff;
	return $this;
	}

	/**
	* @task context
	*/
	final public function setHandles(array $handles) {
	assert_instances_of($handles, 'PhabricatorObjectHandle');
	$this->handles = $handles;
	return $this;
	}

	/**
	* @task context
	*/
	final public function setDiffProperties(array $diff_properties) {
	$this->diffProperties = $diff_properties;
	return $this;
	}

	/**
	* @task context
	*/
	final public function setUser(PhabricatorUser $user) {
	$this->user = $user;
	return $this;
	}

	/**
	* @task context
	*/
	final protected function getRevision() {
	if (empty($this->revision)) {
	throw new DifferentialFieldDataNotAvailableException($this);
	}
	return $this->revision;
	}


	/**
	* Determine if revision context is currently available.
	*
	* @task context
	*/
	final protected function hasRevision() {
	return (bool)$this->revision;
	}


	/**
	* @task context
	*/
	final protected function getDiff() {
	if (empty($this->diff)) {
	throw new DifferentialFieldDataNotAvailableException($this);
	}
	return $this->diff;
	}

	/**
	* @task context
	*/
	final protected function getManualDiff() {
	if (!$this->manualDiff) {
	return $this->getDiff();
	}
	return $this->manualDiff;
	}

	/**
	* @task context
	*/
	final protected function getUser() {
	if (empty($this->user)) {
	throw new DifferentialFieldDataNotAvailableException($this);
	}
	return $this->user;
	}

	/**
	* Get the handle for an object PHID. You must overload
	* @{method:getRequiredHandlePHIDs} (or a more specific version thereof)
	* and include the PHID you want in the list for it to be available here.
	*
	* @return PhabricatorObjectHandle Handle to the object.
	* @task context
	*/
	final protected function getHandle($phid) {
	if ($this->handles === null) {
	throw new DifferentialFieldDataNotAvailableException($this);
	}
	if (empty($this->handles[$phid])) {
	$class = get_class($this);
	throw new Exception(
	"A differential field (of class '{$class}') is attempting to retrieve ".
	"a handle ('{$phid}') which it did not request. Return all handle ".
	"PHIDs you need from getRequiredHandlePHIDs().");
	}
	return $this->handles[$phid];
	}

	final protected function getLoadedHandles() {
	if ($this->handles === null) {
	throw new DifferentialFieldDataNotAvailableException($this);
	}

	return $this->handles;
	}

	/**
	* Get the list of properties for a diff set by @{method:setManualDiff}.
	*
	* @return array Array of all Diff properties.
	* @task context
	*/
	final public function getDiffProperties() {
	if ($this->diffProperties === null) {
	// This will be set to some (possibly empty) array if we've loaded
	// properties, so null means diff properties aren't available in this
	// context.
	throw new DifferentialFieldDataNotAvailableException($this);
	}
	return $this->diffProperties;
	}

	/**
	* Get a property of a diff set by @{method:setManualDiff}.
	*
	* @param string Diff property key.
	* @return mixed\|null Diff property, or null if the property does not have
	* a value.
	* @task context
	*/
	final public function getDiffProperty($key) {
	return idx($this->getDiffProperties(), $key);
	}

	}
	diff --git a/src/applications/differential/field/specification/DifferentialFreeformFieldSpecification.php b/src/applications/differential/field/specification/DifferentialFreeformFieldSpecification.php
	index a00dc7b9fb..694fbf1b62 100644
	--- a/src/applications/differential/field/specification/DifferentialFreeformFieldSpecification.php
	+++ b/src/applications/differential/field/specification/DifferentialFreeformFieldSpecification.php
	@@ -1,192 +1,164 @@
	<?php

	abstract class DifferentialFreeformFieldSpecification
	extends DifferentialFieldSpecification {

	private function findMentionedTasks($message) {
	$maniphest = 'PhabricatorApplicationManiphest';
	if (!PhabricatorApplication::isClassInstalled($maniphest)) {
	return array();
	}

	$prefixes = ManiphestTaskStatus::getStatusPrefixMap();
	$suffixes = ManiphestTaskStatus::getStatusSuffixMap();

	$matches = id(new ManiphestCustomFieldStatusParser())
	->parseCorpus($message);

	$task_statuses = array();
	foreach ($matches as $match) {
	$prefix = phutil_utf8_strtolower($match['prefix']);
	$suffix = phutil_utf8_strtolower($match['suffix']);

	$status = idx($suffixes, $suffix);
	if (!$status) {
	$status = idx($prefixes, $prefix);
	}

	foreach ($match['monograms'] as $task_monogram) {
	$task_id = (int)trim($task_monogram, 'tT');
	$task_statuses[$task_id] = $status;
	}
	}

	return $task_statuses;
	}

	private function findDependentRevisions($message) {
	$matches = id(new DifferentialCustomFieldDependsOnParser())
	->parseCorpus($message);

	$dependents = array();
	foreach ($matches as $match) {
	foreach ($match['monograms'] as $monogram) {
	$id = (int)trim($monogram, 'dD');
	$dependents[$id] = $id;
	}
	}

	return $dependents;
	}

	public static function findRevertedCommits($message) {
	$matches = id(new DifferentialCustomFieldRevertsParser())
	->parseCorpus($message);

	$result = array();
	foreach ($matches as $match) {
	foreach ($match['monograms'] as $monogram) {
	$result[$monogram] = $monogram;
	}
	}

	return $result;
	}

	- public function didWriteRevision(DifferentialRevisionEditor $editor) {
	- $message = $this->renderValueForCommitMessage(false);
	-
	- $tasks = $this->findMentionedTasks($message);
	- if ($tasks) {
	- $tasks = id(new ManiphestTaskQuery())
	- ->setViewer($editor->getActor())
	- ->withIDs(array_keys($tasks))
	- ->execute();
	- $this->saveFieldEdges(
	- $editor->getRevision(),
	- PhabricatorEdgeConfig::TYPE_DREV_HAS_RELATED_TASK,
	- mpull($tasks, 'getPHID'));
	- }
	-
	- $dependents = $this->findDependentRevisions($message);
	- if ($dependents) {
	- $dependents = id(new DifferentialRevisionQuery())
	- ->setViewer($editor->getActor())
	- ->withIDs($dependents)
	- ->execute();
	- $this->saveFieldEdges(
	- $editor->getRevision(),
	- PhabricatorEdgeConfig::TYPE_DREV_DEPENDS_ON_DREV,
	- mpull($dependents, 'getPHID'));
	- }
	- }
	-
	private function saveFieldEdges(
	DifferentialRevision $revision,
	$edge_type,
	array $add_phids) {

	$revision_phid = $revision->getPHID();

	$old_phids = PhabricatorEdgeQuery::loadDestinationPHIDs(
	$revision_phid,
	$edge_type);

	$add_phids = array_diff($add_phids, $old_phids);
	if (!$add_phids) {
	return;
	}

	$edge_editor = id(new PhabricatorEdgeEditor())->setActor($this->getUser());
	foreach ($add_phids as $phid) {
	$edge_editor->addEdge($revision_phid, $edge_type, $phid);
	}
	// NOTE: Deletes only through the fields.
	$edge_editor->save();
	}

	public function didParseCommit(
	PhabricatorRepository $repository,
	PhabricatorRepositoryCommit $commit,
	PhabricatorRepositoryCommitData $data) {

	$message = $this->renderValueForCommitMessage($is_edit = false);

	$user = id(new PhabricatorUser())->loadOneWhere(
	'phid = %s',
	$data->getCommitDetail('authorPHID'));
	if (!$user) {
	// TODO: Maybe after grey users, we should find a way to proceed even
	// if we don't know who the author is.
	return;
	}

	$commit_names = self::findRevertedCommits($message);
	if ($commit_names) {
	$reverts = id(new DiffusionCommitQuery())
	->setViewer($user)
	->withIdentifiers($commit_names)
	->withDefaultRepository($repository)
	->execute();
	foreach ($reverts as $revert) {
	// TODO: Do interesting things here.
	}
	}

	$tasks_statuses = $this->findMentionedTasks($message);
	if (!$tasks_statuses) {
	return;
	}

	$tasks = id(new ManiphestTaskQuery())
	->setViewer($user)
	->withIDs(array_keys($tasks_statuses))
	->execute();

	foreach ($tasks as $task_id => $task) {
	id(new PhabricatorEdgeEditor())
	->setActor($user)
	->addEdge(
	$task->getPHID(),
	PhabricatorEdgeConfig::TYPE_TASK_HAS_COMMIT,
	$commit->getPHID())
	->save();

	$status = $tasks_statuses[$task_id];
	if (!$status) {
	// Text like "Ref T123", don't change the task status.
	continue;
	}

	if ($task->getStatus() == $status) {
	// Task is already in the specified status, so skip updating it.
	continue;
	}

	$commit_name = $repository->formatCommitName(
	$commit->getCommitIdentifier());

	$call = new ConduitCall(
	'maniphest.update',
	array(
	'id' => $task->getID(),
	'status' => $status,
	'comments' => "Closed by commit {$commit_name}.",
	));

	$call->setUser($user);
	$call->execute();
	}
	}

	}
	diff --git a/src/applications/differential/field/specification/DifferentialJIRAIssuesFieldSpecification.php b/src/applications/differential/field/specification/DifferentialJIRAIssuesFieldSpecification.php
	index 8f9394d069..27a2db98e6 100644
	--- a/src/applications/differential/field/specification/DifferentialJIRAIssuesFieldSpecification.php
	+++ b/src/applications/differential/field/specification/DifferentialJIRAIssuesFieldSpecification.php
	@@ -1,195 +1,170 @@
	<?php

	final class DifferentialJIRAIssuesFieldSpecification
	extends DifferentialFieldSpecification {

	private $value;
	private $error;

	public function getStorageKey() {
	return 'phabricator:jira-issues';
	}

	public function getValueForStorage() {
	return json_encode($this->value);
	}

	public function setValueFromStorage($value) {
	if (!strlen($value)) {
	$this->value = array();
	} else {
	$this->value = json_decode($value, true);
	}
	return $this;
	}

	public function shouldAppearOnEdit() {
	return true;
	}

	public function setValueFromRequest(AphrontRequest $request) {
	$this->value = $request->getStrList($this->getStorageKey());
	return $this;
	}

	public function renderEditControl() {
	return id(new AphrontFormTextControl())
	->setLabel(pht('JIRA Issues'))
	->setCaption(
	pht('Example: %s', phutil_tag('tt', array(), 'JIS-3, JIS-9')))
	->setName($this->getStorageKey())
	->setValue(implode(', ', nonempty($this->value, array())))
	->setError($this->error);
	}

	public function shouldAppearOnRevisionView() {
	return true;
	}

	public function renderLabelForRevisionView() {
	return pht('JIRA Issues:');
	}

	public function renderValueForRevisionView() {
	$xobjs = $this->loadDoorkeeperExternalObjects();
	if (!$xobjs) {
	return null;
	}

	$links = array();
	foreach ($xobjs as $xobj) {
	$links[] = id(new DoorkeeperTagView())
	->setExternalObject($xobj);
	}

	return phutil_implode_html(phutil_tag('br'), $links);
	}

	public function shouldAppearOnConduitView() {
	return true;
	}

	public function getValueForConduit() {
	return $this->value;
	}

	public function shouldAppearOnCommitMessage() {
	return true;
	}

	public function getCommitMessageKey() {
	return 'jira.issues';
	}

	public function setValueFromParsedCommitMessage($value) {
	$this->value = $value;
	return $this;
	}

	public function shouldOverwriteWhenCommitMessageIsEdited() {
	return true;
	}

	public function renderLabelForCommitMessage() {
	return 'JIRA Issues';
	}

	public function renderValueForCommitMessage($is_edit) {
	return implode(', ', $this->value);
	}

	public function getSupportedCommitMessageLabels() {
	return array(
	'JIRA',
	'JIRA Issues',
	'JIRA Issue',
	);
	}

	public function parseValueFromCommitMessage($value) {
	return preg_split('/[\s,]+/', $value, $limit = -1, PREG_SPLIT_NO_EMPTY);
	}

	public function validateField() {
	if ($this->value) {
	$refs = id(new DoorkeeperImportEngine())
	->setViewer($this->getUser())
	->setRefs($this->buildDoorkeeperRefs())
	->execute();

	$bad = array();
	foreach ($refs as $ref) {
	if (!$ref->getIsVisible()) {
	$bad[] = $ref->getObjectID();
	}
	}

	if ($bad) {
	$bad = implode(', ', $bad);
	$this->error = pht('Invalid');
	throw new DifferentialFieldValidationException(
	pht(
	"Some JIRA issues could not be loaded. They may not exist, or ".
	"you may not have permission to view them: %s",
	$bad));
	}
	}
	}

	private function buildDoorkeeperRefs() {
	$provider = PhabricatorAuthProviderOAuth1JIRA::getJIRAProvider();

	$refs = array();
	if ($this->value) {
	foreach ($this->value as $jira_key) {
	$refs[] = id(new DoorkeeperObjectRef())
	->setApplicationType(DoorkeeperBridgeJIRA::APPTYPE_JIRA)
	->setApplicationDomain($provider->getProviderDomain())
	->setObjectType(DoorkeeperBridgeJIRA::OBJTYPE_ISSUE)
	->setObjectID($jira_key);
	}
	}

	return $refs;
	}

	private function loadDoorkeeperExternalObjects() {
	$refs = $this->buildDoorkeeperRefs();
	if (!$refs) {
	return array();
	}

	$xobjs = id(new DoorkeeperExternalObjectQuery())
	->setViewer($this->getUser())
	->withObjectKeys(mpull($refs, 'getObjectKey'))
	->execute();

	return $xobjs;
	}

	- public function didWriteRevision(DifferentialRevisionEditor $editor) {
	- $revision = $editor->getRevision();
	- $revision_phid = $revision->getPHID();
	-
	- $edge_type = PhabricatorEdgeConfig::TYPE_PHOB_HAS_JIRAISSUE;
	- $edge_dsts = mpull($this->loadDoorkeeperExternalObjects(), 'getPHID');
	-
	- $edges = PhabricatorEdgeQuery::loadDestinationPHIDs(
	- $revision_phid,
	- $edge_type);
	-
	- $editor = id(new PhabricatorEdgeEditor())
	- ->setActor($this->getUser());
	-
	- foreach (array_diff($edges, $edge_dsts) as $rem_edge) {
	- $editor->removeEdge($revision_phid, $edge_type, $rem_edge);
	- }
	-
	- foreach (array_diff($edge_dsts, $edges) as $add_edge) {
	- $editor->addEdge($revision_phid, $edge_type, $add_edge);
	- }
	-
	- $editor->save();
	- }
	-
	}
	diff --git a/src/applications/differential/field/specification/DifferentialManiphestTasksFieldSpecification.php b/src/applications/differential/field/specification/DifferentialManiphestTasksFieldSpecification.php
	index dd851590ab..9cdb7b72a3 100644
	--- a/src/applications/differential/field/specification/DifferentialManiphestTasksFieldSpecification.php
	+++ b/src/applications/differential/field/specification/DifferentialManiphestTasksFieldSpecification.php
	@@ -1,186 +1,158 @@
	<?php

	final class DifferentialManiphestTasksFieldSpecification
	extends DifferentialFieldSpecification {

	private $oldManiphestTasks = array();
	private $maniphestTasks = array();

	public function shouldAppearOnRevisionView() {
	return PhabricatorApplication::isClassInstalled(
	'PhabricatorApplicationManiphest');
	}

	public function getRequiredHandlePHIDsForRevisionView() {
	return $this->getManiphestTaskPHIDs();
	}

	public function renderLabelForRevisionView() {
	return 'Maniphest Tasks:';
	}

	public function renderValueForRevisionView() {
	$task_phids = $this->getManiphestTaskPHIDs();
	if (!$task_phids) {
	return null;
	}

	$links = array();
	foreach ($task_phids as $task_phid) {
	$links[] = $this->getHandle($task_phid)->renderLink();
	}

	return phutil_implode_html(phutil_tag('br'), $links);
	}

	private function getManiphestTaskPHIDs() {
	$revision = $this->getRevision();
	if (!$revision->getPHID()) {
	return array();
	}
	return PhabricatorEdgeQuery::loadDestinationPHIDs(
	$revision->getPHID(),
	PhabricatorEdgeConfig::TYPE_DREV_HAS_RELATED_TASK);
	}

	- /**
	- * Attach the revision to the task(s) and the task(s) to the revision.
	- *
	- * @return void
	- */
	- public function didWriteRevision(DifferentialRevisionEditor $editor) {
	- $revision = $editor->getRevision();
	- $revision_phid = $revision->getPHID();
	- $edge_type = PhabricatorEdgeConfig::TYPE_DREV_HAS_RELATED_TASK;
	-
	- $old_phids = $this->oldManiphestTasks;
	- $add_phids = $this->maniphestTasks;
	- $rem_phids = array_diff($old_phids, $add_phids);
	-
	- $edge_editor = id(new PhabricatorEdgeEditor())
	- ->setActor($this->getUser());
	-
	- foreach ($add_phids as $phid) {
	- $edge_editor->addEdge($revision_phid, $edge_type, $phid);
	- }
	-
	- foreach ($rem_phids as $phid) {
	- $edge_editor->removeEdge($revision_phid, $edge_type, $phid);
	- }
	-
	- $edge_editor->save();
	- }
	-
	protected function didSetRevision() {
	$this->maniphestTasks = $this->getManiphestTaskPHIDs();
	$this->oldManiphestTasks = $this->maniphestTasks;
	}

	public function getRequiredHandlePHIDsForCommitMessage() {
	return $this->maniphestTasks;
	}

	public function shouldAppearOnCommitMessageTemplate() {
	return false;
	}

	public function shouldAppearOnCommitMessage() {
	return $this->shouldAppearOnRevisionView();
	}

	public function getCommitMessageKey() {
	return 'maniphestTaskPHIDs';
	}

	public function setValueFromParsedCommitMessage($value) {
	$this->maniphestTasks = array_unique(nonempty($value, array()));
	return $this;
	}

	public function renderLabelForCommitMessage() {
	return 'Maniphest Tasks';
	}

	public function getSupportedCommitMessageLabels() {
	return array(
	'Maniphest Task',
	'Maniphest Tasks',
	);
	}

	public function renderValueForCommitMessage($is_edit) {
	if (!$this->maniphestTasks) {
	return null;
	}

	$names = array();
	foreach ($this->maniphestTasks as $phid) {
	$handle = $this->getHandle($phid);
	$names[] = $handle->getName();
	}
	return implode(', ', $names);
	}

	public function parseValueFromCommitMessage($value) {
	$matches = null;
	preg_match_all('/T(\d+)/', $value, $matches);
	if (empty($matches[0])) {
	return array();
	}

	// TODO: T603 Get a viewer here so we can issue the right query.

	$task_ids = $matches[1];
	$tasks = id(new ManiphestTask())
	->loadAllWhere('id in (%Ld)', $task_ids);

	$task_phids = array();
	$invalid = array();
	foreach ($task_ids as $task_id) {
	$task = idx($tasks, $task_id);
	if (empty($task)) {
	$invalid[] = 'T'.$task_id;
	} else {
	$task_phids[] = $task->getPHID();
	}
	}

	if ($invalid) {
	$what = pht('Maniphest Task(s)', count($invalid));
	$invalid = implode(', ', $invalid);
	throw new DifferentialFieldParseException(
	"Commit message references nonexistent {$what}: {$invalid}.");
	}

	return $task_phids;
	}

	public function renderValueForMail($phase) {
	if ($phase == DifferentialMailPhase::COMMENT) {
	return null;
	}

	if (!$this->maniphestTasks) {
	return null;
	}

	$handles = id(new PhabricatorHandleQuery())
	->setViewer($this->getUser())
	->withPHIDs($this->maniphestTasks)
	->execute();
	$body = array();
	$body[] = 'MANIPHEST TASKS';
	foreach ($handles as $handle) {
	$body[] = ' '.PhabricatorEnv::getProductionURI($handle->getURI());
	}
	return implode("\n", $body);
	}

	public function getCommitMessageTips() {
	return array(
	'Use "Fixes T123" in your summary to mark that the current '.
	'revision completes a given task.'
	);
	}

	}
	diff --git a/src/applications/differential/field/specification/DifferentialRepositoryFieldSpecification.php b/src/applications/differential/field/specification/DifferentialRepositoryFieldSpecification.php
	index 36adc65d1f..6cd56fa681 100644
	--- a/src/applications/differential/field/specification/DifferentialRepositoryFieldSpecification.php
	+++ b/src/applications/differential/field/specification/DifferentialRepositoryFieldSpecification.php
	@@ -1,48 +1,44 @@
	<?php

	final class DifferentialRepositoryFieldSpecification
	extends DifferentialFieldSpecification {

	private $value;

	public function shouldAppearOnEdit() {
	return true;
	}

	protected function didSetRevision() {
	$this->value = $this->getRevision()->getRepositoryPHID();
	}

	public function setValueFromRequest(AphrontRequest $request) {
	$value = head($request->getArr('repositoryPHID'));
	$this->value = nonempty($value, null);
	return $this;
	}


	public function getRequiredHandlePHIDsForRevisionEdit() {
	return array_filter(array($this->value));
	}

	public function renderEditControl() {
	$value = array();
	if ($this->value) {
	$value = array(
	$this->getHandle($this->value),
	);
	}

	return id(new AphrontFormTokenizerControl())
	->setLabel('Repository')
	->setName('repositoryPHID')
	->setUser($this->getUser())
	->setLimit(1)
	->setDatasource('/typeahead/common/repositories/')
	->setValue($value);
	}

	- public function willWriteRevision(DifferentialRevisionEditor $editor) {
	- $this->getRevision()->setRepositoryPHID($this->value);
	- }
	-
	}
	diff --git a/src/applications/differential/field/specification/DifferentialReviewersFieldSpecification.php b/src/applications/differential/field/specification/DifferentialReviewersFieldSpecification.php
	index 35c47afef7..d6965b7900 100644
	--- a/src/applications/differential/field/specification/DifferentialReviewersFieldSpecification.php
	+++ b/src/applications/differential/field/specification/DifferentialReviewersFieldSpecification.php
	@@ -1,201 +1,197 @@
	<?php

	final class DifferentialReviewersFieldSpecification
	extends DifferentialFieldSpecification {

	private $reviewers = array();
	private $error;

	public function shouldAppearOnRevisionView() {
	return true;
	}

	public function getRequiredHandlePHIDsForRevisionView() {
	return $this->getReviewerPHIDs();
	}

	public function renderLabelForRevisionView() {
	return pht('Reviewers');
	}

	public function renderValueForRevisionView() {
	$reviewers = array();
	foreach ($this->getRevision()->getReviewerStatus() as $reviewer) {
	if ($reviewer->isUser()) {
	$reviewers[] = $reviewer;
	}
	}

	if (!$reviewers) {
	// Renders "None".
	return $this->renderUserList(array());
	}

	$view = id(new DifferentialReviewersView())
	->setUser($this->getUser())
	->setReviewers($reviewers)
	->setHandles($this->getLoadedHandles());

	$diff = $this->getRevision()->loadActiveDiff();
	if ($diff) {
	$view->setActiveDiff($diff);
	}

	return $view;
	}

	private function getReviewerPHIDs() {
	$revision = $this->getRevision();
	return $revision->getReviewers();
	}

	public function shouldAppearOnEdit() {
	return true;
	}

	protected function didSetRevision() {
	$this->reviewers = $this->getReviewerPHIDs();
	}

	public function getRequiredHandlePHIDsForRevisionEdit() {
	return $this->reviewers;
	}

	public function setValueFromRequest(AphrontRequest $request) {
	$this->reviewers = $request->getArr('reviewers');
	return $this;
	}

	public function validateField() {
	if (!$this->hasRevision()) {
	return;
	}

	$self = PhabricatorEnv::getEnvConfig('differential.allow-self-accept');
	if ($self) {
	return;
	}

	$author_phid = $this->getRevision()->getAuthorPHID();
	if (!in_array($author_phid, $this->reviewers)) {
	return;
	}

	$this->error = 'Invalid';
	throw new DifferentialFieldValidationException(
	"The owner of a revision may not be a reviewer.");
	}

	public function renderEditControl() {
	$reviewer_map = array();
	foreach ($this->reviewers as $phid) {
	$reviewer_map[] = $this->getHandle($phid);
	}
	return id(new AphrontFormTokenizerControl())
	->setLabel(pht('Reviewers'))
	->setName('reviewers')
	->setUser($this->getUser())
	->setDatasource('/typeahead/common/usersorprojects/')
	->setValue($reviewer_map)
	->setError($this->error);
	}

	- public function willWriteRevision(DifferentialRevisionEditor $editor) {
	- $editor->setReviewers($this->reviewers);
	- }
	-
	public function shouldAppearOnCommitMessage() {
	return true;
	}

	public function getCommitMessageKey() {
	return 'reviewerPHIDs';
	}

	public function setValueFromParsedCommitMessage($value) {
	$this->reviewers = array_unique(nonempty($value, array()));
	return $this;
	}

	public function renderLabelForCommitMessage() {
	return 'Reviewers';
	}

	public function getRequiredHandlePHIDsForCommitMessage() {
	return $this->reviewers;
	}

	public function renderValueForCommitMessage($is_edit) {
	if (!$this->reviewers) {
	return null;
	}

	$names = array();
	foreach ($this->reviewers as $phid) {
	$names[] = $this->getHandle($phid)->getObjectName();
	}

	return implode(', ', $names);
	}

	public function getSupportedCommitMessageLabels() {
	return array(
	'Reviewer',
	'Reviewers',
	);
	}

	public function parseValueFromCommitMessage($value) {
	return $this->parseCommitMessageUserOrProjectList($value);
	}

	public function shouldAppearOnRevisionList() {
	return true;
	}

	public function renderHeaderForRevisionList() {
	return 'Reviewers';
	}

	public function renderValueForRevisionList(DifferentialRevision $revision) {
	$primary_reviewer = $revision->getPrimaryReviewer();
	if ($primary_reviewer) {
	$names = array();

	foreach ($revision->getReviewers() as $reviewer) {
	$names[] = $this->getHandle($reviewer)->renderLink();
	}

	return phutil_implode_html(', ', $names);
	} else {
	return phutil_tag('em', array(), 'None');
	}
	}

	public function getRequiredHandlePHIDsForRevisionList(
	DifferentialRevision $revision) {
	return $revision->getReviewers();
	}

	public function renderValueForMail($phase) {
	if ($phase == DifferentialMailPhase::COMMENT) {
	return null;
	}

	if (!$this->reviewers) {
	return null;
	}

	$handles = id(new PhabricatorHandleQuery())
	->setViewer($this->getUser())
	->withPHIDs($this->reviewers)
	->execute();
	$handles = array_select_keys(
	$handles,
	array($this->getRevision()->getPrimaryReviewer())) + $handles;

	$names = mpull($handles, 'getObjectName');
	return 'Reviewers: '.implode(', ', $names);
	}

	}
	diff --git a/src/applications/differential/field/specification/DifferentialSummaryFieldSpecification.php b/src/applications/differential/field/specification/DifferentialSummaryFieldSpecification.php
	index cb1515d6f7..19f6004a07 100644
	--- a/src/applications/differential/field/specification/DifferentialSummaryFieldSpecification.php
	+++ b/src/applications/differential/field/specification/DifferentialSummaryFieldSpecification.php
	@@ -1,105 +1,101 @@
	<?php

	final class DifferentialSummaryFieldSpecification
	extends DifferentialFreeformFieldSpecification {

	private $summary = '';
	private $controlID;

	public function shouldAppearOnEdit() {
	return true;
	}

	protected function didSetRevision() {
	$this->summary = (string)$this->getRevision()->getSummary();
	}

	public function setValueFromRequest(AphrontRequest $request) {
	$this->summary = $request->getStr('summary');
	return $this;
	}

	public function renderEditControl() {
	return id(new PhabricatorRemarkupControl())
	->setLabel(pht('Summary'))
	->setName('summary')
	->setID($this->getControlID())
	->setValue($this->summary);
	}

	public function renderEditPreview() {
	return id(new PHUIRemarkupPreviewPanel())
	->setHeader(pht('Summary Preview'))
	->setControlID($this->getControlID())
	->setPreviewURI('/differential/preview/');
	}

	public function shouldExtractMentions() {
	return true;
	}

	- public function willWriteRevision(DifferentialRevisionEditor $editor) {
	- $this->getRevision()->setSummary($this->summary);
	- }
	-
	public function shouldAppearOnCommitMessage() {
	return true;
	}

	public function getCommitMessageKey() {
	return 'summary';
	}

	public function setValueFromParsedCommitMessage($value) {
	$this->summary = (string)$value;
	return $this;
	}

	public function shouldOverwriteWhenCommitMessageIsEdited() {
	return true;
	}

	public function renderLabelForCommitMessage() {
	return 'Summary';
	}

	public function renderValueForCommitMessage($is_edit) {
	return $this->summary;
	}

	public function parseValueFromCommitMessage($value) {
	return (string)$value;
	}

	public function renderValueForMail($phase) {
	if ($phase != DifferentialMailPhase::WELCOME) {
	return null;
	}

	if ($this->summary == '') {
	return null;
	}

	return $this->summary;
	}

	public function shouldAddToSearchIndex() {
	return true;
	}

	public function getValueForSearchIndex() {
	return $this->summary;
	}

	public function getKeyForSearchIndex() {
	return PhabricatorSearchField::FIELD_BODY;
	}

	private function getControlID() {
	if (!$this->controlID) {
	$this->controlID = celerity_generate_unique_node_id();
	}
	return $this->controlID;
	}

	}
	diff --git a/src/applications/differential/field/specification/DifferentialTestPlanFieldSpecification.php b/src/applications/differential/field/specification/DifferentialTestPlanFieldSpecification.php
	index 74dcb42014..7928902843 100644
	--- a/src/applications/differential/field/specification/DifferentialTestPlanFieldSpecification.php
	+++ b/src/applications/differential/field/specification/DifferentialTestPlanFieldSpecification.php
	@@ -1,128 +1,124 @@
	<?php

	final class DifferentialTestPlanFieldSpecification
	extends DifferentialFieldSpecification {

	private $plan = '';

	// NOTE: This means "uninitialized".
	private $error = false;

	public function shouldAppearOnEdit() {
	return PhabricatorEnv::getEnvConfig('differential.show-test-plan-field');
	}

	protected function didSetRevision() {
	$this->plan = (string)$this->getRevision()->getTestPlan();
	}

	public function setValueFromRequest(AphrontRequest $request) {
	$this->plan = $request->getStr('testplan');
	$this->error = null;
	return $this;
	}

	public function renderEditControl() {
	if ($this->error === false) {
	if ($this->isRequired()) {
	$this->error = true;
	} else {
	$this->error = null;
	}
	}

	return id(new PhabricatorRemarkupControl())
	->setLabel('Test Plan')
	->setName('testplan')
	->setValue($this->plan)
	->setError($this->error);
	}

	public function shouldExtractMentions() {
	return true;
	}

	- public function willWriteRevision(DifferentialRevisionEditor $editor) {
	- $this->getRevision()->setTestPlan($this->plan);
	- }
	-
	public function validateField() {
	if ($this->isRequired()) {
	if (!strlen($this->plan)) {
	$this->error = 'Required';
	throw new DifferentialFieldValidationException(
	"You must provide a test plan.");
	}
	}
	}

	public function shouldAppearOnCommitMessage() {
	return PhabricatorEnv::getEnvConfig('differential.show-test-plan-field');
	}

	public function getCommitMessageKey() {
	return 'testPlan';
	}

	public function setValueFromParsedCommitMessage($value) {
	$this->plan = (string)$value;
	return $this;
	}

	public function shouldOverwriteWhenCommitMessageIsEdited() {
	return true;
	}

	public function renderLabelForCommitMessage() {
	return 'Test Plan';
	}

	public function getSupportedCommitMessageLabels() {
	return array(
	'Test Plan',
	'Testplan',
	'Tested',
	'Tests',
	);
	}


	public function renderValueForCommitMessage($is_edit) {
	return $this->plan;
	}

	public function parseValueFromCommitMessage($value) {
	return $value;
	}

	public function renderValueForMail($phase) {
	if ($phase != DifferentialMailPhase::WELCOME) {
	return null;
	}

	if ($this->plan == '') {
	return null;
	}

	return "TEST PLAN\n".preg_replace('/^/m', ' ', $this->plan);
	}

	public function shouldAddToSearchIndex() {
	return true;
	}

	public function getValueForSearchIndex() {
	return $this->plan;
	}

	public function getKeyForSearchIndex() {
	return 'tpln';
	}

	private function isRequired() {
	return PhabricatorEnv::getEnvConfig('differential.require-test-plan-field');
	}



	}
	diff --git a/src/applications/differential/field/specification/DifferentialTitleFieldSpecification.php b/src/applications/differential/field/specification/DifferentialTitleFieldSpecification.php
	index 59fb375e32..b05a210b05 100644
	--- a/src/applications/differential/field/specification/DifferentialTitleFieldSpecification.php
	+++ b/src/applications/differential/field/specification/DifferentialTitleFieldSpecification.php
	@@ -1,111 +1,107 @@
	<?php

	final class DifferentialTitleFieldSpecification
	extends DifferentialFreeformFieldSpecification {

	private $title;
	private $error = true;

	public function shouldAppearOnEdit() {
	return true;
	}

	protected function didSetRevision() {
	$this->title = $this->getRevision()->getTitle();
	}

	public function setValueFromRequest(AphrontRequest $request) {
	$this->title = $request->getStr('title');
	$this->error = null;
	return $this;
	}

	public function renderEditControl() {
	return id(new AphrontFormTextAreaControl())
	->setLabel('Title')
	->setName('title')
	->setHeight(AphrontFormTextAreaControl::HEIGHT_VERY_SHORT)
	->setError($this->error)
	->setValue($this->title);
	}

	public function shouldExtractMentions() {
	return true;
	}

	- public function willWriteRevision(DifferentialRevisionEditor $editor) {
	- $this->getRevision()->setTitle($this->title);
	- }
	-
	public function validateField() {
	if (!strlen($this->title)) {
	$this->error = 'Required';
	throw new DifferentialFieldValidationException(
	"You must provide a revision title in the first line ".
	"of your commit message.");
	}

	if (preg_match('/^<<.*>>$/', $this->title)) {
	$default_title = self::getDefaultRevisionTitle();
	$this->error = 'Required';
	throw new DifferentialFieldValidationException(
	"Replace the line '{$default_title}' with a revision title ".
	"that describes the change.");
	}
	}

	public function shouldAppearOnCommitMessage() {
	return true;
	}

	public function getCommitMessageKey() {
	return 'title';
	}

	public function setValueFromParsedCommitMessage($value) {
	$this->title = $value;
	return $this;
	}

	public function shouldOverwriteWhenCommitMessageIsEdited() {
	return true;
	}

	public function renderLabelForCommitMessage() {
	return 'Title';
	}

	public function renderValueForCommitMessage($is_edit) {
	return $this->title;
	}

	public function parseValueFromCommitMessage($value) {
	return preg_replace('/\s\n\s/', ' ', $value);
	}

	public function shouldAppearOnRevisionList() {
	return true;
	}

	public function renderHeaderForRevisionList() {
	return 'Revision';
	}

	public function getColumnClassForRevisionList() {
	return 'wide pri';
	}

	public static function getDefaultRevisionTitle() {
	return '<<Replace this line with your Revision Title>>';
	}

	public function renderValueForRevisionList(DifferentialRevision $revision) {
	return phutil_tag(
	'a',
	array(
	'href' => '/D'.$revision->getID(),
	),
	$revision->getTitle());
	}

	}
	diff --git a/src/applications/differential/field/specification/DifferentialViewPolicyFieldSpecification.php b/src/applications/differential/field/specification/DifferentialViewPolicyFieldSpecification.php
	index df8568c33e..f8205afdfe 100644
	--- a/src/applications/differential/field/specification/DifferentialViewPolicyFieldSpecification.php
	+++ b/src/applications/differential/field/specification/DifferentialViewPolicyFieldSpecification.php
	@@ -1,42 +1,38 @@
	<?php

	final class DifferentialViewPolicyFieldSpecification
	extends DifferentialFieldSpecification {

	private $value;

	public function shouldAppearOnEdit() {
	return true;
	}

	protected function didSetRevision() {
	$this->value = $this->getRevision()->getViewPolicy();
	}

	public function setValueFromRequest(AphrontRequest $request) {
	$this->value = $request->getStr('viewPolicy');
	return $this;
	}

	public function renderEditControl() {
	$viewer = $this->getUser();
	$revision = $this->getRevision();

	$policies = id(new PhabricatorPolicyQuery())
	->setViewer($viewer)
	->setObject($revision)
	->execute();

	return id(new AphrontFormPolicyControl())
	->setUser($viewer)
	->setCapability(PhabricatorPolicyCapability::CAN_VIEW)
	->setPolicyObject($revision)
	->setPolicies($policies)
	->setName('viewPolicy');
	}

	- public function willWriteRevision(DifferentialRevisionEditor $editor) {
	- $this->getRevision()->setViewPolicy($this->value);
	- }
	-
	}

File Metadata

Mime Type: text/x-diff
Expires: Sun, Sep 7, 10:02 AM (1 d, 10 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 223011
Default Alt Text: (145 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions