No OneTemporary
Actions

Size

70 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/resources/sql/patches/130.denormalrevisionquery.sql b/resources/sql/patches/130.denormalrevisionquery.sql
	new file mode 100644
	index 0000000000..125d7131a3
	--- /dev/null
	+++ b/resources/sql/patches/130.denormalrevisionquery.sql
	@@ -0,0 +1,5 @@
	+ALTER TABLE phabricator_differential.differential_revision
	+ ADD branchName VARCHAR(255) COLLATE utf8_general_ci;
	+
	+ALTER TABLE phabricator_differential.differential_revision
	+ ADD arcanistProjectPHID VARCHAR(64) COLLATE utf8_bin;
	diff --git a/resources/sql/patches/131.migraterevisionquery.php b/resources/sql/patches/131.migraterevisionquery.php
	new file mode 100644
	index 0000000000..aacb1ea9df
	--- /dev/null
	+++ b/resources/sql/patches/131.migraterevisionquery.php
	@@ -0,0 +1,44 @@
	+<?php
	+
	+/*
	+ * Copyright 2012 Facebook, Inc.
	+ *
	+ * Licensed under the Apache License, Version 2.0 (the "License");
	+ * you may not use this file except in compliance with the License.
	+ * You may obtain a copy of the License at
	+ *
	+ * http://www.apache.org/licenses/LICENSE-2.0
	+ *
	+ * Unless required by applicable law or agreed to in writing, software
	+ * distributed under the License is distributed on an "AS IS" BASIS,
	+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	+ * See the License for the specific language governing permissions and
	+ * limitations under the License.
	+ */
	+
	+$table = new DifferentialRevision();
	+$conn_w = $table->establishConnection('w');
	+
	+$revisions = id(new DifferentialRevision())->loadAll();
	+
	+echo "Migrating ".count($revisions)." revisions";
	+foreach ($revisions as $revision) {
	+ echo ".";
	+
	+ $diff = $revision->loadActiveDiff();
	+ if (!$diff) {
	+ continue;
	+ }
	+
	+ $branch_name = $diff->getBranch();
	+ $arc_project_phid = $diff->getArcanistProjectPHID();
	+
	+ queryfx(
	+ $conn_w,
	+ 'UPDATE %T SET branchName = %s, arcanistProjectPHID = %s WHERE id = %d',
	+ $table->getTableName(),
	+ $branch_name,
	+ $arc_project_phid,
	+ $revision->getID());
	+}
	+echo "\nDone.\n";
	diff --git a/src/applications/conduit/method/differential/query/ConduitAPI_differential_query_Method.php b/src/applications/conduit/method/differential/query/ConduitAPI_differential_query_Method.php
	index ac75247814..983a4c0e2d 100644
	--- a/src/applications/conduit/method/differential/query/ConduitAPI_differential_query_Method.php
	+++ b/src/applications/conduit/method/differential/query/ConduitAPI_differential_query_Method.php
	@@ -1,203 +1,218 @@
	<?php

	/*
	* Copyright 2012 Facebook, Inc.
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

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

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

	public function defineParamTypes() {
	$hash_types = ArcanistDifferentialRevisionHash::getTypes();
	$hash_types = implode(', ', $hash_types);

	$status_types = array(
	DifferentialRevisionQuery::STATUS_ANY,
	DifferentialRevisionQuery::STATUS_OPEN,
	DifferentialRevisionQuery::STATUS_ACCEPTED,
	DifferentialRevisionQuery::STATUS_COMMITTED,
	);
	$status_types = implode(', ', $status_types);

	$order_types = array(
	DifferentialRevisionQuery::ORDER_MODIFIED,
	DifferentialRevisionQuery::ORDER_CREATED,
	);
	$order_types = implode(', ', $order_types);

	return array(
	'authors' => 'optional list<phid>',
	'ccs' => 'optional list<phid>',
	'reviewers' => 'optional list<phid>',
	// TODO: Implement this, it needs to accept a repository ID in addition
	// to a path so the signature needs to be a little more complicated.
	// 'paths' => 'optional list<pair<...>>',
	'commitHashes' => 'optional list<pair<enum<'.
	$hash_types.'>, string>>',
	'status' => 'optional enum<'.$status_types.'>',
	'order' => 'optional enum<'.$order_types.'>',
	'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>',
	+ 'arcanistProjects' => 'optional list<string>',
	);
	}

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

	public function defineErrorTypes() {
	return array(
	'ERR-INVALID-PARAMETER' => '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');
	$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');
	+ $arc_projects = $request->getValue('arcanistProjects');

	$query = new DifferentialRevisionQuery();
	if ($authors) {
	$query->withAuthors($authors);
	}
	if ($ccs) {
	$query->withCCs($ccs);
	}
	if ($reviewers) {
	$query->withReviewers($reviewers);
	}
	/* TODO: Implement.
	$paths = $request->getValue('paths');
	if ($paths) {
	foreach ($paths as $path) {

	// (Lookup the repository IDs.)

	$query->withPath($repository_id, $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->withSubscribers($subscribers);
	}
	if ($branches) {
	$query->withBranches($branches);
	}
	+ if ($arc_projects) {
	+ // This is sort of special-cased, but don't make arc do an extra round
	+ // trip.
	+ $projects = id(new PhabricatorRepositoryArcanistProject())
	+ ->loadAllWhere(
	+ 'name in (%Ls)',
	+ $arc_projects);
	+ if (!$projects) {
	+ return array();
	+ }
	+
	+ $query->withArcanistProjectPHIDs(mpull($projects, 'getPHID'));
	+ }

	$query->needRelationships(true);
	$query->needCommitPHIDs(true);
	$query->needDiffIDs(true);
	$query->needActiveDiffs(true);

	$revisions = $query->execute();

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

	$id = $revision->getID();
	$result = array(
	'id' => $id,
	'phid' => $revision->getPHID(),
	'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()),
	'branch' => $diff->getBranch(),
	'summary' => $revision->getSummary(),
	'testPlan' => $revision->getTestPlan(),
	'lineCount' => $revision->getLineCount(),
	'diffs' => $revision->getDiffIDs(),
	'commits' => $revision->getCommitPHIDs(),
	'reviewers' => array_values($revision->getReviewers()),
	'ccs' => array_values($revision->getCCPHIDs()),
	);

	// 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/conduit/method/differential/query/__init__.php b/src/applications/conduit/method/differential/query/__init__.php
	index 131a224e23..2e58c93283 100644
	--- a/src/applications/conduit/method/differential/query/__init__.php
	+++ b/src/applications/conduit/method/differential/query/__init__.php
	@@ -1,18 +1,21 @@
	<?php
	/**
	* This file is automatically generated. Lint this module to rebuild it.
	* @generated
	*/



	phutil_require_module('arcanist', 'differential/constants/revisionhash');
	phutil_require_module('arcanist', 'differential/constants/revisionstatus');

	phutil_require_module('phabricator', 'applications/conduit/method/base');
	phutil_require_module('phabricator', 'applications/conduit/protocol/exception');
	phutil_require_module('phabricator', 'applications/differential/query/revision');
	+phutil_require_module('phabricator', 'applications/repository/storage/arcanistproject');
	phutil_require_module('phabricator', 'infrastructure/env');

	+phutil_require_module('phutil', 'utils');
	+

	phutil_require_source('ConduitAPI_differential_query_Method.php');
	diff --git a/src/applications/differential/editor/revision/DifferentialRevisionEditor.php b/src/applications/differential/editor/revision/DifferentialRevisionEditor.php
	index 496b4766fb..e31ad1f260 100644
	--- a/src/applications/differential/editor/revision/DifferentialRevisionEditor.php
	+++ b/src/applications/differential/editor/revision/DifferentialRevisionEditor.php
	@@ -1,957 +1,963 @@
	<?php

	/*
	* Copyright 2012 Facebook, Inc.
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

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

	protected $revision;
	protected $actorPHID;

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

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

	public function __construct(DifferentialRevision $revision, $actor_phid) {
	$this->revision = $revision;
	$this->actorPHID = $actor_phid;
	}

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

	$revision = new DifferentialRevision();
	$revision->setPHID($revision->generatePHID());

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

	$editor = new DifferentialRevisionEditor($revision, $user_phid);

	$editor->copyFieldsFromConduit($fields);

	$editor->addDiff($diff, null);
	$editor->save();

	return $revision;
	}

	public function copyFieldsFromConduit(array $fields) {

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

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

	$user = id(new PhabricatorUser())->loadOneWhere(
	'phid = %s',
	$this->actorPHID);

	foreach ($aux_fields as $key => $aux_field) {
	$aux_field->setRevision($revision);
	$aux_field->setUser($user);
	if (!$aux_field->shouldAppearOnCommitMessage()) {
	unset($aux_fields[$key]);
	}
	}

	$aux_fields = mpull($aux_fields, null, 'getCommitMessageKey');

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

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

	$aux_fields = array_values($aux_fields);
	$this->setAuxiliaryFields($aux_fields);
	}

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

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

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

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

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

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

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

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

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

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

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

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

	$is_new = $this->isNewRevision();
	if ($is_new) {
	$this->initializeNewRevision($revision);
	}

	$revision->loadRelationships();

	$this->willWriteRevision();

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

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

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

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

	$revision->openTransaction();

	+ if ($diff) {
	+ $revision->setBranchName($diff->getBranch());
	+ $revision->setArcanistProjectPHID($diff->getArcanistProjectPHID());
	+ }
	+
	$revision->save();
	+
	if ($diff) {
	$diff->setRevisionID($revision->getID());
	$diff->save();
	}

	$revision->saveTransaction();


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

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

	$xscript_header = null;
	$xscript_uri = null;

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

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

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

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

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

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

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

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

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

	self::alterReviewers(
	$revision,
	$this->reviewers,
	array_keys($rem['rev']),
	array_keys($add['rev']),
	$this->actorPHID);

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

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

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

	$this->updateAuxiliaryFields();

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

	$mail = array();

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

	$handles = id(new PhabricatorObjectHandleData($phids))
	->loadHandles();
	$actor_handle = $handles[$this->getActorPHID()];

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

	// Save the changes we made above.

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

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

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

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

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

	$revision->save();

	$this->didWriteRevision();

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

	id(new PhabricatorFeedStoryPublisher())
	->setStoryType(PhabricatorFeedStoryTypeConstants::STORY_DIFFERENTIAL)
	->setStoryData($event_data)
	->setStoryTime(time())
	->setStoryAuthorPHID($revision->getAuthorPHID())
	->setRelatedPHIDs(
	array(
	$revision->getPHID(),
	$revision->getAuthorPHID(),
	))
	->publish();

	// TODO: Move this into a worker task thing.
	PhabricatorSearchDifferentialIndexer::indexRevision($revision);

	if ($this->silentUpdate) {
	return;
	}

	$revision->loadRelationships();

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

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

	$mail[] = $message;
	}

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

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

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

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

	public static function addCCAndUpdateRevision(
	$revision,
	$phid,
	$reason) {

	self::addCC($revision, $phid, $reason);

	$unsubscribed = $revision->getUnsubscribed();
	if (isset($unsubscribed[$phid])) {
	unset($unsubscribed[$phid]);
	$revision->setUnsubscribed($unsubscribed);
	$revision->save();
	}
	}

	public static function removeCCAndUpdateRevision(
	$revision,
	$phid,
	$reason) {

	self::removeCC($revision, $phid, $reason);

	$unsubscribed = $revision->getUnsubscribed();
	if (empty($unsubscribed[$phid])) {
	$unsubscribed[$phid] = true;
	$revision->setUnsubscribed($unsubscribed);
	$revision->save();
	}
	}

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

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

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

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

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

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

	public static function alterReviewers(
	DifferentialRevision $revision,
	array $stable_phids,
	array $rem_phids,
	array $add_phids,
	$reason_phid) {

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

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

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

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

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

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

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

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

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

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

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

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

	$revision->loadRelationships();
	}


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

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

	$comment->save();

	return $comment;
	}

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

	if (!$aux_map) {
	return;
	}

	$revision = $this->revision;

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

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

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

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

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

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

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

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

	$path_prefix = null;

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

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

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

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

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

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

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

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

	$sql = array();
	foreach ($all_paths as $path) {
	$path_id = idx($path_map, $path);
	if (!$path_id) {
	// Don't bother creating these, it probably means we're either adding
	// a file (in which case having this row is irrelevant since Diffusion
	// won't be querying for it) or something is misconfigured (in which
	// case we'd just be writing garbage).
	continue;
	}
	$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 initializeNewRevision(DifferentialRevision $revision) {
	// These fields aren't nullable; set them to sensible defaults if they
	// haven't been configured. We're just doing this so we can generate an
	// ID for the revision if we don't have one already.
	$revision->setLineCount(0);
	if ($revision->getStatus() === null) {
	$revision->setStatus(ArcanistDifferentialRevisionStatus::NEEDS_REVIEW);
	}
	if ($revision->getTitle() === null) {
	$revision->setTitle('Untitled Revision');
	}
	if ($revision->getAuthorPHID() === null) {
	$revision->setAuthorPHID($this->getActorPHID());
	}
	if ($revision->getSummary() === null) {
	$revision->setSummary('');
	}
	if ($revision->getTestPlan() === null) {
	$revision->setTestPlan('');
	}
	}

	}

	diff --git a/src/applications/differential/query/revision/DifferentialRevisionQuery.php b/src/applications/differential/query/revision/DifferentialRevisionQuery.php
	index 2e512a613f..e14aa25470 100644
	--- a/src/applications/differential/query/revision/DifferentialRevisionQuery.php
	+++ b/src/applications/differential/query/revision/DifferentialRevisionQuery.php
	@@ -1,856 +1,859 @@
	<?php

	/*
	* Copyright 2012 Facebook, Inc.
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

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

	// TODO: Replace DifferentialRevisionListData with this class.

	private $pathIDs = array();

	private $status = 'status-any';
	const STATUS_ANY = 'status-any';
	const STATUS_OPEN = 'status-open';
	const STATUS_ACCEPTED = 'status-accepted';
	const STATUS_COMMITTED = 'status-committed';
	const STATUS_ABANDONED = 'status-abandoned';

	private $authors = array();
	private $draftAuthors = array();
	private $ccs = array();
	private $reviewers = array();
	private $revIDs = array();
	private $commitHashes = array();
	private $phids = array();
	private $subscribers = array();
	private $responsibles = array();
	private $branches = array();
	+ private $arcanistProjectPHIDs = array();

	private $order = 'order-modified';
	const ORDER_MODIFIED = 'order-modified';
	const ORDER_CREATED = 'order-created';
	/**
	* This is essentially a denormalized copy of the revision modified time that
	* should perform better for path queries with a LIMIT. Critically, when you
	* browse "/", every revision in that repository for all time will match so
	* the query benefits from being able to stop before fully materializing the
	* result set.
	*/
	const ORDER_PATH_MODIFIED = 'order-path-modified';

	private $limit = 1000;
	private $offset = 0;

	private $needRelationships = false;
	private $needActiveDiffs = false;
	private $needDiffIDs = false;
	private $needCommitPHIDs = false;


	/* -( 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 with comments authored bythe given PHIDs
	*
	* @param array List of PHIDs of authors
	* @return this
	* @task config
	*/
	public function withDraftRepliesByAuthors(array $author_phids) {
	$this->draftAuthors = $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 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;
	}


	/**
	* Filter results to only return revisions with a given set of subscribers
	* (i.e., they are authors, reviewers or CC'd).
	*
	* @param array List of user PHIDs.
	* @return this
	* @task config
	*/
	public function withSubscribers(array $subscriber_phids) {
	$this->subscribers = $subscriber_phids;
	return $this;
	}


	+ /**
	+ * Filter results to only return revisions with a given set of arcanist
	+ * projects.
	+ *
	+ * @param array List of project PHIDs.
	+ * @return this
	+ * @task config
	+ */
	+ public function withArcanistProjectPHIDs(array $arc_project_phids) {
	+ $this->arcanistProjectPHIDs = $arc_project_phids;
	+ return $this;
	+ }
	+
	+
	/**
	* Set result ordering. Provide a class constant, such as
	* ##DifferentialRevisionQuery::ORDER_CREATED##.
	*
	* @task config
	*/
	public function setOrder($order_constant) {
	$this->order = $order_constant;
	return $this;
	}


	/**
	* Set result limit. If unspecified, defaults to 1000.
	*
	* @param int Result limit.
	* @return this
	* @task config
	*/
	public function setLimit($limit) {
	$this->limit = $limit;
	return $this;
	}


	/**
	* Set result offset. If unspecified, defaults to 0.
	*
	* @param int Result offset.
	* @return this
	* @task config
	*/
	public function setOffset($offset) {
	$this->offset = $offset;
	return $this;
	}


	/**
	* Set whether or not the query will load and attach relationships.
	*
	* @param bool True to load and attach relationships.
	* @return this
	* @task config
	*/
	public function needRelationships($need_relationships) {
	$this->needRelationships = $need_relationships;
	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;
	}


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


	/**
	* Execute the query as configured, returning matching
	* @{class:DifferentialRevision} objects.
	*
	* @return list List of matching DifferentialRevision objects.
	* @task exec
	*/
	public function execute() {
	$table = new DifferentialRevision();
	$conn_r = $table->establishConnection('r');

	if ($this->shouldUseResponsibleFastPath()) {
	$data = $this->loadDataUsingResponsibleFastPath();
	} else {
	$data = $this->loadData();
	}

	$revisions = $table->loadAllFromArray($data);

	if ($revisions) {
	if ($this->needRelationships) {
	$this->loadRelationships($conn_r, $revisions);
	}

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

	- $need_active = $this->needActiveDiffs \|\|
	- $this->branches;
	-
	+ $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->branches) {
	-
	- // TODO: We could filter this in SQL instead and might get better
	- // performance in some cases.
	-
	- $branch_map = array_fill_keys($this->branches, true);
	- foreach ($revisions as $key => $revision) {
	- $diff = $revision->getActiveDiff();
	- if (!$diff) {
	- unset($revisions[$key]);
	- continue;
	- }
	-
	- // TODO: Old arc uploaded the wrong branch name for Mercurial (i.e.,
	- // with a trailing "\n"). Once the arc version gets bumped, do a
	- // migration and remove this.
	- $branch = trim($diff->getBranch());
	-
	- if (!$diff \|\| empty($branch_map[$branch])) {
	- unset($revisions[$key]);
	- continue;
	- }
	- }
	- }
	}

	return $revisions;
	}


	/**
	* Determine if we should execute an optimized, fast-path query to fetch
	* open revisions for one responsible user. This is used by the Differential
	* dashboard and much faster when executed as a UNION ALL than with JOIN
	* and WHERE, which is why we special case it.
	*/
	private function shouldUseResponsibleFastPath() {
	if ((count($this->responsibles) == 1) &&
	($this->status == self::STATUS_OPEN) &&
	($this->order == self::ORDER_MODIFIED) &&
	!$this->offset &&
	!$this->limit &&
	!$this->subscribers &&
	!$this->reviewers &&
	!$this->ccs &&
	!$this->authors &&
	!$this->revIDs &&
	!$this->commitHashes &&
	- !$this->phids) {
	+ !$this->phids &&
	+ !$this->branches &&
	+ !$this->arcanistProjectPHIDs) {
	return true;
	}
	return false;
	}


	private function loadDataUsingResponsibleFastPath() {
	$table = new DifferentialRevision();
	$conn_r = $table->establishConnection('r');

	$responsible_phid = reset($this->responsibles);
	$open_statuses = array(
	ArcanistDifferentialRevisionStatus::NEEDS_REVIEW,
	ArcanistDifferentialRevisionStatus::NEEDS_REVISION,
	ArcanistDifferentialRevisionStatus::ACCEPTED,
	);

	return queryfx_all(
	$conn_r,
	'SELECT * FROM %T WHERE authorPHID = %s AND status IN (%Ld)
	UNION ALL
	SELECT r.* FROM %T r JOIN %T rel
	ON rel.revisionID = r.id
	AND rel.relation = %s
	AND rel.objectPHID = %s
	WHERE r.status IN (%Ld) ORDER BY dateModified DESC',
	$table->getTableName(),
	$responsible_phid,
	$open_statuses,

	$table->getTableName(),
	DifferentialRevision::RELATIONSHIP_TABLE,
	DifferentialRevision::RELATION_REVIEWER,
	$responsible_phid,
	$open_statuses);
	}

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

	$select = qsprintf(
	$conn_r,
	'SELECT r.* FROM %T r',
	$table->getTableName());

	$joins = $this->buildJoinsClause($conn_r);
	$where = $this->buildWhereClause($conn_r);
	$group_by = $this->buildGroupByClause($conn_r);
	$order_by = $this->buildOrderByClause($conn_r);

	$limit = '';
	if ($this->offset \|\| $this->limit) {
	$limit = qsprintf(
	$conn_r,
	'LIMIT %d, %d',
	(int)$this->offset,
	$this->limit);
	}

	return queryfx_all(
	$conn_r,
	'%Q %Q %Q %Q %Q %Q',
	$select,
	$joins,
	$where,
	$group_by,
	$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 cc_rel ON cc_rel.revisionID = r.id '.
	'AND cc_rel.relation = %s '.
	'AND cc_rel.objectPHID in (%Ls)',
	DifferentialRevision::RELATIONSHIP_TABLE,
	DifferentialRevision::RELATION_SUBSCRIBED,
	$this->ccs);
	}

	if ($this->reviewers) {
	$joins[] = qsprintf(
	$conn_r,
	'JOIN %T reviewer_rel ON reviewer_rel.revisionID = r.id '.
	'AND reviewer_rel.relation = %s '.
	'AND reviewer_rel.objectPHID in (%Ls)',
	DifferentialRevision::RELATIONSHIP_TABLE,
	DifferentialRevision::RELATION_REVIEWER,
	$this->reviewers);
	}

	if ($this->subscribers) {
	$joins[] = qsprintf(
	$conn_r,
	'JOIN %T sub_rel ON sub_rel.revisionID = r.id '.
	'AND sub_rel.relation IN (%Ls) '.
	'AND sub_rel.objectPHID in (%Ls)',
	DifferentialRevision::RELATIONSHIP_TABLE,
	array(
	DifferentialRevision::RELATION_SUBSCRIBED,
	DifferentialRevision::RELATION_REVIEWER,
	),
	$this->subscribers);
	}

	if ($this->responsibles) {
	$joins[] = qsprintf(
	$conn_r,
	'LEFT JOIN %T responsibles_rel ON responsibles_rel.revisionID = r.id '.
	'AND responsibles_rel.relation = %s '.
	'AND responsibles_rel.objectPHID in (%Ls)',
	DifferentialRevision::RELATIONSHIP_TABLE,
	DifferentialRevision::RELATION_REVIEWER,
	$this->responsibles);
	}

	if ($this->draftAuthors) {
	$joins[] = qsprintf(
	$conn_r,
	'JOIN %T inline_comment ON inline_comment.revisionID = r.id '.
	'AND inline_comment.commentID is NULL',
	id(new DifferentialInlineComment())->getTableName());
	}

	$joins = implode(' ', $joins);

	return $joins;
	}


	/**
	* @task internal
	*/
	private function buildWhereClause($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,
	'(repositoryID = %d AND pathID IN (%Ld))',
	$repository_id,
	ipull($paths, 'pathID'));
	}
	$path_clauses = '('.implode(' OR ', $path_clauses).')';
	$where[] = $path_clauses;
	}

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

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

	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->phids) {
	$where[] = qsprintf(
	$conn_r,
	'phid IN (%Ls)',
	$this->phids);
	}

	if ($this->responsibles) {
	$where[] = qsprintf(
	$conn_r,
	'(responsibles_rel.objectPHID IS NOT NULL OR r.authorPHID IN (%Ls))',
	$this->responsibles);
	}

	+ if ($this->branches) {
	+ $where[] = qsprintf(
	+ $conn_r,
	+ 'r.branchName in (%Ls)',
	+ $this->branches);
	+ }
	+
	+ if ($this->arcanistProjectPHIDs) {
	+ $where[] = qsprintf(
	+ $conn_r,
	+ 'r.arcanistProjectPHID in (%Ls)',
	+ $this->arcanistProjectPHIDs);
	+ }
	+
	switch ($this->status) {
	case self::STATUS_ANY:
	break;
	case self::STATUS_OPEN:
	$where[] = qsprintf(
	$conn_r,
	'status IN (%Ld)',
	array(
	ArcanistDifferentialRevisionStatus::NEEDS_REVIEW,
	ArcanistDifferentialRevisionStatus::NEEDS_REVISION,
	ArcanistDifferentialRevisionStatus::ACCEPTED,
	));
	break;
	case self::STATUS_ACCEPTED:
	$where[] = qsprintf(
	$conn_r,
	'status IN (%Ld)',
	array(
	ArcanistDifferentialRevisionStatus::ACCEPTED,
	));
	break;
	case self::STATUS_COMMITTED:
	$where[] = qsprintf(
	$conn_r,
	'status IN (%Ld)',
	array(
	ArcanistDifferentialRevisionStatus::COMMITTED,
	));
	break;
	case self::STATUS_ABANDONED:
	$where[] = qsprintf(
	$conn_r,
	'status IN (%Ld)',
	array(
	ArcanistDifferentialRevisionStatus::ABANDONED,
	));
	break;
	default:
	throw new Exception(
	"Unknown revision status filter constant '{$this->status}'!");
	}

	if ($where) {
	$where = 'WHERE '.implode(' AND ', $where);
	} else {
	$where = '';
	}

	return $where;
	}


	/**
	* @task internal
	*/
	private function buildGroupByClause($conn_r) {
	$join_triggers = array_merge(
	$this->pathIDs,
	$this->ccs,
	$this->reviewers,
	$this->subscribers,
	$this->responsibles);

	$needs_distinct = (count($join_triggers) > 1);

	if ($needs_distinct) {
	return 'GROUP BY r.id';
	} else {
	return '';
	}
	}


	/**
	* @task internal
	*/
	private function buildOrderByClause($conn_r) {
	switch ($this->order) {
	case self::ORDER_MODIFIED:
	return 'ORDER BY r.dateModified DESC';
	case self::ORDER_CREATED:
	return 'ORDER BY r.dateCreated DESC';
	case self::ORDER_PATH_MODIFIED:
	if (!$this->pathIDs) {
	throw new Exception(
	"To use ORDER_PATH_MODIFIED, you must specify withPath().");
	}
	return 'ORDER BY p.epoch DESC';
	default:
	throw new Exception("Unknown query order constant '{$this->order}'.");
	}
	}

	private function loadRelationships($conn_r, array $revisions) {
	assert_instances_of($revisions, 'DifferentialRevision');
	$relationships = queryfx_all(
	$conn_r,
	'SELECT * FROM %T WHERE revisionID in (%Ld) ORDER BY sequence',
	DifferentialRevision::RELATIONSHIP_TABLE,
	mpull($revisions, 'getID'));
	$relationships = igroup($relationships, 'revisionID');
	foreach ($revisions as $revision) {
	$revision->attachRelationships(
	idx(
	$relationships,
	$revision->getID(),
	array()));
	}
	}

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

	public static function splitResponsible(array $revisions, $user_phid) {
	$active = array();
	$waiting = array();
	$status_review = ArcanistDifferentialRevisionStatus::NEEDS_REVIEW;

	// Bucket revisions into $active (revisions you need to do something
	// about) and $waiting (revisions you're waiting on someone else to do
	// something about).
	foreach ($revisions as $revision) {
	$needs_review = ($revision->getStatus() == $status_review);
	$filter_is_author = ($revision->getAuthorPHID() == $user_phid);

	// If exactly one of "needs review" and "the user is the author" is
	// true, the user needs to act on it. Otherwise, they're waiting on
	// it.
	if ($needs_review ^ $filter_is_author) {
	$active[] = $revision;
	} else {
	$waiting[] = $revision;
	}
	}

	return array($active, $waiting);
	}


	}
	diff --git a/src/applications/differential/storage/revision/DifferentialRevision.php b/src/applications/differential/storage/revision/DifferentialRevision.php
	index bdfb745c96..e25431f6ee 100644
	--- a/src/applications/differential/storage/revision/DifferentialRevision.php
	+++ b/src/applications/differential/storage/revision/DifferentialRevision.php
	@@ -1,226 +1,229 @@
	<?php

	/*
	* Copyright 2012 Facebook, Inc.
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	final class DifferentialRevision extends DifferentialDAO {

	protected $title;
	protected $status;

	protected $summary;
	protected $testPlan;

	protected $phid;
	protected $authorPHID;
	protected $lastReviewerPHID;

	protected $dateCommitted;

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

	protected $mailKey;
	+ protected $branchName;
	+ protected $arcanistProjectPHID;

	private $relationships;
	private $commits;
	private $activeDiff = false;
	private $diffIDs;

	+
	const RELATIONSHIP_TABLE = 'differential_relationship';
	const TABLE_COMMIT = 'differential_commit';

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

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

	public function 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() {
	if ($this->commits === null) {
	throw new Exception("Must attach commits first!");
	}
	return $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.

	if ($this->activeDiff === false) {
	throw new Exception("Must attach active diff first!");
	}
	return $this->activeDiff;
	}

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

	public function getDiffIDs() {
	if ($this->diffIDs === null) {
	throw new Exception("Must attach diff IDs first!");
	}
	return $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(
	PhabricatorPHIDConstants::PHID_TYPE_DREV);
	}

	public function loadDiffs() {
	if (!$this->getID()) {
	return array();
	}
	return id(new DifferentialDiff())->loadAllWhere(
	'revisionID = %d',
	$this->getID());
	}

	public function loadComments() {
	if (!$this->getID()) {
	return array();
	}
	return id(new DifferentialComment())->loadAllWhere(
	'revisionID = %d',
	$this->getID());
	}

	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 loadRelationships() {
	if (!$this->getID()) {
	$this->relationships = array();
	return;
	}

	$data = queryfx_all(
	$this->establishConnection('r'),
	'SELECT * FROM %T WHERE revisionID = %d ORDER BY sequence',
	self::RELATIONSHIP_TABLE,
	$this->getID());

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

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

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

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

	private function getRelatedPHIDs($relation) {
	if ($this->relationships === null) {
	throw new Exception("Must load relationships!");
	}

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

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

	public function getUnsubscribedPHIDs() {
	return array_keys($this->getUnsubscribed());
	}

	public function loadReviewedBy() {
	$reviewer = null;

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

	return $reviewer;
	}
	}

File Metadata

Mime Type: text/x-diff
Expires: Sun, Jan 19, 15:13 (3 w, 1 d ago)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1125866
Default Alt Text: (70 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions