No OneTemporary
Actions

Size

114 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/src/applications/differential/controller/DifferentialController.php b/src/applications/differential/controller/DifferentialController.php
	index 1860a07745..8fe5b5caca 100644
	--- a/src/applications/differential/controller/DifferentialController.php
	+++ b/src/applications/differential/controller/DifferentialController.php
	@@ -1,276 +1,286 @@
	<?php

	abstract class DifferentialController extends PhabricatorController {

	private $packageChangesetMap;
	private $pathPackageMap;
	private $authorityPackages;

	public function buildSideNavView($for_app = false) {
	$viewer = $this->getRequest()->getUser();

	$nav = new AphrontSideNavFilterView();
	$nav->setBaseURI(new PhutilURI($this->getApplicationURI()));

	id(new DifferentialRevisionSearchEngine())
	->setViewer($viewer)
	->addNavigationItems($nav->getMenu());

	$nav->selectFilter(null);

	return $nav;
	}

	public function buildApplicationMenu() {
	return $this->buildSideNavView(true)->getMenu();
	}

	protected function buildPackageMaps(array $changesets) {
	assert_instances_of($changesets, 'DifferentialChangeset');

	$this->packageChangesetMap = array();
	$this->pathPackageMap = array();
	$this->authorityPackages = array();

	if (!$changesets) {
	return;
	}

	$viewer = $this->getViewer();

	$have_owners = PhabricatorApplication::isClassInstalledForViewer(
	'PhabricatorOwnersApplication',
	$viewer);
	if (!$have_owners) {
	return;
	}

	$changeset = head($changesets);
	$diff = $changeset->getDiff();
	$repository_phid = $diff->getRepositoryPHID();
	if (!$repository_phid) {
	return;
	}

	if ($viewer->getPHID()) {
	$packages = id(new PhabricatorOwnersPackageQuery())
	->setViewer($viewer)
	->withStatuses(array(PhabricatorOwnersPackage::STATUS_ACTIVE))
	->withAuthorityPHIDs(array($viewer->getPHID()))
	->execute();
	$this->authorityPackages = $packages;
	}

	$paths = mpull($changesets, 'getOwnersFilename');

	$control_query = id(new PhabricatorOwnersPackageQuery())
	->setViewer($viewer)
	->withStatuses(array(PhabricatorOwnersPackage::STATUS_ACTIVE))
	->withControl($repository_phid, $paths);
	$control_query->execute();

	foreach ($changesets as $changeset) {
	$changeset_path = $changeset->getOwnersFilename();

	$packages = $control_query->getControllingPackagesForPath(
	$repository_phid,
	$changeset_path);

	+ // If this particular changeset is generated code and the package does
	+ // not match generated code, remove it from the list.
	+ if ($changeset->isGeneratedChangeset()) {
	+ foreach ($packages as $key => $package) {
	+ if ($package->getMustMatchUngeneratedPaths()) {
	+ unset($packages[$key]);
	+ }
	+ }
	+ }
	+
	$this->pathPackageMap[$changeset_path] = $packages;
	foreach ($packages as $package) {
	$this->packageChangesetMap[$package->getPHID()][] = $changeset;
	}
	}
	}

	protected function getAuthorityPackages() {
	if ($this->authorityPackages === null) {
	throw new PhutilInvalidStateException('buildPackageMaps');
	}
	return $this->authorityPackages;
	}

	protected function getChangesetPackages(DifferentialChangeset $changeset) {
	if ($this->pathPackageMap === null) {
	throw new PhutilInvalidStateException('buildPackageMaps');
	}

	$path = $changeset->getOwnersFilename();
	return idx($this->pathPackageMap, $path, array());
	}

	protected function getPackageChangesets($package_phid) {
	if ($this->packageChangesetMap === null) {
	throw new PhutilInvalidStateException('buildPackageMaps');
	}

	return idx($this->packageChangesetMap, $package_phid, array());
	}

	protected function buildTableOfContents(
	array $changesets,
	array $visible_changesets,
	array $coverage) {
	$viewer = $this->getViewer();

	$toc_view = id(new PHUIDiffTableOfContentsListView())
	->setViewer($viewer)
	->setBare(true)
	->setAuthorityPackages($this->getAuthorityPackages());

	foreach ($changesets as $changeset_id => $changeset) {
	$is_visible = isset($visible_changesets[$changeset_id]);
	$anchor = $changeset->getAnchorName();

	$filename = $changeset->getFilename();
	$coverage_id = 'differential-mcoverage-'.md5($filename);

	$item = id(new PHUIDiffTableOfContentsItemView())
	->setChangeset($changeset)
	->setIsVisible($is_visible)
	->setAnchor($anchor)
	->setCoverage(idx($coverage, $filename))
	->setCoverageID($coverage_id);

	$packages = $this->getChangesetPackages($changeset);
	$item->setPackages($packages);

	$toc_view->addItem($item);
	}

	return $toc_view;
	}

	protected function loadDiffProperties(array $diffs) {
	$diffs = mpull($diffs, null, 'getID');

	$properties = id(new DifferentialDiffProperty())->loadAllWhere(
	'diffID IN (%Ld)',
	array_keys($diffs));
	$properties = mgroup($properties, 'getDiffID');

	foreach ($diffs as $id => $diff) {
	$values = idx($properties, $id, array());
	$values = mpull($values, 'getData', 'getName');
	$diff->attachDiffProperties($values);
	}
	}


	protected function loadHarbormasterData(array $diffs) {
	$viewer = $this->getViewer();

	$diffs = mpull($diffs, null, 'getPHID');

	$buildables = id(new HarbormasterBuildableQuery())
	->setViewer($viewer)
	->withBuildablePHIDs(array_keys($diffs))
	->withManualBuildables(false)
	->needBuilds(true)
	->needTargets(true)
	->execute();

	$buildables = mpull($buildables, null, 'getBuildablePHID');
	foreach ($diffs as $phid => $diff) {
	$diff->attachBuildable(idx($buildables, $phid));
	}

	$target_map = array();
	foreach ($diffs as $phid => $diff) {
	$target_map[$phid] = $diff->getBuildTargetPHIDs();
	}
	$all_target_phids = array_mergev($target_map);

	if ($all_target_phids) {
	$unit_messages = id(new HarbormasterBuildUnitMessage())->loadAllWhere(
	'buildTargetPHID IN (%Ls)',
	$all_target_phids);
	$unit_messages = mgroup($unit_messages, 'getBuildTargetPHID');
	} else {
	$unit_messages = array();
	}

	foreach ($diffs as $phid => $diff) {
	$target_phids = idx($target_map, $phid, array());
	$messages = array_select_keys($unit_messages, $target_phids);
	$messages = array_mergev($messages);
	$diff->attachUnitMessages($messages);
	}

	// For diffs with no messages, look for legacy unit messages stored on the
	// diff itself.
	foreach ($diffs as $phid => $diff) {
	if ($diff->getUnitMessages()) {
	continue;
	}

	if (!$diff->hasDiffProperty('arc:unit')) {
	continue;
	}

	$legacy_messages = $diff->getProperty('arc:unit');
	if (!$legacy_messages) {
	continue;
	}

	// Show the top 100 legacy lint messages. Previously, we showed some
	// by default and let the user toggle the rest. With modern messages,
	// we can send the user to the Harbormaster detail page. Just show
	// "a lot" of messages in legacy cases to try to strike a balance
	// between implementation simplicity and compatibility.
	$legacy_messages = array_slice($legacy_messages, 0, 100);

	$messages = array();
	foreach ($legacy_messages as $message) {
	$messages[] = HarbormasterBuildUnitMessage::newFromDictionary(
	new HarbormasterBuildTarget(),
	$this->getModernUnitMessageDictionary($message));
	}

	$diff->attachUnitMessages($messages);
	}
	}

	private function getModernUnitMessageDictionary(array $map) {
	// Strip out `null` values to satisfy stricter typechecks.
	foreach ($map as $key => $value) {
	if ($value === null) {
	unset($map[$key]);
	}
	}

	// Cast duration to a float since it used to be a string in some
	// cases.
	if (isset($map['duration'])) {
	$map['duration'] = (double)$map['duration'];
	}

	return $map;
	}

	protected function getDiffTabLabels(array $diffs) {
	// Make sure we're only going to render unique diffs.
	$diffs = mpull($diffs, null, 'getID');
	$labels = array(pht('Left'), pht('Right'));

	$results = array();

	foreach ($diffs as $diff) {
	if (count($diffs) == 2) {
	$label = array_shift($labels);
	$label = pht('%s (Diff %d)', $label, $diff->getID());
	} else {
	$label = pht('Diff %d', $diff->getID());
	}

	$results[] = array(
	$label,
	$diff,
	);
	}

	return $results;
	}


	}
	diff --git a/src/applications/differential/editor/DifferentialTransactionEditor.php b/src/applications/differential/editor/DifferentialTransactionEditor.php
	index 82740459b0..3271248ce8 100644
	--- a/src/applications/differential/editor/DifferentialTransactionEditor.php
	+++ b/src/applications/differential/editor/DifferentialTransactionEditor.php
	@@ -1,1694 +1,1706 @@
	<?php

	final class DifferentialTransactionEditor
	extends PhabricatorApplicationTransactionEditor {

	private $changedPriorToCommitURI;
	private $isCloseByCommit;
	private $repositoryPHIDOverride = false;
	private $didExpandInlineState = false;
	- private $affectedPaths;
	private $firstBroadcast = false;
	private $wasBroadcasting;
	private $isDraftDemotion;

	+ private $ownersDiff;
	+ private $ownersChangesets;
	+
	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 isFirstBroadcast() {
	return $this->firstBroadcast;
	}

	public function getDiffUpdateTransaction(array $xactions) {
	$type_update = DifferentialRevisionUpdateTransaction::TRANSACTIONTYPE;

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

	return $types;
	}

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

	switch ($xaction->getTransactionType()) {
	case DifferentialTransaction::TYPE_INLINE:
	return null;
	}

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

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

	switch ($xaction->getTransactionType()) {
	case DifferentialTransaction::TYPE_INLINE:
	return null;
	}

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

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

	switch ($xaction->getTransactionType()) {
	case DifferentialTransaction::TYPE_INLINE:
	return;
	}

	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 DifferentialRevisionPlanChangesTransaction::TRANSACTIONTYPE:
	if ($xaction->getMetadataValue('draft.demote')) {
	$this->isDraftDemotion = true;
	}
	break;
	}
	}

	$this->wasBroadcasting = $object->getShouldBroadcast();

	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;

	$edge_ref_task = DifferentialRevisionHasTaskEdgeType::EDGECONST;

	$want_downgrade = array();
	$must_downgrade = array();
	if ($this->getIsCloseByCommit()) {
	// Never downgrade reviewers when we're closing a revision after a
	// commit.
	} else {
	switch ($xaction->getTransactionType()) {
	case DifferentialRevisionUpdateTransaction::TRANSACTIONTYPE:
	$want_downgrade[] = DifferentialReviewerStatus::STATUS_ACCEPTED;
	$want_downgrade[] = DifferentialReviewerStatus::STATUS_REJECTED;
	break;
	case DifferentialRevisionRequestReviewTransaction::TRANSACTIONTYPE:
	if (!$object->isChangePlanned()) {
	// If the old state isn't "Changes Planned", downgrade the accepts
	// even if they're sticky.

	// We don't downgrade for "Changes Planned" to allow an author to
	// undo a "Plan Changes" by immediately following it up with a
	// "Request Review".
	$want_downgrade[] = DifferentialReviewerStatus::STATUS_ACCEPTED;
	$must_downgrade[] = DifferentialReviewerStatus::STATUS_ACCEPTED;
	}
	$want_downgrade[] = DifferentialReviewerStatus::STATUS_REJECTED;
	break;
	}
	}

	if ($want_downgrade) {
	$void_type = DifferentialRevisionVoidTransaction::TRANSACTIONTYPE;

	$results[] = id(new DifferentialTransaction())
	->setTransactionType($void_type)
	->setIgnoreOnNoEffect(true)
	->setMetadataValue('void.force', $must_downgrade)
	->setNewValue($want_downgrade);
	}

	$is_commandeer = false;
	switch ($xaction->getTransactionType()) {
	case DifferentialRevisionUpdateTransaction::TRANSACTIONTYPE:
	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 DifferentialRevisionCommandeerTransaction::TRANSACTIONTYPE:
	$is_commandeer = true;
	break;
	}

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

	if (!$this->didExpandInlineState) {
	switch ($xaction->getTransactionType()) {
	case PhabricatorTransactions::TYPE_COMMENT:
	case DifferentialRevisionUpdateTransaction::TRANSACTIONTYPE:
	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_INLINE:
	$reply = $xaction->getComment()->getReplyToComment();
	if ($reply && !$reply->getHasReplies()) {
	$reply->setHasReplies(1)->save();
	}
	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 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())
	->needReviewers(true)
	->needActiveDiffs(true)
	->withIDs(array($object->getID()))
	->executeOne();
	if (!$new_revision) {
	throw new Exception(
	pht('Failed to load revision from transaction finalization.'));
	}

	$object->attachReviewers($new_revision->getReviewers());
	$object->attachActiveDiff($new_revision->getActiveDiff());
	$object->attachRepository($new_revision->getRepository());

	foreach ($xactions as $xaction) {
	switch ($xaction->getTransactionType()) {
	case DifferentialRevisionUpdateTransaction::TRANSACTIONTYPE:
	$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;
	}
	}

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

	return $xactions;
	}

	private function updateReviewStatus(
	DifferentialRevision $revision,
	array $xactions) {

	$was_accepted = $revision->isAccepted();
	$was_revision = $revision->isNeedsRevision();
	$was_review = $revision->isNeedsReview();
	if (!$was_accepted && !$was_revision && !$was_review) {
	// Revisions can't transition out of other statuses (like closed or
	// abandoned) as a side effect of reviewer status changes.
	return $xactions;
	}

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

	$active_diff = $revision->getActiveDiff();
	foreach ($revision->getReviewers() as $reviewer) {
	$reviewer_status = $reviewer->getReviewerStatus();
	switch ($reviewer_status) {
	case DifferentialReviewerStatus::STATUS_REJECTED:
	$active_phid = $active_diff->getPHID();
	if ($reviewer->isRejected($active_phid)) {
	$has_rejecting_reviewer = true;
	} else {
	$has_rejecting_older_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()) {
	$active_phid = $active_diff->getPHID();
	if ($reviewer->isAccepted($active_phid)) {
	$has_accepting_user = true;
	}
	}
	break;
	}
	}

	$new_status = null;
	if ($has_accepting_user &&
	!$has_rejecting_reviewer &&
	!$has_rejecting_older_reviewer &&
	!$has_blocking_reviewer) {
	$new_status = DifferentialRevisionStatus::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 = DifferentialRevisionStatus::NEEDS_REVISION;
	} else if ($was_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 = DifferentialRevisionStatus::NEEDS_REVIEW;
	}

	if ($new_status === null) {
	return $xactions;
	}

	$old_status = $revision->getModernRevisionStatus();
	if ($new_status == $old_status) {
	return $xactions;
	}

	$xaction = id(new DifferentialTransaction())
	->setTransactionType(
	DifferentialRevisionStatusTransaction::TRANSACTIONTYPE)
	->setOldValue($old_status)
	->setNewValue($new_status);

	$xaction = $this->populateTransaction($revision, $xaction)
	->save();
	$xactions[] = $xaction;

	// Save the status adjustment we made earlier.
	$revision
	->setModernRevisionStatus($new_status)
	->save();

	return $xactions;
	}

	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 shouldPublishFeedStory(
	PhabricatorLiskDAO $object,
	array $xactions) {

	if (!$object->getShouldBroadcast()) {
	return false;
	}

	return true;
	}

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

	protected function getMailTo(PhabricatorLiskDAO $object) {
	if ($object->getShouldBroadcast()) {
	$this->requireReviewers($object);

	$phids = array();
	$phids[] = $object->getAuthorPHID();
	foreach ($object->getReviewers() as $reviewer) {
	if ($reviewer->isResigned()) {
	continue;
	}

	$phids[] = $reviewer->getReviewerPHID();
	}
	return $phids;
	}

	// If we're demoting a draft after a build failure, just notify the author.
	if ($this->isDraftDemotion) {
	$author_phid = $object->getAuthorPHID();
	return array(
	$author_phid,
	);
	}

	return array();
	}

	protected function getMailCC(PhabricatorLiskDAO $object) {
	if (!$object->getShouldBroadcast()) {
	return array();
	}

	return parent::getMailCC($object);
	}

	protected function newMailUnexpandablePHIDs(PhabricatorLiskDAO $object) {
	$this->requireReviewers($object);

	$phids = array();

	foreach ($object->getReviewers() as $reviewer) {
	if ($reviewer->isResigned()) {
	$phids[] = $reviewer->getReviewerPHID();
	}
	}

	return $phids;
	}

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

	$show_lines = false;
	if ($this->isFirstBroadcast()) {
	$action = pht('Request');

	$show_lines = true;
	} else {
	$action = parent::getMailAction($object, $xactions);

	$strongest = $this->getStrongestAction($object, $xactions);
	$type_update = DifferentialRevisionUpdateTransaction::TRANSACTIONTYPE;
	if ($strongest->getTransactionType() == $type_update) {
	$show_lines = true;
	}
	}

	if ($show_lines) {
	$count = new PhutilNumber($object->getLineCount());
	$action = pht('%s] [%s', $action, $object->getRevisionScaleGlyphs());
	}

	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();
	$subject = "D{$id}: {$title}";

	return id(new PhabricatorMetaMTAMail())
	->setSubject($subject);
	}

	protected function getTransactionsForMail(
	PhabricatorLiskDAO $object,
	array $xactions) {
	// If this is the first time we're sending mail about this revision, we
	// generate mail for all prior transactions, not just whatever is being
	// applied now. This gets the "added reviewers" lines and other relevant
	// information into the mail.
	if ($this->isFirstBroadcast()) {
	return $this->loadUnbroadcastTransactions($object);
	}

	return $xactions;
	}

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

	$viewer = $this->requireActor();

	$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 DifferentialRevisionUpdateTransaction::TRANSACTIONTYPE:
	$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) {
	// See T12033, T11767, and PHI55. This is a crude fix to stop the
	// major concrete problems that lackluster email size limits cause.
	if (strlen($patch) < $body_limit) {
	$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) {

	// For "Fixes ..." and "Depends on ...", we're only going to look at
	// content blocks which are part of the revision itself (like "Summary"
	// and "Test Plan"), not comments.
	$content_parts = array();
	foreach ($changes as $change) {
	if ($change->getTransaction()->isCommentTransaction()) {
	continue;
	}
	$content_parts[] = $change->getNewValue();
	}
	if (!$content_parts) {
	return array();
	}
	$content_block = implode("\n\n", $content_parts);
	$task_map = array();
	$task_refs = id(new ManiphestCustomFieldStatusParser())
	->parseCorpus($content_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($content_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;
	}
	}

	$revert_refs = id(new DifferentialCustomFieldRevertsParser())
	->parseCorpus($content_block);

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

	if ($revert_monograms) {
	$revert_objects = id(new PhabricatorObjectQuery())
	->setViewer($this->getActor())
	->withNames($revert_monograms)
	->withTypes(
	array(
	DifferentialRevisionPHIDType::TYPECONST,
	PhabricatorRepositoryCommitPHIDType::TYPECONST,
	))
	->execute();

	$revert_phids = mpull($revert_objects, 'getPHID', 'getPHID');

	// Don't let an object revert itself, although other silly stuff like
	// cycles of objects reverting each other is not prevented.
	unset($revert_phids[$object->getPHID()]);

	$revert_type = DiffusionCommitRevertsCommitEdgeType::EDGECONST;
	$edges[$revert_type] = $revert_phids;
	} else {
	$revert_phids = array();
	}

	// See PHI574. Respect any unmentionable PHIDs which were set on the
	// Editor by the caller.
	$unmentionable_map = $this->getUnmentionablePHIDMap();
	$unmentionable_map += $task_phids;
	$unmentionable_map += $rev_phids;
	$unmentionable_map += $revert_phids;
	$this->setUnmentionablePHIDMap($unmentionable_map);

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

	public 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) {
	return true;
	}

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

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

	- if (!$this->affectedPaths) {
	+ $diff = $this->ownersDiff;
	+ $changesets = $this->ownersChangesets;
	+
	+ $this->ownersDiff = null;
	+ $this->ownersChangesets = null;
	+
	+ if (!$changesets) {
	return array();
	}

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

	// Identify the packages with "Non-Owner Author" review rules and remove
	// them if the author has authority over the package.

	$autoreview_map = PhabricatorOwnersPackage::getAutoreviewOptionsMap();
	$need_authority = array();
	foreach ($packages as $package) {
	$autoreview_setting = $package->getAutoReview();

	$spec = idx($autoreview_map, $autoreview_setting);
	if (!$spec) {
	continue;
	}

	if (idx($spec, 'authority')) {
	$need_authority[$package->getPHID()] = $package->getPHID();
	}
	}

	if ($need_authority) {
	$authority = id(new PhabricatorOwnersPackageQuery())
	->setViewer(PhabricatorUser::getOmnipotentUser())
	->withPHIDs($need_authority)
	->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_REVIEW:
	case PhabricatorOwnersPackage::AUTOREVIEW_REVIEW_ALWAYS:
	$auto_review[] = $package;
	break;
	case PhabricatorOwnersPackage::AUTOREVIEW_BLOCK:
	case PhabricatorOwnersPackage::AUTOREVIEW_BLOCK_ALWAYS:
	$auto_block[] = $package;
	break;
	case PhabricatorOwnersPackage::AUTOREVIEW_SUBSCRIBE:
	case PhabricatorOwnersPackage::AUTOREVIEW_SUBSCRIBE_ALWAYS:
	$auto_subscribe[] = $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->getReviewers();
	$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]->getReviewerStatus());
	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)
	->needReviewers(true)
	->executeOne();
	if (!$revision) {
	throw new Exception(
	pht('Failed to load revision for Herald adapter construction!'));
	}

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

	// If the object is still a draft, prevent "Send me an email" and other
	// similar rules from acting yet.
	if (!$object->getShouldBroadcast()) {
	$adapter->setForbiddenAction(
	HeraldMailableState::STATECONST,
	DifferentialHeraldStateReasons::REASON_DRAFT);
	}

	// If this edit didn't actually change the diff (for example, a user
	// edited the title or changed subscribers), prevent "Run build plan"
	// and other similar rules from acting yet, since the build results will
	// not (or, at least, should not) change unless the actual source changes.
	// We also don't run Differential builds if the update was caused by
	// discovering a commit, as the expectation is that Diffusion builds take
	// over once things land.
	$has_update = false;
	$has_commit = false;

	$type_update = DifferentialRevisionUpdateTransaction::TRANSACTIONTYPE;
	foreach ($xactions as $xaction) {
	if ($xaction->getTransactionType() != $type_update) {
	continue;
	}

	if ($xaction->getMetadataValue('isCommitUpdate')) {
	$has_commit = true;
	} else {
	$has_update = true;
	}

	break;
	}

	if ($has_commit) {
	$adapter->setForbiddenAction(
	HeraldBuildableState::STATECONST,
	DifferentialHeraldStateReasons::REASON_LANDED);
	} else if (!$has_update) {
	$adapter->setForbiddenAction(
	HeraldBuildableState::STATECONST,
	DifferentialHeraldStateReasons::REASON_UNCHANGED);
	}

	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;
	+ // If this change affected paths, save the changesets so we can apply
	+ // Owners rules to them later.
	+ if ($paths) {
	+ $this->ownersDiff = $diff;
	+ $this->ownersChangesets = $changesets;
	+ }

	// 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())
	->needReviewers(true)
	->needActiveDiffs(true)
	->withIDs(array($object->getID()))
	->executeOne();
	}

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

	protected function loadCustomWorkerState(array $state) {
	$this->changedPriorToCommitURI = idx($state, 'changedPriorToCommitURI');
	$this->firstBroadcast = idx($state, 'firstBroadcast');
	$this->isDraftDemotion = idx($state, 'isDraftDemotion');
	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);
	}

	private function loadUnbroadcastTransactions($object) {
	$viewer = $this->requireActor();

	$xactions = id(new DifferentialTransactionQuery())
	->setViewer($viewer)
	->withObjectPHIDs(array($object->getPHID()))
	->execute();

	return array_reverse($xactions);
	}


	protected function didApplyTransactions($object, array $xactions) {
	// In a moment, we're going to try to publish draft revisions which have
	// completed all their builds. However, we only want to do that if the
	// actor is either the revision author or an omnipotent user (generally,
	// the Harbormaster application).

	// If we let any actor publish the revision as a side effect of other
	// changes then an unlucky third party who innocently comments on the draft
	// can end up racing Harbormaster and promoting the revision. At best, this
	// is confusing. It can also run into validation problems with the "Request
	// Review" transaction. See PHI309 for some discussion.
	$author_phid = $object->getAuthorPHID();
	$viewer = $this->requireActor();
	$can_undraft =
	($this->getActingAsPHID() === $author_phid) \|\|
	($viewer->isOmnipotent());

	// If a draft revision has no outstanding builds and we're automatically
	// making drafts public after builds finish, make the revision public.
	if ($can_undraft) {
	$auto_undraft = !$object->getHoldAsDraft();
	} else {
	$auto_undraft = false;
	}

	$can_promote = false;
	$can_demote = false;

	// "Draft" revisions can promote to "Review Requested" after builds pass,
	// or demote to "Changes Planned" after builds fail.
	if ($object->isDraft()) {
	$can_promote = true;
	$can_demote = true;
	}

	// See PHI584. "Changes Planned" revisions which are not yet broadcasting
	// can promote to "Review Requested" if builds pass.

	// This pass is presumably the result of someone restarting the builds and
	// having them work this time, perhaps because the builds are not perfectly
	// reliable or perhaps because someone fixed some issue with build hardware
	// or some other dependency.

	// Currently, there's no legitimate way to end up in this state except
	// through automatic demotion, so this behavior should not generate an
	// undue level of confusion or ambiguity. Also note that these changes can
	// not demote again since they've already been demoted once.
	if ($object->isChangePlanned()) {
	if (!$object->getShouldBroadcast()) {
	$can_promote = true;
	}
	}

	if (($can_promote \|\| $can_demote) && $auto_undraft) {
	$status = $this->loadCompletedBuildableStatus($object);

	$is_passed = ($status === HarbormasterBuildableStatus::STATUS_PASSED);
	$is_failed = ($status === HarbormasterBuildableStatus::STATUS_FAILED);

	if ($is_passed && $can_promote) {
	// When Harbormaster moves a revision out of the draft state, we
	// attribute the action to the revision author since this is more
	// natural and more useful.

	// Additionally, we change the acting PHID for the transaction set
	// to the author if it isn't already a user so that mail comes from
	// the natural author.
	$acting_phid = $this->getActingAsPHID();
	$user_type = PhabricatorPeopleUserPHIDType::TYPECONST;
	if (phid_get_type($acting_phid) != $user_type) {
	$this->setActingAsPHID($author_phid);
	}

	$xaction = $object->getApplicationTransactionTemplate()
	->setAuthorPHID($author_phid)
	->setTransactionType(
	DifferentialRevisionRequestReviewTransaction::TRANSACTIONTYPE)
	->setNewValue(true);

	// If we're creating this revision and immediately moving it out of
	// the draft state, mark this as a create transaction so it gets
	// hidden in the timeline and mail, since it isn't interesting: it
	// is as though the draft phase never happened.
	if ($this->getIsNewObject()) {
	$xaction->setIsCreateTransaction(true);
	}

	// Queue this transaction and apply it separately after the current
	// batch of transactions finishes so that Herald can fire on the new
	// revision state. See T13027 for discussion.
	$this->queueTransaction($xaction);
	} else if ($is_failed && $can_demote) {
	// When demoting a revision, we act as "Harbormaster" instead of
	// the author since this feels a little more natural.
	$harbormaster_phid = id(new PhabricatorHarbormasterApplication())
	->getPHID();

	$xaction = $object->getApplicationTransactionTemplate()
	->setAuthorPHID($harbormaster_phid)
	->setMetadataValue('draft.demote', true)
	->setTransactionType(
	DifferentialRevisionPlanChangesTransaction::TRANSACTIONTYPE)
	->setNewValue(true);

	$this->queueTransaction($xaction);
	}
	}

	// If the revision is new or was a draft, and is no longer a draft, we
	// might be sending the first email about it.

	// This might mean it was created directly into a non-draft state, or
	// it just automatically undrafted after builds finished, or a user
	// explicitly promoted it out of the draft state with an action like
	// "Request Review".

	// If we haven't sent any email about it yet, mark this email as the first
	// email so the mail gets enriched with "SUMMARY" and "TEST PLAN".

	$is_new = $this->getIsNewObject();
	$was_broadcasting = $this->wasBroadcasting;

	if ($object->getShouldBroadcast()) {
	if (!$was_broadcasting \|\| $is_new) {
	// Mark this as the first broadcast we're sending about the revision
	// so mail can generate specially.
	$this->firstBroadcast = true;
	}
	}

	return $xactions;
	}

	private function loadCompletedBuildableStatus(
	DifferentialRevision $revision) {
	$viewer = $this->requireActor();
	$builds = $revision->loadImpactfulBuilds($viewer);
	return $revision->newBuildableStatusForBuilds($builds);
	}

	private function requireReviewers(DifferentialRevision $revision) {
	if ($revision->hasAttachedReviewers()) {
	return;
	}

	$with_reviewers = id(new DifferentialRevisionQuery())
	->setViewer($this->getActor())
	->needReviewers(true)
	->withPHIDs(array($revision->getPHID()))
	->executeOne();
	if (!$with_reviewers) {
	throw new Exception(
	pht(
	'Failed to reload revision ("%s").',
	$revision->getPHID()));
	}

	$revision->attachReviewers($with_reviewers->getReviewers());
	}


	}
	diff --git a/src/applications/differential/herald/HeraldDifferentialRevisionAdapter.php b/src/applications/differential/herald/HeraldDifferentialRevisionAdapter.php
	index 9f7f8fe3f2..858a42dbc9 100644
	--- a/src/applications/differential/herald/HeraldDifferentialRevisionAdapter.php
	+++ b/src/applications/differential/herald/HeraldDifferentialRevisionAdapter.php
	@@ -1,157 +1,158 @@
	<?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 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())
	->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(
	+ $packages = PhabricatorOwnersPackage::loadAffectedPackagesForChangesets(
	$repository,
	- $this->loadAffectedPaths());
	+ $this->getDiff(),
	+ $this->loadChangesets());
	$this->affectedPackages = $packages;
	}
	}
	return $this->affectedPackages;
	}

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


	/* -( 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/storage/DifferentialDiff.php b/src/applications/differential/storage/DifferentialDiff.php
	index cd8364c8aa..f121a1cb67 100644
	--- a/src/applications/differential/storage/DifferentialDiff.php
	+++ b/src/applications/differential/storage/DifferentialDiff.php
	@@ -1,870 +1,872 @@
	<?php

	final class DifferentialDiff
	extends DifferentialDAO
	implements
	PhabricatorPolicyInterface,
	PhabricatorExtendedPolicyInterface,
	HarbormasterBuildableInterface,
	HarbormasterCircleCIBuildableInterface,
	HarbormasterBuildkiteBuildableInterface,
	PhabricatorApplicationTransactionInterface,
	PhabricatorDestructibleInterface,
	PhabricatorConduitResultInterface {

	protected $revisionID;
	protected $authorPHID;
	protected $repositoryPHID;
	protected $commitPHID;

	protected $sourceMachine;
	protected $sourcePath;

	protected $sourceControlSystem;
	protected $sourceControlBaseRevision;
	protected $sourceControlPath;

	protected $lintStatus;
	protected $unitStatus;

	protected $lineCount;

	protected $branch;
	protected $bookmark;

	protected $creationMethod;
	protected $repositoryUUID;

	protected $description;

	protected $viewPolicy;

	private $unsavedChangesets = array();
	private $changesets = self::ATTACHABLE;
	private $revision = self::ATTACHABLE;
	private $properties = array();
	private $buildable = self::ATTACHABLE;

	private $unitMessages = self::ATTACHABLE;

	protected function getConfiguration() {
	return array(
	self::CONFIG_AUX_PHID => true,
	self::CONFIG_COLUMN_SCHEMA => array(
	'revisionID' => 'id?',
	'authorPHID' => 'phid?',
	'repositoryPHID' => 'phid?',
	'sourceMachine' => 'text255?',
	'sourcePath' => 'text255?',
	'sourceControlSystem' => 'text64?',
	'sourceControlBaseRevision' => 'text255?',
	'sourceControlPath' => 'text255?',
	'lintStatus' => 'uint32',
	'unitStatus' => 'uint32',
	'lineCount' => 'uint32',
	'branch' => 'text255?',
	'bookmark' => 'text255?',
	'repositoryUUID' => 'text64?',
	'commitPHID' => 'phid?',

	// T6203/NULLABILITY
	// These should be non-null; all diffs should have a creation method
	// and the description should just be empty.
	'creationMethod' => 'text255?',
	'description' => 'text255?',
	),
	self::CONFIG_KEY_SCHEMA => array(
	'revisionID' => array(
	'columns' => array('revisionID'),
	),
	'key_commit' => array(
	'columns' => array('commitPHID'),
	),
	),
	) + parent::getConfiguration();
	}

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

	public function addUnsavedChangeset(DifferentialChangeset $changeset) {
	if ($this->changesets === null) {
	$this->changesets = array();
	}
	$this->unsavedChangesets[] = $changeset;
	$this->changesets[] = $changeset;
	return $this;
	}

	public function attachChangesets(array $changesets) {
	assert_instances_of($changesets, 'DifferentialChangeset');
	$this->changesets = $changesets;
	return $this;
	}

	public function getChangesets() {
	return $this->assertAttached($this->changesets);
	}

	public function loadChangesets() {
	if (!$this->getID()) {
	return array();
	}
	$changesets = id(new DifferentialChangeset())->loadAllWhere(
	'diffID = %d',
	$this->getID());

	foreach ($changesets as $changeset) {
	$changeset->attachDiff($this);
	}

	return $changesets;
	}

	public function save() {
	$this->openTransaction();
	$ret = parent::save();
	foreach ($this->unsavedChangesets as $changeset) {
	$changeset->setDiffID($this->getID());
	$changeset->save();
	}
	$this->saveTransaction();
	return $ret;
	}

	public static function initializeNewDiff(PhabricatorUser $actor) {
	$app = id(new PhabricatorApplicationQuery())
	->setViewer($actor)
	->withClasses(array('PhabricatorDifferentialApplication'))
	->executeOne();
	$view_policy = $app->getPolicy(
	DifferentialDefaultViewCapability::CAPABILITY);

	$diff = id(new DifferentialDiff())
	->setViewPolicy($view_policy);

	return $diff;
	}

	public static function newFromRawChanges(
	PhabricatorUser $actor,
	array $changes) {

	assert_instances_of($changes, 'ArcanistDiffChange');

	$diff = self::initializeNewDiff($actor);
	return self::buildChangesetsFromRawChanges($diff, $changes);
	}

	public static function newEphemeralFromRawChanges(array $changes) {
	assert_instances_of($changes, 'ArcanistDiffChange');

	$diff = id(new DifferentialDiff())->makeEphemeral();
	return self::buildChangesetsFromRawChanges($diff, $changes);
	}

	private static function buildChangesetsFromRawChanges(
	DifferentialDiff $diff,
	array $changes) {

	// There may not be any changes; initialize the changesets list so that
	// we don't throw later when accessing it.
	$diff->attachChangesets(array());

	$lines = 0;
	foreach ($changes as $change) {
	if ($change->getType() == ArcanistDiffChangeType::TYPE_MESSAGE) {
	// If a user pastes a diff into Differential which includes a commit
	// message (e.g., they ran `git show` to generate it), discard that
	// change when constructing a DifferentialDiff.
	continue;
	}

	$changeset = new DifferentialChangeset();
	$add_lines = 0;
	$del_lines = 0;
	$first_line = PHP_INT_MAX;
	$hunks = $change->getHunks();
	if ($hunks) {
	foreach ($hunks as $hunk) {
	$dhunk = new DifferentialHunk();
	$dhunk->setOldOffset($hunk->getOldOffset());
	$dhunk->setOldLen($hunk->getOldLength());
	$dhunk->setNewOffset($hunk->getNewOffset());
	$dhunk->setNewLen($hunk->getNewLength());
	$dhunk->setChanges($hunk->getCorpus());
	$changeset->addUnsavedHunk($dhunk);
	$add_lines += $hunk->getAddLines();
	$del_lines += $hunk->getDelLines();
	$added_lines = $hunk->getChangedLines('new');
	if ($added_lines) {
	$first_line = min($first_line, head_key($added_lines));
	}
	}
	$lines += $add_lines + $del_lines;
	} else {
	// This happens when you add empty files.
	$changeset->attachHunks(array());
	}

	$metadata = $change->getAllMetadata();
	if ($first_line != PHP_INT_MAX) {
	$metadata['line:first'] = $first_line;
	}

	$changeset->setOldFile($change->getOldPath());
	$changeset->setFilename($change->getCurrentPath());
	$changeset->setChangeType($change->getType());

	$changeset->setFileType($change->getFileType());
	$changeset->setMetadata($metadata);
	$changeset->setOldProperties($change->getOldProperties());
	$changeset->setNewProperties($change->getNewProperties());
	$changeset->setAwayPaths($change->getAwayPaths());
	$changeset->setAddLines($add_lines);
	$changeset->setDelLines($del_lines);

	self::detectGeneratedCode($changeset);

	$diff->addUnsavedChangeset($changeset);
	}
	$diff->setLineCount($lines);

	$parser = new DifferentialChangesetParser();
	$changesets = $parser->detectCopiedCode(
	$diff->getChangesets(),
	$min_width = 30,
	$min_lines = 3);
	$diff->attachChangesets($changesets);

	return $diff;
	}


	public function getDiffDict() {
	$dict = array(
	'id' => $this->getID(),
	'revisionID' => $this->getRevisionID(),
	'dateCreated' => $this->getDateCreated(),
	'dateModified' => $this->getDateModified(),
	'sourceControlBaseRevision' => $this->getSourceControlBaseRevision(),
	'sourceControlPath' => $this->getSourceControlPath(),
	'sourceControlSystem' => $this->getSourceControlSystem(),
	'branch' => $this->getBranch(),
	'bookmark' => $this->getBookmark(),
	'creationMethod' => $this->getCreationMethod(),
	'description' => $this->getDescription(),
	'unitStatus' => $this->getUnitStatus(),
	'lintStatus' => $this->getLintStatus(),
	'changes' => array(),
	);

	$dict['changes'] = $this->buildChangesList();

	return $dict + $this->getDiffAuthorshipDict();
	}

	public function getDiffAuthorshipDict() {
	$dict = array('properties' => array());

	$properties = id(new DifferentialDiffProperty())->loadAllWhere(
	'diffID = %d',
	$this->getID());
	foreach ($properties as $property) {
	$dict['properties'][$property->getName()] = $property->getData();

	if ($property->getName() == 'local:commits') {
	foreach ($property->getData() as $commit) {
	$dict['authorName'] = $commit['author'];
	$dict['authorEmail'] = idx($commit, 'authorEmail');
	break;
	}
	}
	}

	return $dict;
	}

	public function buildChangesList() {
	$changes = array();
	foreach ($this->getChangesets() as $changeset) {
	$hunks = array();
	foreach ($changeset->getHunks() as $hunk) {
	$hunks[] = array(
	'oldOffset' => $hunk->getOldOffset(),
	'newOffset' => $hunk->getNewOffset(),
	'oldLength' => $hunk->getOldLen(),
	'newLength' => $hunk->getNewLen(),
	'addLines' => null,
	'delLines' => null,
	'isMissingOldNewline' => null,
	'isMissingNewNewline' => null,
	'corpus' => $hunk->getChanges(),
	);
	}
	$change = array(
	'id' => $changeset->getID(),
	'metadata' => $changeset->getMetadata(),
	'oldPath' => $changeset->getOldFile(),
	'currentPath' => $changeset->getFilename(),
	'awayPaths' => $changeset->getAwayPaths(),
	'oldProperties' => $changeset->getOldProperties(),
	'newProperties' => $changeset->getNewProperties(),
	'type' => $changeset->getChangeType(),
	'fileType' => $changeset->getFileType(),
	'commitHash' => null,
	'addLines' => $changeset->getAddLines(),
	'delLines' => $changeset->getDelLines(),
	'hunks' => $hunks,
	);
	$changes[] = $change;
	}
	return $changes;
	}

	public function hasRevision() {
	return $this->revision !== self::ATTACHABLE;
	}

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

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

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

	public function getProperty($key) {
	return $this->assertAttachedKey($this->properties, $key);
	}

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

	public function attachDiffProperties(array $properties) {
	$this->properties = $properties;
	return $this;
	}

	public function getDiffProperties() {
	return $this->assertAttached($this->properties);
	}

	public function attachBuildable(HarbormasterBuildable $buildable = null) {
	$this->buildable = $buildable;
	return $this;
	}

	public function getBuildable() {
	return $this->assertAttached($this->buildable);
	}

	public function getBuildTargetPHIDs() {
	$buildable = $this->getBuildable();

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

	$target_phids = array();
	foreach ($buildable->getBuilds() as $build) {
	foreach ($build->getBuildTargets() as $target) {
	$target_phids[] = $target->getPHID();
	}
	}

	return $target_phids;
	}

	public function loadCoverageMap(PhabricatorUser $viewer) {
	$target_phids = $this->getBuildTargetPHIDs();
	if (!$target_phids) {
	return array();
	}

	$unit = id(new HarbormasterBuildUnitMessage())->loadAllWhere(
	'buildTargetPHID IN (%Ls)',
	$target_phids);

	$map = array();
	foreach ($unit as $message) {
	$coverage = $message->getProperty('coverage', array());
	foreach ($coverage as $path => $coverage_data) {
	$map[$path][] = $coverage_data;
	}
	}

	foreach ($map as $path => $coverage_items) {
	$map[$path] = ArcanistUnitTestResult::mergeCoverage($coverage_items);
	}

	return $map;
	}

	public function getURI() {
	$id = $this->getID();
	return "/differential/diff/{$id}/";
	}


	public function attachUnitMessages(array $unit_messages) {
	$this->unitMessages = $unit_messages;
	return $this;
	}


	public function getUnitMessages() {
	return $this->assertAttached($this->unitMessages);
	}


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


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

	public function getPolicy($capability) {
	if ($this->hasRevision()) {
	return PhabricatorPolicies::getMostOpenPolicy();
	}

	return $this->viewPolicy;
	}

	public function hasAutomaticCapability($capability, PhabricatorUser $viewer) {
	if ($this->hasRevision()) {
	return $this->getRevision()->hasAutomaticCapability($capability, $viewer);
	}

	return ($this->getAuthorPHID() == $viewer->getPHID());
	}

	public function describeAutomaticCapability($capability) {
	if ($this->hasRevision()) {
	return pht(
	'This diff is attached to a revision, and inherits its policies.');
	}

	return pht('The author of a diff can see it.');
	}


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


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

	switch ($capability) {
	case PhabricatorPolicyCapability::CAN_VIEW:
	if ($this->hasRevision()) {
	$extended[] = array(
	$this->getRevision(),
	PhabricatorPolicyCapability::CAN_VIEW,
	);
	}
	break;
	}

	return $extended;
	}


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


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

	return $this->getHarbormasterBuildablePHID();
	}

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

	public function getHarbormasterContainerPHID() {
	if ($this->getRevisionID()) {
	$revision = id(new DifferentialRevision())->load($this->getRevisionID());
	if ($revision) {
	return $revision->getPHID();
	}
	}

	return null;
	}

	public function getBuildVariables() {
	$results = array();

	$results['buildable.diff'] = $this->getID();
	if ($this->revisionID) {
	$revision = $this->getRevision();
	$results['buildable.revision'] = $revision->getID();
	$repo = $revision->getRepository();

	if ($repo) {
	$results['repository.callsign'] = $repo->getCallsign();
	$results['repository.phid'] = $repo->getPHID();
	$results['repository.vcs'] = $repo->getVersionControlSystem();
	$results['repository.uri'] = $repo->getPublicCloneURI();

	$results['repository.staging.uri'] = $repo->getStagingURI();
	$results['repository.staging.ref'] = $this->getStagingRef();
	}
	}

	return $results;
	}

	public function getAvailableBuildVariables() {
	return array(
	'buildable.diff' =>
	pht('The differential diff ID, if applicable.'),
	'buildable.revision' =>
	pht('The differential revision ID, if applicable.'),
	'repository.callsign' =>
	pht('The callsign of the repository in Phabricator.'),
	'repository.phid' =>
	pht('The PHID of the repository in Phabricator.'),
	'repository.vcs' =>
	pht('The version control system, either "svn", "hg" or "git".'),
	'repository.uri' =>
	pht('The URI to clone or checkout the repository from.'),
	'repository.staging.uri' =>
	pht('The URI of the staging repository.'),
	'repository.staging.ref' =>
	pht('The ref name for this change in the staging repository.'),
	);
	}

	public function newBuildableEngine() {
	return new DifferentialBuildableEngine();
	}


	/* -( HarbormasterCircleCIBuildableInterface )----------------------------- */


	public function getCircleCIGitHubRepositoryURI() {
	$diff_phid = $this->getPHID();
	$repository_phid = $this->getRepositoryPHID();
	if (!$repository_phid) {
	throw new Exception(
	pht(
	'This diff ("%s") is not associated with a repository. A diff '.
	'must belong to a tracked repository to be built by CircleCI.',
	$diff_phid));
	}

	$repository = id(new PhabricatorRepositoryQuery())
	->setViewer(PhabricatorUser::getOmnipotentUser())
	->withPHIDs(array($repository_phid))
	->executeOne();
	if (!$repository) {
	throw new Exception(
	pht(
	'This diff ("%s") is associated with a repository ("%s") which '.
	'could not be loaded.',
	$diff_phid,
	$repository_phid));
	}

	$staging_uri = $repository->getStagingURI();
	if (!$staging_uri) {
	throw new Exception(
	pht(
	'This diff ("%s") is associated with a repository ("%s") that '.
	'does not have a Staging Area configured. You must configure a '.
	'Staging Area to use CircleCI integration.',
	$diff_phid,
	$repository_phid));
	}

	$path = HarbormasterCircleCIBuildStepImplementation::getGitHubPath(
	$staging_uri);
	if (!$path) {
	throw new Exception(
	pht(
	'This diff ("%s") is associated with a repository ("%s") that '.
	'does not have a Staging Area ("%s") that is hosted on GitHub. '.
	'CircleCI can only build from GitHub, so the Staging Area for '.
	'the repository must be hosted there.',
	$diff_phid,
	$repository_phid,
	$staging_uri));
	}

	return $staging_uri;
	}

	public function getCircleCIBuildIdentifierType() {
	return 'tag';
	}

	public function getCircleCIBuildIdentifier() {
	$ref = $this->getStagingRef();
	$ref = preg_replace('(^refs/tags/)', '', $ref);
	return $ref;
	}


	/* -( HarbormasterBuildkiteBuildableInterface )---------------------------- */

	public function getBuildkiteBranch() {
	$ref = $this->getStagingRef();

	// NOTE: Circa late January 2017, Buildkite fails with the error message
	// "Tags have been disabled for this project" if we pass the "refs/tags/"
	// prefix via the API and the project doesn't have GitHub tag builds
	// enabled, even if GitHub builds are disabled. The tag builds fine
	// without this prefix.
	$ref = preg_replace('(^refs/tags/)', '', $ref);

	return $ref;
	}

	public function getBuildkiteCommit() {
	return 'HEAD';
	}


	public function getStagingRef() {
	// TODO: We're just hoping to get lucky. Instead, `arc` should store
	// where it sent changes and we should only provide staging details
	// if we reasonably believe they are accurate.
	return 'refs/tags/phabricator/diff/'.$this->getID();
	}

	public function loadTargetBranch() {
	// TODO: This is sketchy, but just eat the query cost until this can get
	// cleaned up.

	// For now, we're only returning a target if there's exactly one and it's
	// a branch, since we don't support landing to more esoteric targets like
	// tags yet.

	$property = id(new DifferentialDiffProperty())->loadOneWhere(
	'diffID = %d AND name = %s',
	$this->getID(),
	'arc:onto');
	if (!$property) {
	return null;
	}

	$data = $property->getData();

	if (!$data) {
	return null;
	}

	if (!is_array($data)) {
	return null;
	}

	if (count($data) != 1) {
	return null;
	}

	$onto = head($data);
	if (!is_array($onto)) {
	return null;
	}

	$type = idx($onto, 'type');
	if ($type != 'branch') {
	return null;
	}

	return idx($onto, 'name');
	}


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


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

	public function getApplicationTransactionObject() {
	return $this;
	}

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

	public function willRenderTimeline(
	PhabricatorApplicationTransactionView $timeline,
	AphrontRequest $request) {

	return $timeline;
	}


	/* -( PhabricatorDestructibleInterface )----------------------------------- */


	public function destroyObjectPermanently(
	PhabricatorDestructionEngine $engine) {

	$this->openTransaction();
	$this->delete();

	foreach ($this->loadChangesets() as $changeset) {
	$engine->destroyObject($changeset);
	}

	$properties = id(new DifferentialDiffProperty())->loadAllWhere(
	'diffID = %d',
	$this->getID());
	foreach ($properties as $prop) {
	$prop->delete();
	}

	$this->saveTransaction();
	}


	/* -( PhabricatorConduitResultInterface )---------------------------------- */


	public function getFieldSpecificationsForConduit() {
	return array(
	id(new PhabricatorConduitSearchFieldSpecification())
	->setKey('revisionPHID')
	->setType('phid')
	->setDescription(pht('Associated revision PHID.')),
	id(new PhabricatorConduitSearchFieldSpecification())
	->setKey('authorPHID')
	->setType('phid')
	->setDescription(pht('Revision author PHID.')),
	id(new PhabricatorConduitSearchFieldSpecification())
	->setKey('repositoryPHID')
	->setType('phid')
	->setDescription(pht('Associated repository PHID.')),
	id(new PhabricatorConduitSearchFieldSpecification())
	->setKey('refs')
	->setType('map<string, wild>')
	->setDescription(pht('List of related VCS references.')),
	);
	}

	public function getFieldValuesForConduit() {
	$refs = array();

	$branch = $this->getBranch();
	if (strlen($branch)) {
	$refs[] = array(
	'type' => 'branch',
	'name' => $branch,
	);
	}

	$onto = $this->loadTargetBranch();
	if (strlen($onto)) {
	$refs[] = array(
	'type' => 'onto',
	'name' => $onto,
	);
	}

	$base = $this->getSourceControlBaseRevision();
	if (strlen($base)) {
	$refs[] = array(
	'type' => 'base',
	'identifier' => $base,
	);
	}

	$bookmark = $this->getBookmark();
	if (strlen($bookmark)) {
	$refs[] = array(
	'type' => 'bookmark',
	'name' => $bookmark,
	);
	}

	$revision_phid = null;
	if ($this->getRevisionID()) {
	$revision_phid = $this->getRevision()->getPHID();
	}

	return array(
	'revisionPHID' => $revision_phid,
	'authorPHID' => $this->getAuthorPHID(),
	'repositoryPHID' => $this->getRepositoryPHID(),
	'refs' => $refs,
	);
	}

	public function getConduitSearchAttachments() {
	return array(
	id(new DifferentialCommitsSearchEngineAttachment())
	->setAttachmentKey('commits'),
	);
	}

	private static function detectGeneratedCode(
	DifferentialChangeset $changeset) {

	$is_generated_trusted = self::isTrustedGeneratedCode($changeset);
	-
	- $changeset->setTrustedChangesetAttribute(
	- DifferentialChangeset::ATTRIBUTE_GENERATED,
	- $is_generated_trusted);
	+ if ($is_generated_trusted) {
	+ $changeset->setTrustedChangesetAttribute(
	+ DifferentialChangeset::ATTRIBUTE_GENERATED,
	+ $is_generated_trusted);
	+ }

	$is_generated_untrusted = self::isUntrustedGeneratedCode($changeset);
	-
	- $changeset->setUntrustedChangesetAttribute(
	- DifferentialChangeset::ATTRIBUTE_GENERATED,
	- $is_generated_untrusted);
	+ if ($is_generated_untrusted) {
	+ $changeset->setUntrustedChangesetAttribute(
	+ DifferentialChangeset::ATTRIBUTE_GENERATED,
	+ $is_generated_untrusted);
	+ }
	}

	private static function isTrustedGeneratedCode(
	DifferentialChangeset $changeset) {

	$filename = $changeset->getFilename();

	$paths = PhabricatorEnv::getEnvConfig('differential.generated-paths');
	foreach ($paths as $regexp) {
	if (preg_match($regexp, $filename)) {
	return true;
	}
	}

	return false;
	}

	private static function isUntrustedGeneratedCode(
	DifferentialChangeset $changeset) {

	if ($changeset->getHunks()) {
	$new_data = $changeset->makeNewFile();
	if (strpos($new_data, '@'.'generated') !== false) {
	return true;
	}
	}

	return false;
	}

	}
	diff --git a/src/applications/owners/storage/PhabricatorOwnersPackage.php b/src/applications/owners/storage/PhabricatorOwnersPackage.php
	index c76864702c..5e856190ec 100644
	--- a/src/applications/owners/storage/PhabricatorOwnersPackage.php
	+++ b/src/applications/owners/storage/PhabricatorOwnersPackage.php
	@@ -1,715 +1,791 @@
	<?php

	final class PhabricatorOwnersPackage
	extends PhabricatorOwnersDAO
	implements
	PhabricatorPolicyInterface,
	PhabricatorApplicationTransactionInterface,
	PhabricatorCustomFieldInterface,
	PhabricatorDestructibleInterface,
	PhabricatorConduitResultInterface,
	PhabricatorFulltextInterface,
	PhabricatorFerretInterface,
	PhabricatorNgramsInterface {

	protected $name;
	protected $auditingEnabled;
	protected $autoReview;
	protected $description;
	protected $mailKey;
	protected $status;
	protected $viewPolicy;
	protected $editPolicy;
	protected $dominion;

	private $paths = self::ATTACHABLE;
	private $owners = self::ATTACHABLE;
	private $customFields = self::ATTACHABLE;
	private $pathRepositoryMap = array();

	const STATUS_ACTIVE = 'active';
	const STATUS_ARCHIVED = 'archived';

	const AUTOREVIEW_NONE = 'none';
	const AUTOREVIEW_SUBSCRIBE = 'subscribe';
	const AUTOREVIEW_SUBSCRIBE_ALWAYS = 'subscribe-always';
	const AUTOREVIEW_REVIEW = 'review';
	const AUTOREVIEW_REVIEW_ALWAYS = 'review-always';
	const AUTOREVIEW_BLOCK = 'block';
	const AUTOREVIEW_BLOCK_ALWAYS = 'block-always';

	const DOMINION_STRONG = 'strong';
	const DOMINION_WEAK = 'weak';

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

	$view_policy = $app->getPolicy(
	PhabricatorOwnersDefaultViewCapability::CAPABILITY);
	$edit_policy = $app->getPolicy(
	PhabricatorOwnersDefaultEditCapability::CAPABILITY);

	return id(new PhabricatorOwnersPackage())
	->setAuditingEnabled(0)
	->setAutoReview(self::AUTOREVIEW_NONE)
	->setDominion(self::DOMINION_STRONG)
	->setViewPolicy($view_policy)
	->setEditPolicy($edit_policy)
	->attachPaths(array())
	->setStatus(self::STATUS_ACTIVE)
	->attachOwners(array())
	->setDescription('');
	}

	public static function getStatusNameMap() {
	return array(
	self::STATUS_ACTIVE => pht('Active'),
	self::STATUS_ARCHIVED => pht('Archived'),
	);
	}

	public static function getAutoreviewOptionsMap() {
	return array(
	self::AUTOREVIEW_NONE => array(
	'name' => pht('No Autoreview'),
	),
	self::AUTOREVIEW_REVIEW => array(
	'name' => pht('Review Changes With Non-Owner Author'),
	'authority' => true,
	),
	self::AUTOREVIEW_BLOCK => array(
	'name' => pht('Review Changes With Non-Owner Author (Blocking)'),
	'authority' => true,
	),
	self::AUTOREVIEW_SUBSCRIBE => array(
	'name' => pht('Subscribe to Changes With Non-Owner Author'),
	'authority' => true,
	),
	self::AUTOREVIEW_REVIEW_ALWAYS => array(
	'name' => pht('Review All Changes'),
	),
	self::AUTOREVIEW_BLOCK_ALWAYS => array(
	'name' => pht('Review All Changes (Blocking)'),
	),
	self::AUTOREVIEW_SUBSCRIBE_ALWAYS => array(
	'name' => pht('Subscribe to All Changes'),
	),
	);
	}

	public static function getDominionOptionsMap() {
	return array(
	self::DOMINION_STRONG => array(
	'name' => pht('Strong (Control All Paths)'),
	'short' => pht('Strong'),
	),
	self::DOMINION_WEAK => array(
	'name' => pht('Weak (Control Unowned Paths)'),
	'short' => pht('Weak'),
	),
	);
	}

	protected function getConfiguration() {
	return array(
	// This information is better available from the history table.
	self::CONFIG_TIMESTAMPS => false,
	self::CONFIG_AUX_PHID => true,
	self::CONFIG_COLUMN_SCHEMA => array(
	'name' => 'sort',
	'description' => 'text',
	'auditingEnabled' => 'bool',
	'mailKey' => 'bytes20',
	'status' => 'text32',
	'autoReview' => 'text32',
	'dominion' => 'text32',
	),
	) + parent::getConfiguration();
	}

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

	public function save() {
	if (!$this->getMailKey()) {
	$this->setMailKey(Filesystem::readRandomCharacters(20));
	}

	return parent::save();
	}

	public function isArchived() {
	return ($this->getStatus() == self::STATUS_ARCHIVED);
	}

	- public function setName($name) {
	- $this->name = $name;
	- return $this;
	+ public function getMustMatchUngeneratedPaths() {
	+ // TODO: For now, there's no way to actually configure this.
	+ return false;
	}

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

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

	public static function loadAffectedPackages(
	PhabricatorRepository $repository,
	array $paths) {

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

	return self::loadPackagesForPaths($repository, $paths);
	}

	+ public static function loadAffectedPackagesForChangesets(
	+ PhabricatorRepository $repository,
	+ DifferentialDiff $diff,
	+ array $changesets) {
	+ assert_instances_of($changesets, 'DifferentialChangeset');
	+
	+ $paths_all = array();
	+ $paths_ungenerated = array();
	+
	+ foreach ($changesets as $changeset) {
	+ $path = $changeset->getAbsoluteRepositoryPath($repository, $diff);
	+
	+ $paths_all[] = $path;
	+
	+ if (!$changeset->isGeneratedChangeset()) {
	+ $paths_ungenerated[] = $path;
	+ }
	+ }
	+
	+ if (!$paths_all) {
	+ return array();
	+ }
	+
	+ $packages_all = self::loadAffectedPackages(
	+ $repository,
	+ $paths_all);
	+
	+ // If there are no generated changesets, we can't possibly need to throw
	+ // away any packages for matching only generated paths. Just return the
	+ // full set of packages.
	+ if ($paths_ungenerated === $paths_all) {
	+ return $packages_all;
	+ }
	+
	+ $must_match_ungenerated = array();
	+ foreach ($packages_all as $package) {
	+ if ($package->getMustMatchUngeneratedPaths()) {
	+ $must_match_ungenerated[] = $package;
	+ }
	+ }
	+
	+ // If no affected packages have the "Ignore Generated Paths" flag set, we
	+ // can't possibly need to throw any away.
	+ if (!$must_match_ungenerated) {
	+ return $packages_all;
	+ }
	+
	+ if ($paths_ungenerated) {
	+ $packages_ungenerated = self::loadAffectedPackages(
	+ $repository,
	+ $paths_ungenerated);
	+ } else {
	+ $packages_ungenerated = array();
	+ }
	+
	+ // We have some generated paths, and some packages that ignore generated
	+ // paths. Take all the packages which:
	+ //
	+ // - ignore generated paths; and
	+ // - didn't match any ungenerated paths
	+ //
	+ // ...and remove them from the list.
	+
	+ $must_match_ungenerated = mpull($must_match_ungenerated, null, 'getID');
	+ $packages_ungenerated = mpull($packages_ungenerated, null, 'getID');
	+ $packages_all = mpull($packages_all, null, 'getID');
	+
	+ foreach ($must_match_ungenerated as $package_id => $package) {
	+ if (!isset($packages_ungenerated[$package_id])) {
	+ unset($packages_all[$package_id]);
	+ }
	+ }
	+
	+ return $packages_all;
	+ }
	+
	public static function loadOwningPackages($repository, $path) {
	if (empty($path)) {
	return array();
	}

	return self::loadPackagesForPaths($repository, array($path), 1);
	}

	private static function loadPackagesForPaths(
	PhabricatorRepository $repository,
	array $paths,
	$limit = 0) {

	$fragments = array();
	foreach ($paths as $path) {
	foreach (self::splitPath($path) as $fragment) {
	$fragments[$fragment][$path] = true;
	}
	}

	$package = new PhabricatorOwnersPackage();
	$path = new PhabricatorOwnersPath();
	$conn = $package->establishConnection('r');

	$repository_clause = qsprintf(
	$conn,
	'AND p.repositoryPHID = %s',
	$repository->getPHID());

	// NOTE: The list of $paths may be very large if we're coming from
	// the OwnersWorker and processing, e.g., an SVN commit which created a new
	// branch. Break it apart so that it will fit within 'max_allowed_packet',
	// and then merge results in PHP.

	$rows = array();
	foreach (array_chunk(array_keys($fragments), 1024) as $chunk) {
	$indexes = array();
	foreach ($chunk as $fragment) {
	$indexes[] = PhabricatorHash::digestForIndex($fragment);
	}

	$rows[] = queryfx_all(
	$conn,
	'SELECT pkg.id, pkg.dominion, p.excluded, p.path
	FROM %T pkg JOIN %T p ON p.packageID = pkg.id
	WHERE p.pathIndex IN (%Ls) AND pkg.status IN (%Ls) %Q',
	$package->getTableName(),
	$path->getTableName(),
	$indexes,
	array(
	self::STATUS_ACTIVE,
	),
	$repository_clause);
	}
	$rows = array_mergev($rows);

	$ids = self::findLongestPathsPerPackage($rows, $fragments);

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

	arsort($ids);
	if ($limit) {
	$ids = array_slice($ids, 0, $limit, $preserve_keys = true);
	}
	$ids = array_keys($ids);

	$packages = $package->loadAllWhere('id in (%Ld)', $ids);
	$packages = array_select_keys($packages, $ids);

	return $packages;
	}

	public static function loadPackagesForRepository($repository) {
	$package = new PhabricatorOwnersPackage();
	$ids = ipull(
	queryfx_all(
	$package->establishConnection('r'),
	'SELECT DISTINCT packageID FROM %T WHERE repositoryPHID = %s',
	id(new PhabricatorOwnersPath())->getTableName(),
	$repository->getPHID()),
	'packageID');

	return $package->loadAllWhere('id in (%Ld)', $ids);
	}

	public static function findLongestPathsPerPackage(array $rows, array $paths) {

	// Build a map from each path to all the package paths which match it.
	$path_hits = array();
	$weak = array();
	foreach ($rows as $row) {
	$id = $row['id'];
	$path = $row['path'];
	$length = strlen($path);
	$excluded = $row['excluded'];

	if ($row['dominion'] === self::DOMINION_WEAK) {
	$weak[$id] = true;
	}

	$matches = $paths[$path];
	foreach ($matches as $match => $ignored) {
	$path_hits[$match][] = array(
	'id' => $id,
	'excluded' => $excluded,
	'length' => $length,
	);
	}
	}

	// For each path, process the matching package paths to figure out which
	// packages actually own it.
	$path_packages = array();
	foreach ($path_hits as $match => $hits) {
	$hits = isort($hits, 'length');

	$packages = array();
	foreach ($hits as $hit) {
	$package_id = $hit['id'];
	if ($hit['excluded']) {
	unset($packages[$package_id]);
	} else {
	$packages[$package_id] = $hit;
	}
	}

	$path_packages[$match] = $packages;
	}

	// Remove packages with weak dominion rules that should cede control to
	// a more specific package.
	if ($weak) {
	foreach ($path_packages as $match => $packages) {

	// Group packages by length.
	$length_map = array();
	foreach ($packages as $package_id => $package) {
	$length_map[$package['length']][$package_id] = $package;
	}

	// For each path length, remove all weak packages if there are any
	// strong packages of the same length. This makes sure that if there
	// are one or more strong claims on a particular path, only those
	// claims stand.
	foreach ($length_map as $package_list) {
	$any_strong = false;
	foreach ($package_list as $package_id => $package) {
	if (!isset($weak[$package_id])) {
	$any_strong = true;
	break;
	}
	}

	if ($any_strong) {
	foreach ($package_list as $package_id => $package) {
	if (isset($weak[$package_id])) {
	unset($packages[$package_id]);
	}
	}
	}
	}

	$packages = isort($packages, 'length');
	$packages = array_reverse($packages, true);

	$best_length = null;
	foreach ($packages as $package_id => $package) {
	// If this is the first package we've encountered, note its length.
	// We're iterating over the packages from longest to shortest match,
	// so packages of this length always have the best claim on the path.
	if ($best_length === null) {
	$best_length = $package['length'];
	}

	// If this package has the same length as the best length, its claim
	// stands.
	if ($package['length'] === $best_length) {
	continue;
	}

	// If this is a weak package and does not have the best length,
	// cede its claim to the stronger package.
	if (isset($weak[$package_id])) {
	unset($packages[$package_id]);
	}
	}

	$path_packages[$match] = $packages;
	}
	}

	// For each package that owns at least one path, identify the longest
	// path it owns.
	$package_lengths = array();
	foreach ($path_packages as $match => $hits) {
	foreach ($hits as $hit) {
	$length = $hit['length'];
	$id = $hit['id'];
	if (empty($package_lengths[$id])) {
	$package_lengths[$id] = $length;
	} else {
	$package_lengths[$id] = max($package_lengths[$id], $length);
	}
	}
	}

	return $package_lengths;
	}

	public static function splitPath($path) {
	$result = array(
	'/',
	);

	$parts = explode('/', $path);
	$buffer = '/';
	foreach ($parts as $part) {
	if (!strlen($part)) {
	continue;
	}

	$buffer = $buffer.$part.'/';
	$result[] = $buffer;
	}

	return $result;
	}

	public function attachPaths(array $paths) {
	assert_instances_of($paths, 'PhabricatorOwnersPath');
	$this->paths = $paths;

	// Drop this cache if we're attaching new paths.
	$this->pathRepositoryMap = array();

	return $this;
	}

	public function getPaths() {
	return $this->assertAttached($this->paths);
	}

	public function getPathsForRepository($repository_phid) {
	if (isset($this->pathRepositoryMap[$repository_phid])) {
	return $this->pathRepositoryMap[$repository_phid];
	}

	$map = array();
	foreach ($this->getPaths() as $path) {
	if ($path->getRepositoryPHID() == $repository_phid) {
	$map[] = $path;
	}
	}

	$this->pathRepositoryMap[$repository_phid] = $map;

	return $this->pathRepositoryMap[$repository_phid];
	}

	public function attachOwners(array $owners) {
	assert_instances_of($owners, 'PhabricatorOwnersOwner');
	$this->owners = $owners;
	return $this;
	}

	public function getOwners() {
	return $this->assertAttached($this->owners);
	}

	public function getOwnerPHIDs() {
	return mpull($this->getOwners(), 'getUserPHID');
	}

	public function isOwnerPHID($phid) {
	if (!$phid) {
	return false;
	}

	$owner_phids = $this->getOwnerPHIDs();
	$owner_phids = array_fuse($owner_phids);

	return isset($owner_phids[$phid]);
	}

	public function getMonogram() {
	return 'O'.$this->getID();
	}

	public function getURI() {
	// TODO: Move these to "/O123" for consistency.
	return '/owners/package/'.$this->getID().'/';
	}

	/* -( 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 $viewer) {
	switch ($capability) {
	case PhabricatorPolicyCapability::CAN_VIEW:
	if ($this->isOwnerPHID($viewer->getPHID())) {
	return true;
	}
	break;
	}

	return false;
	}

	public function describeAutomaticCapability($capability) {
	return pht('Owners of a package may always view it.');
	}


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


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

	public function getApplicationTransactionObject() {
	return $this;
	}

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

	public function willRenderTimeline(
	PhabricatorApplicationTransactionView $timeline,
	AphrontRequest $request) {
	return $timeline;
	}


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


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

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

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

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


	/* -( PhabricatorDestructibleInterface )----------------------------------- */


	public function destroyObjectPermanently(
	PhabricatorDestructionEngine $engine) {

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

	queryfx(
	$conn_w,
	'DELETE FROM %T WHERE packageID = %d',
	id(new PhabricatorOwnersPath())->getTableName(),
	$this->getID());

	queryfx(
	$conn_w,
	'DELETE FROM %T WHERE packageID = %d',
	id(new PhabricatorOwnersOwner())->getTableName(),
	$this->getID());

	$this->delete();
	$this->saveTransaction();
	}


	/* -( PhabricatorConduitResultInterface )---------------------------------- */


	public function getFieldSpecificationsForConduit() {
	return array(
	id(new PhabricatorConduitSearchFieldSpecification())
	->setKey('name')
	->setType('string')
	->setDescription(pht('The name of the package.')),
	id(new PhabricatorConduitSearchFieldSpecification())
	->setKey('description')
	->setType('string')
	->setDescription(pht('The package description.')),
	id(new PhabricatorConduitSearchFieldSpecification())
	->setKey('status')
	->setType('string')
	->setDescription(pht('Active or archived status of the package.')),
	id(new PhabricatorConduitSearchFieldSpecification())
	->setKey('owners')
	->setType('list<map<string, wild>>')
	->setDescription(pht('List of package owners.')),
	id(new PhabricatorConduitSearchFieldSpecification())
	->setKey('review')
	->setType('map<string, wild>')
	->setDescription(pht('Auto review information.')),
	id(new PhabricatorConduitSearchFieldSpecification())
	->setKey('audit')
	->setType('map<string, wild>')
	->setDescription(pht('Auto audit information.')),
	id(new PhabricatorConduitSearchFieldSpecification())
	->setKey('dominion')
	->setType('map<string, wild>')
	->setDescription(pht('Dominion setting information.')),
	);
	}

	public function getFieldValuesForConduit() {
	$owner_list = array();
	foreach ($this->getOwners() as $owner) {
	$owner_list[] = array(
	'ownerPHID' => $owner->getUserPHID(),
	);
	}

	$review_map = self::getAutoreviewOptionsMap();
	$review_value = $this->getAutoReview();
	if (isset($review_map[$review_value])) {
	$review_label = $review_map[$review_value]['name'];
	} else {
	$review_label = pht('Unknown ("%s")', $review_value);
	}

	$review = array(
	'value' => $review_value,
	'label' => $review_label,
	);

	if ($this->getAuditingEnabled()) {
	$audit_value = 'audit';
	$audit_label = pht('Auditing Enabled');
	} else {
	$audit_value = 'none';
	$audit_label = pht('No Auditing');
	}

	$audit = array(
	'value' => $audit_value,
	'label' => $audit_label,
	);

	$dominion_value = $this->getDominion();
	$dominion_map = self::getDominionOptionsMap();
	if (isset($dominion_map[$dominion_value])) {
	$dominion_label = $dominion_map[$dominion_value]['name'];
	$dominion_short = $dominion_map[$dominion_value]['short'];
	} else {
	$dominion_label = pht('Unknown ("%s")', $dominion_value);
	$dominion_short = pht('Unknown ("%s")', $dominion_value);
	}

	$dominion = array(
	'value' => $dominion_value,
	'label' => $dominion_label,
	'short' => $dominion_short,
	);

	return array(
	'name' => $this->getName(),
	'description' => $this->getDescription(),
	'status' => $this->getStatus(),
	'owners' => $owner_list,
	'review' => $review,
	'audit' => $audit,
	'dominion' => $dominion,
	);
	}

	public function getConduitSearchAttachments() {
	return array(
	id(new PhabricatorOwnersPathsSearchEngineAttachment())
	->setAttachmentKey('paths'),
	);
	}


	/* -( PhabricatorFulltextInterface )--------------------------------------- */


	public function newFulltextEngine() {
	return new PhabricatorOwnersPackageFulltextEngine();
	}


	/* -( PhabricatorFerretInterface )----------------------------------------- */


	public function newFerretEngine() {
	return new PhabricatorOwnersPackageFerretEngine();
	}


	/* -( PhabricatorNgramsInterface )----------------------------------------- */


	public function newNgrams() {
	return array(
	id(new PhabricatorOwnersPackageNameNgrams())
	->setValue($this->getName()),
	);
	}

	}

File Metadata

Mime Type: text/x-diff
Expires: Mon, Apr 28, 2:38 PM (1 d, 4 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 108025
Default Alt Text: (114 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions