No OneTemporary
Actions

Size

75 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/resources/sql/autopatches/20140224.dxclean.1.datecommitted.sql b/resources/sql/autopatches/20140224.dxclean.1.datecommitted.sql
	new file mode 100644
	index 0000000000..65f2cbe7b6
	--- /dev/null
	+++ b/resources/sql/autopatches/20140224.dxclean.1.datecommitted.sql
	@@ -0,0 +1,2 @@
	+ALTER TABLE {$NAMESPACE}_differential.differential_revision
	+ DROP dateCommitted;
	diff --git a/src/applications/differential/conduit/ConduitAPI_differential_close_Method.php b/src/applications/differential/conduit/ConduitAPI_differential_close_Method.php
	index f59aff2767..d5cdb7ebfb 100644
	--- a/src/applications/differential/conduit/ConduitAPI_differential_close_Method.php
	+++ b/src/applications/differential/conduit/ConduitAPI_differential_close_Method.php
	@@ -1,69 +1,68 @@
	<?php

	/**
	* @group conduit
	*/
	final class ConduitAPI_differential_close_Method
	extends ConduitAPIMethod {

	public function getMethodDescription() {
	return "Close a Differential revision.";
	}

	public function defineParamTypes() {
	return array(
	'revisionID' => 'required int',
	);
	}

	public function defineReturnType() {
	return 'void';
	}

	public function defineErrorTypes() {
	return array(
	'ERR_NOT_FOUND' => 'Revision was not found.',
	);
	}

	protected function execute(ConduitAPIRequest $request) {
	$id = $request->getValue('revisionID');

	$revision = id(new DifferentialRevisionQuery())
	->withIDs(array($id))
	->setViewer($request->getUser())
	->needRelationships(true)
	->needReviewerStatus(true)
	->executeOne();
	if (!$revision) {
	throw new ConduitException('ERR_NOT_FOUND');
	}

	if ($revision->getStatus() == ArcanistDifferentialRevisionStatus::CLOSED) {
	// This can occur if someone runs 'close-revision' and hits a race, or
	// they have a remote hook installed but don't have the
	// 'remote_hook_installed' flag set, or similar. In any case, just treat
	// it as a no-op rather than adding another "X closed this revision"
	// message to the revision comments.
	return;
	}

	$content_source = PhabricatorContentSource::newForSource(
	PhabricatorContentSource::SOURCE_CONDUIT,
	array());

	$editor = new DifferentialCommentEditor(
	$revision,
	DifferentialAction::ACTION_CLOSE);
	$editor->setContentSource($content_source);
	$editor->setActor($request->getUser());
	$editor->save();

	$revision->setStatus(ArcanistDifferentialRevisionStatus::CLOSED);
	- $revision->setDateCommitted(time());
	$revision->save();

	return;
	}

	}
	diff --git a/src/applications/differential/editor/DifferentialCommentEditor.php b/src/applications/differential/editor/DifferentialCommentEditor.php
	index 525ea7259a..1e50c4dcec 100644
	--- a/src/applications/differential/editor/DifferentialCommentEditor.php
	+++ b/src/applications/differential/editor/DifferentialCommentEditor.php
	@@ -1,804 +1,800 @@
	<?php

	final class DifferentialCommentEditor extends PhabricatorEditor {

	protected $revision;
	protected $action;

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

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

	private $isDaemonWorkflow;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	$metadata = array();

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

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

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

	break;

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

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

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

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

	break;

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

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

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

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

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

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

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

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

	$update_accepted_status = true;
	break;

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

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

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

	break;

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

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

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

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

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

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

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

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


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

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

	$update_accepted_status = true;
	break;

	case DifferentialAction::ACTION_CLOSE:

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

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

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

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

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

	- if (!$revision->getDateCommitted()) {
	- $revision->setDateCommitted(time());
	- }
	-
	$revision->setStatus(ArcanistDifferentialRevisionStatus::CLOSED);
	break;

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

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

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

	break;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	$template = id(new DifferentialComment())
	->setAuthorPHID($actor_phid)
	->setRevision($revision);

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

	$template->setContentSource($content_source);

	$comments = array();

	// If this edit performs a meaningful action, save a transaction for the
	// action. Do this first, since the mail currently assumes the first
	// transaction is the strongest.
	if ($action != DifferentialAction::ACTION_COMMENT &&
	$action != DifferentialAction::ACTION_ADDREVIEWERS &&
	$action != DifferentialAction::ACTION_ADDCCS) {
	$comments[] = id(clone $template)
	->setAction($action);
	}

	// If this edit adds reviewers, save a transaction for those changes.
	$rev_add = DifferentialComment::METADATA_ADDED_REVIEWERS;
	$rev_rem = DifferentialComment::METADATA_REMOVED_REVIEWERS;
	if (idx($metadata, $rev_add) \|\| idx($metadata, $rev_rem)) {
	$reviewer_meta = array_select_keys($metadata, array($rev_add, $rev_rem));

	$comments[] = id(clone $template)
	->setAction(DifferentialAction::ACTION_ADDREVIEWERS)
	->setMetadata($reviewer_meta);
	}

	// If this edit adds CCs, save a transaction for the new CCs. We build this
	// for either explicit CCs, or for @mentions. First, find any "@mentions" in
	// the comment blocks.
	$content_blocks = array($this->message);
	foreach ($inline_comments as $inline) {
	$content_blocks[] = $inline->getContent();
	}
	$mention_ccs = PhabricatorMarkupEngine::extractPHIDsFromMentions(
	$content_blocks);

	// Now, build a comment if we have explicit action CCs or mention CCs.
	$cc_add = DifferentialComment::METADATA_ADDED_CCS;
	if (idx($metadata, $cc_add) \|\| $mention_ccs) {
	$all_adds = array_merge(
	idx($metadata, $cc_add, array()),
	$mention_ccs);
	$all_adds = $this->filterAddedCCs($all_adds);
	if ($all_adds) {
	$cc_meta = array(
	DifferentialComment::METADATA_ADDED_CCS => $all_adds,
	);

	foreach ($all_adds as $cc_phid) {
	DifferentialRevisionEditor::addCC(
	$revision,
	$cc_phid,
	$actor_phid);
	}

	$comments[] = id(clone $template)
	->setAction(DifferentialAction::ACTION_ADDCCS)
	->setMetadata($cc_meta);
	}
	}

	// If this edit has comments or inline comments, save a transaction for
	// the comment content.
	if (strlen($this->message)) {
	$comments[] = id(clone $template)
	->setAction(DifferentialAction::ACTION_COMMENT)
	->setContent((string)$this->message);
	}

	foreach ($comments as $comment) {
	$comment->save();
	}

	$changesets = array();
	$mail_inlines = array();
	if ($inline_comments) {
	$load_ids = mpull($inline_comments, 'getChangesetID');
	if ($load_ids) {
	$load_ids = array_unique($load_ids);
	$changesets = id(new DifferentialChangeset())->loadAllWhere(
	'id in (%Ld)',
	$load_ids);
	}
	foreach ($inline_comments as $inline) {
	$inline_xaction_comment = $inline->getTransactionCommentForSave();
	$inline_xaction_comment->setRevisionPHID($revision->getPHID());

	$inline_xaction = id(clone $template)
	->setAction(DifferentialTransaction::TYPE_INLINE)
	->setProxyComment($inline_xaction_comment)
	->save();

	$comments[] = $inline_xaction;
	$mail_inlines[] = $inline_xaction->getProxyTransaction();
	}
	}

	$revision->saveTransaction();

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

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

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

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


	$event_data = array(
	'revision_id' => $revision->getID(),
	'revision_phid' => $revision->getPHID(),
	'revision_name' => $revision->getTitle(),
	'revision_author_phid' => $revision->getAuthorPHID(),
	'action' => head($comments)->getAction(),
	'feedback_content' => $this->message,
	'actor_phid' => $actor_phid,

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

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

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

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

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

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

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

	return $ccs;
	}

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

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

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

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

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

	return array($added_reviewers, $removed_reviewers);
	}

	}
	diff --git a/src/applications/differential/editor/DifferentialTransactionEditor.php b/src/applications/differential/editor/DifferentialTransactionEditor.php
	index 59f83b39c1..c2ee36ae4b 100644
	--- a/src/applications/differential/editor/DifferentialTransactionEditor.php
	+++ b/src/applications/differential/editor/DifferentialTransactionEditor.php
	@@ -1,501 +1,496 @@
	<?php

	final class DifferentialTransactionEditor
	extends PhabricatorApplicationTransactionEditor {

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

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

	switch ($xaction->getNewValue()) {
	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_revision);
	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;
	}
	}

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


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

	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:
	// TODO: When removing reviewers, we may be able to move the revision
	// to "Accepted".
	return;
	case DifferentialTransaction::TYPE_ACTION:
	$status_review = ArcanistDifferentialRevisionStatus::NEEDS_REVIEW;
	$status_revision = ArcanistDifferentialRevisionStatus::NEEDS_REVISION;

	switch ($xaction->getNewValue()) {
	case DifferentialAction::ACTION_RESIGN:
	// TODO: Update review status?
	break;
	case DifferentialAction::ACTION_ABANDON:
	$object->setStatus(ArcanistDifferentialRevisionStatus::ABANDONED);
	break;
	case DifferentialAction::ACTION_RETHINK:
	$object->setStatus($status_revision);
	break;
	case DifferentialAction::ACTION_RECLAIM:
	$object->setStatus($status_review);
	// TODO: Update review status?
	break;
	case DifferentialAction::ACTION_REOPEN:
	$object->setStatus($status_review);
	// TODO: Update review status?
	break;
	case DifferentialAction::ACTION_REQUEST:
	$object->setStatus($status_review);
	// TODO: Update review status?
	break;
	case DifferentialAction::ACTION_CLOSE:
	- if (!$object->getDateCommitted()) {
	- // TODO: Can we remove this? It is probably no longer used by
	- // anything anymore. See also T4434.
	- $object->setDateCommitted(time());
	- }
	$object->setStatus(ArcanistDifferentialRevisionStatus::CLOSED);
	break;
	default:
	// TODO: For now, we're just shipping the rest of these through
	// without acting on them.
	break;
	}
	return null;
	}

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

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

	$results = parent::expandTransaction($object, $xaction);
	switch ($xaction->getTransactionType()) {
	case DifferentialTransaction::TYPE_ACTION:
	switch ($xaction->getNewValue()) {
	case DifferentialAction::ACTION_RESIGN:
	// If the user is resigning, add a separate reviewer edit
	// transaction which removes them as a reviewer.

	$actor_phid = $this->getActor()->getPHID();
	$type_edge = PhabricatorTransactions::TYPE_EDGE;
	$edge_reviewer = PhabricatorEdgeConfig::TYPE_DREV_HAS_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;
	}

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

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

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

	foreach ($xactions as $xaction) {
	switch ($type) {
	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);

	$revision_status = $revision->getStatus();

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

	switch ($action) {
	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_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 chagnes 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::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:
	// 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:

	// TODO: Permit the daemons to take this action in all cases.

	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) {
	$head = array();
	$tail = array();

	// Move bare comments to the end, so the actions precede them.
	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 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 getMailSubjectPrefix() {
	return PhabricatorEnv::getEnvConfig('metamta.differential.subject-prefix');
	}

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

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

	}
	diff --git a/src/applications/differential/storage/DifferentialRevision.php b/src/applications/differential/storage/DifferentialRevision.php
	index 8acd3c3f6f..76379884d6 100644
	--- a/src/applications/differential/storage/DifferentialRevision.php
	+++ b/src/applications/differential/storage/DifferentialRevision.php
	@@ -1,518 +1,516 @@
	<?php

	final class DifferentialRevision extends DifferentialDAO
	implements
	PhabricatorTokenReceiverInterface,
	PhabricatorPolicyInterface,
	PhabricatorFlaggableInterface,
	PhrequentTrackableInterface,
	HarbormasterBuildableInterface,
	PhabricatorSubscribableInterface,
	PhabricatorCustomFieldInterface {

	protected $title = '';
	protected $originalTitle;
	protected $status;

	protected $summary = '';
	protected $testPlan = '';

	protected $authorPHID;
	protected $lastReviewerPHID;

	- protected $dateCommitted;
	-
	protected $lineCount = 0;
	protected $attached = array();

	protected $mailKey;
	protected $branchName;
	protected $arcanistProjectPHID;
	protected $repositoryPHID;
	protected $viewPolicy = PhabricatorPolicies::POLICY_USER;
	protected $editPolicy = PhabricatorPolicies::POLICY_USER;

	private $relationships = self::ATTACHABLE;
	private $commits = self::ATTACHABLE;
	private $activeDiff = self::ATTACHABLE;
	private $diffIDs = self::ATTACHABLE;
	private $hashes = self::ATTACHABLE;
	private $repository = self::ATTACHABLE;

	private $reviewerStatus = self::ATTACHABLE;
	private $customFields = self::ATTACHABLE;
	private $drafts = array();
	private $flags = array();

	const TABLE_COMMIT = 'differential_commit';

	const RELATION_REVIEWER = 'revw';
	const RELATION_SUBSCRIBED = 'subd';

	public static function initializeNewRevision(PhabricatorUser $actor) {
	$app = id(new PhabricatorApplicationQuery())
	->setViewer($actor)
	->withClasses(array('PhabricatorApplicationDifferential'))
	->executeOne();

	$view_policy = $app->getPolicy(
	DifferentialCapabilityDefaultView::CAPABILITY);

	return id(new DifferentialRevision())
	->setViewPolicy($view_policy)
	->setAuthorPHID($actor->getPHID())
	->attachRelationships(array())
	->setStatus(ArcanistDifferentialRevisionStatus::NEEDS_REVIEW);
	}

	public function getConfiguration() {
	return array(
	self::CONFIG_AUX_PHID => true,
	self::CONFIG_SERIALIZATION => array(
	'attached' => self::SERIALIZATION_JSON,
	'unsubscribed' => self::SERIALIZATION_JSON,
	),
	) + parent::getConfiguration();
	}

	public function setTitle($title) {
	$this->title = $title;
	if (!$this->getID()) {
	$this->originalTitle = $title;
	}
	return $this;
	}

	public function loadIDsByCommitPHIDs($phids) {
	if (!$phids) {
	return array();
	}
	$revision_ids = queryfx_all(
	$this->establishConnection('r'),
	'SELECT * FROM %T WHERE commitPHID IN (%Ls)',
	self::TABLE_COMMIT,
	$phids);
	return ipull($revision_ids, 'revisionID', 'commitPHID');
	}

	public function loadCommitPHIDs() {
	if (!$this->getID()) {
	return ($this->commits = array());
	}

	$commits = queryfx_all(
	$this->establishConnection('r'),
	'SELECT commitPHID FROM %T WHERE revisionID = %d',
	self::TABLE_COMMIT,
	$this->getID());
	$commits = ipull($commits, 'commitPHID');

	return ($this->commits = $commits);
	}

	public function getCommitPHIDs() {
	return $this->assertAttached($this->commits);
	}

	public function getActiveDiff() {
	// TODO: Because it's currently technically possible to create a revision
	// without an associated diff, we allow an attached-but-null active diff.
	// It would be good to get rid of this once we make diff-attaching
	// transactional.

	return $this->assertAttached($this->activeDiff);
	}

	public function attachActiveDiff($diff) {
	$this->activeDiff = $diff;
	return $this;
	}

	public function getDiffIDs() {
	return $this->assertAttached($this->diffIDs);
	}

	public function attachDiffIDs(array $ids) {
	rsort($ids);
	$this->diffIDs = array_values($ids);
	return $this;
	}

	public function attachCommitPHIDs(array $phids) {
	$this->commits = array_values($phids);
	return $this;
	}

	public function getAttachedPHIDs($type) {
	return array_keys(idx($this->attached, $type, array()));
	}

	public function setAttachedPHIDs($type, array $phids) {
	$this->attached[$type] = array_fill_keys($phids, array());
	return $this;
	}

	public function generatePHID() {
	return PhabricatorPHID::generateNewPHID(
	DifferentialPHIDTypeRevision::TYPECONST);
	}

	public function loadComments() {
	if (!$this->getID()) {
	return array();
	}
	return id(new DifferentialCommentQuery())
	->withRevisionPHIDs(array($this->getPHID()))
	->execute();
	}

	public function loadActiveDiff() {
	return id(new DifferentialDiff())->loadOneWhere(
	'revisionID = %d ORDER BY id DESC LIMIT 1',
	$this->getID());
	}

	public function save() {
	if (!$this->getMailKey()) {
	$this->mailKey = Filesystem::readRandomCharacters(40);
	}
	return parent::save();
	}

	public function delete() {
	$this->openTransaction();
	$diffs = id(new DifferentialDiffQuery())
	->setViewer(PhabricatorUser::getOmnipotentUser())
	->withRevisionIDs(array($this->getID()))
	->execute();
	foreach ($diffs as $diff) {
	$diff->delete();
	}

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

	queryfx(
	$conn_w,
	'DELETE FROM %T WHERE revisionID = %d',
	self::TABLE_COMMIT,
	$this->getID());

	$comments = id(new DifferentialCommentQuery())
	->withRevisionPHIDs(array($this->getPHID()))
	->execute();
	foreach ($comments as $comment) {
	$comment->delete();
	}

	$inlines = id(new DifferentialInlineCommentQuery())
	->withRevisionIDs(array($this->getID()))
	->execute();
	foreach ($inlines as $inline) {
	$inline->delete();
	}

	$fields = id(new DifferentialAuxiliaryField())->loadAllWhere(
	'revisionPHID = %s',
	$this->getPHID());
	foreach ($fields as $field) {
	$field->delete();
	}

	// we have to do paths a little differentally as they do not have
	// an id or phid column for delete() to act on
	$dummy_path = new DifferentialAffectedPath();
	queryfx(
	$conn_w,
	'DELETE FROM %T WHERE revisionID = %d',
	$dummy_path->getTableName(),
	$this->getID());

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

	public function loadRelationships() {
	if (!$this->getID()) {
	$this->relationships = array();
	return;
	}

	$data = array();

	$subscriber_phids = PhabricatorEdgeQuery::loadDestinationPHIDs(
	$this->getPHID(),
	PhabricatorEdgeConfig::TYPE_OBJECT_HAS_SUBSCRIBER);
	$subscriber_phids = array_reverse($subscriber_phids);
	foreach ($subscriber_phids as $phid) {
	$data[] = array(
	'relation' => self::RELATION_SUBSCRIBED,
	'objectPHID' => $phid,
	'reasonPHID' => null,
	);
	}

	$reviewer_phids = PhabricatorEdgeQuery::loadDestinationPHIDs(
	$this->getPHID(),
	PhabricatorEdgeConfig::TYPE_DREV_HAS_REVIEWER);
	$reviewer_phids = array_reverse($reviewer_phids);
	foreach ($reviewer_phids as $phid) {
	$data[] = array(
	'relation' => self::RELATION_REVIEWER,
	'objectPHID' => $phid,
	'reasonPHID' => null,
	);
	}

	return $this->attachRelationships($data);
	}

	public function attachRelationships(array $relationships) {
	$this->relationships = igroup($relationships, 'relation');
	return $this;
	}

	public function getReviewers() {
	return $this->getRelatedPHIDs(self::RELATION_REVIEWER);
	}

	public function getCCPHIDs() {
	return $this->getRelatedPHIDs(self::RELATION_SUBSCRIBED);
	}

	private function getRelatedPHIDs($relation) {
	$this->assertAttached($this->relationships);

	return ipull($this->getRawRelations($relation), 'objectPHID');
	}

	public function getRawRelations($relation) {
	return idx($this->relationships, $relation, array());
	}

	public function getPrimaryReviewer() {
	$reviewers = $this->getReviewers();
	$last = $this->lastReviewerPHID;
	if (!$last \|\| !in_array($last, $reviewers)) {
	return head($this->getReviewers());
	}
	return $last;
	}

	public function loadReviewedBy() {
	$reviewer = null;

	if ($this->status == ArcanistDifferentialRevisionStatus::ACCEPTED \|\|
	$this->status == ArcanistDifferentialRevisionStatus::CLOSED) {
	$comments = $this->loadComments();
	foreach ($comments as $comment) {
	$action = $comment->getAction();
	if ($action == DifferentialAction::ACTION_ACCEPT) {
	$reviewer = $comment->getAuthorPHID();
	} else if ($action == DifferentialAction::ACTION_REJECT \|\|
	$action == DifferentialAction::ACTION_ABANDON \|\|
	$action == DifferentialAction::ACTION_RETHINK) {
	$reviewer = null;
	}
	}
	}

	return $reviewer;
	}

	public function getHashes() {
	return $this->assertAttached($this->hashes);
	}

	public function attachHashes(array $hashes) {
	$this->hashes = $hashes;
	return $this;
	}

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

	public function getPolicy($capability) {
	switch ($capability) {
	case PhabricatorPolicyCapability::CAN_VIEW:
	return $this->getViewPolicy();
	case PhabricatorPolicyCapability::CAN_EDIT:
	return $this->getEditPolicy();
	}
	}

	public function hasAutomaticCapability($capability, PhabricatorUser $user) {

	// A revision's author (which effectively means "owner" after we added
	// commandeering) can always view and edit it.
	$author_phid = $this->getAuthorPHID();
	if ($author_phid) {
	if ($user->getPHID() == $author_phid) {
	return true;
	}
	}

	return false;
	}

	public function describeAutomaticCapability($capability) {
	$description = array(
	pht('The owner of a revision can always view and edit it.'),
	);

	switch ($capability) {
	case PhabricatorPolicyCapability::CAN_VIEW:
	$description[] = pht(
	"A revision's reviewers can always view it.");
	$description[] = pht(
	'If a revision belongs to a repository, other users must be able '.
	'to view the repository in order to view the revision.');
	break;
	}

	return $description;
	}

	public function getUsersToNotifyOfTokenGiven() {
	return array(
	$this->getAuthorPHID(),
	);
	}

	public function getReviewerStatus() {
	return $this->assertAttached($this->reviewerStatus);
	}

	public function attachReviewerStatus(array $reviewers) {
	assert_instances_of($reviewers, 'DifferentialReviewer');

	$this->reviewerStatus = $reviewers;
	return $this;
	}

	public function getRepository() {
	return $this->assertAttached($this->repository);
	}

	public function attachRepository(PhabricatorRepository $repository = null) {
	$this->repository = $repository;
	return $this;
	}

	public function isClosed() {
	return DifferentialRevisionStatus::isClosedStatus($this->getStatus());
	}

	public function getFlag(PhabricatorUser $viewer) {
	return $this->assertAttachedKey($this->flags, $viewer->getPHID());
	}

	public function attachFlag(
	PhabricatorUser $viewer,
	PhabricatorFlag $flag = null) {
	$this->flags[$viewer->getPHID()] = $flag;
	return $this;
	}

	public function getDrafts(PhabricatorUser $viewer) {
	return $this->assertAttachedKey($this->drafts, $viewer->getPHID());
	}

	public function attachDrafts(PhabricatorUser $viewer, array $drafts) {
	$this->drafts[$viewer->getPHID()] = $drafts;
	return $this;
	}


	/* -( HarbormasterBuildableInterface )------------------------------------- */


	public function getHarbormasterBuildablePHID() {
	return $this->loadActiveDiff()->getPHID();
	}

	public function getHarbormasterContainerPHID() {
	return $this->getPHID();
	}


	/* -( PhabricatorSubscribableInterface )----------------------------------- */


	public function isAutomaticallySubscribed($phid) {
	if ($phid == $this->getAuthorPHID()) {
	return true;
	}

	// TODO: This only happens when adding or removing CCs, and is safe from a
	// policy perspective, but the subscription pathway should have some
	// opportunity to load this data properly. For now, this is the only case
	// where implicit subscription is not an intrinsic property of the object.
	if ($this->reviewerStatus == self::ATTACHABLE) {
	$reviewers = id(new DifferentialRevisionQuery())
	->setViewer(PhabricatorUser::getOmnipotentUser())
	->withPHIDs(array($this->getPHID()))
	->needReviewerStatus(true)
	->executeOne()
	->getReviewerStatus();
	} else {
	$reviewers = $this->getReviewerStatus();
	}

	foreach ($reviewers as $reviewer) {
	if ($reviewer->getReviewerPHID() == $phid) {
	return true;
	}
	}

	return false;
	}

	public function shouldShowSubscribersProperty() {
	// TODO: Differential does its own thing for now.
	return false;
	}

	public function shouldAllowSubscription($phid) {
	return true;
	}


	/* -( PhabricatorCustomFieldInterface )------------------------------------ */


	public function getCustomFieldSpecificationForRole($role) {
	$fields = array(
	new DifferentialTitleField(),
	new DifferentialSummaryField(),
	new DifferentialTestPlanField(),
	new DifferentialReviewersField(),
	new DifferentialSubscribersField(),
	new DifferentialRepositoryField(),
	new DifferentialViewPolicyField(),
	new DifferentialEditPolicyField(),
	);

	return array_fill_keys(
	mpull($fields, 'getFieldKey'),
	array('disabled' => false));
	}

	public function getCustomFieldBaseClass() {
	return 'DifferentialCustomField';
	}

	public function getCustomFields() {
	return $this->assertAttached($this->customFields);
	}

	public function attachCustomFields(PhabricatorCustomFieldAttachment $fields) {
	$this->customFields = $fields;
	return $this;
	}

	}
	diff --git a/src/applications/repository/worker/commitmessageparser/PhabricatorRepositoryCommitMessageParserWorker.php b/src/applications/repository/worker/commitmessageparser/PhabricatorRepositoryCommitMessageParserWorker.php
	index aa1295523d..b9941be50d 100644
	--- a/src/applications/repository/worker/commitmessageparser/PhabricatorRepositoryCommitMessageParserWorker.php
	+++ b/src/applications/repository/worker/commitmessageparser/PhabricatorRepositoryCommitMessageParserWorker.php
	@@ -1,385 +1,384 @@
	<?php

	abstract class PhabricatorRepositoryCommitMessageParserWorker
	extends PhabricatorRepositoryCommitParserWorker {

	final protected function updateCommitData(DiffusionCommitRef $ref) {
	$commit = $this->commit;
	$author = $ref->getAuthor();
	$message = $ref->getMessage();
	$committer = $ref->getCommitter();
	$hashes = $ref->getHashes();

	$data = id(new PhabricatorRepositoryCommitData())->loadOneWhere(
	'commitID = %d',
	$commit->getID());
	if (!$data) {
	$data = new PhabricatorRepositoryCommitData();
	}
	$data->setCommitID($commit->getID());
	$data->setAuthorName($author);
	$data->setCommitDetail(
	'authorPHID',
	$this->resolveUserPHID($commit, $author));

	$data->setCommitMessage($message);

	if (strlen($committer)) {
	$data->setCommitDetail('committer', $committer);
	$data->setCommitDetail(
	'committerPHID',
	$this->resolveUserPHID($commit, $committer));
	}

	$repository = $this->repository;

	$author_phid = $data->getCommitDetail('authorPHID');
	$committer_phid = $data->getCommitDetail('committerPHID');

	$user = new PhabricatorUser();
	if ($author_phid) {
	$user = $user->loadOneWhere(
	'phid = %s',
	$author_phid);
	}

	$field_values = id(new DiffusionLowLevelCommitFieldsQuery())
	->setRepository($repository)
	->withCommitRef($ref)
	->execute();
	$revision_id = idx($field_values, 'revisionID');

	if (!empty($field_values['reviewedByPHIDs'])) {
	$data->setCommitDetail(
	'reviewerPHID',
	reset($field_values['reviewedByPHIDs']));
	}

	$data->setCommitDetail('differential.revisionID', $revision_id);

	if ($author_phid != $commit->getAuthorPHID()) {
	$commit->setAuthorPHID($author_phid);
	}

	$commit->setSummary($data->getSummary());
	$commit->save();

	$conn_w = id(new DifferentialRevision())->establishConnection('w');

	// NOTE: The `differential_commit` table has a unique ID on `commitPHID`,
	// preventing more than one revision from being associated with a commit.
	// Generally this is good and desirable, but with the advent of hash
	// tracking we may end up in a situation where we match several different
	// revisions. We just kind of ignore this and pick one, we might want to
	// revisit this and do something differently. (If we match several revisions
	// someone probably did something very silly, though.)

	$revision = null;
	$should_autoclose = $repository->shouldAutocloseCommit($commit, $data);

	if ($revision_id) {
	$lock = PhabricatorGlobalLock::newLock(get_class($this).':'.$revision_id);
	$lock->lock(5 * 60);

	// TODO: Check if a more restrictive viewer could be set here
	$revision = id(new DifferentialRevisionQuery())
	->withIDs(array($revision_id))
	->setViewer(PhabricatorUser::getOmnipotentUser())
	->needRelationships(true)
	->needReviewerStatus(true)
	->executeOne();

	if ($revision) {
	$commit_drev = PhabricatorEdgeConfig::TYPE_COMMIT_HAS_DREV;
	id(new PhabricatorEdgeEditor())
	->setActor($user)
	->addEdge($commit->getPHID(), $commit_drev, $revision->getPHID())
	->save();

	queryfx(
	$conn_w,
	'INSERT IGNORE INTO %T (revisionID, commitPHID) VALUES (%d, %s)',
	DifferentialRevision::TABLE_COMMIT,
	$revision->getID(),
	$commit->getPHID());

	$status_closed = ArcanistDifferentialRevisionStatus::CLOSED;
	$should_close = ($revision->getStatus() != $status_closed) &&
	$should_autoclose;

	if ($should_close) {
	$actor_phid = nonempty(
	$committer_phid,
	$author_phid,
	$revision->getAuthorPHID());
	$actor = id(new PhabricatorUser())
	->loadOneWhere('phid = %s', $actor_phid);

	$diff = $this->attachToRevision($revision, $actor_phid);

	- $revision->setDateCommitted($commit->getEpoch());
	$editor = new DifferentialCommentEditor(
	$revision,
	DifferentialAction::ACTION_CLOSE);
	$editor->setActor($actor);
	$editor->setIsDaemonWorkflow(true);

	$vs_diff = $this->loadChangedByCommit($diff);
	if ($vs_diff) {
	$data->setCommitDetail('vsDiff', $vs_diff->getID());

	$changed_by_commit = PhabricatorEnv::getProductionURI(
	'/D'.$revision->getID().
	'?vs='.$vs_diff->getID().
	'&id='.$diff->getID().
	'#toc');
	$editor->setChangedByCommit($changed_by_commit);
	}

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

	$committer_name = $this->loadUserName(
	$committer_phid,
	$data->getCommitDetail('committer'),
	$actor);

	$author_name = $this->loadUserName(
	$author_phid,
	$data->getAuthorName(),
	$actor);

	$info = array();
	$info[] = "authored by {$author_name}";
	if ($committer_name && ($committer_name != $author_name)) {
	$info[] = "committed by {$committer_name}";
	}
	$info = implode(', ', $info);

	$editor
	->setMessage("Closed by commit {$commit_name} ({$info}).")
	->save();
	}

	}

	$lock->unlock();
	}

	if ($should_autoclose) {
	$fields = DifferentialFieldSelector::newSelector()
	->getFieldSpecifications();
	foreach ($fields as $key => $field) {
	if (!$field->shouldAppearOnCommitMessage()) {
	continue;
	}
	$field->setUser($user);
	$value = idx($field_values, $field->getCommitMessageKey());
	$field->setValueFromParsedCommitMessage($value);
	if ($revision) {
	$field->setRevision($revision);
	}
	$field->didParseCommit($repository, $commit, $data);
	}
	}

	$data->save();

	$commit->writeImportStatusFlag(
	PhabricatorRepositoryCommit::IMPORTED_MESSAGE);
	}

	private function loadUserName($user_phid, $default, PhabricatorUser $actor) {
	if (!$user_phid) {
	return $default;
	}
	$handle = id(new PhabricatorHandleQuery())
	->setViewer($actor)
	->withPHIDs(array($user_phid))
	->executeOne();

	return '@'.$handle->getName();
	}

	private function attachToRevision(
	DifferentialRevision $revision,
	$actor_phid) {

	$viewer = PhabricatorUser::getOmnipotentUser();

	$drequest = DiffusionRequest::newFromDictionary(array(
	'user' => $viewer,
	'repository' => $this->repository,
	));

	$raw_diff = DiffusionQuery::callConduitWithDiffusionRequest(
	$viewer,
	$drequest,
	'diffusion.rawdiffquery',
	array(
	'commit' => $this->commit->getCommitIdentifier(),
	));

	// TODO: Support adds, deletes and moves under SVN.
	if (strlen($raw_diff)) {
	$changes = id(new ArcanistDiffParser())->parseDiff($raw_diff);
	} else {
	// This is an empty diff, maybe made with `git commit --allow-empty`.
	// NOTE: These diffs have the same tree hash as their ancestors, so
	// they may attach to revisions in an unexpected way. Just let this
	// happen for now, although it might make sense to special case it
	// eventually.
	$changes = array();
	}

	$diff = DifferentialDiff::newFromRawChanges($changes)
	->setRevisionID($revision->getID())
	->setAuthorPHID($actor_phid)
	->setCreationMethod('commit')
	->setSourceControlSystem($this->repository->getVersionControlSystem())
	->setLintStatus(DifferentialLintStatus::LINT_SKIP)
	->setUnitStatus(DifferentialUnitStatus::UNIT_SKIP)
	->setDateCreated($this->commit->getEpoch())
	->setDescription(
	'Commit r'.
	$this->repository->getCallsign().
	$this->commit->getCommitIdentifier());

	// TODO: This is not correct in SVN where one repository can have multiple
	// Arcanist projects.
	$arcanist_project = id(new PhabricatorRepositoryArcanistProject())
	->loadOneWhere('repositoryID = %d LIMIT 1', $this->repository->getID());
	if ($arcanist_project) {
	$diff->setArcanistProjectPHID($arcanist_project->getPHID());
	}

	$parents = DiffusionQuery::callConduitWithDiffusionRequest(
	$viewer,
	$drequest,
	'diffusion.commitparentsquery',
	array(
	'commit' => $this->commit->getCommitIdentifier(),
	));
	if ($parents) {
	$diff->setSourceControlBaseRevision(head($parents));
	}

	// TODO: Attach binary files.

	$revision->setLineCount($diff->getLineCount());

	return $diff->save();
	}

	private function loadChangedByCommit(DifferentialDiff $diff) {
	$repository = $this->repository;

	$vs_changesets = array();
	$vs_diff = id(new DifferentialDiff())->loadOneWhere(
	'revisionID = %d AND creationMethod != %s ORDER BY id DESC LIMIT 1',
	$diff->getRevisionID(),
	'commit');
	foreach ($vs_diff->loadChangesets() as $changeset) {
	$path = $changeset->getAbsoluteRepositoryPath($repository, $vs_diff);
	$path = ltrim($path, '/');
	$vs_changesets[$path] = $changeset;
	}

	$changesets = array();
	foreach ($diff->getChangesets() as $changeset) {
	$path = $changeset->getAbsoluteRepositoryPath($repository, $diff);
	$path = ltrim($path, '/');
	$changesets[$path] = $changeset;
	}

	if (array_fill_keys(array_keys($changesets), true) !=
	array_fill_keys(array_keys($vs_changesets), true)) {
	return $vs_diff;
	}

	$hunks = id(new DifferentialHunk())->loadAllWhere(
	'changesetID IN (%Ld)',
	mpull($vs_changesets, 'getID'));
	$hunks = mgroup($hunks, 'getChangesetID');
	foreach ($vs_changesets as $changeset) {
	$changeset->attachHunks(idx($hunks, $changeset->getID(), array()));
	}

	$file_phids = array();
	foreach ($vs_changesets as $changeset) {
	$metadata = $changeset->getMetadata();
	$file_phid = idx($metadata, 'new:binary-phid');
	if ($file_phid) {
	$file_phids[$file_phid] = $file_phid;
	}
	}

	$files = array();
	if ($file_phids) {
	$files = id(new PhabricatorFileQuery())
	->setViewer(PhabricatorUser::getOmnipotentUser())
	->withPHIDs($file_phids)
	->execute();
	$files = mpull($files, null, 'getPHID');
	}

	foreach ($changesets as $path => $changeset) {
	$vs_changeset = $vs_changesets[$path];

	$file_phid = idx($vs_changeset->getMetadata(), 'new:binary-phid');
	if ($file_phid) {
	if (!isset($files[$file_phid])) {
	return $vs_diff;
	}
	$drequest = DiffusionRequest::newFromDictionary(array(
	'user' => PhabricatorUser::getOmnipotentUser(),
	'initFromConduit' => false,
	'repository' => $this->repository,
	'commit' => $this->commit->getCommitIdentifier(),
	'path' => $path,
	));
	$corpus = DiffusionFileContentQuery::newFromDiffusionRequest($drequest)
	->setViewer(PhabricatorUser::getOmnipotentUser())
	->loadFileContent()
	->getCorpus();
	if ($files[$file_phid]->loadFileData() != $corpus) {
	return $vs_diff;
	}
	} else {
	$context = implode("\n", $changeset->makeChangesWithContext());
	$vs_context = implode("\n", $vs_changeset->makeChangesWithContext());

	// We couldn't just compare $context and $vs_context because following
	// diffs will be considered different:
	//
	// -(empty line)
	// -echo 'test';
	// (empty line)
	//
	// (empty line)
	// -echo "test";
	// -(empty line)

	$hunk = id(new DifferentialHunk())->setChanges($context);
	$vs_hunk = id(new DifferentialHunk())->setChanges($vs_context);
	if ($hunk->makeOldFile() != $vs_hunk->makeOldFile() \|\|
	$hunk->makeNewFile() != $vs_hunk->makeNewFile()) {
	return $vs_diff;
	}
	}
	}

	return null;
	}

	private function resolveUserPHID(
	PhabricatorRepositoryCommit $commit,
	$user_name) {

	return id(new DiffusionResolveUserQuery())
	->withCommit($commit)
	->withName($user_name)
	->execute();
	}

	}

File Metadata

Mime Type: text/x-diff
Expires: Tue, Jul 29, 9:12 AM (3 w, 1 d ago)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 188434
Default Alt Text: (75 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions