No OneTemporary
Actions

Size

298 KB

Referenced Files

None

Subscribers

None

View Options

This file is larger than 256 KB, so syntax highlighting was skipped.

	diff --git a/src/applications/differential/conduit/DifferentialCloseConduitAPIMethod.php b/src/applications/differential/conduit/DifferentialCloseConduitAPIMethod.php
	index d71876961e..30f8a5e5b7 100644
	--- a/src/applications/differential/conduit/DifferentialCloseConduitAPIMethod.php
	+++ b/src/applications/differential/conduit/DifferentialCloseConduitAPIMethod.php
	@@ -1,71 +1,71 @@
	<?php

	final class DifferentialCloseConduitAPIMethod
	extends DifferentialConduitAPIMethod {

	public function getAPIMethodName() {
	return 'differential.close';
	}

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

	public function getMethodStatus() {
	return self::METHOD_STATUS_FROZEN;
	}

	public function getMethodStatusDescription() {
	return pht(
	'This method is frozen and will eventually be deprecated. New code '.
	'should use "differential.revision.edit" instead.');
	}

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

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

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

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

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

	$xactions = array();
	$xactions[] = id(new DifferentialTransaction())
	->setTransactionType(DifferentialTransaction::TYPE_ACTION)
	->setNewValue(DifferentialAction::ACTION_CLOSE);

	$content_source = $request->newContentSource();

	$editor = id(new DifferentialTransactionEditor())
	->setActor($viewer)
	->setContentSource($request->newContentSource())
	->setContinueOnMissingFields(true)
	->setContinueOnNoEffect(true);

	$editor->applyTransactions($revision, $xactions);

	return;
	}

	}
	diff --git a/src/applications/differential/conduit/DifferentialCreateCommentConduitAPIMethod.php b/src/applications/differential/conduit/DifferentialCreateCommentConduitAPIMethod.php
	index 23b8f770cd..ee70644537 100644
	--- a/src/applications/differential/conduit/DifferentialCreateCommentConduitAPIMethod.php
	+++ b/src/applications/differential/conduit/DifferentialCreateCommentConduitAPIMethod.php
	@@ -1,119 +1,119 @@
	<?php

	final class DifferentialCreateCommentConduitAPIMethod
	extends DifferentialConduitAPIMethod {

	public function getAPIMethodName() {
	return 'differential.createcomment';
	}

	public function getMethodDescription() {
	return pht('Add a comment to a Differential revision.');
	}

	public function getMethodStatus() {
	return self::METHOD_STATUS_FROZEN;
	}

	public function getMethodStatusDescription() {
	return pht(
	'This method is frozen and will eventually be deprecated. New code '.
	'should use "differential.revision.edit" instead.');
	}

	protected function defineParamTypes() {
	return array(
	'revision_id' => 'required revisionid',
	'message' => 'optional string',
	'action' => 'optional string',
	'silent' => 'optional bool',
	'attach_inlines' => 'optional bool',
	);
	}

	protected function defineReturnType() {
	return 'nonempty dict';
	}

	protected function defineErrorTypes() {
	return array(
	'ERR_BAD_REVISION' => pht('Bad revision ID.'),
	);
	}

	protected function execute(ConduitAPIRequest $request) {
	$viewer = $request->getUser();

	$revision = id(new DifferentialRevisionQuery())
	->setViewer($viewer)
	->withIDs(array($request->getValue('revision_id')))
	- ->needReviewerStatus(true)
	+ ->needReviewers(true)
	->needReviewerAuthority(true)
	->executeOne();
	if (!$revision) {
	throw new ConduitException('ERR_BAD_REVISION');
	}

	$xactions = array();

	$modular_map = array(
	'accept' => DifferentialRevisionAcceptTransaction::TRANSACTIONTYPE,
	'reject' => DifferentialRevisionRejectTransaction::TRANSACTIONTYPE,
	'resign' => DifferentialRevisionResignTransaction::TRANSACTIONTYPE,
	);

	$action = $request->getValue('action');
	if (isset($modular_map[$action])) {
	$xactions[] = id(new DifferentialTransaction())
	->setTransactionType($modular_map[$action])
	->setNewValue(true);
	} else if ($action) {
	switch ($action) {
	case 'comment':
	case 'none':
	break;
	default:
	$xactions[] = id(new DifferentialTransaction())
	->setTransactionType(DifferentialTransaction::TYPE_ACTION)
	->setNewValue($action);
	break;
	}
	}

	$content = $request->getValue('message');
	if (strlen($content)) {
	$xactions[] = id(new DifferentialTransaction())
	->setTransactionType(PhabricatorTransactions::TYPE_COMMENT)
	->attachComment(
	id(new DifferentialTransactionComment())
	->setContent($content));
	}

	if ($request->getValue('attach_inlines')) {
	$type_inline = DifferentialTransaction::TYPE_INLINE;
	$inlines = DifferentialTransactionQuery::loadUnsubmittedInlineComments(
	$viewer,
	$revision);
	foreach ($inlines as $inline) {
	$xactions[] = id(new DifferentialTransaction())
	->setTransactionType($type_inline)
	->attachComment($inline);
	}
	}

	$editor = id(new DifferentialTransactionEditor())
	->setActor($viewer)
	->setDisableEmail($request->getValue('silent'))
	->setContentSource($request->newContentSource())
	->setContinueOnNoEffect(true)
	->setContinueOnMissingFields(true);

	$editor->applyTransactions($revision, $xactions);

	return array(
	'revisionid' => $revision->getID(),
	'uri' => PhabricatorEnv::getURI('/D'.$revision->getID()),
	);
	}

	}
	diff --git a/src/applications/differential/conduit/DifferentialGetCommitMessageConduitAPIMethod.php b/src/applications/differential/conduit/DifferentialGetCommitMessageConduitAPIMethod.php
	index d45fc22fd3..51225023ff 100644
	--- a/src/applications/differential/conduit/DifferentialGetCommitMessageConduitAPIMethod.php
	+++ b/src/applications/differential/conduit/DifferentialGetCommitMessageConduitAPIMethod.php
	@@ -1,168 +1,168 @@
	<?php

	final class DifferentialGetCommitMessageConduitAPIMethod
	extends DifferentialConduitAPIMethod {

	public function getAPIMethodName() {
	return 'differential.getcommitmessage';
	}

	public function getMethodDescription() {
	return pht('Retrieve Differential commit messages or message templates.');
	}

	protected function defineParamTypes() {
	$edit_types = array('edit', 'create');

	return array(
	'revision_id' => 'optional revision_id',
	'fields' => 'optional dict<string, wild>',
	'edit' => 'optional '.$this->formatStringConstants($edit_types),
	);
	}

	protected function defineReturnType() {
	return 'nonempty string';
	}

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

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

	if ($id) {
	$revision = id(new DifferentialRevisionQuery())
	->withIDs(array($id))
	->setViewer($viewer)
	- ->needReviewerStatus(true)
	+ ->needReviewers(true)
	->needActiveDiffs(true)
	->executeOne();
	if (!$revision) {
	throw new ConduitException('ERR_NOT_FOUND');
	}
	} else {
	$revision = DifferentialRevision::initializeNewRevision($viewer);
	}

	// There are three modes here: "edit", "create", and "read" (which has
	// no value for the "edit" parameter).

	// In edit or create mode, we hide read-only fields. In create mode, we
	// show "Field:" templates for some fields even if they are empty.
	$edit_mode = $request->getValue('edit');

	$is_any_edit = (bool)strlen($edit_mode);
	$is_create = ($edit_mode == 'create');

	$field_list = DifferentialCommitMessageField::newEnabledFields($viewer);

	$custom_storage = $this->loadCustomFieldStorage($viewer, $revision);
	foreach ($field_list as $field) {
	$field->setCustomFieldStorage($custom_storage);
	}

	// If we're editing the message, remove fields like "Conflicts" and
	// "git-svn-id" which should not be presented to the user for editing.
	if ($is_any_edit) {
	foreach ($field_list as $field_key => $field) {
	if (!$field->isFieldEditable()) {
	unset($field_list[$field_key]);
	}
	}
	}

	$overrides = $request->getValue('fields', array());

	$value_map = array();
	foreach ($field_list as $field_key => $field) {
	if (array_key_exists($field_key, $overrides)) {
	$field_value = $overrides[$field_key];
	} else {
	$field_value = $field->readFieldValueFromObject($revision);
	}

	// We're calling this method on the value no matter where we got it
	// from, so we hit the same validation logic for values which came over
	// the wire and which we generated.
	$field_value = $field->readFieldValueFromConduit($field_value);

	$value_map[$field_key] = $field_value;
	}

	$key_title = DifferentialTitleCommitMessageField::FIELDKEY;

	$commit_message = array();
	foreach ($field_list as $field_key => $field) {
	$label = $field->getFieldName();
	$wire_value = $value_map[$field_key];
	$value = $field->renderFieldValue($wire_value);

	$is_template = ($is_create && $field->isTemplateField());

	if (!is_string($value) && !is_null($value)) {
	throw new Exception(
	pht(
	'Commit message field "%s" was expected to render a string or '.
	'null value, but rendered a "%s" instead.',
	$field->getFieldKey(),
	gettype($value)));
	}

	$is_title = ($field_key == $key_title);

	if (!strlen($value)) {
	if ($is_template) {
	$commit_message[] = $label.': ';
	}
	} else {
	if ($is_title) {
	$commit_message[] = $value;
	} else {
	$value = str_replace(
	array("\r\n", "\r"),
	array("\n", "\n"),
	$value);
	if (strpos($value, "\n") !== false \|\| substr($value, 0, 2) === ' ') {
	$commit_message[] = "{$label}:\n{$value}";
	} else {
	$commit_message[] = "{$label}: {$value}";
	}
	}
	}
	}

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

	private function loadCustomFieldStorage(
	PhabricatorUser $viewer,
	DifferentialRevision $revision) {

	$custom_field_list = PhabricatorCustomField::getObjectFields(
	$revision,
	PhabricatorCustomField::ROLE_STORAGE);

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

	$custom_field_map = array();
	foreach ($custom_field_list->getFields() as $custom_field) {
	if (!$custom_field->shouldUseStorage()) {
	continue;
	}
	$custom_field_key = $custom_field->getFieldKey();
	$custom_field_value = $custom_field->getValueForStorage();
	$custom_field_map[$custom_field_key] = $custom_field_value;
	}

	return $custom_field_map;
	}


	}
	diff --git a/src/applications/differential/conduit/DifferentialGetRevisionConduitAPIMethod.php b/src/applications/differential/conduit/DifferentialGetRevisionConduitAPIMethod.php
	index 3b4d9a6a63..b05efb5c15 100644
	--- a/src/applications/differential/conduit/DifferentialGetRevisionConduitAPIMethod.php
	+++ b/src/applications/differential/conduit/DifferentialGetRevisionConduitAPIMethod.php
	@@ -1,101 +1,101 @@
	<?php

	final class DifferentialGetRevisionConduitAPIMethod
	extends DifferentialConduitAPIMethod {

	public function getAPIMethodName() {
	return 'differential.getrevision';
	}

	public function getMethodStatus() {
	return self::METHOD_STATUS_DEPRECATED;
	}

	public function getMethodStatusDescription() {
	return pht("Replaced by '%s'.", 'differential.query');
	}

	public function getMethodDescription() {
	return pht('Load the content of a revision from Differential.');
	}

	protected function defineParamTypes() {
	return array(
	'revision_id' => 'required id',
	);
	}

	protected function defineReturnType() {
	return 'nonempty dict';
	}

	protected function defineErrorTypes() {
	return array(
	'ERR_BAD_REVISION' => pht('No such revision exists.'),
	);
	}

	protected function execute(ConduitAPIRequest $request) {
	$diff = null;

	$revision_id = $request->getValue('revision_id');
	$revision = id(new DifferentialRevisionQuery())
	->withIDs(array($revision_id))
	->setViewer($request->getUser())
	- ->needReviewerStatus(true)
	+ ->needReviewers(true)
	->executeOne();

	if (!$revision) {
	throw new ConduitException('ERR_BAD_REVISION');
	}

	$reviewer_phids = $revision->getReviewerPHIDs();

	$diffs = id(new DifferentialDiffQuery())
	->setViewer($request->getUser())
	->withRevisionIDs(array($revision_id))
	->needChangesets(true)
	->execute();
	$diff_dicts = mpull($diffs, 'getDiffDict');

	$commit_dicts = array();
	$commit_phids = $revision->loadCommitPHIDs();
	$handles = id(new PhabricatorHandleQuery())
	->setViewer($request->getUser())
	->withPHIDs($commit_phids)
	->execute();

	foreach ($commit_phids as $commit_phid) {
	$commit_dicts[] = array(
	'fullname' => $handles[$commit_phid]->getFullName(),
	'dateCommitted' => $handles[$commit_phid]->getTimestamp(),
	);
	}

	$field_data = $this->loadCustomFieldsForRevisions(
	$request->getUser(),
	array($revision));

	$dict = array(
	'id' => $revision->getID(),
	'phid' => $revision->getPHID(),
	'authorPHID' => $revision->getAuthorPHID(),
	'uri' => PhabricatorEnv::getURI('/D'.$revision->getID()),
	'title' => $revision->getTitle(),
	'status' => $revision->getStatus(),
	'statusName' =>
	ArcanistDifferentialRevisionStatus::getNameForRevisionStatus(
	$revision->getStatus()),
	'summary' => $revision->getSummary(),
	'testPlan' => $revision->getTestPlan(),
	'lineCount' => $revision->getLineCount(),
	'reviewerPHIDs' => $reviewer_phids,
	'diffs' => $diff_dicts,
	'commits' => $commit_dicts,
	'auxiliary' => idx($field_data, $revision->getPHID(), array()),
	);

	return $dict;
	}

	}
	diff --git a/src/applications/differential/conduit/DifferentialQueryConduitAPIMethod.php b/src/applications/differential/conduit/DifferentialQueryConduitAPIMethod.php
	index c9f90d0877..3b88087a67 100644
	--- a/src/applications/differential/conduit/DifferentialQueryConduitAPIMethod.php
	+++ b/src/applications/differential/conduit/DifferentialQueryConduitAPIMethod.php
	@@ -1,254 +1,254 @@
	<?php

	final class DifferentialQueryConduitAPIMethod
	extends DifferentialConduitAPIMethod {

	public function getAPIMethodName() {
	return 'differential.query';
	}

	public function getMethodDescription() {
	return pht('Query Differential revisions which match certain criteria.');
	}

	public function getMethodStatus() {
	return self::METHOD_STATUS_FROZEN;
	}

	public function getMethodStatusDescription() {
	return pht(
	'This method is frozen and will eventually be deprecated. New code '.
	'should use "differential.revision.search" instead.');
	}

	protected function defineParamTypes() {
	$hash_types = ArcanistDifferentialRevisionHash::getTypes();
	$hash_const = $this->formatStringConstants($hash_types);

	$status_types = array(
	DifferentialRevisionQuery::STATUS_ANY,
	DifferentialRevisionQuery::STATUS_OPEN,
	DifferentialRevisionQuery::STATUS_ACCEPTED,
	DifferentialRevisionQuery::STATUS_CLOSED,
	);
	$status_const = $this->formatStringConstants($status_types);

	$order_types = array(
	DifferentialRevisionQuery::ORDER_MODIFIED,
	DifferentialRevisionQuery::ORDER_CREATED,
	);
	$order_const = $this->formatStringConstants($order_types);

	return array(
	'authors' => 'optional list<phid>',
	'ccs' => 'optional list<phid>',
	'reviewers' => 'optional list<phid>',
	'paths' => 'optional list<pair<callsign, path>>',
	'commitHashes' => 'optional list<pair<'.$hash_const.', string>>',
	'status' => 'optional '.$status_const,
	'order' => 'optional '.$order_const,
	'limit' => 'optional uint',
	'offset' => 'optional uint',
	'ids' => 'optional list<uint>',
	'phids' => 'optional list<phid>',
	'subscribers' => 'optional list<phid>',
	'responsibleUsers' => 'optional list<phid>',
	'branches' => 'optional list<string>',
	);
	}

	protected function defineReturnType() {
	return 'list<dict>';
	}

	protected function defineErrorTypes() {
	return array(
	'ERR-INVALID-PARAMETER' => pht('Missing or malformed parameter.'),
	);
	}

	protected function execute(ConduitAPIRequest $request) {
	$authors = $request->getValue('authors');
	$ccs = $request->getValue('ccs');
	$reviewers = $request->getValue('reviewers');
	$status = $request->getValue('status');
	$order = $request->getValue('order');
	$path_pairs = $request->getValue('paths');
	$commit_hashes = $request->getValue('commitHashes');
	$limit = $request->getValue('limit');
	$offset = $request->getValue('offset');
	$ids = $request->getValue('ids');
	$phids = $request->getValue('phids');
	$subscribers = $request->getValue('subscribers');
	$responsible_users = $request->getValue('responsibleUsers');
	$branches = $request->getValue('branches');

	$query = id(new DifferentialRevisionQuery())
	->setViewer($request->getUser());

	if ($authors) {
	$query->withAuthors($authors);
	}
	if ($ccs) {
	$query->withCCs($ccs);
	}
	if ($reviewers) {
	$query->withReviewers($reviewers);
	}

	if ($path_pairs) {
	$paths = array();
	foreach ($path_pairs as $pair) {
	list($callsign, $path) = $pair;
	$paths[] = $path;
	}

	$path_map = id(new DiffusionPathIDQuery($paths))->loadPathIDs();
	if (count($path_map) != count($paths)) {
	$unknown_paths = array();
	foreach ($paths as $p) {
	if (!idx($path_map, $p)) {
	$unknown_paths[] = $p;
	}
	}
	throw id(new ConduitException('ERR-INVALID-PARAMETER'))
	->setErrorDescription(
	pht(
	'Unknown paths: %s',
	implode(', ', $unknown_paths)));
	}

	$repos = array();
	foreach ($path_pairs as $pair) {
	list($callsign, $path) = $pair;
	if (!idx($repos, $callsign)) {
	$repos[$callsign] = id(new PhabricatorRepositoryQuery())
	->setViewer($request->getUser())
	->withCallsigns(array($callsign))
	->executeOne();

	if (!$repos[$callsign]) {
	throw id(new ConduitException('ERR-INVALID-PARAMETER'))
	->setErrorDescription(
	pht(
	'Unknown repo callsign: %s',
	$callsign));
	}
	}
	$repo = $repos[$callsign];

	$query->withPath($repo->getID(), idx($path_map, $path));
	}
	}

	if ($commit_hashes) {
	$hash_types = ArcanistDifferentialRevisionHash::getTypes();
	foreach ($commit_hashes as $info) {
	list($type, $hash) = $info;
	if (empty($type) \|\|
	!in_array($type, $hash_types) \|\|
	empty($hash)) {
	throw new ConduitException('ERR-INVALID-PARAMETER');
	}
	}
	$query->withCommitHashes($commit_hashes);
	}

	if ($status) {
	$query->withStatus($status);
	}
	if ($order) {
	$query->setOrder($order);
	}
	if ($limit) {
	$query->setLimit($limit);
	}
	if ($offset) {
	$query->setOffset($offset);
	}
	if ($ids) {
	$query->withIDs($ids);
	}
	if ($phids) {
	$query->withPHIDs($phids);
	}
	if ($responsible_users) {
	$query->withResponsibleUsers($responsible_users);
	}
	if ($subscribers) {
	$query->withCCs($subscribers);
	}
	if ($branches) {
	$query->withBranches($branches);
	}

	- $query->needReviewerStatus(true);
	+ $query->needReviewers(true);
	$query->needCommitPHIDs(true);
	$query->needDiffIDs(true);
	$query->needActiveDiffs(true);
	$query->needHashes(true);

	$revisions = $query->execute();

	$field_data = $this->loadCustomFieldsForRevisions(
	$request->getUser(),
	$revisions);

	if ($revisions) {
	$ccs = id(new PhabricatorSubscribersQuery())
	->withObjectPHIDs(mpull($revisions, 'getPHID'))
	->execute();
	} else {
	$ccs = array();
	}

	$results = array();
	foreach ($revisions as $revision) {
	$diff = $revision->getActiveDiff();
	if (!$diff) {
	continue;
	}

	$id = $revision->getID();
	$phid = $revision->getPHID();

	$result = array(
	'id' => $id,
	'phid' => $phid,
	'title' => $revision->getTitle(),
	'uri' => PhabricatorEnv::getProductionURI('/D'.$id),
	'dateCreated' => $revision->getDateCreated(),
	'dateModified' => $revision->getDateModified(),
	'authorPHID' => $revision->getAuthorPHID(),
	'status' => $revision->getStatus(),
	'statusName' =>
	ArcanistDifferentialRevisionStatus::getNameForRevisionStatus(
	$revision->getStatus()),
	'properties' => $revision->getProperties(),
	'branch' => $diff->getBranch(),
	'summary' => $revision->getSummary(),
	'testPlan' => $revision->getTestPlan(),
	'lineCount' => $revision->getLineCount(),
	'activeDiffPHID' => $diff->getPHID(),
	'diffs' => $revision->getDiffIDs(),
	'commits' => $revision->getCommitPHIDs(),
	'reviewers' => $revision->getReviewerPHIDs(),
	'ccs' => idx($ccs, $phid, array()),
	'hashes' => $revision->getHashes(),
	'auxiliary' => idx($field_data, $phid, array()),
	'repositoryPHID' => $diff->getRepositoryPHID(),
	);

	// TODO: This is a hacky way to put permissions on this field until we
	// have first-class support, see T838.
	if ($revision->getAuthorPHID() == $request->getUser()->getPHID()) {
	$result['sourcePath'] = $diff->getSourcePath();
	}

	$results[] = $result;
	}

	return $results;
	}

	}
	diff --git a/src/applications/differential/conduit/DifferentialUpdateRevisionConduitAPIMethod.php b/src/applications/differential/conduit/DifferentialUpdateRevisionConduitAPIMethod.php
	index d45dc9749e..3ad5b07564 100644
	--- a/src/applications/differential/conduit/DifferentialUpdateRevisionConduitAPIMethod.php
	+++ b/src/applications/differential/conduit/DifferentialUpdateRevisionConduitAPIMethod.php
	@@ -1,89 +1,89 @@
	<?php

	final class DifferentialUpdateRevisionConduitAPIMethod
	extends DifferentialConduitAPIMethod {

	public function getAPIMethodName() {
	return 'differential.updaterevision';
	}

	public function getMethodDescription() {
	return pht('Update a Differential revision.');
	}

	public function getMethodStatus() {
	return self::METHOD_STATUS_FROZEN;
	}

	public function getMethodStatusDescription() {
	return pht(
	'This method is frozen and will eventually be deprecated. New code '.
	'should use "differential.revision.edit" instead.');
	}

	protected function defineParamTypes() {
	return array(
	'id' => 'required revisionid',
	'diffid' => 'required diffid',
	'fields' => 'required dict',
	'message' => 'required string',
	);
	}

	protected function defineReturnType() {
	return 'nonempty dict';
	}

	protected function defineErrorTypes() {
	return array(
	'ERR_BAD_DIFF' => pht('Bad diff ID.'),
	'ERR_BAD_REVISION' => pht('Bad revision ID.'),
	'ERR_WRONG_USER' => pht('You are not the author of this revision.'),
	'ERR_CLOSED' => pht('This revision has already been closed.'),
	);
	}

	protected function execute(ConduitAPIRequest $request) {
	$viewer = $request->getUser();

	$diff = id(new DifferentialDiffQuery())
	->setViewer($viewer)
	->withIDs(array($request->getValue('diffid')))
	->executeOne();
	if (!$diff) {
	throw new ConduitException('ERR_BAD_DIFF');
	}

	$revision = id(new DifferentialRevisionQuery())
	->setViewer($request->getUser())
	->withIDs(array($request->getValue('id')))
	- ->needReviewerStatus(true)
	+ ->needReviewers(true)
	->needActiveDiffs(true)
	->requireCapabilities(
	array(
	PhabricatorPolicyCapability::CAN_VIEW,
	PhabricatorPolicyCapability::CAN_EDIT,
	))
	->executeOne();
	if (!$revision) {
	throw new ConduitException('ERR_BAD_REVISION');
	}

	if ($revision->getStatus() == ArcanistDifferentialRevisionStatus::CLOSED) {
	throw new ConduitException('ERR_CLOSED');
	}

	$this->applyFieldEdit(
	$request,
	$revision,
	$diff,
	$request->getValue('fields', array()),
	$request->getValue('message'));

	return array(
	'revisionid' => $revision->getID(),
	'uri' => PhabricatorEnv::getURI('/D'.$revision->getID()),
	);
	}

	}
	diff --git a/src/applications/differential/controller/DifferentialRevisionViewController.php b/src/applications/differential/controller/DifferentialRevisionViewController.php
	index 9b87d1163d..e7d0a1cc87 100644
	--- a/src/applications/differential/controller/DifferentialRevisionViewController.php
	+++ b/src/applications/differential/controller/DifferentialRevisionViewController.php
	@@ -1,1109 +1,1109 @@
	<?php

	final class DifferentialRevisionViewController extends DifferentialController {

	private $revisionID;

	public function shouldAllowPublic() {
	return true;
	}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	$request_uri = $request->getRequestURI();

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

	$old = array_select_keys($changesets, $old_ids);
	$new = array_select_keys($changesets, $new_ids);

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

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

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

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

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

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

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

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

	$this->loadHarbormasterData($detail_diffs);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	$tab_view = id(new PHUIObjectBoxView())
	->setHeaderText(pht('Revision Contents'))
	->setBackground(PHUIObjectBoxView::BLUE_PROPERTY)
	->addTabGroup($tab_group);

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

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

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

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

	$comment_view->setTransactionTimeline($timeline);

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

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

	$comment_view->setInfoView($warnings_view);
	}

	$footer[] = $comment_view;

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

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

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

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

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

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

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

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

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

	return $page;
	}

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

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

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

	return $view;
	}

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

	$author_phid = $revision->getAuthorPHID();

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	$curtain->addAction($revision_submenu);

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

	return $curtain;
	}

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

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

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

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

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

	return $unit_status;
	}

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

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

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

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

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

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

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

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

	$engine = PhabricatorSyntaxHighlighter::newEngine();

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

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

	$symbol_indexes = array();

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

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

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

	return $symbol_indexes;
	}

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

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

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

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

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

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

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

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

	$results = $query->execute();

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

	return $results;
	}

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

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

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

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

	return $view;
	}


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

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

	$viewer = $this->getViewer();

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

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

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

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

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

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

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

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

	$unguarded = AphrontWriteGuard::beginScopedUnguardedWrites();
	$file->attachToObject($revision->getPHID());
	unset($unguarded);

	return $file->getRedirectResponse();
	}

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

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

	return $timeline;
	}

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

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

	return $warnings;
	}

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

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

	if (!$fields) {
	return null;
	}

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

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

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

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

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

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

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

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

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

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

	return $view;
	}

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

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

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

	$state_fail = DrydockRepositoryOperation::STATE_FAIL;

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

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

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

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

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

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

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

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

	if (!$interesting_messages) {
	return null;
	}

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

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

	}
	diff --git a/src/applications/differential/doorkeeper/DifferentialDoorkeeperRevisionFeedStoryPublisher.php b/src/applications/differential/doorkeeper/DifferentialDoorkeeperRevisionFeedStoryPublisher.php
	index 135e9b560d..9583486c98 100644
	--- a/src/applications/differential/doorkeeper/DifferentialDoorkeeperRevisionFeedStoryPublisher.php
	+++ b/src/applications/differential/doorkeeper/DifferentialDoorkeeperRevisionFeedStoryPublisher.php
	@@ -1,90 +1,90 @@
	<?php

	final class DifferentialDoorkeeperRevisionFeedStoryPublisher
	extends DoorkeeperFeedStoryPublisher {

	public function canPublishStory(PhabricatorFeedStory $story, $object) {
	return ($object instanceof DifferentialRevision);
	}

	public function isStoryAboutObjectCreation($object) {
	$story = $this->getFeedStory();
	$action = $story->getStoryData()->getValue('action');

	return ($action == DifferentialAction::ACTION_CREATE);
	}

	public function isStoryAboutObjectClosure($object) {
	$story = $this->getFeedStory();
	$action = $story->getStoryData()->getValue('action');

	return ($action == DifferentialAction::ACTION_CLOSE) \|\|
	($action == DifferentialAction::ACTION_ABANDON);
	}

	public function willPublishStory($object) {
	return id(new DifferentialRevisionQuery())
	->setViewer($this->getViewer())
	->withIDs(array($object->getID()))
	- ->needReviewerStatus(true)
	+ ->needReviewers(true)
	->executeOne();
	}

	public function getOwnerPHID($object) {
	return $object->getAuthorPHID();
	}

	public function getActiveUserPHIDs($object) {
	$status = $object->getStatus();
	if ($status == ArcanistDifferentialRevisionStatus::NEEDS_REVIEW) {
	return $object->getReviewerPHIDs();
	} else {
	return array();
	}
	}

	public function getPassiveUserPHIDs($object) {
	$status = $object->getStatus();
	if ($status == ArcanistDifferentialRevisionStatus::NEEDS_REVIEW) {
	return array();
	} else {
	return $object->getReviewerPHIDs();
	}
	}

	public function getCCUserPHIDs($object) {
	return PhabricatorSubscribersQuery::loadSubscribersForPHID(
	$object->getPHID());
	}

	public function getObjectTitle($object) {
	$id = $object->getID();

	$title = $object->getTitle();

	return "D{$id}: {$title}";
	}

	public function getObjectURI($object) {
	return PhabricatorEnv::getProductionURI('/D'.$object->getID());
	}

	public function getObjectDescription($object) {
	return $object->getSummary();
	}

	public function isObjectClosed($object) {
	return $object->isClosed();
	}

	public function getResponsibilityTitle($object) {
	$prefix = $this->getTitlePrefix($object);
	return pht('%s Review Request', $prefix);
	}

	private function getTitlePrefix(DifferentialRevision $revision) {
	$prefix_key = 'metamta.differential.subject-prefix';
	return PhabricatorEnv::getEnvConfig($prefix_key);
	}

	}
	diff --git a/src/applications/differential/editor/DifferentialRevisionEditEngine.php b/src/applications/differential/editor/DifferentialRevisionEditEngine.php
	index 5c2fef275d..9aad031a7c 100644
	--- a/src/applications/differential/editor/DifferentialRevisionEditEngine.php
	+++ b/src/applications/differential/editor/DifferentialRevisionEditEngine.php
	@@ -1,323 +1,323 @@
	<?php

	final class DifferentialRevisionEditEngine
	extends PhabricatorEditEngine {

	private $diff;

	const ENGINECONST = 'differential.revision';

	const KEY_UPDATE = 'update';

	const ACTIONGROUP_REVIEW = 'review';
	const ACTIONGROUP_REVISION = 'revision';

	public function getEngineName() {
	return pht('Revisions');
	}

	public function getSummaryHeader() {
	return pht('Configure Revision Forms');
	}

	public function getSummaryText() {
	return pht(
	'Configure creation and editing revision forms in Differential.');
	}

	public function getEngineApplicationClass() {
	return 'PhabricatorDifferentialApplication';
	}

	public function isEngineConfigurable() {
	return false;
	}

	protected function newEditableObject() {
	$viewer = $this->getViewer();
	return DifferentialRevision::initializeNewRevision($viewer);
	}

	protected function newObjectQuery() {
	return id(new DifferentialRevisionQuery())
	->needActiveDiffs(true)
	- ->needReviewerStatus(true)
	+ ->needReviewers(true)
	->needReviewerAuthority(true);
	}

	protected function getObjectCreateTitleText($object) {
	return pht('Create New Revision');
	}

	protected function getObjectEditTitleText($object) {
	$monogram = $object->getMonogram();
	$title = $object->getTitle();

	$diff = $this->getDiff();
	if ($diff) {
	return pht('Update Revision %s: %s', $monogram, $title);
	} else {
	return pht('Edit Revision %s: %s', $monogram, $title);
	}
	}

	protected function getObjectEditShortText($object) {
	return $object->getMonogram();
	}

	protected function getObjectCreateShortText() {
	return pht('Create Revision');
	}

	protected function getObjectName() {
	return pht('Revision');
	}

	protected function getObjectViewURI($object) {
	return $object->getURI();
	}

	protected function getEditorURI() {
	return $this->getApplication()->getApplicationURI('revision/edit/');
	}

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

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

	protected function newCommentActionGroups() {
	return array(
	id(new PhabricatorEditEngineCommentActionGroup())
	->setKey(self::ACTIONGROUP_REVIEW)
	->setLabel(pht('Review Actions')),
	id(new PhabricatorEditEngineCommentActionGroup())
	->setKey(self::ACTIONGROUP_REVISION)
	->setLabel(pht('Revision Actions')),
	);
	}

	protected function buildCustomEditFields($object) {
	$viewer = $this->getViewer();

	$plan_required = PhabricatorEnv::getEnvConfig(
	'differential.require-test-plan-field');
	$plan_enabled = $this->isCustomFieldEnabled(
	$object,
	'differential:test-plan');

	$diff = $this->getDiff();
	if ($diff) {
	$diff_phid = $diff->getPHID();
	} else {
	$diff_phid = null;
	}

	$is_create = $this->getIsCreate();
	$is_update = ($diff && !$is_create);

	$fields = array();

	$fields[] = id(new PhabricatorHandlesEditField())
	->setKey(self::KEY_UPDATE)
	->setLabel(pht('Update Diff'))
	->setDescription(pht('New diff to create or update the revision with.'))
	->setConduitDescription(pht('Create or update a revision with a diff.'))
	->setConduitTypeDescription(pht('PHID of the diff.'))
	->setTransactionType(DifferentialTransaction::TYPE_UPDATE)
	->setHandleParameterType(new AphrontPHIDListHTTPParameterType())
	->setSingleValue($diff_phid)
	->setIsConduitOnly(!$diff)
	->setIsReorderable(false)
	->setIsDefaultable(false)
	->setIsInvisible(true)
	->setIsLockable(false);

	if ($is_update) {
	$fields[] = id(new PhabricatorInstructionsEditField())
	->setKey('update.help')
	->setValue(pht('Describe the updates you have made to the diff.'));
	$fields[] = id(new PhabricatorCommentEditField())
	->setKey('update.comment')
	->setLabel(pht('Comment'))
	->setTransactionType(PhabricatorTransactions::TYPE_COMMENT)
	->setIsWebOnly(true)
	->setDescription(pht('Comments providing context for the update.'));
	$fields[] = id(new PhabricatorSubmitEditField())
	->setKey('update.submit')
	->setValue($this->getObjectEditButtonText($object));
	$fields[] = id(new PhabricatorDividerEditField())
	->setKey('update.note');
	}

	$fields[] = id(new PhabricatorTextEditField())
	->setKey(DifferentialRevisionTitleTransaction::EDITKEY)
	->setLabel(pht('Title'))
	->setIsRequired(true)
	->setTransactionType(
	DifferentialRevisionTitleTransaction::TRANSACTIONTYPE)
	->setDescription(pht('The title of the revision.'))
	->setConduitDescription(pht('Retitle the revision.'))
	->setConduitTypeDescription(pht('New revision title.'))
	->setValue($object->getTitle());

	$fields[] = id(new PhabricatorRemarkupEditField())
	->setKey(DifferentialRevisionSummaryTransaction::EDITKEY)
	->setLabel(pht('Summary'))
	->setTransactionType(
	DifferentialRevisionSummaryTransaction::TRANSACTIONTYPE)
	->setDescription(pht('The summary of the revision.'))
	->setConduitDescription(pht('Change the revision summary.'))
	->setConduitTypeDescription(pht('New revision summary.'))
	->setValue($object->getSummary());

	if ($plan_enabled) {
	$fields[] = id(new PhabricatorRemarkupEditField())
	->setKey(DifferentialRevisionTestPlanTransaction::EDITKEY)
	->setLabel(pht('Test Plan'))
	->setIsRequired($plan_required)
	->setTransactionType(
	DifferentialRevisionTestPlanTransaction::TRANSACTIONTYPE)
	->setDescription(
	pht('Actions performed to verify the behavior of the change.'))
	->setConduitDescription(pht('Update the revision test plan.'))
	->setConduitTypeDescription(pht('New test plan.'))
	->setValue($object->getTestPlan());
	}

	$fields[] = id(new PhabricatorDatasourceEditField())
	->setKey(DifferentialRevisionReviewersTransaction::EDITKEY)
	->setLabel(pht('Reviewers'))
	->setDatasource(new DifferentialReviewerDatasource())
	->setUseEdgeTransactions(true)
	->setTransactionType(
	DifferentialRevisionReviewersTransaction::TRANSACTIONTYPE)
	->setCommentActionLabel(pht('Change Reviewers'))
	->setDescription(pht('Reviewers for this revision.'))
	->setConduitDescription(pht('Change the reviewers for this revision.'))
	->setConduitTypeDescription(pht('New reviewers.'))
	->setValue($object->getReviewerPHIDsForEdit());

	$fields[] = id(new PhabricatorDatasourceEditField())
	->setKey('repositoryPHID')
	->setLabel(pht('Repository'))
	->setDatasource(new DiffusionRepositoryDatasource())
	->setTransactionType(
	DifferentialRevisionRepositoryTransaction::TRANSACTIONTYPE)
	->setDescription(pht('The repository the revision belongs to.'))
	->setConduitDescription(pht('Change the repository for this revision.'))
	->setConduitTypeDescription(pht('New repository.'))
	->setSingleValue($object->getRepositoryPHID());

	// This is a little flimsy, but allows "Maniphest Tasks: ..." to continue
	// working properly in commit messages until we fully sort out T5873.
	$fields[] = id(new PhabricatorHandlesEditField())
	->setKey('tasks')
	->setUseEdgeTransactions(true)
	->setIsConduitOnly(true)
	->setTransactionType(PhabricatorTransactions::TYPE_EDGE)
	->setMetadataValue(
	'edge:type',
	DifferentialRevisionHasTaskEdgeType::EDGECONST)
	->setDescription(pht('Tasks associated with this revision.'))
	->setConduitDescription(pht('Change associated tasks.'))
	->setConduitTypeDescription(pht('List of tasks.'))
	->setValue(array());

	$actions = DifferentialRevisionActionTransaction::loadAllActions();
	$actions = msortv($actions, 'getRevisionActionOrderVector');

	foreach ($actions as $key => $action) {
	$fields[] = $action->newEditField($object, $viewer);
	}

	return $fields;
	}

	private function isCustomFieldEnabled(DifferentialRevision $revision, $key) {
	$field_list = PhabricatorCustomField::getObjectFields(
	$revision,
	PhabricatorCustomField::ROLE_VIEW);

	$fields = $field_list->getFields();
	return isset($fields[$key]);
	}

	protected function newAutomaticCommentTransactions($object) {
	$viewer = $this->getViewer();
	$xactions = array();

	$inlines = DifferentialTransactionQuery::loadUnsubmittedInlineComments(
	$viewer,
	$object);
	$inlines = msort($inlines, 'getID');

	foreach ($inlines as $inline) {
	$xactions[] = id(new DifferentialTransaction())
	->setTransactionType(DifferentialTransaction::TYPE_INLINE)
	->attachComment($inline);
	}

	$viewer_phid = $viewer->getPHID();
	$viewer_is_author = ($object->getAuthorPHID() == $viewer_phid);
	if ($viewer_is_author) {
	$state_map = PhabricatorTransactions::getInlineStateMap();

	$inlines = id(new DifferentialDiffInlineCommentQuery())
	->setViewer($viewer)
	->withRevisionPHIDs(array($object->getPHID()))
	->withFixedStates(array_keys($state_map))
	->execute();
	if ($inlines) {
	$old_value = mpull($inlines, 'getFixedState', 'getPHID');
	$new_value = array();
	foreach ($old_value as $key => $state) {
	$new_value[$key] = $state_map[$state];
	}

	$xactions[] = id(new DifferentialTransaction())
	->setTransactionType(PhabricatorTransactions::TYPE_INLINESTATE)
	->setIgnoreOnNoEffect(true)
	->setOldValue($old_value)
	->setNewValue($new_value);
	}
	}

	return $xactions;
	}

	protected function newCommentPreviewContent($object, array $xactions) {
	$viewer = $this->getViewer();
	$type_inline = DifferentialTransaction::TYPE_INLINE;

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

	$content = array();

	if ($inlines) {
	$inline_preview = id(new PHUIDiffInlineCommentPreviewListView())
	->setViewer($viewer)
	->setInlineComments($inlines);

	$content[] = phutil_tag(
	'div',
	array(
	'id' => 'inline-comment-preview',
	),
	$inline_preview);
	}

	return $content;
	}


	}
	diff --git a/src/applications/differential/editor/DifferentialTransactionEditor.php b/src/applications/differential/editor/DifferentialTransactionEditor.php
	index cfaff0cbef..340a4e6735 100644
	--- a/src/applications/differential/editor/DifferentialTransactionEditor.php
	+++ b/src/applications/differential/editor/DifferentialTransactionEditor.php
	@@ -1,1897 +1,1897 @@
	<?php

	final class DifferentialTransactionEditor
	extends PhabricatorApplicationTransactionEditor {

	private $changedPriorToCommitURI;
	private $isCloseByCommit;
	private $repositoryPHIDOverride = false;
	private $didExpandInlineState = false;
	private $hasReviewTransaction = false;
	private $affectedPaths;

	public function getEditorApplicationClass() {
	return 'PhabricatorDifferentialApplication';
	}

	public function getEditorObjectsDescription() {
	return pht('Differential Revisions');
	}

	public function getCreateObjectTitle($author, $object) {
	return pht('%s created this revision.', $author);
	}

	public function getCreateObjectTitleForFeed($author, $object) {
	return pht('%s created %s.', $author, $object);
	}

	public function getDiffUpdateTransaction(array $xactions) {
	$type_update = DifferentialTransaction::TYPE_UPDATE;

	foreach ($xactions as $xaction) {
	if ($xaction->getTransactionType() == $type_update) {
	return $xaction;
	}
	}

	return null;
	}

	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 setRepositoryPHIDOverride($phid_or_null) {
	$this->repositoryPHIDOverride = $phid_or_null;
	return $this;
	}

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

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

	$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 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 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) {

	$actor_phid = $this->getActingAsPHID();

	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_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_CLAIM:
	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;
	$status_abandoned = ArcanistDifferentialRevisionStatus::ABANDONED;
	$status_accepted = ArcanistDifferentialRevisionStatus::ACCEPTED;

	switch ($xaction->getTransactionType()) {
	case DifferentialTransaction::TYPE_INLINE:
	return;
	case DifferentialTransaction::TYPE_UPDATE:
	if (!$this->getIsCloseByCommit()) {
	switch ($object->getStatus()) {
	case $status_revision:
	case $status_plan:
	case $status_abandoned:
	$object->setStatus($status_review);
	break;
	}
	}

	$diff = $this->requireDiff($xaction->getNewValue());

	$object->setLineCount($diff->getLineCount());
	if ($this->repositoryPHIDOverride !== false) {
	$object->setRepositoryPHID($this->repositoryPHIDOverride);
	} else {
	$object->setRepositoryPHID($diff->getRepositoryPHID());
	}
	$object->attachActiveDiff($diff);

	// TODO: Update the `diffPHID` once we add that.
	return;
	case DifferentialTransaction::TYPE_ACTION:
	switch ($xaction->getNewValue()) {
	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:
	$old_status = $object->getStatus();
	$object->setStatus(ArcanistDifferentialRevisionStatus::CLOSED);
	$was_accepted = ($old_status == $status_accepted);
	$object->setProperty(
	DifferentialRevision::PROPERTY_CLOSED_FROM_ACCEPTED,
	$was_accepted);
	return;
	case DifferentialAction::ACTION_CLAIM:
	$object->setAuthorPHID($this->getActingAsPHID());
	return;
	default:
	throw new Exception(
	pht(
	'Differential action "%s" is not a valid action!',
	$xaction->getNewValue()));
	}
	break;
	}

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

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

	foreach ($xactions as $xaction) {
	switch ($xaction->getTransactionType()) {
	case PhabricatorTransactions::TYPE_INLINESTATE:
	// If we have an "Inline State" transaction already, the caller
	// built it for us so we don't need to expand it again.
	$this->didExpandInlineState = true;
	break;
	case DifferentialRevisionAcceptTransaction::TRANSACTIONTYPE:
	case DifferentialRevisionRejectTransaction::TRANSACTIONTYPE:
	case DifferentialRevisionResignTransaction::TRANSACTIONTYPE:
	// If we have a review transaction, we'll skip marking the user
	// as "Commented" later. This should get cleaner after T10967.
	$this->hasReviewTransaction = true;
	break;
	}
	}

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

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

	$results = parent::expandTransaction($object, $xaction);

	$actor = $this->getActor();
	$actor_phid = $this->getActingAsPHID();
	$type_edge = PhabricatorTransactions::TYPE_EDGE;

	$status_plan = ArcanistDifferentialRevisionStatus::CHANGES_PLANNED;

	$edge_reviewer = DifferentialRevisionHasReviewerEdgeType::EDGECONST;
	$edge_ref_task = DifferentialRevisionHasTaskEdgeType::EDGECONST;

	$is_sticky_accept = PhabricatorEnv::getEnvConfig(
	'differential.sticky-accept');

	$downgrade_rejects = false;
	$downgrade_accepts = false;
	if ($this->getIsCloseByCommit()) {
	// Never downgrade reviewers when we're closing a revision after a
	// commit.
	} else {
	switch ($xaction->getTransactionType()) {
	case DifferentialTransaction::TYPE_UPDATE:
	$downgrade_rejects = true;
	if (!$is_sticky_accept) {
	// If "sticky accept" is disabled, also downgrade the accepts.
	$downgrade_accepts = true;
	}
	break;
	case DifferentialRevisionRequestReviewTransaction::TRANSACTIONTYPE:
	$downgrade_rejects = true;
	if ((!$is_sticky_accept) \|\|
	($object->getStatus() != $status_plan)) {
	// If the old state isn't "changes planned", downgrade the accepts.
	// This exception allows an accepted revision to go through
	// "Plan Changes" -> "Request Review" and return to "accepted" if
	// the author didn't update the revision, essentially undoing the
	// "Plan Changes".
	$downgrade_accepts = true;
	}
	break;

	// TODO: Remove this, obsoleted by ModularTransactions above.
	case DifferentialTransaction::TYPE_ACTION:
	switch ($xaction->getNewValue()) {
	case DifferentialAction::ACTION_REQUEST:
	$downgrade_rejects = true;
	if ((!$is_sticky_accept) \|\|
	($object->getStatus() != $status_plan)) {
	$downgrade_accepts = true;
	}
	break;
	}
	break;
	}
	}

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

	if ($downgrade_rejects \|\| $downgrade_accepts) {
	// 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".

	// We also do this for "Request Review", even though the diff is not
	// updated directly. Essentially, this acts like an update which doesn't
	// actually change the diff text.

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

	if ($downgrade_accepts) {
	if ($reviewer->getStatus() == $new_accept) {
	$edits[$reviewer->getReviewerPHID()] = array(
	'data' => array(
	'status' => $old_accept,
	),
	);
	}
	}
	}

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

	$is_commandeer = false;
	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;
	}

	// 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 = 'PhabricatorManiphestApplication';
	if (PhabricatorApplication::isClassInstalled($maniphest)) {
	$diff = $this->requireDiff($xaction->getNewValue());
	$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.

	if ($this->hasReviewTransaction) {
	// If we're also applying a review transaction, skip this.
	break;
	}

	$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 DifferentialRevisionCommandeerTransaction::TRANSACTIONTYPE:
	$is_commandeer = true;
	break;

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

	switch ($action_type) {
	case DifferentialAction::ACTION_CLAIM:
	$is_commandeer = true;
	break;
	}
	break;
	}

	if ($is_commandeer) {
	$results[] = $this->newCommandeerReviewerTransaction($object);
	}

	if (!$this->didExpandInlineState) {
	switch ($xaction->getTransactionType()) {
	case PhabricatorTransactions::TYPE_COMMENT:
	case DifferentialTransaction::TYPE_ACTION:
	case DifferentialTransaction::TYPE_UPDATE:
	case DifferentialTransaction::TYPE_INLINE:
	$this->didExpandInlineState = true;

	$actor_phid = $this->getActingAsPHID();
	$actor_is_author = ($object->getAuthorPHID() == $actor_phid);
	if (!$actor_is_author) {
	break;
	}

	$state_map = PhabricatorTransactions::getInlineStateMap();

	$inlines = id(new DifferentialDiffInlineCommentQuery())
	->setViewer($this->getActor())
	->withRevisionPHIDs(array($object->getPHID()))
	->withFixedStates(array_keys($state_map))
	->execute();

	if (!$inlines) {
	break;
	}

	$old_value = mpull($inlines, 'getFixedState', 'getPHID');
	$new_value = array();
	foreach ($old_value as $key => $state) {
	$new_value[$key] = $state_map[$state];
	}

	$results[] = id(new DifferentialTransaction())
	->setTransactionType(PhabricatorTransactions::TYPE_INLINESTATE)
	->setIgnoreOnNoEffect(true)
	->setOldValue($old_value)
	->setNewValue($new_value);
	break;
	}
	}

	return $results;
	}

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

	switch ($xaction->getTransactionType()) {
	case DifferentialTransaction::TYPE_ACTION:
	return;
	case DifferentialTransaction::TYPE_INLINE:
	$reply = $xaction->getComment()->getReplyToComment();
	if ($reply && !$reply->getHasReplies()) {
	$reply->setHasReplies(1)->save();
	}
	return;
	case DifferentialTransaction::TYPE_UPDATE:
	// Now that we're inside the transaction, do a final check.
	$diff = $this->requireDiff($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.

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

	// TODO: This can race with diff updates, particularly those from
	// Harbormaster. See discussion in T8650.
	$diff->setRevisionID($object->getID());
	$diff->save();

	// Update Harbormaster to set the containerPHID correctly for any
	// existing buildables. We may otherwise have buildables stuck with
	// the old (`null`) container.

	// TODO: This is a bit iffy, maybe we can find a cleaner approach?
	// In particular, this could (rarely) be overwritten by Harbormaster
	// workers.
	$table = new HarbormasterBuildable();
	$conn_w = $table->establishConnection('w');
	queryfx(
	$conn_w,
	'UPDATE %T SET containerPHID = %s WHERE buildablePHID = %s',
	$table->getTableName(),
	$object->getPHID(),
	$diff->getPHID());

	return;
	}

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

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

	switch ($xaction->getTransactionType()) {
	case PhabricatorTransactions::TYPE_INLINESTATE:
	$table = new DifferentialTransactionComment();
	$conn_w = $table->establishConnection('w');
	foreach ($xaction->getNewValue() as $phid => $state) {
	queryfx(
	$conn_w,
	'UPDATE %T SET fixedState = %s WHERE phid = %s',
	$table->getTableName(),
	$state,
	$phid);
	}
	break;
	}

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

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

	switch ($type) {
	case DifferentialRevisionHasReviewerEdgeType::EDGECONST:
	// 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) {

	// 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. Then, update the reviewers
	// on the object to make sure we're acting on the current reviewer set
	// (and, for example, sending mail to the right people).

	$new_revision = id(new DifferentialRevisionQuery())
	->setViewer($this->getActor())
	- ->needReviewerStatus(true)
	+ ->needReviewers(true)
	->needActiveDiffs(true)
	->withIDs(array($object->getID()))
	->executeOne();
	if (!$new_revision) {
	throw new Exception(
	pht('Failed to load revision from transaction finalization.'));
	}

	$object->attachReviewerStatus($new_revision->getReviewerStatus());
	$object->attachActiveDiff($new_revision->getActiveDiff());
	$object->attachRepository($new_revision->getRepository());

	foreach ($xactions as $xaction) {
	switch ($xaction->getTransactionType()) {
	case DifferentialTransaction::TYPE_UPDATE:
	$diff = $this->requireDiff($xaction->getNewValue(), true);

	// Update these denormalized index tables when we attach a new
	// diff to a revision.

	$this->updateRevisionHashTable($object, $diff);
	$this->updateAffectedPathTable($object, $diff);
	break;
	}
	}

	$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:
	// 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 ($object->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;
	}


	$this->markReviewerComments($object, $xactions);

	return $xactions;
	}

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

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

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

	foreach ($xactions as $xaction) {
	switch ($type) {
	case PhabricatorTransactions::TYPE_EDGE:
	switch ($xaction->getMetadataValue('edge:type')) {
	case DifferentialRevisionHasReviewerEdgeType::EDGECONST:

	// Prevent the author from becoming a reviewer.

	// NOTE: This is pretty gross, but this restriction is unusual.
	// If we end up with too much more of this, we should try to clean
	// this up -- maybe by moving validation to after transactions
	// are adjusted (so we can just examine the final value) or adding
	// a second phase there?

	$author_phid = $object->getAuthorPHID();
	$new = $xaction->getNewValue();

	$add = idx($new, '+', array());
	$eq = idx($new, '=', array());
	$phids = array_keys($add + $eq);

	foreach ($phids as $phid) {
	if (($phid == $author_phid) &&
	!$allow_self_accept &&
	!$xaction->getIsCommandeerSideEffect()) {
	$errors[] =
	new PhabricatorApplicationTransactionValidationError(
	$type,
	pht('Invalid'),
	pht('The author of a revision can not be a reviewer.'),
	$xaction);
	}
	}
	break;
	}
	break;
	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->getActingAsPHID();
	$actor_is_author = ($author_phid == $actor_phid);

	$config_abandon_key = 'differential.always-allow-abandon';
	$always_allow_abandon = PhabricatorEnv::getEnvConfig($config_abandon_key);

	$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_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 && !$always_allow_abandon) {
	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 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);
	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 = new PhabricatorMetaMTAMailBody();
	$body->setViewer($this->requireActor());

	$revision_uri = PhabricatorEnv::getProductionURI('/D'.$object->getID());

	$this->addHeadersAndCommentsToMailBody(
	$body,
	$xactions,
	pht('View Revision'),
	$revision_uri);

	$type_inline = DifferentialTransaction::TYPE_INLINE;

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

	if ($inlines) {
	$this->appendInlineCommentsForMail($object, $inlines, $body);
	}

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

	$this->addCustomFieldsToMailBody($body, $object, $xactions);

	$body->addLinkSection(
	pht('REVISION DETAIL'),
	$revision_uri);

	$update_xaction = null;
	foreach ($xactions as $xaction) {
	switch ($xaction->getTransactionType()) {
	case DifferentialTransaction::TYPE_UPDATE:
	$update_xaction = $xaction;
	break;
	}
	}

	if ($update_xaction) {
	$diff = $this->requireDiff($update_xaction->getNewValue(), true);

	$body->addTextSection(
	pht('AFFECTED FILES'),
	$this->renderAffectedFilesForMail($diff));

	$config_key_inline = 'metamta.differential.inline-patches';
	$config_inline = PhabricatorEnv::getEnvConfig($config_key_inline);

	$config_key_attach = 'metamta.differential.attach-patches';
	$config_attach = PhabricatorEnv::getEnvConfig($config_key_attach);

	if ($config_inline \|\| $config_attach) {
	$body_limit = PhabricatorEnv::getEnvConfig('metamta.email-body-limit');

	$patch = $this->buildPatchForMail($diff);
	if ($config_inline) {
	$lines = substr_count($patch, "\n");
	$bytes = strlen($patch);

	// Limit the patch size to the smaller of 256 bytes per line or
	// the mail body limit. This prevents degenerate behavior for patches
	// with one line that is 10MB long. See T11748.
	$byte_limits = array();
	$byte_limits[] = (256 * $config_inline);
	$byte_limits[] = $body_limit;
	$byte_limit = min($byte_limits);

	$lines_ok = ($lines <= $config_inline);
	$bytes_ok = ($bytes <= $byte_limit);

	if ($lines_ok && $bytes_ok) {
	$this->appendChangeDetailsForMail($object, $diff, $patch, $body);
	} else {
	// TODO: Provide a helpful message about the patch being too
	// large or lengthy here.
	}
	}

	if ($config_attach) {
	$name = pht('D%s.%s.patch', $object->getID(), $diff->getID());
	$mime_type = 'text/x-patch; charset=utf-8';
	$body->addAttachment(
	new PhabricatorMetaMTAAttachment($patch, $name, $mime_type));
	}
	}
	}

	return $body;
	}

	public function getMailTagsMap() {
	return array(
	DifferentialTransaction::MAILTAG_REVIEW_REQUEST =>
	pht('A revision is created.'),
	DifferentialTransaction::MAILTAG_UPDATED =>
	pht('A revision is updated.'),
	DifferentialTransaction::MAILTAG_COMMENT =>
	pht('Someone comments on a revision.'),
	DifferentialTransaction::MAILTAG_CLOSED =>
	pht('A revision is closed.'),
	DifferentialTransaction::MAILTAG_REVIEWERS =>
	pht("A revision's reviewers change."),
	DifferentialTransaction::MAILTAG_CC =>
	pht("A revision's CCs change."),
	DifferentialTransaction::MAILTAG_OTHER =>
	pht('Other revision activity not listed above occurs.'),
	);
	}

	protected function supportsSearch() {
	return true;
	}

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

	$flat_blocks = mpull($changes, 'getNewValue');
	$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();
	$task_phids = array();
	$rev_phids = array();

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

	if ($tasks) {
	$task_phids = mpull($tasks, 'getPHID', 'getPHID');
	$edge_related = DifferentialRevisionHasTaskEdgeType::EDGECONST;
	$edges[$edge_related] = $task_phids;
	}
	}

	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) {
	$depends = DifferentialRevisionDependsOnRevisionEdgeType::EDGECONST;
	$edges[$depends] = $rev_phids;
	}
	}

	$this->setUnmentionablePHIDMap(array_merge($task_phids, $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 appendInlineCommentsForMail(
	PhabricatorLiskDAO $object,
	array $inlines,
	PhabricatorMetaMTAMailBody $body) {

	$section = id(new DifferentialInlineCommentMailView())
	->setViewer($this->getActor())
	->setInlines($inlines)
	->buildMailSection();

	$header = pht('INLINE COMMENTS');

	$section_text = "\n".$section->getPlaintext();

	$style = array(
	'margin: 6px 0 12px 0;',
	);

	$section_html = phutil_tag(
	'div',
	array(
	'style' => implode(' ', $style),
	),
	$section->getHTML());

	$body->addPlaintextSection($header, $section_text, false);
	$body->addHTMLSection($header, $section_html);
	}

	private function appendChangeDetailsForMail(
	PhabricatorLiskDAO $object,
	DifferentialDiff $diff,
	$patch,
	PhabricatorMetaMTAMailBody $body) {

	$section = id(new DifferentialChangeDetailMailView())
	->setViewer($this->getActor())
	->setDiff($diff)
	->setPatch($patch)
	->buildMailSection();

	$header = pht('CHANGE DETAILS');

	$section_text = "\n".$section->getPlaintext();

	$style = array(
	'margin: 6px 0 12px 0;',
	);

	$section_html = phutil_tag(
	'div',
	array(
	'style' => implode(' ', $style),
	),
	$section->getHTML());

	$body->addPlaintextSection($header, $section_text, false);
	$body->addHTMLSection($header, $section_html);
	}

	private function loadDiff($phid, $need_changesets = false) {
	$query = id(new DifferentialDiffQuery())
	->withPHIDs(array($phid))
	->setViewer($this->getActor());

	if ($need_changesets) {
	$query->needChangesets(true);
	}

	return $query->executeOne();
	}

	private function requireDiff($phid, $need_changesets = false) {
	$diff = $this->loadDiff($phid, $need_changesets);
	if (!$diff) {
	throw new Exception(pht('Diff "%s" does not exist!', $phid));
	}

	return $diff;
	}

	/* -( 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;
	}
	break;
	case DifferentialRevisionCommandeerTransaction::TRANSACTIONTYPE:
	// When users commandeer revisions, we may need to trigger
	// signatures or author-based rules.
	return true;
	case DifferentialTransaction::TYPE_ACTION:
	switch ($xaction->getNewValue()) {
	case DifferentialAction::ACTION_CLAIM:
	// When users commandeer revisions, we may need to trigger
	// signatures or author-based rules.
	return true;
	}
	break;
	}
	}

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

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

	$repository = $object->getRepository();
	if (!$repository) {
	return array();
	}

	if (!$this->affectedPaths) {
	return array();
	}

	$packages = PhabricatorOwnersPackage::loadAffectedPackages(
	$repository,
	$this->affectedPaths);
	if (!$packages) {
	return array();
	}

	// Remove packages that the revision author is an owner of. If you own
	// code, you don't need another owner to review it.
	$authority = id(new PhabricatorOwnersPackageQuery())
	->setViewer(PhabricatorUser::getOmnipotentUser())
	->withPHIDs(mpull($packages, 'getPHID'))
	->withAuthorityPHIDs(array($object->getAuthorPHID()))
	->execute();
	$authority = mpull($authority, null, 'getPHID');

	foreach ($packages as $key => $package) {
	$package_phid = $package->getPHID();
	if (isset($authority[$package_phid])) {
	unset($packages[$key]);
	continue;
	}
	}

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

	$auto_subscribe = array();
	$auto_review = array();
	$auto_block = array();

	foreach ($packages as $package) {
	switch ($package->getAutoReview()) {
	case PhabricatorOwnersPackage::AUTOREVIEW_SUBSCRIBE:
	$auto_subscribe[] = $package;
	break;
	case PhabricatorOwnersPackage::AUTOREVIEW_REVIEW:
	$auto_review[] = $package;
	break;
	case PhabricatorOwnersPackage::AUTOREVIEW_BLOCK:
	$auto_block[] = $package;
	break;
	case PhabricatorOwnersPackage::AUTOREVIEW_NONE:
	default:
	break;
	}
	}

	$owners_phid = id(new PhabricatorOwnersApplication())
	->getPHID();

	$xactions = array();
	if ($auto_subscribe) {
	$xactions[] = $object->getApplicationTransactionTemplate()
	->setAuthorPHID($owners_phid)
	->setTransactionType(PhabricatorTransactions::TYPE_SUBSCRIBERS)
	->setNewValue(
	array(
	'+' => mpull($auto_subscribe, 'getPHID'),
	));
	}

	$specs = array(
	array($auto_review, false),
	array($auto_block, true),
	);

	foreach ($specs as $spec) {
	list($reviewers, $blocking) = $spec;
	if (!$reviewers) {
	continue;
	}

	$phids = mpull($reviewers, 'getPHID');
	$xaction = $this->newAutoReviewTransaction($object, $phids, $blocking);
	if ($xaction) {
	$xactions[] = $xaction;
	}
	}

	return $xactions;
	}

	private function newAutoReviewTransaction(
	PhabricatorLiskDAO $object,
	array $phids,
	$is_blocking) {

	// TODO: This is substantially similar to DifferentialReviewersHeraldAction
	// and both are needlessly complex. This logic should live in the normal
	// transaction application pipeline. See T10967.

	$reviewers = $object->getReviewerStatus();
	$reviewers = mpull($reviewers, null, 'getReviewerPHID');

	if ($is_blocking) {
	$new_status = DifferentialReviewerStatus::STATUS_BLOCKING;
	} else {
	$new_status = DifferentialReviewerStatus::STATUS_ADDED;
	}

	$new_strength = DifferentialReviewerStatus::getStatusStrength(
	$new_status);

	$current = array();
	foreach ($phids as $phid) {
	if (!isset($reviewers[$phid])) {
	continue;
	}

	// If we're applying a stronger status (usually, upgrading a reviewer
	// into a blocking reviewer), skip this check so we apply the change.
	$old_strength = DifferentialReviewerStatus::getStatusStrength(
	$reviewers[$phid]->getStatus());
	if ($old_strength <= $new_strength) {
	continue;
	}

	$current[] = $phid;
	}

	$phids = array_diff($phids, $current);

	if (!$phids) {
	return null;
	}

	$phids = array_fuse($phids);

	$value = array();
	foreach ($phids as $phid) {
	if ($is_blocking) {
	$value[] = 'blocking('.$phid.')';
	} else {
	$value[] = $phid;
	}
	}

	$owners_phid = id(new PhabricatorOwnersApplication())
	->getPHID();

	$reviewers_type = DifferentialRevisionReviewersTransaction::TRANSACTIONTYPE;

	return $object->getApplicationTransactionTemplate()
	->setAuthorPHID($owners_phid)
	->setTransactionType($reviewers_type)
	->setNewValue(
	array(
	'+' => $value,
	));
	}

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

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

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

	return $adapter;
	}

	/**
	* 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) {

	$repository = $revision->getRepository();
	if (!$repository) {
	// The repository where the code 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));
	}
	}

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

	// Save the affected paths; we'll use them later to query Owners. This
	// uses the un-expanded paths.
	$this->affectedPaths = $paths;

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

	private function renderAffectedFilesForMail(DifferentialDiff $diff) {
	$changesets = $diff->getChangesets();

	$filenames = mpull($changesets, 'getDisplayFilename');
	sort($filenames);

	$count = count($filenames);
	$max = 250;
	if ($count > $max) {
	$filenames = array_slice($filenames, 0, $max);
	$filenames[] = pht('(%d more files...)', ($count - $max));
	}

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

	private function renderPatchHTMLForMail($patch) {
	return phutil_tag('pre',
	array('style' => 'font-family: monospace;'), $patch);
	}

	private function buildPatchForMail(DifferentialDiff $diff) {
	$format = PhabricatorEnv::getEnvConfig('metamta.differential.patch-format');

	return id(new DifferentialRawDiffRenderer())
	->setViewer($this->getActor())
	->setFormat($format)
	->setChangesets($diff->getChangesets())
	->buildPatch();
	}

	protected function willPublish(PhabricatorLiskDAO $object, array $xactions) {
	// Reload to pick up the active diff and reviewer status.
	return id(new DifferentialRevisionQuery())
	->setViewer($this->getActor())
	- ->needReviewerStatus(true)
	+ ->needReviewers(true)
	->needActiveDiffs(true)
	->withIDs(array($object->getID()))
	->executeOne();
	}

	protected function getCustomWorkerState() {
	return array(
	'changedPriorToCommitURI' => $this->changedPriorToCommitURI,
	);
	}

	protected function loadCustomWorkerState(array $state) {
	$this->changedPriorToCommitURI = idx($state, 'changedPriorToCommitURI');
	return $this;
	}

	private function newCommandeerReviewerTransaction(
	DifferentialRevision $revision) {

	$actor_phid = $this->getActingAsPHID();
	$owner_phid = $revision->getAuthorPHID();

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

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

	// NOTE: We're setting setIsCommandeerSideEffect() on this because normally
	// you can't add a revision's author as a reviewer, but this action swaps
	// them after validation executes.

	$xaction_type = DifferentialRevisionReviewersTransaction::TRANSACTIONTYPE;

	return id(new DifferentialTransaction())
	->setTransactionType($xaction_type)
	->setIgnoreOnNoEffect(true)
	->setIsCommandeerSideEffect(true)
	->setNewValue($edits);
	}

	public function getActiveDiff($object) {
	if ($this->getIsNewObject()) {
	return null;
	} else {
	return $object->getActiveDiff();
	}
	}

	/**
	* When a reviewer makes a comment, mark the last revision they commented
	* on.
	*
	* This allows us to show a hint to help authors and other reviewers quickly
	* distinguish between reviewers who have participated in the discussion and
	* reviewers who haven't been part of it.
	*/
	private function markReviewerComments($object, array $xactions) {
	$acting_phid = $this->getActingAsPHID();
	if (!$acting_phid) {
	return;
	}

	$diff = $this->getActiveDiff($object);
	if (!$diff) {
	return;
	}

	$has_comment = false;
	foreach ($xactions as $xaction) {
	if ($xaction->hasComment()) {
	$has_comment = true;
	break;
	}
	}

	if (!$has_comment) {
	return;
	}

	$reviewer_table = new DifferentialReviewer();
	$conn = $reviewer_table->establishConnection('w');

	queryfx(
	$conn,
	'UPDATE %T SET lastCommentDiffPHID = %s
	WHERE revisionPHID = %s
	AND reviewerPHID = %s',
	$reviewer_table->getTableName(),
	$diff->getPHID(),
	$object->getPHID(),
	$acting_phid);
	}



	}
	diff --git a/src/applications/differential/engineextension/DifferentialHovercardEngineExtension.php b/src/applications/differential/engineextension/DifferentialHovercardEngineExtension.php
	index 6c178f44e0..ef7ad9cbc6 100644
	--- a/src/applications/differential/engineextension/DifferentialHovercardEngineExtension.php
	+++ b/src/applications/differential/engineextension/DifferentialHovercardEngineExtension.php
	@@ -1,75 +1,75 @@
	<?php

	final class DifferentialHovercardEngineExtension
	extends PhabricatorHovercardEngineExtension {

	const EXTENSIONKEY = 'differential';

	public function isExtensionEnabled() {
	return PhabricatorApplication::isClassInstalled(
	'PhabricatorDifferentialApplication');
	}

	public function getExtensionName() {
	return pht('Differential Revisions');
	}

	public function canRenderObjectHovercard($object) {
	return ($object instanceof DifferentialRevision);
	}

	public function willRenderHovercards(array $objects) {
	$viewer = $this->getViewer();
	$phids = mpull($objects, 'getPHID');

	$revisions = id(new DifferentialRevisionQuery())
	->setViewer($viewer)
	->withPHIDs($phids)
	- ->needReviewerStatus(true)
	+ ->needReviewers(true)
	->execute();
	$revisions = mpull($revisions, null, 'getPHID');

	return array(
	'revisions' => $revisions,
	);
	}

	public function renderHovercard(
	PHUIHovercardView $hovercard,
	PhabricatorObjectHandle $handle,
	$object,
	$data) {

	$viewer = $this->getViewer();

	$revision = idx($data['revisions'], $object->getPHID());
	if (!$revision) {
	return;
	}

	$hovercard->setTitle('D'.$revision->getID());
	$hovercard->setDetail($revision->getTitle());

	$hovercard->addField(
	pht('Author'),
	$viewer->renderHandle($revision->getAuthorPHID()));

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

	$hovercard->addField(
	pht('Reviewers'),
	$viewer->renderHandleList($reviewer_phids)->setAsInline(true));

	$summary = $revision->getSummary();
	if (strlen($summary)) {
	$summary = id(new PhutilUTF8StringTruncator())
	->setMaximumGlyphs(120)
	->truncateString($summary);

	$hovercard->addField(pht('Summary'), $summary);
	}

	}

	}
	diff --git a/src/applications/differential/herald/HeraldDifferentialRevisionAdapter.php b/src/applications/differential/herald/HeraldDifferentialRevisionAdapter.php
	index 19d15c5c3f..509ad37564 100644
	--- a/src/applications/differential/herald/HeraldDifferentialRevisionAdapter.php
	+++ b/src/applications/differential/herald/HeraldDifferentialRevisionAdapter.php
	@@ -1,165 +1,165 @@
	<?php

	final class HeraldDifferentialRevisionAdapter
	extends HeraldDifferentialAdapter
	implements HarbormasterBuildableAdapterInterface {

	protected $revision;

	protected $affectedPackages;
	protected $changesets;
	private $haveHunks;

	private $buildRequests = array();

	public function getAdapterApplicationClass() {
	return 'PhabricatorDifferentialApplication';
	}

	protected function newObject() {
	return new DifferentialRevision();
	}

	public function isTestAdapterForObject($object) {
	return ($object instanceof DifferentialRevision);
	}

	public function getAdapterTestDescription() {
	return pht(
	'Test rules which run when a revision is created or updated.');
	}

	public function newTestAdapter(PhabricatorUser $viewer, $object) {
	return self::newLegacyAdapter(
	$object,
	$object->loadActiveDiff());
	}

	protected function initializeNewAdapter() {
	$this->revision = $this->newObject();
	}

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

	public function getAdapterContentType() {
	return 'differential';
	}

	public function getAdapterContentName() {
	return pht('Differential Revisions');
	}

	public function getAdapterContentDescription() {
	return pht(
	"React to revisions being created or updated.\n".
	"Revision rules can send email, flag revisions, add reviewers, ".
	"and run build plans.");
	}

	public function supportsRuleType($rule_type) {
	switch ($rule_type) {
	case HeraldRuleTypeConfig::RULE_TYPE_GLOBAL:
	case HeraldRuleTypeConfig::RULE_TYPE_PERSONAL:
	return true;
	case HeraldRuleTypeConfig::RULE_TYPE_OBJECT:
	default:
	return false;
	}
	}

	public function getRepetitionOptions() {
	return array(
	HeraldRepetitionPolicyConfig::EVERY,
	HeraldRepetitionPolicyConfig::FIRST,
	);
	}

	public static function newLegacyAdapter(
	DifferentialRevision $revision,
	DifferentialDiff $diff) {
	$object = new HeraldDifferentialRevisionAdapter();

	// Reload the revision to pick up relationship information.
	$revision = id(new DifferentialRevisionQuery())
	->withIDs(array($revision->getID()))
	->setViewer(PhabricatorUser::getOmnipotentUser())
	- ->needReviewerStatus(true)
	+ ->needReviewers(true)
	->executeOne();

	$object->revision = $revision;
	$object->setDiff($diff);

	return $object;
	}

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

	protected function loadChangesets() {
	if ($this->changesets === null) {
	$this->changesets = $this->getDiff()->loadChangesets();
	}
	return $this->changesets;
	}

	protected function loadChangesetsWithHunks() {
	$changesets = $this->loadChangesets();

	if ($changesets && !$this->haveHunks) {
	$this->haveHunks = true;

	id(new DifferentialHunkQuery())
	->setViewer(PhabricatorUser::getOmnipotentUser())
	->withChangesets($changesets)
	->needAttachToChangesets(true)
	->execute();
	}

	return $changesets;
	}

	public function loadAffectedPackages() {
	if ($this->affectedPackages === null) {
	$this->affectedPackages = array();

	$repository = $this->loadRepository();
	if ($repository) {
	$packages = PhabricatorOwnersPackage::loadAffectedPackages(
	$repository,
	$this->loadAffectedPaths());
	$this->affectedPackages = $packages;
	}
	}
	return $this->affectedPackages;
	}

	public function loadReviewers() {
	$reviewers = $this->getObject()->getReviewerStatus();
	return mpull($reviewers, 'getReviewerPHID');
	}


	/* -( HarbormasterBuildableAdapterInterface )------------------------------ */


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

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

	public function getQueuedHarbormasterBuildRequests() {
	return $this->buildRequests;
	}

	public function queueHarbormasterBuildRequest(
	HarbormasterBuildRequest $request) {
	$this->buildRequests[] = $request;
	}

	}
	diff --git a/src/applications/differential/mail/DifferentialRevisionMailReceiver.php b/src/applications/differential/mail/DifferentialRevisionMailReceiver.php
	index 6b27c5a371..929ee72647 100644
	--- a/src/applications/differential/mail/DifferentialRevisionMailReceiver.php
	+++ b/src/applications/differential/mail/DifferentialRevisionMailReceiver.php
	@@ -1,31 +1,31 @@
	<?php

	final class DifferentialRevisionMailReceiver
	extends PhabricatorObjectMailReceiver {

	public function isEnabled() {
	return PhabricatorApplication::isClassInstalled(
	'PhabricatorDifferentialApplication');
	}

	protected function getObjectPattern() {
	return 'D[1-9]\d*';
	}

	protected function loadObject($pattern, PhabricatorUser $viewer) {
	$id = (int)trim($pattern, 'D');

	return id(new DifferentialRevisionQuery())
	->setViewer($viewer)
	->withIDs(array($id))
	- ->needReviewerStatus(true)
	+ ->needReviewers(true)
	->needReviewerAuthority(true)
	->needActiveDiffs(true)
	->executeOne();
	}

	protected function getTransactionReplyHandler() {
	return new DifferentialReplyHandler();
	}

	}
	diff --git a/src/applications/differential/query/DifferentialRevisionQuery.php b/src/applications/differential/query/DifferentialRevisionQuery.php
	index 1b60df777a..dd74862b58 100644
	--- a/src/applications/differential/query/DifferentialRevisionQuery.php
	+++ b/src/applications/differential/query/DifferentialRevisionQuery.php
	@@ -1,1057 +1,1057 @@
	<?php

	/**
	* Flexible query API for Differential revisions. Example:
	*
	* // Load open revisions
	* $revisions = id(new DifferentialRevisionQuery())
	* ->withStatus(DifferentialRevisionQuery::STATUS_OPEN)
	* ->execute();
	*
	* @task config Query Configuration
	* @task exec Query Execution
	* @task internal Internals
	*/
	final class DifferentialRevisionQuery
	extends PhabricatorCursorPagedPolicyAwareQuery {

	private $pathIDs = array();

	private $status = 'status-any';
	const STATUS_ANY = 'status-any';
	const STATUS_OPEN = 'status-open';
	const STATUS_ACCEPTED = 'status-accepted';
	const STATUS_NEEDS_REVIEW = 'status-needs-review';
	const STATUS_NEEDS_REVISION = 'status-needs-revision';
	const STATUS_CLOSED = 'status-closed';
	const STATUS_ABANDONED = 'status-abandoned';

	private $authors = array();
	private $draftAuthors = array();
	private $ccs = array();
	private $reviewers = array();
	private $revIDs = array();
	private $commitHashes = array();
	private $commitPHIDs = array();
	private $phids = array();
	private $responsibles = array();
	private $branches = array();
	private $repositoryPHIDs;
	private $updatedEpochMin;
	private $updatedEpochMax;

	const ORDER_MODIFIED = 'order-modified';
	const ORDER_CREATED = 'order-created';

	private $needActiveDiffs = false;
	private $needDiffIDs = false;
	private $needCommitPHIDs = false;
	private $needHashes = false;
	- private $needReviewerStatus = false;
	+ private $needReviewers = false;
	private $needReviewerAuthority;
	private $needDrafts;
	private $needFlags;

	private $buildingGlobalOrder;


	/* -( Query Configuration )------------------------------------------------ */


	/**
	* Filter results to revisions which affect a Diffusion path ID in a given
	* repository. You can call this multiple times to select revisions for
	* several paths.
	*
	* @param int Diffusion repository ID.
	* @param int Diffusion path ID.
	* @return this
	* @task config
	*/
	public function withPath($repository_id, $path_id) {
	$this->pathIDs[] = array(
	'repositoryID' => $repository_id,
	'pathID' => $path_id,
	);
	return $this;
	}

	/**
	* Filter results to revisions authored by one of the given PHIDs. Calling
	* this function will clear anything set by previous calls to
	* @{method:withAuthors}.
	*
	* @param array List of PHIDs of authors
	* @return this
	* @task config
	*/
	public function withAuthors(array $author_phids) {
	$this->authors = $author_phids;
	return $this;
	}

	/**
	* Filter results to revisions which CC one of the listed people. Calling this
	* function will clear anything set by previous calls to @{method:withCCs}.
	*
	* @param array List of PHIDs of subscribers.
	* @return this
	* @task config
	*/
	public function withCCs(array $cc_phids) {
	$this->ccs = $cc_phids;
	return $this;
	}

	/**
	* Filter results to revisions that have one of the provided PHIDs as
	* reviewers. Calling this function will clear anything set by previous calls
	* to @{method:withReviewers}.
	*
	* @param array List of PHIDs of reviewers
	* @return this
	* @task config
	*/
	public function withReviewers(array $reviewer_phids) {
	$this->reviewers = $reviewer_phids;
	return $this;
	}

	/**
	* Filter results to revisions that have one of the provided commit hashes.
	* Calling this function will clear anything set by previous calls to
	* @{method:withCommitHashes}.
	*
	* @param array List of pairs <Class
	* ArcanistDifferentialRevisionHash::HASH_$type constant,
	* hash>
	* @return this
	* @task config
	*/
	public function withCommitHashes(array $commit_hashes) {
	$this->commitHashes = $commit_hashes;
	return $this;
	}

	/**
	* Filter results to revisions that have one of the provided PHIDs as
	* commits. Calling this function will clear anything set by previous calls
	* to @{method:withCommitPHIDs}.
	*
	* @param array List of PHIDs of commits
	* @return this
	* @task config
	*/
	public function withCommitPHIDs(array $commit_phids) {
	$this->commitPHIDs = $commit_phids;
	return $this;
	}

	/**
	* Filter results to revisions with a given status. Provide a class constant,
	* such as `DifferentialRevisionQuery::STATUS_OPEN`.
	*
	* @param const Class STATUS constant, like STATUS_OPEN.
	* @return this
	* @task config
	*/
	public function withStatus($status_constant) {
	$this->status = $status_constant;
	return $this;
	}


	/**
	* Filter results to revisions on given branches.
	*
	* @param list List of branch names.
	* @return this
	* @task config
	*/
	public function withBranches(array $branches) {
	$this->branches = $branches;
	return $this;
	}


	/**
	* Filter results to only return revisions whose ids are in the given set.
	*
	* @param array List of revision ids
	* @return this
	* @task config
	*/
	public function withIDs(array $ids) {
	$this->revIDs = $ids;
	return $this;
	}


	/**
	* Filter results to only return revisions whose PHIDs are in the given set.
	*
	* @param array List of revision PHIDs
	* @return this
	* @task config
	*/
	public function withPHIDs(array $phids) {
	$this->phids = $phids;
	return $this;
	}


	/**
	* Given a set of users, filter results to return only revisions they are
	* responsible for (i.e., they are either authors or reviewers).
	*
	* @param array List of user PHIDs.
	* @return this
	* @task config
	*/
	public function withResponsibleUsers(array $responsible_phids) {
	$this->responsibles = $responsible_phids;
	return $this;
	}


	public function withRepositoryPHIDs(array $repository_phids) {
	$this->repositoryPHIDs = $repository_phids;
	return $this;
	}

	public function withUpdatedEpochBetween($min, $max) {
	$this->updatedEpochMin = $min;
	$this->updatedEpochMax = $max;
	return $this;
	}


	/**
	* Set whether or not the query should load the active diff for each
	* revision.
	*
	* @param bool True to load and attach diffs.
	* @return this
	* @task config
	*/
	public function needActiveDiffs($need_active_diffs) {
	$this->needActiveDiffs = $need_active_diffs;
	return $this;
	}


	/**
	* Set whether or not the query should load the associated commit PHIDs for
	* each revision.
	*
	* @param bool True to load and attach diffs.
	* @return this
	* @task config
	*/
	public function needCommitPHIDs($need_commit_phids) {
	$this->needCommitPHIDs = $need_commit_phids;
	return $this;
	}


	/**
	* Set whether or not the query should load associated diff IDs for each
	* revision.
	*
	* @param bool True to load and attach diff IDs.
	* @return this
	* @task config
	*/
	public function needDiffIDs($need_diff_ids) {
	$this->needDiffIDs = $need_diff_ids;
	return $this;
	}


	/**
	* Set whether or not the query should load associated commit hashes for each
	* revision.
	*
	* @param bool True to load and attach commit hashes.
	* @return this
	* @task config
	*/
	public function needHashes($need_hashes) {
	$this->needHashes = $need_hashes;
	return $this;
	}


	/**
	- * Set whether or not the query should load associated reviewer status.
	+ * Set whether or not the query should load associated reviewers.
	*
	* @param bool True to load and attach reviewers.
	* @return this
	* @task config
	*/
	- public function needReviewerStatus($need_reviewer_status) {
	- $this->needReviewerStatus = $need_reviewer_status;
	+ public function needReviewers($need_reviewers) {
	+ $this->needReviewers = $need_reviewers;
	return $this;
	}


	/**
	* Request information about the viewer's authority to act on behalf of each
	* reviewer. In particular, they have authority to act on behalf of projects
	* they are a member of.
	*
	* @param bool True to load and attach authority.
	* @return this
	* @task config
	*/
	public function needReviewerAuthority($need_reviewer_authority) {
	$this->needReviewerAuthority = $need_reviewer_authority;
	return $this;
	}

	public function needFlags($need_flags) {
	$this->needFlags = $need_flags;
	return $this;
	}

	public function needDrafts($need_drafts) {
	$this->needDrafts = $need_drafts;
	return $this;
	}


	/* -( Query Execution )---------------------------------------------------- */


	public function newResultObject() {
	return new DifferentialRevision();
	}


	/**
	* Execute the query as configured, returning matching
	* @{class:DifferentialRevision} objects.
	*
	* @return list List of matching DifferentialRevision objects.
	* @task exec
	*/
	protected function loadPage() {
	$data = $this->loadData();

	$table = $this->newResultObject();
	return $table->loadAllFromArray($data);
	}

	protected function willFilterPage(array $revisions) {
	$viewer = $this->getViewer();

	$repository_phids = mpull($revisions, 'getRepositoryPHID');
	$repository_phids = array_filter($repository_phids);

	$repositories = array();
	if ($repository_phids) {
	$repositories = id(new PhabricatorRepositoryQuery())
	->setViewer($this->getViewer())
	->withPHIDs($repository_phids)
	->execute();
	$repositories = mpull($repositories, null, 'getPHID');
	}

	// If a revision is associated with a repository:
	//
	// - the viewer must be able to see the repository; or
	// - the viewer must have an automatic view capability.
	//
	// In the latter case, we'll load the revision but not load the repository.

	$can_view = PhabricatorPolicyCapability::CAN_VIEW;
	foreach ($revisions as $key => $revision) {
	$repo_phid = $revision->getRepositoryPHID();
	if (!$repo_phid) {
	// The revision has no associated repository. Attach `null` and move on.
	$revision->attachRepository(null);
	continue;
	}

	$repository = idx($repositories, $repo_phid);
	if ($repository) {
	// The revision has an associated repository, and the viewer can see
	// it. Attach it and move on.
	$revision->attachRepository($repository);
	continue;
	}

	if ($revision->hasAutomaticCapability($can_view, $viewer)) {
	// The revision has an associated repository which the viewer can not
	// see, but the viewer has an automatic capability on this revision.
	// Load the revision without attaching a repository.
	$revision->attachRepository(null);
	continue;
	}

	if ($this->getViewer()->isOmnipotent()) {
	// The viewer is omnipotent. Allow the revision to load even without
	// a repository.
	$revision->attachRepository(null);
	continue;
	}

	// The revision has an associated repository, and the viewer can't see
	// it, and the viewer has no special capabilities. Filter out this
	// revision.
	$this->didRejectResult($revision);
	unset($revisions[$key]);
	}

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

	$table = new DifferentialRevision();
	$conn_r = $table->establishConnection('r');

	if ($this->needCommitPHIDs) {
	$this->loadCommitPHIDs($conn_r, $revisions);
	}

	$need_active = $this->needActiveDiffs;
	$need_ids = $need_active \|\| $this->needDiffIDs;

	if ($need_ids) {
	$this->loadDiffIDs($conn_r, $revisions);
	}

	if ($need_active) {
	$this->loadActiveDiffs($conn_r, $revisions);
	}

	if ($this->needHashes) {
	$this->loadHashes($conn_r, $revisions);
	}

	- if ($this->needReviewerStatus \|\| $this->needReviewerAuthority) {
	+ if ($this->needReviewers \|\| $this->needReviewerAuthority) {
	$this->loadReviewers($conn_r, $revisions);
	}

	return $revisions;
	}

	protected function didFilterPage(array $revisions) {
	$viewer = $this->getViewer();

	if ($this->needFlags) {
	$flags = id(new PhabricatorFlagQuery())
	->setViewer($viewer)
	->withOwnerPHIDs(array($viewer->getPHID()))
	->withObjectPHIDs(mpull($revisions, 'getPHID'))
	->execute();
	$flags = mpull($flags, null, 'getObjectPHID');
	foreach ($revisions as $revision) {
	$revision->attachFlag(
	$viewer,
	idx($flags, $revision->getPHID()));
	}
	}

	if ($this->needDrafts) {
	PhabricatorDraftEngine::attachDrafts(
	$viewer,
	$revisions);
	}

	return $revisions;
	}

	private function loadData() {
	$table = $this->newResultObject();
	$conn_r = $table->establishConnection('r');

	$selects = array();

	// NOTE: If the query includes "responsiblePHIDs", we execute it as a
	// UNION of revisions they own and revisions they're reviewing. This has
	// much better performance than doing it with JOIN/WHERE.
	if ($this->responsibles) {
	$basic_authors = $this->authors;
	$basic_reviewers = $this->reviewers;

	try {
	// Build the query where the responsible users are authors.
	$this->authors = array_merge($basic_authors, $this->responsibles);

	$this->reviewers = $basic_reviewers;
	$selects[] = $this->buildSelectStatement($conn_r);

	// Build the query where the responsible users are reviewers, or
	// projects they are members of are reviewers.
	$this->authors = $basic_authors;
	$this->reviewers = array_merge($basic_reviewers, $this->responsibles);
	$selects[] = $this->buildSelectStatement($conn_r);

	// Put everything back like it was.
	$this->authors = $basic_authors;
	$this->reviewers = $basic_reviewers;
	} catch (Exception $ex) {
	$this->authors = $basic_authors;
	$this->reviewers = $basic_reviewers;
	throw $ex;
	}
	} else {
	$selects[] = $this->buildSelectStatement($conn_r);
	}

	if (count($selects) > 1) {
	$this->buildingGlobalOrder = true;
	$query = qsprintf(
	$conn_r,
	'%Q %Q %Q',
	implode(' UNION DISTINCT ', $selects),
	$this->buildOrderClause($conn_r),
	$this->buildLimitClause($conn_r));
	} else {
	$query = head($selects);
	}

	return queryfx_all($conn_r, '%Q', $query);
	}

	private function buildSelectStatement(AphrontDatabaseConnection $conn_r) {
	$table = new DifferentialRevision();

	$select = $this->buildSelectClause($conn_r);

	$from = qsprintf(
	$conn_r,
	'FROM %T r',
	$table->getTableName());

	$joins = $this->buildJoinsClause($conn_r);
	$where = $this->buildWhereClause($conn_r);
	$group_by = $this->buildGroupClause($conn_r);
	$having = $this->buildHavingClause($conn_r);

	$this->buildingGlobalOrder = false;
	$order_by = $this->buildOrderClause($conn_r);

	$limit = $this->buildLimitClause($conn_r);

	return qsprintf(
	$conn_r,
	'(%Q %Q %Q %Q %Q %Q %Q %Q)',
	$select,
	$from,
	$joins,
	$where,
	$group_by,
	$having,
	$order_by,
	$limit);
	}


	/* -( Internals )---------------------------------------------------------- */


	/**
	* @task internal
	*/
	private function buildJoinsClause($conn_r) {
	$joins = array();
	if ($this->pathIDs) {
	$path_table = new DifferentialAffectedPath();
	$joins[] = qsprintf(
	$conn_r,
	'JOIN %T p ON p.revisionID = r.id',
	$path_table->getTableName());
	}

	if ($this->commitHashes) {
	$joins[] = qsprintf(
	$conn_r,
	'JOIN %T hash_rel ON hash_rel.revisionID = r.id',
	ArcanistDifferentialRevisionHash::TABLE_NAME);
	}

	if ($this->ccs) {
	$joins[] = qsprintf(
	$conn_r,
	'JOIN %T e_ccs ON e_ccs.src = r.phid '.
	'AND e_ccs.type = %s '.
	'AND e_ccs.dst in (%Ls)',
	PhabricatorEdgeConfig::TABLE_NAME_EDGE,
	PhabricatorObjectHasSubscriberEdgeType::EDGECONST,
	$this->ccs);
	}

	if ($this->reviewers) {
	$joins[] = qsprintf(
	$conn_r,
	'JOIN %T reviewer ON reviewer.revisionPHID = r.phid
	AND reviewer.reviewerStatus != %s
	AND reviewer.reviewerPHID in (%Ls)',
	id(new DifferentialReviewer())->getTableName(),
	DifferentialReviewerStatus::STATUS_RESIGNED,
	$this->reviewers);
	}

	if ($this->draftAuthors) {
	$joins[] = qsprintf(
	$conn_r,
	'JOIN %T has_draft ON has_draft.srcPHID = r.phid
	AND has_draft.type = %s
	AND has_draft.dstPHID IN (%Ls)',
	PhabricatorEdgeConfig::TABLE_NAME_EDGE,
	PhabricatorObjectHasDraftEdgeType::EDGECONST,
	$this->draftAuthors);
	}

	if ($this->commitPHIDs) {
	$joins[] = qsprintf(
	$conn_r,
	'JOIN %T commits ON commits.revisionID = r.id',
	DifferentialRevision::TABLE_COMMIT);
	}

	$joins[] = $this->buildJoinClauseParts($conn_r);

	return $this->formatJoinClause($joins);
	}


	/**
	* @task internal
	*/
	protected function buildWhereClause(AphrontDatabaseConnection $conn_r) {
	$where = array();

	if ($this->pathIDs) {
	$path_clauses = array();
	$repo_info = igroup($this->pathIDs, 'repositoryID');
	foreach ($repo_info as $repository_id => $paths) {
	$path_clauses[] = qsprintf(
	$conn_r,
	'(p.repositoryID = %d AND p.pathID IN (%Ld))',
	$repository_id,
	ipull($paths, 'pathID'));
	}
	$path_clauses = '('.implode(' OR ', $path_clauses).')';
	$where[] = $path_clauses;
	}

	if ($this->authors) {
	$where[] = qsprintf(
	$conn_r,
	'r.authorPHID IN (%Ls)',
	$this->authors);
	}

	if ($this->revIDs) {
	$where[] = qsprintf(
	$conn_r,
	'r.id IN (%Ld)',
	$this->revIDs);
	}

	if ($this->repositoryPHIDs) {
	$where[] = qsprintf(
	$conn_r,
	'r.repositoryPHID IN (%Ls)',
	$this->repositoryPHIDs);
	}

	if ($this->commitHashes) {
	$hash_clauses = array();
	foreach ($this->commitHashes as $info) {
	list($type, $hash) = $info;
	$hash_clauses[] = qsprintf(
	$conn_r,
	'(hash_rel.type = %s AND hash_rel.hash = %s)',
	$type,
	$hash);
	}
	$hash_clauses = '('.implode(' OR ', $hash_clauses).')';
	$where[] = $hash_clauses;
	}

	if ($this->commitPHIDs) {
	$where[] = qsprintf(
	$conn_r,
	'commits.commitPHID IN (%Ls)',
	$this->commitPHIDs);
	}

	if ($this->phids) {
	$where[] = qsprintf(
	$conn_r,
	'r.phid IN (%Ls)',
	$this->phids);
	}

	if ($this->branches) {
	$where[] = qsprintf(
	$conn_r,
	'r.branchName in (%Ls)',
	$this->branches);
	}

	if ($this->updatedEpochMin !== null) {
	$where[] = qsprintf(
	$conn_r,
	'r.dateModified >= %d',
	$this->updatedEpochMin);
	}

	if ($this->updatedEpochMax !== null) {
	$where[] = qsprintf(
	$conn_r,
	'r.dateModified <= %d',
	$this->updatedEpochMax);
	}

	// NOTE: Although the status constants are integers in PHP, the column is a
	// string column in MySQL, and MySQL won't use keys on string columns if
	// you put integers in the query.

	switch ($this->status) {
	case self::STATUS_ANY:
	break;
	case self::STATUS_OPEN:
	$where[] = qsprintf(
	$conn_r,
	'r.status IN (%Ls)',
	DifferentialRevisionStatus::getOpenStatuses());
	break;
	case self::STATUS_NEEDS_REVIEW:
	$where[] = qsprintf(
	$conn_r,
	'r.status IN (%Ls)',
	array(
	ArcanistDifferentialRevisionStatus::NEEDS_REVIEW,
	));
	break;
	case self::STATUS_NEEDS_REVISION:
	$where[] = qsprintf(
	$conn_r,
	'r.status IN (%Ls)',
	array(
	ArcanistDifferentialRevisionStatus::NEEDS_REVISION,
	));
	break;
	case self::STATUS_ACCEPTED:
	$where[] = qsprintf(
	$conn_r,
	'r.status IN (%Ls)',
	array(
	ArcanistDifferentialRevisionStatus::ACCEPTED,
	));
	break;
	case self::STATUS_CLOSED:
	$where[] = qsprintf(
	$conn_r,
	'r.status IN (%Ls)',
	DifferentialRevisionStatus::getClosedStatuses());
	break;
	case self::STATUS_ABANDONED:
	$where[] = qsprintf(
	$conn_r,
	'r.status IN (%Ls)',
	array(
	ArcanistDifferentialRevisionStatus::ABANDONED,
	));
	break;
	default:
	throw new Exception(
	pht("Unknown revision status filter constant '%s'!", $this->status));
	}

	$where[] = $this->buildWhereClauseParts($conn_r);
	return $this->formatWhereClause($where);
	}


	/**
	* @task internal
	*/
	protected function shouldGroupQueryResultRows() {

	$join_triggers = array_merge(
	$this->pathIDs,
	$this->ccs,
	$this->reviewers);

	if (count($join_triggers) > 1) {
	return true;
	}

	return parent::shouldGroupQueryResultRows();
	}

	public function getBuiltinOrders() {
	$orders = parent::getBuiltinOrders() + array(
	'updated' => array(
	'vector' => array('updated', 'id'),
	'name' => pht('Date Updated (Latest First)'),
	'aliases' => array(self::ORDER_MODIFIED),
	),
	'outdated' => array(
	'vector' => array('-updated', '-id'),
	'name' => pht('Date Updated (Oldest First)'),
	),
	);

	// Alias the "newest" builtin to the historical key for it.
	$orders['newest']['aliases'][] = self::ORDER_CREATED;

	return $orders;
	}

	protected function getDefaultOrderVector() {
	return array('updated', 'id');
	}

	public function getOrderableColumns() {
	$primary = ($this->buildingGlobalOrder ? null : 'r');

	return array(
	'id' => array(
	'table' => $primary,
	'column' => 'id',
	'type' => 'int',
	'unique' => true,
	),
	'updated' => array(
	'table' => $primary,
	'column' => 'dateModified',
	'type' => 'int',
	),
	);
	}

	protected function getPagingValueMap($cursor, array $keys) {
	$revision = $this->loadCursorObject($cursor);
	return array(
	'id' => $revision->getID(),
	'updated' => $revision->getDateModified(),
	);
	}

	private function loadCommitPHIDs($conn_r, array $revisions) {
	assert_instances_of($revisions, 'DifferentialRevision');
	$commit_phids = queryfx_all(
	$conn_r,
	'SELECT * FROM %T WHERE revisionID IN (%Ld)',
	DifferentialRevision::TABLE_COMMIT,
	mpull($revisions, 'getID'));
	$commit_phids = igroup($commit_phids, 'revisionID');
	foreach ($revisions as $revision) {
	$phids = idx($commit_phids, $revision->getID(), array());
	$phids = ipull($phids, 'commitPHID');
	$revision->attachCommitPHIDs($phids);
	}
	}

	private function loadDiffIDs($conn_r, array $revisions) {
	assert_instances_of($revisions, 'DifferentialRevision');

	$diff_table = new DifferentialDiff();

	$diff_ids = queryfx_all(
	$conn_r,
	'SELECT revisionID, id FROM %T WHERE revisionID IN (%Ld)
	ORDER BY id DESC',
	$diff_table->getTableName(),
	mpull($revisions, 'getID'));
	$diff_ids = igroup($diff_ids, 'revisionID');

	foreach ($revisions as $revision) {
	$ids = idx($diff_ids, $revision->getID(), array());
	$ids = ipull($ids, 'id');
	$revision->attachDiffIDs($ids);
	}
	}

	private function loadActiveDiffs($conn_r, array $revisions) {
	assert_instances_of($revisions, 'DifferentialRevision');

	$diff_table = new DifferentialDiff();

	$load_ids = array();
	foreach ($revisions as $revision) {
	$diffs = $revision->getDiffIDs();
	if ($diffs) {
	$load_ids[] = max($diffs);
	}
	}

	$active_diffs = array();
	if ($load_ids) {
	$active_diffs = $diff_table->loadAllWhere(
	'id IN (%Ld)',
	$load_ids);
	}

	$active_diffs = mpull($active_diffs, null, 'getRevisionID');
	foreach ($revisions as $revision) {
	$revision->attachActiveDiff(idx($active_diffs, $revision->getID()));
	}
	}

	private function loadHashes(
	AphrontDatabaseConnection $conn_r,
	array $revisions) {
	assert_instances_of($revisions, 'DifferentialRevision');

	$data = queryfx_all(
	$conn_r,
	'SELECT * FROM %T WHERE revisionID IN (%Ld)',
	'differential_revisionhash',
	mpull($revisions, 'getID'));

	$data = igroup($data, 'revisionID');
	foreach ($revisions as $revision) {
	$hashes = idx($data, $revision->getID(), array());
	$list = array();
	foreach ($hashes as $hash) {
	$list[] = array($hash['type'], $hash['hash']);
	}
	$revision->attachHashes($list);
	}
	}

	private function loadReviewers(
	AphrontDatabaseConnection $conn,
	array $revisions) {

	assert_instances_of($revisions, 'DifferentialRevision');

	$reviewer_table = new DifferentialReviewer();
	$reviewer_rows = queryfx_all(
	$conn,
	'SELECT * FROM %T WHERE revisionPHID IN (%Ls)
	ORDER BY id ASC',
	$reviewer_table->getTableName(),
	mpull($revisions, 'getPHID'));
	$reviewer_list = $reviewer_table->loadAllFromArray($reviewer_rows);
	$reviewer_map = mgroup($reviewer_list, 'getRevisionPHID');

	foreach ($reviewer_map as $key => $reviewers) {
	$reviewer_map[$key] = mpull($reviewers, null, 'getReviewerPHID');
	}

	$viewer = $this->getViewer();
	$viewer_phid = $viewer->getPHID();

	$allow_key = 'differential.allow-self-accept';
	$allow_self = PhabricatorEnv::getEnvConfig($allow_key);

	// Figure out which of these reviewers the viewer has authority to act as.
	if ($this->needReviewerAuthority && $viewer_phid) {
	$authority = $this->loadReviewerAuthority(
	$revisions,
	$reviewer_map,
	$allow_self);
	}

	foreach ($revisions as $revision) {
	$reviewers = idx($reviewer_map, $revision->getPHID(), array());
	foreach ($reviewers as $reviewer_phid => $reviewer) {
	if ($this->needReviewerAuthority) {
	if (!$viewer_phid) {
	// Logged-out users never have authority.
	$has_authority = false;
	} else if ((!$allow_self) &&
	($revision->getAuthorPHID() == $viewer_phid)) {
	// The author can never have authority unless we allow self-accept.
	$has_authority = false;
	} else {
	// Otherwise, look up whether the viewer has authority.
	$has_authority = isset($authority[$reviewer_phid]);
	}

	$reviewer->attachAuthority($viewer, $has_authority);
	}

	$reviewers[$reviewer_phid] = $reviewer;
	}

	$revision->attachReviewerStatus($reviewers);
	}
	}

	private function loadReviewerAuthority(
	array $revisions,
	array $reviewers,
	$allow_self) {

	$revision_map = mpull($revisions, null, 'getPHID');
	$viewer_phid = $this->getViewer()->getPHID();

	// Find all the project/package reviewers which the user may have authority
	// over.
	$project_phids = array();
	$package_phids = array();
	$project_type = PhabricatorProjectProjectPHIDType::TYPECONST;
	$package_type = PhabricatorOwnersPackagePHIDType::TYPECONST;

	$edge_type = DifferentialRevisionHasReviewerEdgeType::EDGECONST;
	foreach ($reviewers as $revision_phid => $reviewer_list) {
	if (!$allow_self) {
	if ($revision_map[$revision_phid]->getAuthorPHID() == $viewer_phid) {
	// If self-review isn't permitted, the user will never have
	// authority over projects on revisions they authored because you
	// can't accept your own revisions, so we don't need to load any
	// data about these reviewers.
	continue;
	}
	}

	foreach ($reviewer_list as $reviewer_phid => $reviewer) {
	$phid_type = phid_get_type($reviewer_phid);
	if ($phid_type == $project_type) {
	$project_phids[] = $reviewer_phid;
	}
	if ($phid_type == $package_type) {
	$package_phids[] = $reviewer_phid;
	}
	}
	}

	// The viewer has authority over themselves.
	$user_authority = array_fuse(array($viewer_phid));

	// And over any projects they are a member of.
	$project_authority = array();
	if ($project_phids) {
	$project_authority = id(new PhabricatorProjectQuery())
	->setViewer($this->getViewer())
	->withPHIDs($project_phids)
	->withMemberPHIDs(array($viewer_phid))
	->execute();
	$project_authority = mpull($project_authority, 'getPHID');
	$project_authority = array_fuse($project_authority);
	}

	// And over any packages they own.
	$package_authority = array();
	if ($package_phids) {
	$package_authority = id(new PhabricatorOwnersPackageQuery())
	->setViewer($this->getViewer())
	->withPHIDs($package_phids)
	->withAuthorityPHIDs(array($viewer_phid))
	->execute();
	$package_authority = mpull($package_authority, 'getPHID');
	$package_authority = array_fuse($package_authority);
	}

	return $user_authority + $project_authority + $package_authority;
	}

	public function getQueryApplicationClass() {
	return 'PhabricatorDifferentialApplication';
	}

	protected function getPrimaryTableAlias() {
	return 'r';
	}

	}
	diff --git a/src/applications/differential/query/DifferentialRevisionSearchEngine.php b/src/applications/differential/query/DifferentialRevisionSearchEngine.php
	index 2c40be4813..a925878bda 100644
	--- a/src/applications/differential/query/DifferentialRevisionSearchEngine.php
	+++ b/src/applications/differential/query/DifferentialRevisionSearchEngine.php
	@@ -1,280 +1,280 @@
	<?php

	final class DifferentialRevisionSearchEngine
	extends PhabricatorApplicationSearchEngine {

	public function getResultTypeDescription() {
	return pht('Differential Revisions');
	}

	public function getApplicationClassName() {
	return 'PhabricatorDifferentialApplication';
	}

	protected function newResultBuckets() {
	return DifferentialRevisionResultBucket::getAllResultBuckets();
	}

	public function newQuery() {
	return id(new DifferentialRevisionQuery())
	->needFlags(true)
	->needDrafts(true)
	- ->needReviewerStatus(true);
	+ ->needReviewers(true);
	}

	protected function buildQueryFromParameters(array $map) {
	$query = $this->newQuery();

	if ($map['responsiblePHIDs']) {
	$query->withResponsibleUsers($map['responsiblePHIDs']);
	}

	if ($map['authorPHIDs']) {
	$query->withAuthors($map['authorPHIDs']);
	}

	if ($map['reviewerPHIDs']) {
	$query->withReviewers($map['reviewerPHIDs']);
	}

	if ($map['repositoryPHIDs']) {
	$query->withRepositoryPHIDs($map['repositoryPHIDs']);
	}

	if ($map['status']) {
	$query->withStatus($map['status']);
	}

	return $query;
	}

	protected function buildCustomSearchFields() {
	return array(
	id(new PhabricatorSearchDatasourceField())
	->setLabel(pht('Responsible Users'))
	->setKey('responsiblePHIDs')
	->setAliases(array('responsiblePHID', 'responsibles', 'responsible'))
	->setDatasource(new DifferentialResponsibleDatasource())
	->setDescription(
	pht('Find revisions that a given user is responsible for.')),
	id(new PhabricatorUsersSearchField())
	->setLabel(pht('Authors'))
	->setKey('authorPHIDs')
	->setAliases(array('author', 'authors', 'authorPHID'))
	->setDescription(
	pht('Find revisions with specific authors.')),
	id(new PhabricatorSearchDatasourceField())
	->setLabel(pht('Reviewers'))
	->setKey('reviewerPHIDs')
	->setAliases(array('reviewer', 'reviewers', 'reviewerPHID'))
	->setDatasource(new DiffusionAuditorFunctionDatasource())
	->setDescription(
	pht('Find revisions with specific reviewers.')),
	id(new PhabricatorSearchDatasourceField())
	->setLabel(pht('Repositories'))
	->setKey('repositoryPHIDs')
	->setAliases(array('repository', 'repositories', 'repositoryPHID'))
	->setDatasource(new DiffusionRepositoryFunctionDatasource())
	->setDescription(
	pht('Find revisions from specific repositories.')),
	id(new PhabricatorSearchSelectField())
	->setLabel(pht('Status'))
	->setKey('status')
	->setOptions($this->getStatusOptions())
	->setDescription(
	pht('Find revisions with particular statuses.')),
	);
	}

	protected function getURI($path) {
	return '/differential/'.$path;
	}

	protected function getBuiltinQueryNames() {
	$names = array();

	if ($this->requireViewer()->isLoggedIn()) {
	$names['active'] = pht('Active Revisions');
	$names['authored'] = pht('Authored');
	}

	$names['all'] = pht('All Revisions');

	return $names;
	}

	public function buildSavedQueryFromBuiltin($query_key) {
	$query = $this->newSavedQuery();
	$query->setQueryKey($query_key);

	$viewer = $this->requireViewer();

	switch ($query_key) {
	case 'active':
	$bucket_key = DifferentialRevisionRequiredActionResultBucket::BUCKETKEY;

	return $query
	->setParameter('responsiblePHIDs', array($viewer->getPHID()))
	->setParameter('status', DifferentialRevisionQuery::STATUS_OPEN)
	->setParameter('bucket', $bucket_key);
	case 'authored':
	return $query
	->setParameter('authorPHIDs', array($viewer->getPHID()));
	case 'all':
	return $query;
	}

	return parent::buildSavedQueryFromBuiltin($query_key);
	}

	private function getStatusOptions() {
	return array(
	DifferentialRevisionQuery::STATUS_ANY => pht('All'),
	DifferentialRevisionQuery::STATUS_OPEN => pht('Open'),
	DifferentialRevisionQuery::STATUS_ACCEPTED => pht('Accepted'),
	DifferentialRevisionQuery::STATUS_NEEDS_REVIEW => pht('Needs Review'),
	DifferentialRevisionQuery::STATUS_NEEDS_REVISION => pht('Needs Revision'),
	DifferentialRevisionQuery::STATUS_CLOSED => pht('Closed'),
	DifferentialRevisionQuery::STATUS_ABANDONED => pht('Abandoned'),
	);
	}

	protected function renderResultList(
	array $revisions,
	PhabricatorSavedQuery $query,
	array $handles) {
	assert_instances_of($revisions, 'DifferentialRevision');

	$viewer = $this->requireViewer();
	$template = id(new DifferentialRevisionListView())
	->setUser($viewer)
	->setNoBox($this->isPanelContext());

	$bucket = $this->getResultBucket($query);

	$unlanded = $this->loadUnlandedDependencies($revisions);

	$views = array();
	if ($bucket) {
	$bucket->setViewer($viewer);

	try {
	$groups = $bucket->newResultGroups($query, $revisions);

	foreach ($groups as $group) {
	$views[] = id(clone $template)
	->setHeader($group->getName())
	->setNoDataString($group->getNoDataString())
	->setRevisions($group->getObjects());
	}
	} catch (Exception $ex) {
	$this->addError($ex->getMessage());
	}
	} else {
	$views[] = id(clone $template)
	->setRevisions($revisions)
	->setHandles(array());
	}

	$phids = array_mergev(mpull($views, 'getRequiredHandlePHIDs'));
	if ($phids) {
	$handles = id(new PhabricatorHandleQuery())
	->setViewer($viewer)
	->withPHIDs($phids)
	->execute();
	} else {
	$handles = array();
	}

	foreach ($views as $view) {
	$view->setHandles($handles);
	$view->setUnlandedDependencies($unlanded);
	}

	if (count($views) == 1) {
	// Reduce this to a PHUIObjectItemListView so we can get the free
	// support from ApplicationSearch.
	$list = head($views)->render();
	} else {
	$list = $views;
	}

	$result = new PhabricatorApplicationSearchResultView();
	$result->setContent($list);

	return $result;
	}

	protected function getNewUserBody() {
	$create_button = id(new PHUIButtonView())
	->setTag('a')
	->setText(pht('Create a Diff'))
	->setHref('/differential/diff/create/')
	->setColor(PHUIButtonView::GREEN);

	$icon = $this->getApplication()->getIcon();
	$app_name = $this->getApplication()->getName();
	$view = id(new PHUIBigInfoView())
	->setIcon($icon)
	->setTitle(pht('Welcome to %s', $app_name))
	->setDescription(
	pht('Pre-commit code review. Revisions that are waiting on your input '.
	'will appear here.'))
	->addAction($create_button);

	return $view;
	}

	private function loadUnlandedDependencies(array $revisions) {
	$status_accepted = ArcanistDifferentialRevisionStatus::ACCEPTED;

	$phids = array();
	foreach ($revisions as $revision) {
	if ($revision->getStatus() != $status_accepted) {
	continue;
	}

	$phids[] = $revision->getPHID();
	}

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

	$query = id(new PhabricatorEdgeQuery())
	->withSourcePHIDs($phids)
	->withEdgeTypes(
	array(
	DifferentialRevisionDependsOnRevisionEdgeType::EDGECONST,
	));

	$query->execute();

	$revision_phids = $query->getDestinationPHIDs();
	if (!$revision_phids) {
	return array();
	}

	$viewer = $this->requireViewer();

	$blocking_revisions = id(new DifferentialRevisionQuery())
	->setViewer($viewer)
	->withPHIDs($revision_phids)
	->withStatus(DifferentialRevisionQuery::STATUS_OPEN)
	->execute();
	$blocking_revisions = mpull($blocking_revisions, null, 'getPHID');

	$result = array();
	foreach ($revisions as $revision) {
	$revision_phid = $revision->getPHID();
	$blocking_phids = $query->getDestinationPHIDs(array($revision_phid));
	$blocking = array_select_keys($blocking_revisions, $blocking_phids);
	if ($blocking) {
	$result[$revision_phid] = $blocking;
	}
	}

	return $result;
	}

	}
	diff --git a/src/applications/differential/search/DifferentialRevisionFulltextEngine.php b/src/applications/differential/search/DifferentialRevisionFulltextEngine.php
	index 60d267fe71..f012c59fbe 100644
	--- a/src/applications/differential/search/DifferentialRevisionFulltextEngine.php
	+++ b/src/applications/differential/search/DifferentialRevisionFulltextEngine.php
	@@ -1,64 +1,64 @@
	<?php

	final class DifferentialRevisionFulltextEngine
	extends PhabricatorFulltextEngine {

	protected function buildAbstractDocument(
	PhabricatorSearchAbstractDocument $document,
	$object) {

	$revision = id(new DifferentialRevisionQuery())
	->setViewer($this->getViewer())
	->withPHIDs(array($object->getPHID()))
	- ->needReviewerStatus(true)
	+ ->needReviewers(true)
	->executeOne();

	// TODO: This isn't very clean, but custom fields currently rely on it.
	$object->attachReviewerStatus($revision->getReviewerStatus());

	$document->setDocumentTitle($revision->getTitle());

	$document->addRelationship(
	PhabricatorSearchRelationship::RELATIONSHIP_AUTHOR,
	$revision->getAuthorPHID(),
	PhabricatorPeopleUserPHIDType::TYPECONST,
	$revision->getDateCreated());

	$document->addRelationship(
	$revision->isClosed()
	? PhabricatorSearchRelationship::RELATIONSHIP_CLOSED
	: PhabricatorSearchRelationship::RELATIONSHIP_OPEN,
	$revision->getPHID(),
	DifferentialRevisionPHIDType::TYPECONST,
	PhabricatorTime::getNow());

	// If a revision needs review, the owners are the reviewers. Otherwise, the
	// owner is the author (e.g., accepted, rejected, closed).
	$status_review = ArcanistDifferentialRevisionStatus::NEEDS_REVIEW;
	if ($revision->getStatus() == $status_review) {
	$reviewers = $revision->getReviewerStatus();
	$reviewers = mpull($reviewers, 'getReviewerPHID', 'getReviewerPHID');
	if ($reviewers) {
	foreach ($reviewers as $phid) {
	$document->addRelationship(
	PhabricatorSearchRelationship::RELATIONSHIP_OWNER,
	$phid,
	PhabricatorPeopleUserPHIDType::TYPECONST,
	$revision->getDateModified()); // Bogus timestamp.
	}
	} else {
	$document->addRelationship(
	PhabricatorSearchRelationship::RELATIONSHIP_UNOWNED,
	$revision->getPHID(),
	PhabricatorPeopleUserPHIDType::TYPECONST,
	$revision->getDateModified()); // Bogus timestamp.
	}
	} else {
	$document->addRelationship(
	PhabricatorSearchRelationship::RELATIONSHIP_OWNER,
	$revision->getAuthorPHID(),
	PhabricatorPHIDConstants::PHID_TYPE_VOID,
	$revision->getDateCreated());
	}
	}
	}
	diff --git a/src/applications/differential/storage/DifferentialRevision.php b/src/applications/differential/storage/DifferentialRevision.php
	index 062503451f..61210ac647 100644
	--- a/src/applications/differential/storage/DifferentialRevision.php
	+++ b/src/applications/differential/storage/DifferentialRevision.php
	@@ -1,682 +1,682 @@
	<?php

	final class DifferentialRevision extends DifferentialDAO
	implements
	PhabricatorTokenReceiverInterface,
	PhabricatorPolicyInterface,
	PhabricatorExtendedPolicyInterface,
	PhabricatorFlaggableInterface,
	PhrequentTrackableInterface,
	HarbormasterBuildableInterface,
	PhabricatorSubscribableInterface,
	PhabricatorCustomFieldInterface,
	PhabricatorApplicationTransactionInterface,
	PhabricatorMentionableInterface,
	PhabricatorDestructibleInterface,
	PhabricatorProjectInterface,
	PhabricatorFulltextInterface,
	PhabricatorConduitResultInterface,
	PhabricatorDraftInterface {

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

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

	protected $authorPHID;
	protected $lastReviewerPHID;

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

	protected $mailKey;
	protected $branchName;
	protected $repositoryPHID;
	protected $viewPolicy = PhabricatorPolicies::POLICY_USER;
	protected $editPolicy = PhabricatorPolicies::POLICY_USER;
	protected $properties = array();

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

	const PROPERTY_CLOSED_FROM_ACCEPTED = 'wasAcceptedBeforeClose';

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

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

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

	protected function getConfiguration() {
	return array(
	self::CONFIG_AUX_PHID => true,
	self::CONFIG_SERIALIZATION => array(
	'attached' => self::SERIALIZATION_JSON,
	'unsubscribed' => self::SERIALIZATION_JSON,
	'properties' => self::SERIALIZATION_JSON,
	),
	self::CONFIG_COLUMN_SCHEMA => array(
	'title' => 'text255',
	'originalTitle' => 'text255',
	'status' => 'text32',
	'summary' => 'text',
	'testPlan' => 'text',
	'authorPHID' => 'phid?',
	'lastReviewerPHID' => 'phid?',
	'lineCount' => 'uint32?',
	'mailKey' => 'bytes40',
	'branchName' => 'text255?',
	'repositoryPHID' => 'phid?',
	),
	self::CONFIG_KEY_SCHEMA => array(
	'key_phid' => null,
	'phid' => array(
	'columns' => array('phid'),
	'unique' => true,
	),
	'authorPHID' => array(
	'columns' => array('authorPHID', 'status'),
	),
	'repositoryPHID' => array(
	'columns' => array('repositoryPHID'),
	),
	// If you (or a project you are a member of) is reviewing a significant
	// fraction of the revisions on an install, the result set of open
	// revisions may be smaller than the result set of revisions where you
	// are a reviewer. In these cases, this key is better than keys on the
	// edge table.
	'key_status' => array(
	'columns' => array('status', 'phid'),
	),
	),
	) + parent::getConfiguration();
	}

	public function setProperty($key, $value) {
	$this->properties[$key] = $value;
	return $this;
	}

	public function getProperty($key, $default = null) {
	return idx($this->properties, $key, $default);
	}

	public function hasRevisionProperty($key) {
	return array_key_exists($key, $this->properties);
	}

	public function getMonogram() {
	$id = $this->getID();
	return "D{$id}";
	}

	public function getURI() {
	return '/'.$this->getMonogram();
	}

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

	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 getHashes() {
	return $this->assertAttached($this->hashes);
	}

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


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


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


	/* -( PhabricatorExtendedPolicyInterface )--------------------------------- */


	public function getExtendedPolicy($capability, PhabricatorUser $viewer) {
	$extended = array();

	switch ($capability) {
	case PhabricatorPolicyCapability::CAN_VIEW:
	$repository_phid = $this->getRepositoryPHID();
	$repository = $this->getRepository();

	// Try to use the object if we have it, since it will save us some
	// data fetching later on. In some cases, we might not have it.
	$repository_ref = nonempty($repository, $repository_phid);
	if ($repository_ref) {
	$extended[] = array(
	$repository_ref,
	PhabricatorPolicyCapability::CAN_VIEW,
	);
	}
	break;
	}

	return $extended;
	}


	/* -( PhabricatorTokenReceiverInterface )---------------------------------- */


	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 getReviewerPHIDs() {
	$reviewers = $this->getReviewerStatus();
	return mpull($reviewers, 'getReviewerPHID');
	}

	public function getReviewerPHIDsForEdit() {
	$reviewers = $this->getReviewerStatus();

	$status_blocking = DifferentialReviewerStatus::STATUS_BLOCKING;

	$value = array();
	foreach ($reviewers as $reviewer) {
	$phid = $reviewer->getReviewerPHID();
	if ($reviewer->getStatus() == $status_blocking) {
	$value[] = 'blocking('.$phid.')';
	} else {
	$value[] = $phid;
	}
	}

	return $value;
	}

	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 isAbandoned() {
	$status_abandoned = ArcanistDifferentialRevisionStatus::ABANDONED;
	return ($this->getStatus() == $status_abandoned);
	}

	public function isAccepted() {
	$status_accepted = ArcanistDifferentialRevisionStatus::ACCEPTED;
	return ($this->getStatus() == $status_accepted);
	}

	public function getStatusIcon() {
	$map = array(
	ArcanistDifferentialRevisionStatus::NEEDS_REVIEW
	=> 'fa-code grey',
	ArcanistDifferentialRevisionStatus::NEEDS_REVISION
	=> 'fa-refresh red',
	ArcanistDifferentialRevisionStatus::CHANGES_PLANNED
	=> 'fa-headphones red',
	ArcanistDifferentialRevisionStatus::ACCEPTED
	=> 'fa-check green',
	ArcanistDifferentialRevisionStatus::CLOSED
	=> 'fa-check-square-o black',
	ArcanistDifferentialRevisionStatus::ABANDONED
	=> 'fa-plane black',
	);

	return idx($map, $this->getStatus());
	}

	public function getStatusDisplayName() {
	$status = $this->getStatus();
	return ArcanistDifferentialRevisionStatus::getNameForRevisionStatus(
	$status);
	}

	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 getHasDraft(PhabricatorUser $viewer) {
	return $this->assertAttachedKey($this->drafts, $viewer->getCacheFragment());
	}

	public function attachHasDraft(PhabricatorUser $viewer, $has_draft) {
	$this->drafts[$viewer->getCacheFragment()] = $has_draft;
	return $this;
	}


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


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

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

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

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

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

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


	/* -( 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)
	+ ->needReviewers(true)
	->executeOne()
	->getReviewerStatus();
	} else {
	$reviewers = $this->getReviewerStatus();
	}

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

	return false;
	}


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


	public function getCustomFieldSpecificationForRole($role) {
	return PhabricatorEnv::getEnvConfig('differential.fields');
	}

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

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

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


	/* -( PhabricatorApplicationTransactionInterface )------------------------- */


	public function getApplicationTransactionEditor() {
	return new DifferentialTransactionEditor();
	}

	public function getApplicationTransactionObject() {
	return $this;
	}

	public function getApplicationTransactionTemplate() {
	return new DifferentialTransaction();
	}

	public function willRenderTimeline(
	PhabricatorApplicationTransactionView $timeline,
	AphrontRequest $request) {
	$viewer = $request->getViewer();

	$render_data = $timeline->getRenderData();
	$left = $request->getInt('left', idx($render_data, 'left'));
	$right = $request->getInt('right', idx($render_data, 'right'));

	$diffs = id(new DifferentialDiffQuery())
	->setViewer($request->getUser())
	->withIDs(array($left, $right))
	->execute();
	$diffs = mpull($diffs, null, 'getID');
	$left_diff = $diffs[$left];
	$right_diff = $diffs[$right];

	$old_ids = $request->getStr('old', idx($render_data, 'old'));
	$new_ids = $request->getStr('new', idx($render_data, 'new'));
	$old_ids = array_filter(explode(',', $old_ids));
	$new_ids = array_filter(explode(',', $new_ids));

	$type_inline = DifferentialTransaction::TYPE_INLINE;
	$changeset_ids = array_merge($old_ids, $new_ids);
	$inlines = array();
	foreach ($timeline->getTransactions() as $xaction) {
	if ($xaction->getTransactionType() == $type_inline) {
	$inlines[] = $xaction->getComment();
	$changeset_ids[] = $xaction->getComment()->getChangesetID();
	}
	}

	if ($changeset_ids) {
	$changesets = id(new DifferentialChangesetQuery())
	->setViewer($request->getUser())
	->withIDs($changeset_ids)
	->execute();
	$changesets = mpull($changesets, null, 'getID');
	} else {
	$changesets = array();
	}

	foreach ($inlines as $key => $inline) {
	$inlines[$key] = DifferentialInlineComment::newFromModernComment(
	$inline);
	}

	$query = id(new DifferentialInlineCommentQuery())
	->needHidden(true)
	->setViewer($viewer);

	// NOTE: This is a bit sketchy: this method adjusts the inlines as a
	// side effect, which means it will ultimately adjust the transaction
	// comments and affect timeline rendering.
	$query->adjustInlinesForChangesets(
	$inlines,
	array_select_keys($changesets, $old_ids),
	array_select_keys($changesets, $new_ids),
	$this);

	return $timeline
	->setChangesets($changesets)
	->setRevision($this)
	->setLeftDiff($left_diff)
	->setRightDiff($right_diff);
	}


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


	public function destroyObjectPermanently(
	PhabricatorDestructionEngine $engine) {

	$this->openTransaction();
	$diffs = id(new DifferentialDiffQuery())
	->setViewer($engine->getViewer())
	->withRevisionIDs(array($this->getID()))
	->execute();
	foreach ($diffs as $diff) {
	$engine->destroyObject($diff);
	}

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

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

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

	$this->delete();
	$this->saveTransaction();
	}


	/* -( PhabricatorFulltextInterface )--------------------------------------- */


	public function newFulltextEngine() {
	return new DifferentialRevisionFulltextEngine();
	}


	/* -( PhabricatorConduitResultInterface )---------------------------------- */


	public function getFieldSpecificationsForConduit() {
	return array(
	id(new PhabricatorConduitSearchFieldSpecification())
	->setKey('title')
	->setType('string')
	->setDescription(pht('The revision title.')),
	id(new PhabricatorConduitSearchFieldSpecification())
	->setKey('authorPHID')
	->setType('phid')
	->setDescription(pht('Revision author PHID.')),
	);
	}

	public function getFieldValuesForConduit() {
	return array(
	'title' => $this->getTitle(),
	'authorPHID' => $this->getAuthorPHID(),
	);
	}

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


	/* -( PhabricatorDraftInterface )------------------------------------------ */


	public function newDraftEngine() {
	return new DifferentialRevisionDraftEngine();
	}

	}
	diff --git a/src/applications/diffusion/controller/DiffusionBrowseController.php b/src/applications/diffusion/controller/DiffusionBrowseController.php
	index dc0131356d..b29dcf3d1e 100644
	--- a/src/applications/diffusion/controller/DiffusionBrowseController.php
	+++ b/src/applications/diffusion/controller/DiffusionBrowseController.php
	@@ -1,2022 +1,2022 @@
	<?php

	final class DiffusionBrowseController extends DiffusionController {

	private $lintCommit;
	private $lintMessages;
	private $coverage;

	public function shouldAllowPublic() {
	return true;
	}

	public function handleRequest(AphrontRequest $request) {
	$response = $this->loadDiffusionContext();
	if ($response) {
	return $response;
	}

	$drequest = $this->getDiffusionRequest();

	// Figure out if we're browsing a directory, a file, or a search result
	// list.

	$grep = $request->getStr('grep');
	$find = $request->getStr('find');
	if (strlen($grep) \|\| strlen($find)) {
	return $this->browseSearch();
	}

	$pager = id(new PHUIPagerView())
	->readFromRequest($request);

	$results = DiffusionBrowseResultSet::newFromConduit(
	$this->callConduitWithDiffusionRequest(
	'diffusion.browsequery',
	array(
	'path' => $drequest->getPath(),
	'commit' => $drequest->getStableCommit(),
	'offset' => $pager->getOffset(),
	'limit' => $pager->getPageSize() + 1,
	)));

	$reason = $results->getReasonForEmptyResultSet();
	$is_file = ($reason == DiffusionBrowseResultSet::REASON_IS_FILE);

	if ($is_file) {
	return $this->browseFile();
	} else {
	$paths = $results->getPaths();
	$paths = $pager->sliceResults($paths);
	$results->setPaths($paths);

	return $this->browseDirectory($results, $pager);
	}
	}

	private function browseSearch() {
	$drequest = $this->getDiffusionRequest();
	$header = $this->buildHeaderView($drequest);

	$search_form = $this->renderSearchForm();
	$search_results = $this->renderSearchResults();

	$search_form = id(new PHUIObjectBoxView())
	->setHeaderText(pht('Search'))
	->setBackground(PHUIObjectBoxView::BLUE_PROPERTY)
	->appendChild($search_form);

	$crumbs = $this->buildCrumbs(
	array(
	'branch' => true,
	'path' => true,
	'view' => 'browse',
	));
	$crumbs->setBorder(true);

	$view = id(new PHUITwoColumnView())
	->setHeader($header)
	->setFooter(
	array(
	$search_form,
	$search_results,
	));

	return $this->newPage()
	->setTitle(
	array(
	nonempty(basename($drequest->getPath()), '/'),
	$drequest->getRepository()->getDisplayName(),
	))
	->setCrumbs($crumbs)
	->appendChild($view);
	}

	private function browseFile() {
	$viewer = $this->getViewer();
	$request = $this->getRequest();
	$drequest = $this->getDiffusionRequest();
	$repository = $drequest->getRepository();

	$before = $request->getStr('before');
	if ($before) {
	return $this->buildBeforeResponse($before);
	}

	$path = $drequest->getPath();

	$blame_key = PhabricatorDiffusionBlameSetting::SETTINGKEY;

	$show_blame = $request->getBool(
	'blame',
	$viewer->getUserSetting($blame_key));

	$view = $request->getStr('view');
	if ($request->isFormPost() && $view != 'raw' && $viewer->isLoggedIn()) {
	$preferences = PhabricatorUserPreferences::loadUserPreferences($viewer);

	$editor = id(new PhabricatorUserPreferencesEditor())
	->setActor($viewer)
	->setContentSourceFromRequest($request)
	->setContinueOnNoEffect(true)
	->setContinueOnMissingFields(true);

	$xactions = array();
	$xactions[] = $preferences->newTransaction($blame_key, $show_blame);
	$editor->applyTransactions($preferences, $xactions);

	$uri = $request->getRequestURI()
	->alter('blame', null);

	return id(new AphrontRedirectResponse())->setURI($uri);
	}

	// We need the blame information if blame is on and this is an Ajax request.
	// If blame is on and this is a colorized request, we don't show blame at
	// first (we ajax it in afterward) so we don't need to query for it.
	$needs_blame = ($show_blame && $request->isAjax());

	$params = array(
	'commit' => $drequest->getCommit(),
	'path' => $drequest->getPath(),
	);

	$byte_limit = null;
	if ($view !== 'raw') {
	$byte_limit = PhabricatorFileStorageEngine::getChunkThreshold();
	$time_limit = 10;

	$params += array(
	'timeout' => $time_limit,
	'byteLimit' => $byte_limit,
	);
	}

	$response = $this->callConduitWithDiffusionRequest(
	'diffusion.filecontentquery',
	$params);

	$hit_byte_limit = $response['tooHuge'];
	$hit_time_limit = $response['tooSlow'];

	$file_phid = $response['filePHID'];
	if ($hit_byte_limit) {
	$corpus = $this->buildErrorCorpus(
	pht(
	'This file is larger than %s byte(s), and too large to display '.
	'in the web UI.',
	phutil_format_bytes($byte_limit)));
	} else if ($hit_time_limit) {
	$corpus = $this->buildErrorCorpus(
	pht(
	'This file took too long to load from the repository (more than '.
	'%s second(s)).',
	new PhutilNumber($time_limit)));
	} else {
	$file = id(new PhabricatorFileQuery())
	->setViewer($viewer)
	->withPHIDs(array($file_phid))
	->executeOne();
	if (!$file) {
	throw new Exception(pht('Failed to load content file!'));
	}

	if ($view === 'raw') {
	return $file->getRedirectResponse();
	}

	$data = $file->loadFileData();

	$lfs_ref = $this->getGitLFSRef($repository, $data);
	if ($lfs_ref) {
	if ($view == 'git-lfs') {
	$file = $this->loadGitLFSFile($lfs_ref);

	// Rename the file locally so we generate a better vanity URI for
	// it. In storage, it just has a name like "lfs-13f9a94c0923...",
	// since we don't get any hints about possible human-readable names
	// at upload time.
	$basename = basename($drequest->getPath());
	$file->makeEphemeral();
	$file->setName($basename);

	return $file->getRedirectResponse();
	} else {
	$corpus = $this->buildGitLFSCorpus($lfs_ref);
	}
	} else if (ArcanistDiffUtils::isHeuristicBinaryFile($data)) {
	$file_uri = $file->getBestURI();

	if ($file->isViewableImage()) {
	$corpus = $this->buildImageCorpus($file_uri);
	} else {
	$corpus = $this->buildBinaryCorpus($file_uri, $data);
	}
	} else {
	$this->loadLintMessages();
	$this->coverage = $drequest->loadCoverage();

	// Build the content of the file.
	$corpus = $this->buildCorpus(
	$show_blame,
	$data,
	$needs_blame,
	$drequest,
	$path,
	$data);
	}
	}

	if ($request->isAjax()) {
	return id(new AphrontAjaxResponse())->setContent($corpus);
	}

	require_celerity_resource('diffusion-source-css');

	// Render the page.
	$view = $this->buildCurtain($drequest);
	$curtain = $this->enrichCurtain(
	$view,
	$drequest,
	$show_blame);

	$properties = $this->buildPropertyView($drequest);
	$header = $this->buildHeaderView($drequest);
	$header->setHeaderIcon('fa-file-code-o');

	$content = array();

	$follow = $request->getStr('follow');
	if ($follow) {
	$notice = new PHUIInfoView();
	$notice->setSeverity(PHUIInfoView::SEVERITY_WARNING);
	$notice->setTitle(pht('Unable to Continue'));
	switch ($follow) {
	case 'first':
	$notice->appendChild(
	pht(
	'Unable to continue tracing the history of this file because '.
	'this commit is the first commit in the repository.'));
	break;
	case 'created':
	$notice->appendChild(
	pht(
	'Unable to continue tracing the history of this file because '.
	'this commit created the file.'));
	break;
	}
	$content[] = $notice;
	}

	$renamed = $request->getStr('renamed');
	if ($renamed) {
	$notice = new PHUIInfoView();
	$notice->setSeverity(PHUIInfoView::SEVERITY_NOTICE);
	$notice->setTitle(pht('File Renamed'));
	$notice->appendChild(
	pht(
	'File history passes through a rename from "%s" to "%s".',
	$drequest->getPath(),
	$renamed));
	$content[] = $notice;
	}

	$content[] = $corpus;
	$content[] = $this->buildOpenRevisions();

	$crumbs = $this->buildCrumbs(
	array(
	'branch' => true,
	'path' => true,
	'view' => 'browse',
	));
	$crumbs->setBorder(true);

	$basename = basename($this->getDiffusionRequest()->getPath());

	$view = id(new PHUITwoColumnView())
	->setHeader($header)
	->setCurtain($curtain)
	->setMainColumn(array(
	$content,
	));

	if ($properties) {
	$view->addPropertySection(pht('Details'), $properties);
	}

	$title = array($basename, $repository->getDisplayName());

	return $this->newPage()
	->setTitle($title)
	->setCrumbs($crumbs)
	->appendChild(
	array(
	$view,
	));

	}

	public function browseDirectory(
	DiffusionBrowseResultSet $results,
	PHUIPagerView $pager) {

	$request = $this->getRequest();
	$drequest = $this->getDiffusionRequest();
	$repository = $drequest->getRepository();

	$reason = $results->getReasonForEmptyResultSet();

	$curtain = $this->buildCurtain($drequest);
	$details = $this->buildPropertyView($drequest);

	$header = $this->buildHeaderView($drequest);
	$header->setHeaderIcon('fa-folder-open');

	$search_form = $this->renderSearchForm();

	$empty_result = null;
	$browse_panel = null;
	$branch_panel = null;
	if (!$results->isValidResults()) {
	$empty_result = new DiffusionEmptyResultView();
	$empty_result->setDiffusionRequest($drequest);
	$empty_result->setDiffusionBrowseResultSet($results);
	$empty_result->setView($request->getStr('view'));
	} else {
	$phids = array();
	foreach ($results->getPaths() as $result) {
	$data = $result->getLastCommitData();
	if ($data) {
	if ($data->getCommitDetail('authorPHID')) {
	$phids[$data->getCommitDetail('authorPHID')] = true;
	}
	}
	}

	$phids = array_keys($phids);
	$handles = $this->loadViewerHandles($phids);

	$browse_table = id(new DiffusionBrowseTableView())
	->setDiffusionRequest($drequest)
	->setHandles($handles)
	->setPaths($results->getPaths())
	->setUser($request->getUser());

	$browse_header = id(new PHUIHeaderView())
	->setHeader(nonempty(basename($drequest->getPath()), '/'))
	->setHeaderIcon('fa-folder-open');

	$browse_panel = id(new PHUIObjectBoxView())
	->setHeader($browse_header)
	->setBackground(PHUIObjectBoxView::BLUE_PROPERTY)
	->setTable($browse_table);

	$browse_panel->setShowHide(
	array(pht('Show Search')),
	pht('Hide Search'),
	$search_form,
	'#');

	$path = $drequest->getPath();
	$is_branch = (!strlen($path) && $repository->supportsBranchComparison());
	if ($is_branch) {
	$branch_panel = $this->buildBranchTable();
	}
	}

	$open_revisions = $this->buildOpenRevisions();
	$readme = $this->renderDirectoryReadme($results);

	$crumbs = $this->buildCrumbs(
	array(
	'branch' => true,
	'path' => true,
	'view' => 'browse',
	));

	$pager_box = $this->renderTablePagerBox($pager);
	$crumbs->setBorder(true);

	$view = id(new PHUITwoColumnView())
	->setHeader($header)
	->setCurtain($curtain)
	->setMainColumn(
	array(
	$branch_panel,
	$empty_result,
	$browse_panel,
	))
	->setFooter(
	array(
	$open_revisions,
	$readme,
	$pager_box,
	));

	if ($details) {
	$view->addPropertySection(pht('Details'), $details);
	}

	return $this->newPage()
	->setTitle(array(
	nonempty(basename($drequest->getPath()), '/'),
	$repository->getDisplayName(),
	))
	->setCrumbs($crumbs)
	->appendChild(
	array(
	$view,
	));
	}

	private function renderSearchResults() {
	$request = $this->getRequest();

	$drequest = $this->getDiffusionRequest();
	$repository = $drequest->getRepository();
	$results = array();

	$pager = id(new PHUIPagerView())
	->readFromRequest($request);

	$search_mode = null;
	switch ($repository->getVersionControlSystem()) {
	case PhabricatorRepositoryType::REPOSITORY_TYPE_SVN:
	$results = array();
	break;
	default:
	if (strlen($this->getRequest()->getStr('grep'))) {
	$search_mode = 'grep';
	$query_string = $request->getStr('grep');
	$results = $this->callConduitWithDiffusionRequest(
	'diffusion.searchquery',
	array(
	'grep' => $query_string,
	'commit' => $drequest->getStableCommit(),
	'path' => $drequest->getPath(),
	'limit' => $pager->getPageSize() + 1,
	'offset' => $pager->getOffset(),
	));
	} else { // Filename search.
	$search_mode = 'find';
	$query_string = $request->getStr('find');
	$results = $this->callConduitWithDiffusionRequest(
	'diffusion.querypaths',
	array(
	'pattern' => $query_string,
	'commit' => $drequest->getStableCommit(),
	'path' => $drequest->getPath(),
	'limit' => $pager->getPageSize() + 1,
	'offset' => $pager->getOffset(),
	));
	}
	break;
	}
	$results = $pager->sliceResults($results);

	if ($search_mode == 'grep') {
	$table = $this->renderGrepResults($results, $query_string);
	$header = pht(
	'File content matching "%s" under "%s"',
	$query_string,
	nonempty($drequest->getPath(), '/'));
	} else {
	$table = $this->renderFindResults($results);
	$header = pht(
	'Paths matching "%s" under "%s"',
	$query_string,
	nonempty($drequest->getPath(), '/'));
	}

	$box = id(new PHUIObjectBoxView())
	->setHeaderText($header)
	->setBackground(PHUIObjectBoxView::BLUE_PROPERTY)
	->setTable($table);

	$pager_box = $this->renderTablePagerBox($pager);

	return array($box, $pager_box);
	}

	private function renderGrepResults(array $results, $pattern) {
	$drequest = $this->getDiffusionRequest();

	require_celerity_resource('phabricator-search-results-css');

	$rows = array();
	foreach ($results as $result) {
	list($path, $line, $string) = $result;

	$href = $drequest->generateURI(array(
	'action' => 'browse',
	'path' => $path,
	'line' => $line,
	));

	$matches = null;
	$count = @preg_match_all(
	'('.$pattern.')u',
	$string,
	$matches,
	PREG_OFFSET_CAPTURE);

	if (!$count) {
	$output = ltrim($string);
	} else {
	$output = array();
	$cursor = 0;
	$length = strlen($string);
	foreach ($matches[0] as $match) {
	$offset = $match[1];
	if ($cursor != $offset) {
	$output[] = array(
	'text' => substr($string, $cursor, $offset),
	'highlight' => false,
	);
	}
	$output[] = array(
	'text' => $match[0],
	'highlight' => true,
	);
	$cursor = $offset + strlen($match[0]);
	}
	if ($cursor != $length) {
	$output[] = array(
	'text' => substr($string, $cursor),
	'highlight' => false,
	);
	}

	if ($output) {
	$output[0]['text'] = ltrim($output[0]['text']);
	}

	foreach ($output as $key => $segment) {
	if ($segment['highlight']) {
	$output[$key] = phutil_tag('strong', array(), $segment['text']);
	} else {
	$output[$key] = $segment['text'];
	}
	}
	}

	$string = phutil_tag(
	'pre',
	array('class' => 'PhabricatorMonospaced phui-source-fragment'),
	$output);

	$path = Filesystem::readablePath($path, $drequest->getPath());

	$rows[] = array(
	phutil_tag('a', array('href' => $href), $path),
	$line,
	$string,
	);
	}

	$table = id(new AphrontTableView($rows))
	->setClassName('remarkup-code')
	->setHeaders(array(pht('Path'), pht('Line'), pht('String')))
	->setColumnClasses(array('', 'n', 'wide'))
	->setNoDataString(
	pht(
	'The pattern you searched for was not found in the content of any '.
	'files.'));

	return $table;
	}

	private function renderFindResults(array $results) {
	$drequest = $this->getDiffusionRequest();

	$rows = array();
	foreach ($results as $result) {
	$href = $drequest->generateURI(array(
	'action' => 'browse',
	'path' => $result,
	));

	$readable = Filesystem::readablePath($result, $drequest->getPath());

	$rows[] = array(
	phutil_tag('a', array('href' => $href), $readable),
	);
	}

	$table = id(new AphrontTableView($rows))
	->setHeaders(array(pht('Path')))
	->setColumnClasses(array('wide'))
	->setNoDataString(
	pht(
	'The pattern you searched for did not match the names of any '.
	'files.'));

	return $table;
	}

	private function loadLintMessages() {
	$drequest = $this->getDiffusionRequest();
	$branch = $drequest->loadBranch();

	if (!$branch \|\| !$branch->getLintCommit()) {
	return;
	}

	$this->lintCommit = $branch->getLintCommit();

	$conn = id(new PhabricatorRepository())->establishConnection('r');

	$where = '';
	if ($drequest->getLint()) {
	$where = qsprintf(
	$conn,
	'AND code = %s',
	$drequest->getLint());
	}

	$this->lintMessages = queryfx_all(
	$conn,
	'SELECT * FROM %T WHERE branchID = %d %Q AND path = %s',
	PhabricatorRepository::TABLE_LINTMESSAGE,
	$branch->getID(),
	$where,
	'/'.$drequest->getPath());
	}

	private function buildCorpus(
	$show_blame,
	$file_corpus,
	$needs_blame,
	DiffusionRequest $drequest,
	$path,
	$data) {

	$viewer = $this->getViewer();
	$blame_timeout = 15;
	$blame_failed = false;

	$highlight_limit = DifferentialChangesetParser::HIGHLIGHT_BYTE_LIMIT;
	$blame_limit = DifferentialChangesetParser::HIGHLIGHT_BYTE_LIMIT;
	$can_highlight = (strlen($file_corpus) <= $highlight_limit);
	$can_blame = (strlen($file_corpus) <= $blame_limit);

	if ($needs_blame && $can_blame) {
	$blame = $this->loadBlame($path, $drequest->getCommit(), $blame_timeout);
	list($blame_list, $blame_commits) = $blame;
	if ($blame_list === null) {
	$blame_failed = true;
	$blame_list = array();
	}
	} else {
	$blame_list = array();
	$blame_commits = array();
	}

	require_celerity_resource('syntax-highlighting-css');
	if ($can_highlight) {
	$highlighted = PhabricatorSyntaxHighlighter::highlightWithFilename(
	$path,
	$file_corpus);
	} else {
	// Highlight as plain text to escape the content properly.
	$highlighted = PhabricatorSyntaxHighlighter::highlightWithLanguage(
	'txt',
	$file_corpus);
	}

	$lines = phutil_split_lines($highlighted);

	$rows = $this->buildDisplayRows(
	$lines,
	$blame_list,
	$blame_commits,
	$show_blame);

	$corpus_table = javelin_tag(
	'table',
	array(
	'class' => 'diffusion-source remarkup-code PhabricatorMonospaced',
	'sigil' => 'phabricator-source',
	),
	$rows);

	if ($this->getRequest()->isAjax()) {
	return $corpus_table;
	}

	$id = celerity_generate_unique_node_id();

	$repo = $drequest->getRepository();
	$symbol_repos = nonempty($repo->getSymbolSources(), array());
	$symbol_repos[] = $repo->getPHID();

	$lang = last(explode('.', $drequest->getPath()));
	$repo_languages = $repo->getSymbolLanguages();
	$repo_languages = nonempty($repo_languages, array());
	$repo_languages = array_fill_keys($repo_languages, true);

	$needs_symbols = true;
	if ($repo_languages && $symbol_repos) {
	$have_symbols = id(new DiffusionSymbolQuery())
	->existsSymbolsInRepository($repo->getPHID());
	if (!$have_symbols) {
	$needs_symbols = false;
	}
	}

	if ($needs_symbols && $repo_languages) {
	$needs_symbols = isset($repo_languages[$lang]);
	}

	if ($needs_symbols) {
	Javelin::initBehavior(
	'repository-crossreference',
	array(
	'container' => $id,
	'lang' => $lang,
	'repositories' => $symbol_repos,
	));
	}

	$corpus = phutil_tag(
	'div',
	array(
	'id' => $id,
	),
	$corpus_table);

	Javelin::initBehavior('load-blame', array('id' => $id));


	$edit = $this->renderEditButton();
	$file = $this->renderFileButton();
	$header = id(new PHUIHeaderView())
	->setHeader(basename($this->getDiffusionRequest()->getPath()))
	->setHeaderIcon('fa-file-code-o')
	->addActionLink($edit)
	->addActionLink($file);

	$corpus = id(new PHUIObjectBoxView())
	->setHeader($header)
	->setBackground(PHUIObjectBoxView::BLUE_PROPERTY)
	->appendChild($corpus)
	->setCollapsed(true);

	$messages = array();

	if (!$can_highlight) {
	$messages[] = pht(
	'This file is larger than %s, so syntax highlighting is disabled '.
	'by default.',
	phutil_format_bytes($highlight_limit));
	}

	if ($show_blame && !$can_blame) {
	$messages[] = pht(
	'This file is larger than %s, so blame is disabled.',
	phutil_format_bytes($blame_limit));
	}

	if ($blame_failed) {
	$messages[] = pht(
	'Failed to load blame information for this file in %s second(s).',
	new PhutilNumber($blame_timeout));
	}

	if ($messages) {
	$corpus->setInfoView(
	id(new PHUIInfoView())
	->setSeverity(PHUIInfoView::SEVERITY_WARNING)
	->setErrors($messages));
	}

	return $corpus;
	}

	private function enrichCurtain(
	PHUICurtainView $curtain,
	DiffusionRequest $drequest,
	$show_blame) {

	$viewer = $this->getViewer();
	$base_uri = $this->getRequest()->getRequestURI();

	$curtain->addAction(
	id(new PhabricatorActionView())
	->setName(pht('Show Last Change'))
	->setHref(
	$drequest->generateURI(
	array(
	'action' => 'change',
	)))
	->setIcon('fa-backward'));

	if ($show_blame) {
	$blame_text = pht('Disable Blame');
	$blame_icon = 'fa-exclamation-circle lightgreytext';
	$blame_value = 0;
	} else {
	$blame_text = pht('Enable Blame');
	$blame_icon = 'fa-exclamation-circle';
	$blame_value = 1;
	}

	$curtain->addAction(
	id(new PhabricatorActionView())
	->setName($blame_text)
	->setHref($base_uri->alter('blame', $blame_value))
	->setIcon($blame_icon)
	->setUser($viewer)
	->setRenderAsForm($viewer->isLoggedIn()));

	$href = null;
	if ($this->getRequest()->getStr('lint') !== null) {
	$lint_text = pht('Hide %d Lint Message(s)', count($this->lintMessages));
	$href = $base_uri->alter('lint', null);

	} else if ($this->lintCommit === null) {
	$lint_text = pht('Lint not Available');
	} else {
	$lint_text = pht(
	'Show %d Lint Message(s)',
	count($this->lintMessages));
	$href = $this->getDiffusionRequest()->generateURI(array(
	'action' => 'browse',
	'commit' => $this->lintCommit,
	))->alter('lint', '');
	}

	$curtain->addAction(
	id(new PhabricatorActionView())
	->setName($lint_text)
	->setHref($href)
	->setIcon('fa-exclamation-triangle')
	->setDisabled(!$href));


	$repository = $drequest->getRepository();

	$owners = 'PhabricatorOwnersApplication';
	if (PhabricatorApplication::isClassInstalled($owners)) {
	$package_query = id(new PhabricatorOwnersPackageQuery())
	->setViewer($viewer)
	->withStatuses(array(PhabricatorOwnersPackage::STATUS_ACTIVE))
	->withControl(
	$repository->getPHID(),
	array(
	$drequest->getPath(),
	));

	$package_query->execute();

	$packages = $package_query->getControllingPackagesForPath(
	$repository->getPHID(),
	$drequest->getPath());

	if ($packages) {
	$ownership = id(new PHUIStatusListView())
	->setUser($viewer);

	foreach ($packages as $package) {
	$icon = 'fa-list-alt';
	$color = 'grey';

	$item = id(new PHUIStatusItemView())
	->setIcon($icon, $color)
	->setTarget($viewer->renderHandle($package->getPHID()));

	$ownership->addItem($item);
	}
	} else {
	$ownership = phutil_tag('em', array(), pht('None'));
	}

	$curtain->newPanel()
	->setHeaderText(pht('Owners'))
	->appendChild($ownership);
	}

	return $curtain;
	}

	private function renderEditButton() {
	$request = $this->getRequest();
	$user = $request->getUser();

	$drequest = $this->getDiffusionRequest();

	$repository = $drequest->getRepository();
	$path = $drequest->getPath();
	$line = nonempty((int)$drequest->getLine(), 1);

	$editor_link = $user->loadEditorLink($path, $line, $repository);
	$template = $user->loadEditorLink($path, '%l', $repository);

	$button = id(new PHUIButtonView())
	->setTag('a')
	->setText(pht('Open in Editor'))
	->setHref($editor_link)
	->setIcon('fa-pencil')
	->setID('editor_link')
	->setMetadata(array('link_template' => $template))
	->setDisabled(!$editor_link);

	return $button;
	}

	private function renderFileButton($file_uri = null, $label = null) {

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

	if ($file_uri) {
	$text = pht('Download Raw File');
	$href = $file_uri;
	$icon = 'fa-download';
	} else {
	$text = pht('View Raw File');
	$href = $base_uri->alter('view', 'raw');
	$icon = 'fa-file-text';
	}

	if ($label !== null) {
	$text = $label;
	}

	$button = id(new PHUIButtonView())
	->setTag('a')
	->setText($text)
	->setHref($href)
	->setIcon($icon);

	return $button;
	}

	private function renderGitLFSButton() {
	$viewer = $this->getViewer();

	$uri = $this->getRequest()->getRequestURI();
	$href = $uri->alter('view', 'git-lfs');

	$text = pht('Download from Git LFS');
	$icon = 'fa-download';

	return id(new PHUIButtonView())
	->setTag('a')
	->setText($text)
	->setHref($href)
	->setIcon($icon);
	}

	private function buildDisplayRows(
	array $lines,
	array $blame_list,
	array $blame_commits,
	$show_blame) {

	$request = $this->getRequest();
	$viewer = $this->getViewer();
	$drequest = $this->getDiffusionRequest();
	$repository = $drequest->getRepository();

	$revision_map = array();
	$revisions = array();
	if ($blame_commits) {
	$commit_map = mpull($blame_commits, 'getCommitIdentifier', 'getPHID');

	$revision_ids = id(new DifferentialRevision())
	->loadIDsByCommitPHIDs(array_keys($commit_map));
	if ($revision_ids) {
	$revisions = id(new DifferentialRevisionQuery())
	->setViewer($viewer)
	->withIDs($revision_ids)
	->execute();
	$revisions = mpull($revisions, null, 'getID');
	}

	foreach ($revision_ids as $commit_phid => $revision_id) {
	$revision_map[$commit_map[$commit_phid]] = $revision_id;
	}
	}

	$phids = array();
	foreach ($blame_commits as $commit) {
	$author_phid = $commit->getAuthorPHID();
	if ($author_phid === null) {
	continue;
	}
	$phids[$author_phid] = $author_phid;
	}

	foreach ($revisions as $revision) {
	$author_phid = $revision->getAuthorPHID();
	if ($author_phid === null) {
	continue;
	}
	$phids[$author_phid] = $author_phid;
	}

	$handles = $viewer->loadHandles($phids);

	$colors = array();
	if ($blame_commits) {
	$epochs = array();

	foreach ($blame_commits as $identifier => $commit) {
	$epochs[$identifier] = $commit->getEpoch();
	}

	$epoch_list = array_filter($epochs);
	$epoch_list = array_unique($epoch_list);
	$epoch_list = array_values($epoch_list);

	$epoch_min = min($epoch_list);
	$epoch_max = max($epoch_list);
	$epoch_range = ($epoch_max - $epoch_min) + 1;

	foreach ($blame_commits as $identifier => $commit) {
	$epoch = $epochs[$identifier];
	if (!$epoch) {
	$color = '#ffffdd'; // Warning color, missing data.
	} else {
	$color_ratio = ($epoch - $epoch_min) / $epoch_range;
	$color_value = 0xE6 * (1.0 - $color_ratio);
	$color = sprintf(
	'#%02x%02x%02x',
	$color_value,
	0xF6,
	$color_value);
	}

	$colors[$identifier] = $color;
	}
	}

	$display = array();
	$last_identifier = null;
	$last_color = null;
	foreach ($lines as $line_index => $line) {
	$color = '#f6f6f6';
	$duplicate = false;
	if (isset($blame_list[$line_index])) {
	$identifier = $blame_list[$line_index];
	if (isset($colors[$identifier])) {
	$color = $colors[$identifier];
	}

	if ($identifier === $last_identifier) {
	$duplicate = true;
	} else {
	$last_identifier = $identifier;
	}
	}

	$display[$line_index] = array(
	'data' => $line,
	'target' => false,
	'highlighted' => false,
	'color' => $color,
	'duplicate' => $duplicate,
	);
	}

	$line_arr = array();
	$line_str = $drequest->getLine();
	$ranges = explode(',', $line_str);
	foreach ($ranges as $range) {
	if (strpos($range, '-') !== false) {
	list($min, $max) = explode('-', $range, 2);
	$line_arr[] = array(
	'min' => min($min, $max),
	'max' => max($min, $max),
	);
	} else if (strlen($range)) {
	$line_arr[] = array(
	'min' => $range,
	'max' => $range,
	);
	}
	}

	// Mark the first highlighted line as the target line.
	if ($line_arr) {
	$target_line = $line_arr[0]['min'];
	if (isset($display[$target_line - 1])) {
	$display[$target_line - 1]['target'] = true;
	}
	}

	// Mark all other highlighted lines as highlighted.
	foreach ($line_arr as $range) {
	for ($ii = $range['min']; $ii <= $range['max']; $ii++) {
	if (isset($display[$ii - 1])) {
	$display[$ii - 1]['highlighted'] = true;
	}
	}
	}

	$engine = null;
	$inlines = array();
	if ($this->getRequest()->getStr('lint') !== null && $this->lintMessages) {
	$engine = new PhabricatorMarkupEngine();
	$engine->setViewer($viewer);

	foreach ($this->lintMessages as $message) {
	$inline = id(new PhabricatorAuditInlineComment())
	->setSyntheticAuthor(
	ArcanistLintSeverity::getStringForSeverity($message['severity']).
	' '.$message['code'].' ('.$message['name'].')')
	->setLineNumber($message['line'])
	->setContent($message['description']);
	$inlines[$message['line']][] = $inline;

	$engine->addObject(
	$inline,
	PhabricatorInlineCommentInterface::MARKUP_FIELD_BODY);
	}

	$engine->process();
	require_celerity_resource('differential-changeset-view-css');
	}

	$rows = $this->renderInlines(
	idx($inlines, 0, array()),
	$show_blame,
	(bool)$this->coverage,
	$engine);

	// NOTE: We're doing this manually because rendering is otherwise
	// dominated by URI generation for very large files.
	$line_base = (string)$drequest->generateURI(
	array(
	'action' => 'browse',
	'stable' => true,
	));

	require_celerity_resource('aphront-tooltip-css');
	Javelin::initBehavior('phabricator-oncopy');
	Javelin::initBehavior('phabricator-tooltips');
	Javelin::initBehavior('phabricator-line-linker');

	// Render these once, since they tend to get repeated many times in large
	// blame outputs.
	$commit_links = $this->renderCommitLinks($blame_commits, $handles);
	$revision_links = $this->renderRevisionLinks($revisions, $handles);

	if ($this->coverage) {
	require_celerity_resource('differential-changeset-view-css');
	Javelin::initBehavior(
	'diffusion-browse-file',
	array(
	'labels' => array(
	'cov-C' => pht('Covered'),
	'cov-N' => pht('Not Covered'),
	'cov-U' => pht('Not Executable'),
	),
	));
	}

	$skip_text = pht('Skip Past This Commit');
	foreach ($display as $line_index => $line) {
	$row = array();

	$line_number = $line_index + 1;
	$line_href = $line_base.'$'.$line_number;

	if (isset($blame_list[$line_index])) {
	$identifier = $blame_list[$line_index];
	} else {
	$identifier = null;
	}

	$revision_link = null;
	$commit_link = null;
	$before_link = null;

	$style = 'background: '.$line['color'].';';

	if ($identifier && !$line['duplicate']) {
	if (isset($commit_links[$identifier])) {
	$commit_link = $commit_links[$identifier];
	}

	if (isset($revision_map[$identifier])) {
	$revision_id = $revision_map[$identifier];
	if (isset($revision_links[$revision_id])) {
	$revision_link = $revision_links[$revision_id];
	}
	}

	$skip_href = $line_href.'?before='.$identifier.'&view=blame';
	$before_link = javelin_tag(
	'a',
	array(
	'href' => $skip_href,
	'sigil' => 'has-tooltip',
	'meta' => array(
	'tip' => $skip_text,
	'align' => 'E',
	'size' => 300,
	),
	),
	"\xC2\xAB");
	}

	if ($show_blame) {
	$row[] = phutil_tag(
	'th',
	array(
	'class' => 'diffusion-blame-link',
	),
	$before_link);

	$object_links = array();
	$object_links[] = $commit_link;
	if ($revision_link) {
	$object_links[] = phutil_tag('span', array(), '/');
	$object_links[] = $revision_link;
	}

	$row[] = phutil_tag(
	'th',
	array(
	'class' => 'diffusion-rev-link',
	),
	$object_links);
	}

	$line_link = phutil_tag(
	'a',
	array(
	'href' => $line_href,
	'style' => $style,
	),
	$line_number);

	$row[] = javelin_tag(
	'th',
	array(
	'class' => 'diffusion-line-link',
	'sigil' => 'phabricator-source-line',
	'style' => $style,
	),
	$line_link);

	if ($line['target']) {
	Javelin::initBehavior(
	'diffusion-jump-to',
	array(
	'target' => 'scroll_target',
	));
	$anchor_text = phutil_tag(
	'a',
	array(
	'id' => 'scroll_target',
	),
	'');
	} else {
	$anchor_text = null;
	}

	$row[] = phutil_tag(
	'td',
	array(
	),
	array(
	$anchor_text,

	// NOTE: See phabricator-oncopy behavior.
	"\xE2\x80\x8B",

	// TODO: [HTML] Not ideal.
	phutil_safe_html(str_replace("\t", ' ', $line['data'])),
	));

	if ($this->coverage) {
	$cov_index = $line_index;

	if (isset($this->coverage[$cov_index])) {
	$cov_class = $this->coverage[$cov_index];
	} else {
	$cov_class = 'N';
	}

	$row[] = phutil_tag(
	'td',
	array(
	'class' => 'cov cov-'.$cov_class,
	),
	'');
	}

	$rows[] = phutil_tag(
	'tr',
	array(
	'class' => ($line['highlighted'] ?
	'phabricator-source-highlight' :
	null),
	),
	$row);

	$cur_inlines = $this->renderInlines(
	idx($inlines, $line_number, array()),
	$show_blame,
	$this->coverage,
	$engine);
	foreach ($cur_inlines as $cur_inline) {
	$rows[] = $cur_inline;
	}
	}

	return $rows;
	}

	private function renderInlines(
	array $inlines,
	$show_blame,
	$has_coverage,
	$engine) {

	$rows = array();
	foreach ($inlines as $inline) {

	// TODO: This should use modern scaffolding code.

	$inline_view = id(new PHUIDiffInlineCommentDetailView())
	->setUser($this->getViewer())
	->setMarkupEngine($engine)
	->setInlineComment($inline)
	->render();

	$row = array_fill(0, ($show_blame ? 3 : 1), phutil_tag('th'));

	$row[] = phutil_tag('td', array(), $inline_view);

	if ($has_coverage) {
	$row[] = phutil_tag(
	'td',
	array(
	'class' => 'cov cov-I',
	));
	}

	$rows[] = phutil_tag('tr', array('class' => 'inline'), $row);
	}

	return $rows;
	}

	private function buildImageCorpus($file_uri) {
	$properties = new PHUIPropertyListView();

	$properties->addImageContent(
	phutil_tag(
	'img',
	array(
	'src' => $file_uri,
	)));

	$file = $this->renderFileButton($file_uri);
	$header = id(new PHUIHeaderView())
	->setHeader(basename($this->getDiffusionRequest()->getPath()))
	->addActionLink($file)
	->setHeaderIcon('fa-file-image-o');

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

	private function buildBinaryCorpus($file_uri, $data) {
	$size = new PhutilNumber(strlen($data));
	$text = pht('This is a binary file. It is %s byte(s) in length.', $size);
	$text = id(new PHUIBoxView())
	->addPadding(PHUI::PADDING_LARGE)
	->appendChild($text);

	$file = $this->renderFileButton($file_uri);
	$header = id(new PHUIHeaderView())
	->setHeader(pht('Details'))
	->addActionLink($file);

	$box = id(new PHUIObjectBoxView())
	->setHeader($header)
	->setBackground(PHUIObjectBoxView::BLUE_PROPERTY)
	->appendChild($text);

	return $box;
	}

	private function buildErrorCorpus($message) {
	$text = id(new PHUIBoxView())
	->addPadding(PHUI::PADDING_LARGE)
	->appendChild($message);

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

	$box = id(new PHUIObjectBoxView())
	->setHeader($header)
	->appendChild($text);

	return $box;
	}

	private function buildBeforeResponse($before) {
	$request = $this->getRequest();
	$drequest = $this->getDiffusionRequest();

	// NOTE: We need to get the grandparent so we can capture filename changes
	// in the parent.

	$parent = $this->loadParentCommitOf($before);
	$old_filename = null;
	$was_created = false;
	if ($parent) {
	$grandparent = $this->loadParentCommitOf($parent);

	if ($grandparent) {
	$rename_query = new DiffusionRenameHistoryQuery();
	$rename_query->setRequest($drequest);
	$rename_query->setOldCommit($grandparent);
	$rename_query->setViewer($request->getUser());
	$old_filename = $rename_query->loadOldFilename();
	$was_created = $rename_query->getWasCreated();
	}
	}

	$follow = null;
	if ($was_created) {
	// If the file was created in history, that means older commits won't
	// have it. Since we know it existed at 'before', it must have been
	// created then; jump there.
	$target_commit = $before;
	$follow = 'created';
	} else if ($parent) {
	// If we found a parent, jump to it. This is the normal case.
	$target_commit = $parent;
	} else {
	// If there's no parent, this was probably created in the initial commit?
	// And the "was_created" check will fail because we can't identify the
	// grandparent. Keep the user at 'before'.
	$target_commit = $before;
	$follow = 'first';
	}

	$path = $drequest->getPath();
	$renamed = null;
	if ($old_filename !== null &&
	$old_filename !== '/'.$path) {
	$renamed = $path;
	$path = $old_filename;
	}

	$line = null;
	// If there's a follow error, drop the line so the user sees the message.
	if (!$follow) {
	$line = $this->getBeforeLineNumber($target_commit);
	}

	$before_uri = $drequest->generateURI(
	array(
	'action' => 'browse',
	'commit' => $target_commit,
	'line' => $line,
	'path' => $path,
	));

	$before_uri->setQueryParams($request->getRequestURI()->getQueryParams());
	$before_uri = $before_uri->alter('before', null);
	$before_uri = $before_uri->alter('renamed', $renamed);
	$before_uri = $before_uri->alter('follow', $follow);

	return id(new AphrontRedirectResponse())->setURI($before_uri);
	}

	private function getBeforeLineNumber($target_commit) {
	$drequest = $this->getDiffusionRequest();
	$viewer = $this->getViewer();

	$line = $drequest->getLine();
	if (!$line) {
	return null;
	}

	$diff_info = $this->callConduitWithDiffusionRequest(
	'diffusion.rawdiffquery',
	array(
	'commit' => $drequest->getCommit(),
	'path' => $drequest->getPath(),
	'againstCommit' => $target_commit,
	));

	$file_phid = $diff_info['filePHID'];
	$file = id(new PhabricatorFileQuery())
	->setViewer($viewer)
	->withPHIDs(array($file_phid))
	->executeOne();
	if (!$file) {
	throw new Exception(
	pht(
	'Failed to load file ("%s") returned by "%s".',
	$file_phid,
	'diffusion.rawdiffquery.'));
	}

	$raw_diff = $file->loadFileData();

	$old_line = 0;
	$new_line = 0;

	foreach (explode("\n", $raw_diff) as $text) {
	if ($text[0] == '-' \|\| $text[0] == ' ') {
	$old_line++;
	}
	if ($text[0] == '+' \|\| $text[0] == ' ') {
	$new_line++;
	}
	if ($new_line == $line) {
	return $old_line;
	}
	}

	// We didn't find the target line.
	return $line;
	}

	private function loadParentCommitOf($commit) {
	$drequest = $this->getDiffusionRequest();
	$user = $this->getRequest()->getUser();

	$before_req = DiffusionRequest::newFromDictionary(
	array(
	'user' => $user,
	'repository' => $drequest->getRepository(),
	'commit' => $commit,
	));

	$parents = DiffusionQuery::callConduitWithDiffusionRequest(
	$user,
	$before_req,
	'diffusion.commitparentsquery',
	array(
	'commit' => $commit,
	));

	return head($parents);
	}

	private function renderRevisionTooltip(
	DifferentialRevision $revision,
	$handles) {
	$viewer = $this->getRequest()->getUser();

	$date = phabricator_date($revision->getDateModified(), $viewer);
	$id = $revision->getID();
	$title = $revision->getTitle();
	$header = "D{$id} {$title}";

	$author = $handles[$revision->getAuthorPHID()]->getName();

	return "{$header}\n{$date} \xC2\xB7 {$author}";
	}

	private function renderCommitTooltip(
	PhabricatorRepositoryCommit $commit,
	$author) {

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

	$date = phabricator_date($commit->getEpoch(), $viewer);
	$summary = trim($commit->getSummary());

	return "{$summary}\n{$date} \xC2\xB7 {$author}";
	}

	protected function renderSearchForm() {
	$drequest = $this->getDiffusionRequest();

	$forms = array();
	$form = id(new AphrontFormView())
	->setUser($this->getViewer())
	->setMethod('GET');

	switch ($drequest->getRepository()->getVersionControlSystem()) {
	case PhabricatorRepositoryType::REPOSITORY_TYPE_SVN:
	$forms[] = id(clone $form)
	->appendChild(pht('Search is not available in Subversion.'));
	break;
	default:
	$forms[] = id(clone $form)
	->appendChild(
	id(new AphrontFormTextWithSubmitControl())
	->setLabel(pht('File Name'))
	->setSubmitLabel(pht('Search File Names'))
	->setName('find')
	->setValue($this->getRequest()->getStr('find')));
	$forms[] = id(clone $form)
	->appendChild(
	id(new AphrontFormTextWithSubmitControl())
	->setLabel(pht('Pattern'))
	->setSubmitLabel(pht('Grep File Content'))
	->setName('grep')
	->setValue($this->getRequest()->getStr('grep')));
	break;
	}

	require_celerity_resource('diffusion-icons-css');
	$form_box = phutil_tag_div('diffusion-search-boxen', $forms);

	return $form_box;
	}

	protected function markupText($text) {
	$engine = PhabricatorMarkupEngine::newDiffusionMarkupEngine();
	$engine->setConfig('viewer', $this->getRequest()->getUser());
	$text = $engine->markupText($text);

	$text = phutil_tag(
	'div',
	array(
	'class' => 'phabricator-remarkup',
	),
	$text);

	return $text;
	}

	protected function buildHeaderView(DiffusionRequest $drequest) {
	$viewer = $this->getViewer();

	$tag = $this->renderCommitHashTag($drequest);

	$header = id(new PHUIHeaderView())
	->setUser($viewer)
	->setHeader($this->renderPathLinks($drequest, $mode = 'browse'))
	->addTag($tag);

	return $header;
	}

	protected function buildCurtain(DiffusionRequest $drequest) {
	$viewer = $this->getViewer();
	$repository = $drequest->getRepository();

	$curtain = $this->newCurtainView($drequest);

	$history_uri = $drequest->generateURI(
	array(
	'action' => 'history',
	));

	$curtain->addAction(
	id(new PhabricatorActionView())
	->setName(pht('View History'))
	->setHref($history_uri)
	->setIcon('fa-list'));

	$behind_head = $drequest->getSymbolicCommit();

	if ($repository->supportsBranchComparison()) {
	$compare_uri = $drequest->generateURI(
	array(
	'action' => 'compare',
	));

	$curtain->addAction(
	id(new PhabricatorActionView())
	->setName(pht('Compare Against...'))
	->setIcon('fa-code-fork')
	->setWorkflow(true)
	->setHref($compare_uri));
	}

	$head_uri = $drequest->generateURI(
	array(
	'commit' => '',
	'action' => 'browse',
	));
	$curtain->addAction(
	id(new PhabricatorActionView())
	->setName(pht('Jump to HEAD'))
	->setHref($head_uri)
	->setIcon('fa-home')
	->setDisabled(!$behind_head));

	return $curtain;
	}

	protected function buildPropertyView(
	DiffusionRequest $drequest) {

	$viewer = $this->getViewer();
	$view = id(new PHUIPropertyListView())
	->setUser($viewer);

	if ($drequest->getSymbolicType() == 'tag') {
	$symbolic = $drequest->getSymbolicCommit();
	$view->addProperty(pht('Tag'), $symbolic);

	$tags = $this->callConduitWithDiffusionRequest(
	'diffusion.tagsquery',
	array(
	'names' => array($symbolic),
	'needMessages' => true,
	));
	$tags = DiffusionRepositoryTag::newFromConduit($tags);

	$tags = mpull($tags, null, 'getName');
	$tag = idx($tags, $symbolic);

	if ($tag && strlen($tag->getMessage())) {
	$view->addSectionHeader(
	pht('Tag Content'), 'fa-tag');
	$view->addTextContent($this->markupText($tag->getMessage()));
	}
	}

	if ($view->hasAnyProperties()) {
	return $view;
	}

	return null;
	}

	private function buildOpenRevisions() {
	$viewer = $this->getViewer();

	$drequest = $this->getDiffusionRequest();
	$repository = $drequest->getRepository();
	$path = $drequest->getPath();

	$path_map = id(new DiffusionPathIDQuery(array($path)))->loadPathIDs();
	$path_id = idx($path_map, $path);
	if (!$path_id) {
	return null;
	}

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

	$revisions = id(new DifferentialRevisionQuery())
	->setViewer($viewer)
	->withPath($repository->getID(), $path_id)
	->withStatus(DifferentialRevisionQuery::STATUS_OPEN)
	->withUpdatedEpochBetween($recent, null)
	->setOrder(DifferentialRevisionQuery::ORDER_MODIFIED)
	->setLimit(10)
	- ->needReviewerStatus(true)
	+ ->needReviewers(true)
	->needFlags(true)
	->needDrafts(true)
	->execute();

	if (!$revisions) {
	return null;
	}

	$header = id(new PHUIHeaderView())
	->setHeader(pht('Open Revisions'))
	->setSubheader(
	pht('Recently updated open revisions affecting this file.'));

	$view = id(new DifferentialRevisionListView())
	->setHeader($header)
	->setRevisions($revisions)
	->setUser($viewer);

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

	return $view;
	}

	private function loadBlame($path, $commit, $timeout) {
	$blame = $this->callConduitWithDiffusionRequest(
	'diffusion.blame',
	array(
	'commit' => $commit,
	'paths' => array($path),
	'timeout' => $timeout,
	));

	$identifiers = idx($blame, $path, null);

	if ($identifiers) {
	$viewer = $this->getViewer();
	$drequest = $this->getDiffusionRequest();
	$repository = $drequest->getRepository();

	$commits = id(new DiffusionCommitQuery())
	->setViewer($viewer)
	->withRepository($repository)
	->withIdentifiers($identifiers)
	// TODO: We only fetch this to improve author display behavior, but
	// shouldn't really need to?
	->needCommitData(true)
	->execute();
	$commits = mpull($commits, null, 'getCommitIdentifier');
	} else {
	$commits = array();
	}

	return array($identifiers, $commits);
	}

	private function renderCommitLinks(array $commits, $handles) {
	$links = array();
	foreach ($commits as $identifier => $commit) {
	$tooltip = $this->renderCommitTooltip(
	$commit,
	$commit->renderAuthorShortName($handles));

	$commit_link = javelin_tag(
	'a',
	array(
	'href' => $commit->getURI(),
	'sigil' => 'has-tooltip',
	'meta' => array(
	'tip' => $tooltip,
	'align' => 'E',
	'size' => 600,
	),
	),
	$commit->getLocalName());

	$links[$identifier] = $commit_link;
	}

	return $links;
	}

	private function renderRevisionLinks(array $revisions, $handles) {
	$links = array();

	foreach ($revisions as $revision) {
	$revision_id = $revision->getID();

	$tooltip = $this->renderRevisionTooltip($revision, $handles);

	$revision_link = javelin_tag(
	'a',
	array(
	'href' => '/'.$revision->getMonogram(),
	'sigil' => 'has-tooltip',
	'meta' => array(
	'tip' => $tooltip,
	'align' => 'E',
	'size' => 600,
	),
	),
	$revision->getMonogram());

	$links[$revision_id] = $revision_link;
	}

	return $links;
	}

	private function getGitLFSRef(PhabricatorRepository $repository, $data) {
	if (!$repository->canUseGitLFS()) {
	return null;
	}

	$lfs_pattern = '(^version https://git-lfs\\.github\\.com/spec/v1[\r\n])';
	if (!preg_match($lfs_pattern, $data)) {
	return null;
	}

	$matches = null;
	if (!preg_match('(^oid sha256:(.*)$)m', $data, $matches)) {
	return null;
	}

	$hash = $matches[1];
	$hash = trim($hash);

	return id(new PhabricatorRepositoryGitLFSRefQuery())
	->setViewer($this->getViewer())
	->withRepositoryPHIDs(array($repository->getPHID()))
	->withObjectHashes(array($hash))
	->executeOne();
	}

	private function buildGitLFSCorpus(PhabricatorRepositoryGitLFSRef $ref) {
	// TODO: We should probably test if we can load the file PHID here and
	// show the user an error if we can't, rather than making them click
	// through to hit an error.

	$header = id(new PHUIHeaderView())
	->setHeader(basename($this->getDiffusionRequest()->getPath()))
	->setHeaderIcon('fa-archive');

	$severity = PHUIInfoView::SEVERITY_NOTICE;

	$messages = array();
	$messages[] = pht(
	'This %s file is stored in Git Large File Storage.',
	phutil_format_bytes($ref->getByteSize()));

	try {
	$file = $this->loadGitLFSFile($ref);
	$data = $this->renderGitLFSButton();
	$header->addActionLink($data);
	} catch (Exception $ex) {
	$severity = PHUIInfoView::SEVERITY_ERROR;
	$messages[] = pht('The data for this file could not be loaded.');
	}

	$raw = $this->renderFileButton(null, pht('View Raw LFS Pointer'));
	$header->addActionLink($raw);

	$corpus = id(new PHUIObjectBoxView())
	->setHeader($header)
	->setBackground(PHUIObjectBoxView::BLUE_PROPERTY)
	->setCollapsed(true);

	if ($messages) {
	$corpus->setInfoView(
	id(new PHUIInfoView())
	->setSeverity($severity)
	->setErrors($messages));
	}

	return $corpus;
	}

	private function loadGitLFSFile(PhabricatorRepositoryGitLFSRef $ref) {
	$viewer = $this->getViewer();

	$file = id(new PhabricatorFileQuery())
	->setViewer($viewer)
	->withPHIDs(array($ref->getFilePHID()))
	->executeOne();
	if (!$file) {
	throw new Exception(
	pht(
	'Failed to load file object for Git LFS ref "%s"!',
	$ref->getObjectHash()));
	}

	return $file;
	}

	private function buildBranchTable() {
	$viewer = $this->getViewer();
	$drequest = $this->getDiffusionRequest();
	$repository = $drequest->getRepository();

	$branch = $drequest->getBranch();
	$default_branch = $repository->getDefaultBranch();

	if ($branch === $default_branch) {
	return null;
	}

	$pager = id(new PHUIPagerView())
	->setPageSize(10);

	try {
	$results = $this->callConduitWithDiffusionRequest(
	'diffusion.historyquery',
	array(
	'commit' => $branch,
	'against' => $default_branch,
	'path' => $drequest->getPath(),
	'offset' => $pager->getOffset(),
	'limit' => $pager->getPageSize() + 1,
	));
	} catch (Exception $ex) {
	return null;
	}

	$history = DiffusionPathChange::newFromConduit($results['pathChanges']);
	$history = $pager->sliceResults($history);

	if (!$history) {
	return null;
	}

	$history_table = id(new DiffusionHistoryTableView())
	->setViewer($viewer)
	->setDiffusionRequest($drequest)
	->setHistory($history);

	$history_table->loadRevisions();

	$history_table
	->setParents($results['parents'])
	->setFilterParents(true)
	->setIsHead(true)
	->setIsTail(!$pager->getHasMorePages());

	$header = id(new PHUIHeaderView())
	->setHeader(pht('%s vs %s', $branch, $default_branch));

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

	}
	diff --git a/src/applications/diffusion/herald/HeraldCommitAdapter.php b/src/applications/diffusion/herald/HeraldCommitAdapter.php
	index 3465924f92..4687028418 100644
	--- a/src/applications/diffusion/herald/HeraldCommitAdapter.php
	+++ b/src/applications/diffusion/herald/HeraldCommitAdapter.php
	@@ -1,366 +1,366 @@
	<?php

	final class HeraldCommitAdapter
	extends HeraldAdapter
	implements HarbormasterBuildableAdapterInterface {

	protected $diff;
	protected $revision;

	protected $commit;
	private $commitDiff;

	protected $affectedPaths;
	protected $affectedRevision;
	protected $affectedPackages;
	protected $auditNeededPackages;

	private $buildRequests = array();

	public function getAdapterApplicationClass() {
	return 'PhabricatorDiffusionApplication';
	}

	protected function newObject() {
	return new PhabricatorRepositoryCommit();
	}

	public function isTestAdapterForObject($object) {
	return ($object instanceof PhabricatorRepositoryCommit);
	}

	public function getAdapterTestDescription() {
	return pht(
	'Test rules which run after a commit is discovered and imported.');
	}

	public function newTestAdapter(PhabricatorUser $viewer, $object) {
	$object = id(new DiffusionCommitQuery())
	->setViewer($viewer)
	->withPHIDs(array($object->getPHID()))
	->needCommitData(true)
	->executeOne();
	if (!$object) {
	throw new Exception(
	pht(
	'Failed to reload commit ("%s") to fetch commit data.',
	$object->getPHID()));
	}

	return id(clone $this)
	->setObject($object);
	}

	protected function initializeNewAdapter() {
	$this->commit = $this->newObject();
	}

	public function setObject($object) {
	$this->commit = $object;

	return $this;
	}

	public function getObject() {
	return $this->commit;
	}

	public function getAdapterContentType() {
	return 'commit';
	}

	public function getAdapterContentName() {
	return pht('Commits');
	}

	public function getAdapterContentDescription() {
	return pht(
	"React to new commits appearing in tracked repositories.\n".
	"Commit rules can send email, flag commits, trigger audits, ".
	"and run build plans.");
	}

	public function supportsRuleType($rule_type) {
	switch ($rule_type) {
	case HeraldRuleTypeConfig::RULE_TYPE_GLOBAL:
	case HeraldRuleTypeConfig::RULE_TYPE_PERSONAL:
	case HeraldRuleTypeConfig::RULE_TYPE_OBJECT:
	return true;
	default:
	return false;
	}
	}

	public function canTriggerOnObject($object) {
	if ($object instanceof PhabricatorRepository) {
	return true;
	}
	if ($object instanceof PhabricatorProject) {
	return true;
	}
	return false;
	}

	public function getTriggerObjectPHIDs() {
	$project_type = PhabricatorProjectObjectHasProjectEdgeType::EDGECONST;

	$repository_phid = $this->getRepository()->getPHID();
	$commit_phid = $this->getObject()->getPHID();

	$phids = array();
	$phids[] = $commit_phid;
	$phids[] = $repository_phid;

	// NOTE: This is projects for the repository, not for the commit. When
	// Herald evalutes, commits normally can not have any project tags yet.
	$repository_project_phids = PhabricatorEdgeQuery::loadDestinationPHIDs(
	$repository_phid,
	$project_type);
	foreach ($repository_project_phids as $phid) {
	$phids[] = $phid;
	}

	$phids = array_unique($phids);
	$phids = array_values($phids);

	return $phids;
	}

	public function explainValidTriggerObjects() {
	return pht('This rule can trigger for repositories and projects.');
	}

	public function getHeraldName() {
	return $this->commit->getMonogram();
	}

	public function loadAffectedPaths() {
	if ($this->affectedPaths === null) {
	$result = PhabricatorOwnerPathQuery::loadAffectedPaths(
	$this->getRepository(),
	$this->commit,
	PhabricatorUser::getOmnipotentUser());
	$this->affectedPaths = $result;
	}
	return $this->affectedPaths;
	}

	public function loadAffectedPackages() {
	if ($this->affectedPackages === null) {
	$packages = PhabricatorOwnersPackage::loadAffectedPackages(
	$this->getRepository(),
	$this->loadAffectedPaths());
	$this->affectedPackages = $packages;
	}
	return $this->affectedPackages;
	}

	public function loadAuditNeededPackages() {
	if ($this->auditNeededPackages === null) {
	$status_arr = array(
	PhabricatorAuditStatusConstants::AUDIT_REQUIRED,
	PhabricatorAuditStatusConstants::CONCERNED,
	);
	$requests = id(new PhabricatorRepositoryAuditRequest())
	->loadAllWhere(
	'commitPHID = %s AND auditStatus IN (%Ls)',
	$this->commit->getPHID(),
	$status_arr);
	$this->auditNeededPackages = $requests;
	}
	return $this->auditNeededPackages;
	}

	public function loadDifferentialRevision() {
	if ($this->affectedRevision === null) {
	$this->affectedRevision = false;

	$commit = $this->getObject();
	$data = $commit->getCommitData();

	$revision_id = $data->getCommitDetail('differential.revisionID');
	if ($revision_id) {
	// NOTE: The Herald rule owner might not actually have access to
	// the revision, and can control which revision a commit is
	// associated with by putting text in the commit message. However,
	// the rules they can write against revisions don't actually expose
	// anything interesting, so it seems reasonable to load unconditionally
	// here.

	$revision = id(new DifferentialRevisionQuery())
	->withIDs(array($revision_id))
	->setViewer(PhabricatorUser::getOmnipotentUser())
	- ->needReviewerStatus(true)
	+ ->needReviewers(true)
	->executeOne();
	if ($revision) {
	$this->affectedRevision = $revision;
	}
	}
	}
	return $this->affectedRevision;
	}

	public static function getEnormousByteLimit() {
	return 1024 * 1024 * 1024; // 1GB
	}

	public static function getEnormousTimeLimit() {
	return 60 * 15; // 15 Minutes
	}

	private function loadCommitDiff() {
	$viewer = PhabricatorUser::getOmnipotentUser();

	$byte_limit = self::getEnormousByteLimit();
	$time_limit = self::getEnormousTimeLimit();

	$diff_info = $this->callConduit(
	'diffusion.rawdiffquery',
	array(
	'commit' => $this->commit->getCommitIdentifier(),
	'timeout' => $time_limit,
	'byteLimit' => $byte_limit,
	'linesOfContext' => 0,
	));

	if ($diff_info['tooHuge']) {
	throw new Exception(
	pht(
	'The raw text of this change is enormous (larger than %s byte(s)). '.
	'Herald can not process it.',
	new PhutilNumber($byte_limit)));
	}

	if ($diff_info['tooSlow']) {
	throw new Exception(
	pht(
	'The raw text of this change took too long to process (longer '.
	'than %s second(s)). Herald can not process it.',
	new PhutilNumber($time_limit)));
	}

	$file_phid = $diff_info['filePHID'];
	$diff_file = id(new PhabricatorFileQuery())
	->setViewer($viewer)
	->withPHIDs(array($file_phid))
	->executeOne();
	if (!$diff_file) {
	throw new Exception(
	pht(
	'Failed to load diff ("%s") for this change.',
	$file_phid));
	}

	$raw = $diff_file->loadFileData();

	$parser = new ArcanistDiffParser();
	$changes = $parser->parseDiff($raw);

	$diff = DifferentialDiff::newEphemeralFromRawChanges(
	$changes);
	return $diff;
	}

	public function isDiffEnormous() {
	$this->loadDiffContent('*');
	return ($this->commitDiff instanceof Exception);
	}

	public function loadDiffContent($type) {
	if ($this->commitDiff === null) {
	try {
	$this->commitDiff = $this->loadCommitDiff();
	} catch (Exception $ex) {
	$this->commitDiff = $ex;
	phlog($ex);
	}
	}

	if ($this->commitDiff instanceof Exception) {
	$ex = $this->commitDiff;
	$ex_class = get_class($ex);
	$ex_message = pht('Failed to load changes: %s', $ex->getMessage());

	return array(
	'<'.$ex_class.'>' => $ex_message,
	);
	}

	$changes = $this->commitDiff->getChangesets();

	$result = array();
	foreach ($changes as $change) {
	$lines = array();
	foreach ($change->getHunks() as $hunk) {
	switch ($type) {
	case '-':
	$lines[] = $hunk->makeOldFile();
	break;
	case '+':
	$lines[] = $hunk->makeNewFile();
	break;
	case '*':
	$lines[] = $hunk->makeChanges();
	break;
	default:
	throw new Exception(pht("Unknown content selection '%s'!", $type));
	}
	}
	$result[$change->getFilename()] = implode("\n", $lines);
	}

	return $result;
	}

	public function loadIsMergeCommit() {
	$parents = $this->callConduit(
	'diffusion.commitparentsquery',
	array(
	'commit' => $this->getObject()->getCommitIdentifier(),
	));

	return (count($parents) > 1);
	}

	private function callConduit($method, array $params) {
	$viewer = PhabricatorUser::getOmnipotentUser();

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

	return DiffusionQuery::callConduitWithDiffusionRequest(
	$viewer,
	$drequest,
	$method,
	$params);
	}

	private function getRepository() {
	return $this->getObject()->getRepository();
	}

	/* -( HarbormasterBuildableAdapterInterface )------------------------------ */


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

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

	public function getQueuedHarbormasterBuildRequests() {
	return $this->buildRequests;
	}

	public function queueHarbormasterBuildRequest(
	HarbormasterBuildRequest $request) {
	$this->buildRequests[] = $request;
	}

	}
	diff --git a/src/applications/diffusion/herald/HeraldPreCommitContentAdapter.php b/src/applications/diffusion/herald/HeraldPreCommitContentAdapter.php
	index 5fbc970dfa..f4d7e794a2 100644
	--- a/src/applications/diffusion/herald/HeraldPreCommitContentAdapter.php
	+++ b/src/applications/diffusion/herald/HeraldPreCommitContentAdapter.php
	@@ -1,226 +1,226 @@
	<?php

	final class HeraldPreCommitContentAdapter extends HeraldPreCommitAdapter {

	private $changesets;
	private $commitRef;
	private $fields;
	private $revision = false;

	public function getAdapterContentName() {
	return pht('Commit Hook: Commit Content');
	}

	public function getAdapterSortOrder() {
	return 2500;
	}

	public function getAdapterContentDescription() {
	return pht(
	"React to commits being pushed to hosted repositories.\n".
	"Hook rules can block changes and send push summary mail.");
	}

	public function isPreCommitRefAdapter() {
	return false;
	}

	public function getHeraldName() {
	return pht('Push Log (Content)');
	}

	public function isDiffEnormous() {
	$this->getDiffContent('*');
	return ($this->changesets instanceof Exception);
	}

	public function getDiffContent($type) {
	if ($this->changesets === null) {
	try {
	$this->changesets = $this->getHookEngine()->loadChangesetsForCommit(
	$this->getObject()->getRefNew());
	} catch (Exception $ex) {
	$this->changesets = $ex;
	}
	}

	if ($this->changesets instanceof Exception) {
	$ex_class = get_class($this->changesets);
	$ex_message = $this->changesets->getMessage();
	if ($type === 'name') {
	return array("<{$ex_class}: {$ex_message}>");
	} else {
	return array("<{$ex_class}>" => $ex_message);
	}
	}

	$result = array();
	if ($type === 'name') {
	foreach ($this->changesets as $change) {
	$result[] = $change->getFilename();
	}
	} else {
	foreach ($this->changesets as $change) {
	$lines = array();
	foreach ($change->getHunks() as $hunk) {
	switch ($type) {
	case '-':
	$lines[] = $hunk->makeOldFile();
	break;
	case '+':
	$lines[] = $hunk->makeNewFile();
	break;
	case '*':
	default:
	$lines[] = $hunk->makeChanges();
	break;
	}
	}
	$result[$change->getFilename()] = implode('', $lines);
	}
	}

	return $result;
	}

	public function getCommitRef() {
	if ($this->commitRef === null) {
	$this->commitRef = $this->getHookEngine()->loadCommitRefForCommit(
	$this->getObject()->getRefNew());
	}
	return $this->commitRef;
	}

	public function getAuthorPHID() {
	$repository = $this->getHookEngine()->getRepository();
	$vcs = $repository->getVersionControlSystem();
	switch ($vcs) {
	case PhabricatorRepositoryType::REPOSITORY_TYPE_GIT:
	case PhabricatorRepositoryType::REPOSITORY_TYPE_MERCURIAL:
	$ref = $this->getCommitRef();
	$author = $ref->getAuthor();
	if (!strlen($author)) {
	return null;
	}
	return $this->lookupUser($author);
	case PhabricatorRepositoryType::REPOSITORY_TYPE_SVN:
	// In Subversion, the pusher is always the author.
	return $this->getHookEngine()->getViewer()->getPHID();
	}
	}

	public function getCommitterPHID() {
	$repository = $this->getHookEngine()->getRepository();
	$vcs = $repository->getVersionControlSystem();
	switch ($vcs) {
	case PhabricatorRepositoryType::REPOSITORY_TYPE_GIT:
	case PhabricatorRepositoryType::REPOSITORY_TYPE_MERCURIAL:
	// If there's no committer information, we're going to return the
	// author instead. However, if there's committer information and we
	// can't resolve it, return `null`.
	$ref = $this->getCommitRef();
	$committer = $ref->getCommitter();
	if (!strlen($committer)) {
	return $this->getAuthorPHID();
	}
	return $this->lookupUser($committer);
	case PhabricatorRepositoryType::REPOSITORY_TYPE_SVN:
	// In Subversion, the pusher is always the committer.
	return $this->getHookEngine()->getViewer()->getPHID();
	}
	}

	public function getAuthorRaw() {
	$repository = $this->getHookEngine()->getRepository();
	$vcs = $repository->getVersionControlSystem();
	switch ($vcs) {
	case PhabricatorRepositoryType::REPOSITORY_TYPE_GIT:
	case PhabricatorRepositoryType::REPOSITORY_TYPE_MERCURIAL:
	$ref = $this->getCommitRef();
	return $ref->getAuthor();
	case PhabricatorRepositoryType::REPOSITORY_TYPE_SVN:
	// In Subversion, the pusher is always the author.
	return $this->getHookEngine()->getViewer()->getUsername();
	}
	}

	public function getCommitterRaw() {
	$repository = $this->getHookEngine()->getRepository();
	$vcs = $repository->getVersionControlSystem();
	switch ($vcs) {
	case PhabricatorRepositoryType::REPOSITORY_TYPE_GIT:
	case PhabricatorRepositoryType::REPOSITORY_TYPE_MERCURIAL:
	// Here, if there's no committer, we're going to return the author
	// instead.
	$ref = $this->getCommitRef();
	$committer = $ref->getCommitter();
	if (strlen($committer)) {
	return $committer;
	}
	return $ref->getAuthor();
	case PhabricatorRepositoryType::REPOSITORY_TYPE_SVN:
	// In Subversion, the pusher is always the committer.
	return $this->getHookEngine()->getViewer()->getUsername();
	}
	}

	private function lookupUser($author) {
	return id(new DiffusionResolveUserQuery())
	->withName($author)
	->execute();
	}

	private function getCommitFields() {
	if ($this->fields === null) {
	$this->fields = id(new DiffusionLowLevelCommitFieldsQuery())
	->setRepository($this->getHookEngine()->getRepository())
	->withCommitRef($this->getCommitRef())
	->execute();
	}
	return $this->fields;
	}

	public function getRevision() {
	if ($this->revision === false) {
	$fields = $this->getCommitFields();
	$revision_id = idx($fields, 'revisionID');
	if (!$revision_id) {
	$this->revision = null;
	} else {
	$this->revision = id(new DifferentialRevisionQuery())
	->setViewer(PhabricatorUser::getOmnipotentUser())
	->withIDs(array($revision_id))
	- ->needReviewerStatus(true)
	+ ->needReviewers(true)
	->executeOne();
	}
	}

	return $this->revision;
	}

	public function getIsMergeCommit() {
	$repository = $this->getHookEngine()->getRepository();
	$vcs = $repository->getVersionControlSystem();
	switch ($vcs) {
	case PhabricatorRepositoryType::REPOSITORY_TYPE_GIT:
	case PhabricatorRepositoryType::REPOSITORY_TYPE_MERCURIAL:
	$parents = id(new DiffusionLowLevelParentsQuery())
	->setRepository($repository)
	->withIdentifier($this->getObject()->getRefNew())
	->execute();

	return (count($parents) > 1);
	case PhabricatorRepositoryType::REPOSITORY_TYPE_SVN:
	// NOTE: For now, we ignore "svn:mergeinfo" at all levels. We might
	// change this some day, but it's not nearly as clear a signal as
	// ancestry is in Git/Mercurial.
	return false;
	}
	}

	public function getBranches() {
	return $this->getHookEngine()->loadBranches(
	$this->getObject()->getRefNew());
	}

	}
	diff --git a/src/applications/repository/worker/PhabricatorRepositoryCommitOwnersWorker.php b/src/applications/repository/worker/PhabricatorRepositoryCommitOwnersWorker.php
	index 5deb975fa9..1192ea379b 100644
	--- a/src/applications/repository/worker/PhabricatorRepositoryCommitOwnersWorker.php
	+++ b/src/applications/repository/worker/PhabricatorRepositoryCommitOwnersWorker.php
	@@ -1,193 +1,193 @@
	<?php

	final class PhabricatorRepositoryCommitOwnersWorker
	extends PhabricatorRepositoryCommitParserWorker {

	protected function getImportStepFlag() {
	return PhabricatorRepositoryCommit::IMPORTED_OWNERS;
	}

	protected function parseCommit(
	PhabricatorRepository $repository,
	PhabricatorRepositoryCommit $commit) {

	if (!$this->shouldSkipImportStep()) {
	$this->triggerOwnerAudits($repository, $commit);
	$commit->writeImportStatusFlag($this->getImportStepFlag());
	}

	if ($this->shouldQueueFollowupTasks()) {
	$this->queueTask(
	'PhabricatorRepositoryCommitHeraldWorker',
	array(
	'commitID' => $commit->getID(),
	));
	}
	}

	private function triggerOwnerAudits(
	PhabricatorRepository $repository,
	PhabricatorRepositoryCommit $commit) {
	$viewer = PhabricatorUser::getOmnipotentUser();

	if (!$repository->shouldPublish()) {
	return;
	}

	$affected_paths = PhabricatorOwnerPathQuery::loadAffectedPaths(
	$repository,
	$commit,
	PhabricatorUser::getOmnipotentUser());

	$affected_packages = PhabricatorOwnersPackage::loadAffectedPackages(
	$repository,
	$affected_paths);

	$commit->writeOwnersEdges(mpull($affected_packages, 'getPHID'));

	if (!$affected_packages) {
	return;
	}

	$commit = id(new DiffusionCommitQuery())
	->setViewer($viewer)
	->withPHIDs(array($commit->getPHID()))
	->needCommitData(true)
	->needAuditRequests(true)
	->executeOne();
	if (!$commit) {
	return;
	}

	$data = $commit->getCommitData();

	$author_phid = $data->getCommitDetail('authorPHID');
	$revision_id = $data->getCommitDetail('differential.revisionID');
	if ($revision_id) {
	$revision = id(new DifferentialRevisionQuery())
	->setViewer($viewer)
	->withIDs(array($revision_id))
	- ->needReviewerStatus(true)
	+ ->needReviewers(true)
	->executeOne();
	} else {
	$revision = null;
	}

	$requests = $commit->getAudits();
	$requests = mpull($requests, null, 'getAuditorPHID');

	$auditor_phids = array();
	foreach ($affected_packages as $package) {
	$request = idx($requests, $package->getPHID());
	if ($request) {
	// Don't update request if it exists already.
	continue;
	}

	$should_audit = $this->shouldTriggerAudit(
	$commit,
	$package,
	$author_phid,
	$revision);
	if (!$should_audit) {
	continue;
	}

	$auditor_phids[] = $package->getPHID();
	}

	// If none of the packages are triggering audits, we're all done.
	if (!$auditor_phids) {
	return;
	}

	$audit_type = DiffusionCommitAuditorsTransaction::TRANSACTIONTYPE;

	$owners_phid = id(new PhabricatorOwnersApplication())
	->getPHID();

	$content_source = $this->newContentSource();

	$xactions = array();
	$xactions[] = $commit->getApplicationTransactionTemplate()
	->setTransactionType($audit_type)
	->setNewValue(
	array(
	'+' => array_fuse($auditor_phids),
	));

	$editor = $commit->getApplicationTransactionEditor()
	->setActor($viewer)
	->setActingAsPHID($owners_phid)
	->setContinueOnNoEffect(true)
	->setContinueOnMissingFields(true)
	->setContentSource($content_source);

	$editor->applyTransactions($commit, $xactions);
	}

	private function shouldTriggerAudit(
	PhabricatorRepositoryCommit $commit,
	PhabricatorOwnersPackage $package,
	$author_phid,
	$revision) {

	// Don't trigger an audit if auditing isn't enabled for the package.
	if (!$package->getAuditingEnabled()) {
	return false;
	}

	// Trigger an audit if we don't recognize the commit's author.
	if (!$author_phid) {
	return true;
	}

	$owner_phids = PhabricatorOwnersOwner::loadAffiliatedUserPHIDs(
	array(
	$package->getID(),
	));
	$owner_phids = array_fuse($owner_phids);

	// Don't trigger an audit if the author is a package owner.
	if (isset($owner_phids[$author_phid])) {
	return false;
	}

	// Trigger an audit of there is no corresponding revision.
	if (!$revision) {
	return true;
	}

	$accepted_statuses = array(
	DifferentialReviewerStatus::STATUS_ACCEPTED,
	DifferentialReviewerStatus::STATUS_ACCEPTED_OLDER,
	);
	$accepted_statuses = array_fuse($accepted_statuses);

	$found_accept = false;
	foreach ($revision->getReviewerStatus() as $reviewer) {
	$reviewer_phid = $reviewer->getReviewerPHID();

	// If this reviewer isn't a package owner, just ignore them.
	if (empty($owner_phids[$reviewer_phid])) {
	continue;
	}

	// If this reviewer accepted the revision and owns the package, we're
	// all clear and do not need to trigger an audit.
	if (isset($accepted_statuses[$reviewer->getStatus()])) {
	$found_accept = true;
	break;
	}
	}

	// Don't trigger an audit if a package owner already reviewed the
	// revision.
	if ($found_accept) {
	return false;
	}

	return true;
	}

	}
	diff --git a/src/applications/repository/worker/commitmessageparser/PhabricatorRepositoryCommitMessageParserWorker.php b/src/applications/repository/worker/commitmessageparser/PhabricatorRepositoryCommitMessageParserWorker.php
	index f340fbf91f..fec7c1f8af 100644
	--- a/src/applications/repository/worker/commitmessageparser/PhabricatorRepositoryCommitMessageParserWorker.php
	+++ b/src/applications/repository/worker/commitmessageparser/PhabricatorRepositoryCommitMessageParserWorker.php
	@@ -1,372 +1,372 @@
	<?php

	abstract class PhabricatorRepositoryCommitMessageParserWorker
	extends PhabricatorRepositoryCommitParserWorker {

	protected function getImportStepFlag() {
	return PhabricatorRepositoryCommit::IMPORTED_MESSAGE;
	}

	abstract protected function getFollowupTaskClass();

	final protected function parseCommit(
	PhabricatorRepository $repository,
	PhabricatorRepositoryCommit $commit) {

	if (!$this->shouldSkipImportStep()) {
	$viewer = PhabricatorUser::getOmnipotentUser();

	$refs_raw = DiffusionQuery::callConduitWithDiffusionRequest(
	$viewer,
	DiffusionRequest::newFromDictionary(
	array(
	'repository' => $repository,
	'user' => $viewer,
	)),
	'diffusion.querycommits',
	array(
	'repositoryPHID' => $repository->getPHID(),
	'phids' => array($commit->getPHID()),
	'bypassCache' => true,
	'needMessages' => true,
	));

	if (empty($refs_raw['data'])) {
	throw new Exception(
	pht(
	'Unable to retrieve details for commit "%s"!',
	$commit->getPHID()));
	}

	$ref = DiffusionCommitRef::newFromConduitResult(head($refs_raw['data']));
	$this->updateCommitData($ref);
	}

	if ($this->shouldQueueFollowupTasks()) {
	$this->queueTask(
	$this->getFollowupTaskClass(),
	array(
	'commitID' => $commit->getID(),
	),
	array(
	// We queue followup tasks at default priority so that the queue
	// finishes work it has started before starting more work. If
	// followups are queued at the same priority level, we do all
	// message parses first, then all change parses, etc. This makes
	// progress uneven. See T11677 for discussion.
	'priority' => PhabricatorWorker::PRIORITY_DEFAULT,
	));
	}
	}

	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(id(new PhutilUTF8StringTruncator())
	->setMaximumBytes(255)
	->truncateString((string)$author));

	$data->setCommitDetail('authorEpoch', $ref->getAuthorEpoch());
	$data->setCommitDetail('authorName', $ref->getAuthorName());
	$data->setCommitDetail('authorEmail', $ref->getAuthorEmail());

	$data->setCommitDetail(
	'authorPHID',
	$this->resolveUserPHID($commit, $author));

	$data->setCommitMessage($message);

	if (strlen($committer)) {
	$data->setCommitDetail('committer', $committer);

	$data->setCommitDetail('committerName', $ref->getCommitterName());
	$data->setCommitDetail('committerEmail', $ref->getCommitterEmail());

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

	$differential_app = 'PhabricatorDifferentialApplication';
	$revision_id = null;
	$low_level_query = null;
	if (PhabricatorApplication::isClassInstalled($differential_app)) {
	$low_level_query = id(new DiffusionLowLevelCommitFieldsQuery())
	->setRepository($repository)
	->withCommitRef($ref);
	$field_values = $low_level_query->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();

	// Figure out if we're going to try to "autoclose" related objects (e.g.,
	// close linked tasks and related revisions) and, if not, record why we
	// aren't. Autoclose can be disabled for various reasons at the repository
	// or commit levels.

	$force_autoclose = idx($this->getTaskData(), 'forceAutoclose', false);
	if ($force_autoclose) {
	$autoclose_reason = PhabricatorRepository::BECAUSE_AUTOCLOSE_FORCED;
	} else {
	$autoclose_reason = $repository->shouldSkipAutocloseCommit($commit);
	}
	$data->setCommitDetail('autocloseReason', $autoclose_reason);
	$should_autoclose = $force_autoclose \|\|
	$repository->shouldAutocloseCommit($commit);


	// When updating related objects, we'll act under an omnipotent user to
	// ensure we can see them, but take actions as either the committer or
	// author (if we recognize their accounts) or the Diffusion application
	// (if we do not).

	$actor = PhabricatorUser::getOmnipotentUser();
	$acting_as_phid = nonempty(
	$committer_phid,
	$author_phid,
	id(new PhabricatorDiffusionApplication())->getPHID());

	$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;
	if ($revision_id) {
	$revision_query = id(new DifferentialRevisionQuery())
	->withIDs(array($revision_id))
	->setViewer($actor)
	- ->needReviewerStatus(true)
	+ ->needReviewers(true)
	->needActiveDiffs(true);

	$revision = $revision_query->executeOne();

	if ($revision) {
	if (!$data->getCommitDetail('precommitRevisionStatus')) {
	$data->setCommitDetail(
	'precommitRevisionStatus',
	$revision->getStatus());
	}
	$commit_drev = DiffusionCommitHasRevisionEdgeType::EDGECONST;
	id(new PhabricatorEdgeEditor())
	->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) {
	$commit_close_xaction = id(new DifferentialTransaction())
	->setTransactionType(DifferentialTransaction::TYPE_ACTION)
	->setNewValue(DifferentialAction::ACTION_CLOSE)
	->setMetadataValue('isCommitClose', true);

	$commit_close_xaction->setMetadataValue(
	'commitPHID',
	$commit->getPHID());
	$commit_close_xaction->setMetadataValue(
	'committerPHID',
	$committer_phid);
	$commit_close_xaction->setMetadataValue(
	'committerName',
	$data->getCommitDetail('committer'));
	$commit_close_xaction->setMetadataValue(
	'authorPHID',
	$author_phid);
	$commit_close_xaction->setMetadataValue(
	'authorName',
	$data->getAuthorName());

	if ($low_level_query) {
	$commit_close_xaction->setMetadataValue(
	'revisionMatchData',
	$low_level_query->getRevisionMatchData());
	$data->setCommitDetail(
	'revisionMatchData',
	$low_level_query->getRevisionMatchData());
	}

	$extraction_engine = id(new DifferentialDiffExtractionEngine())
	->setViewer($actor)
	->setAuthorPHID($acting_as_phid);

	$content_source = $this->newContentSource();

	$update_data = $extraction_engine->updateRevisionWithCommit(
	$revision,
	$commit,
	array(
	$commit_close_xaction,
	),
	$content_source);

	foreach ($update_data as $key => $value) {
	$data->setCommitDetail($key, $value);
	}
	}
	}
	}

	if ($should_autoclose) {
	$this->closeTasks(
	$actor,
	$acting_as_phid,
	$repository,
	$commit,
	$message);
	}

	$data->save();

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

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

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

	private function closeTasks(
	PhabricatorUser $actor,
	$acting_as,
	PhabricatorRepository $repository,
	PhabricatorRepositoryCommit $commit,
	$message) {

	$maniphest = 'PhabricatorManiphestApplication';
	if (!PhabricatorApplication::isClassInstalled($maniphest)) {
	return;
	}

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

	if (!$task_statuses) {
	return;
	}

	$tasks = id(new ManiphestTaskQuery())
	->setViewer($actor)
	->withIDs(array_keys($task_statuses))
	->needProjectPHIDs(true)
	->execute();

	foreach ($tasks as $task_id => $task) {
	$xactions = array();

	$edge_type = ManiphestTaskHasCommitEdgeType::EDGECONST;
	$edge_xaction = id(new ManiphestTransaction())
	->setTransactionType(PhabricatorTransactions::TYPE_EDGE)
	->setMetadataValue('edge:type', $edge_type)
	->setNewValue(
	array(
	'+' => array(
	$commit->getPHID() => $commit->getPHID(),
	),
	));

	$status = $task_statuses[$task_id];
	if ($status) {
	if ($task->getStatus() != $status) {
	$xactions[] = id(new ManiphestTransaction())
	->setTransactionType(ManiphestTransaction::TYPE_STATUS)
	->setMetadataValue('commitPHID', $commit->getPHID())
	->setNewValue($status);

	$edge_xaction->setMetadataValue('commitPHID', $commit->getPHID());
	}
	}

	$xactions[] = $edge_xaction;

	$content_source = $this->newContentSource();

	$editor = id(new ManiphestTransactionEditor())
	->setActor($actor)
	->setActingAsPHID($acting_as)
	->setContinueOnNoEffect(true)
	->setContinueOnMissingFields(true)
	->setUnmentionablePHIDMap(
	array($commit->getPHID() => $commit->getPHID()))
	->setContentSource($content_source);

	$editor->applyTransactions($task, $xactions);
	}
	}

	}

File Metadata

Mime Type: text/x-diff
Expires: Mon, Jul 28, 8:28 AM (1 w, 18 h ago)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 186540
Default Alt Text: (298 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions