No OneTemporary
Actions

Size

91 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/src/applications/differential/storage/DifferentialDiff.php b/src/applications/differential/storage/DifferentialDiff.php
	index f055000fdb..1124582263 100644
	--- a/src/applications/differential/storage/DifferentialDiff.php
	+++ b/src/applications/differential/storage/DifferentialDiff.php
	@@ -1,466 +1,480 @@
	<?php

	final class DifferentialDiff
	extends DifferentialDAO
	implements
	PhabricatorPolicyInterface,
	HarbormasterBuildableInterface,
	PhabricatorApplicationTransactionInterface,
	PhabricatorDestructibleInterface {

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

	protected $sourceMachine;
	protected $sourcePath;

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

	protected $lintStatus;
	protected $unitStatus;

	protected $lineCount;

	protected $branch;
	protected $bookmark;

	protected $arcanistProjectPHID;
	protected $creationMethod;
	protected $repositoryUUID;

	protected $description;

	protected $viewPolicy;

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

	public 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?',
	'arcanistProjectPHID' => 'phid?',
	'repositoryUUID' => 'text64?',

	// 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'),
	),
	),
	) + 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();
	}
	return id(new DifferentialChangeset())->loadAllWhere(
	'diffID = %d',
	$this->getID());
	}

	public function attachArcanistProject(
	PhabricatorRepositoryArcanistProject $project = null) {
	$this->arcanistProject = $project;
	return $this;
	}

	public function getArcanistProject() {
	return $this->assertAttached($this->arcanistProject);
	}

	public function getArcanistProjectName() {
	$name = '';
	if ($this->arcanistProject) {
	$project = $this->getArcanistProject();
	$name = $project->getName();
	}
	return $name;
	}

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

	$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(),
	'properties' => array(),
	'projectName' => $this->getArcanistProjectName(),
	);

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

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


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


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

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

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



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


	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();
	$revision = $this->getRevision();
	$results['buildable.revision'] = $revision->getID();
	$repo = $revision->getRepository();

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

	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.vcs' =>
	pht('The version control system, either "svn", "hg" or "git".'),
	'repository.uri' =>
	pht('The URI to clone or checkout the repository from.'),
	);
	}


	/* -( 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) {
	$changeset->delete();
	}

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

	$this->saveTransaction();
	}

	}
	diff --git a/src/applications/diffusion/controller/DiffusionChangeController.php b/src/applications/diffusion/controller/DiffusionChangeController.php
	index ddfa283883..373209e645 100644
	--- a/src/applications/diffusion/controller/DiffusionChangeController.php
	+++ b/src/applications/diffusion/controller/DiffusionChangeController.php
	@@ -1,164 +1,163 @@
	<?php

	final class DiffusionChangeController extends DiffusionController {

	public function shouldAllowPublic() {
	return true;
	}

	public function processRequest() {
	$drequest = $this->diffusionRequest;
	$viewer = $this->getRequest()->getUser();

	$content = array();

	$data = $this->callConduitWithDiffusionRequest(
	'diffusion.diffquery',
	array(
	'commit' => $drequest->getCommit(),
	'path' => $drequest->getPath(),
	));

	$drequest->updateSymbolicCommit($data['effectiveCommit']);

	$raw_changes = ArcanistDiffChange::newFromConduit($data['changes']);
	- $diff = DifferentialDiff::newFromRawChanges(
	- $viewer,
	+ $diff = DifferentialDiff::newEphemeralFromRawChanges(
	$raw_changes);
	$changesets = $diff->getChangesets();
	$changeset = reset($changesets);

	if (!$changeset) {
	// TODO: Refine this.
	return new Aphront404Response();
	}

	$repository = $drequest->getRepository();
	$callsign = $repository->getCallsign();
	$changesets = array(
	0 => $changeset,
	);

	$changeset_view = new DifferentialChangesetListView();
	$changeset_view->setTitle(pht('Change'));
	$changeset_view->setChangesets($changesets);
	$changeset_view->setVisibleChangesets($changesets);
	$changeset_view->setRenderingReferences(
	array(
	0 => $drequest->generateURI(array('action' => 'rendering-ref')),
	));

	$raw_params = array(
	'action' => 'browse',
	'params' => array(
	'view' => 'raw',
	),
	);

	$right_uri = $drequest->generateURI($raw_params);
	$raw_params['params']['before'] = $drequest->getStableCommit();
	$left_uri = $drequest->generateURI($raw_params);
	$changeset_view->setRawFileURIs($left_uri, $right_uri);

	$changeset_view->setRenderURI('/diffusion/'.$callsign.'/diff/');
	$changeset_view->setWhitespace(
	DifferentialChangesetParser::WHITESPACE_SHOW_ALL);
	$changeset_view->setUser($this->getRequest()->getUser());

	// TODO: This is pretty awkward, unify the CSS between Diffusion and
	// Differential better.
	require_celerity_resource('differential-core-view-css');
	$content[] = $changeset_view->render();

	$crumbs = $this->buildCrumbs(
	array(
	'branch' => true,
	'path' => true,
	'view' => 'change',
	));

	$links = $this->renderPathLinks($drequest, $mode = 'browse');

	$header = id(new PHUIHeaderView())
	->setHeader($links)
	->setUser($viewer)
	->setPolicyObject($drequest->getRepository());
	$actions = $this->buildActionView($drequest);
	$properties = $this->buildPropertyView($drequest, $actions);

	$object_box = id(new PHUIObjectBoxView())
	->setHeader($header)
	->addPropertyList($properties);

	return $this->buildApplicationPage(
	array(
	$crumbs,
	$object_box,
	$content,
	),
	array(
	'title' => pht('Change'),
	));
	}

	private function buildActionView(DiffusionRequest $drequest) {
	$viewer = $this->getRequest()->getUser();

	$view = id(new PhabricatorActionListView())
	->setUser($viewer);

	$history_uri = $drequest->generateURI(
	array(
	'action' => 'history',
	));

	$view->addAction(
	id(new PhabricatorActionView())
	->setName(pht('View History'))
	->setHref($history_uri)
	->setIcon('fa-clock-o'));

	$browse_uri = $drequest->generateURI(
	array(
	'action' => 'browse',
	));

	$view->addAction(
	id(new PhabricatorActionView())
	->setName(pht('Browse Content'))
	->setHref($browse_uri)
	->setIcon('fa-files-o'));

	return $view;
	}

	protected function buildPropertyView(
	DiffusionRequest $drequest,
	PhabricatorActionListView $actions) {

	$viewer = $this->getRequest()->getUser();

	$view = id(new PHUIPropertyListView())
	->setUser($viewer)
	->setActionList($actions);

	$stable_commit = $drequest->getStableCommit();
	$callsign = $drequest->getRepository()->getCallsign();

	$view->addProperty(
	pht('Commit'),
	phutil_tag(
	'a',
	array(
	'href' => $drequest->generateURI(
	array(
	'action' => 'commit',
	'commit' => $stable_commit,
	)),
	),
	$drequest->getRepository()->formatCommitName($stable_commit)));

	return $view;
	}

	}
	diff --git a/src/applications/diffusion/controller/DiffusionDiffController.php b/src/applications/diffusion/controller/DiffusionDiffController.php
	index 81460ea67a..4f6e3a8067 100644
	--- a/src/applications/diffusion/controller/DiffusionDiffController.php
	+++ b/src/applications/diffusion/controller/DiffusionDiffController.php
	@@ -1,129 +1,128 @@
	<?php

	final class DiffusionDiffController extends DiffusionController {

	public function shouldAllowPublic() {
	return true;
	}

	public function willProcessRequest(array $data) {
	$data = $data + array(
	'dblob' => $this->getRequest()->getStr('ref'),
	);
	$drequest = DiffusionRequest::newFromAphrontRequestDictionary(
	$data,
	$this->getRequest());

	$this->diffusionRequest = $drequest;
	}

	public function processRequest() {
	$drequest = $this->getDiffusionRequest();
	$request = $this->getRequest();
	$user = $request->getUser();

	if (!$request->isAjax()) {

	// This request came out of the dropdown menu, either "View Standalone"
	// or "View Raw File".

	$view = $request->getStr('view');
	if ($view == 'r') {
	$uri = $drequest->generateURI(
	array(
	'action' => 'browse',
	'params' => array(
	'view' => 'raw',
	),
	));
	} else {
	$uri = $drequest->generateURI(
	array(
	'action' => 'change',
	));
	}

	return id(new AphrontRedirectResponse())->setURI($uri);
	}

	$data = $this->callConduitWithDiffusionRequest(
	'diffusion.diffquery',
	array(
	'commit' => $drequest->getCommit(),
	'path' => $drequest->getPath(),
	));
	$drequest->updateSymbolicCommit($data['effectiveCommit']);
	$raw_changes = ArcanistDiffChange::newFromConduit($data['changes']);
	- $diff = DifferentialDiff::newFromRawChanges(
	- $user,
	+ $diff = DifferentialDiff::newEphemeralFromRawChanges(
	$raw_changes);
	$changesets = $diff->getChangesets();
	$changeset = reset($changesets);

	if (!$changeset) {
	return new Aphront404Response();
	}

	$parser = new DifferentialChangesetParser();
	$parser->setUser($user);
	$parser->setChangeset($changeset);
	$parser->setRenderingReference($drequest->generateURI(
	array(
	'action' => 'rendering-ref',
	)));

	$parser->setCharacterEncoding($request->getStr('encoding'));
	$parser->setHighlightAs($request->getStr('highlight'));

	$coverage = $drequest->loadCoverage();
	if ($coverage) {
	$parser->setCoverage($coverage);
	}

	$pquery = new DiffusionPathIDQuery(array($changeset->getFilename()));
	$ids = $pquery->loadPathIDs();
	$path_id = $ids[$changeset->getFilename()];

	$parser->setLeftSideCommentMapping($path_id, false);
	$parser->setRightSideCommentMapping($path_id, true);

	$parser->setWhitespaceMode(
	DifferentialChangesetParser::WHITESPACE_SHOW_ALL);

	$inlines = PhabricatorAuditInlineComment::loadDraftAndPublishedComments(
	$user,
	$drequest->loadCommit()->getPHID(),
	$path_id);

	if ($inlines) {
	foreach ($inlines as $inline) {
	$parser->parseInlineComment($inline);
	}

	$phids = mpull($inlines, 'getAuthorPHID');
	$handles = $this->loadViewerHandles($phids);
	$parser->setHandles($handles);
	}

	$engine = new PhabricatorMarkupEngine();
	$engine->setViewer($user);

	foreach ($inlines as $inline) {
	$engine->addObject(
	$inline,
	PhabricatorInlineCommentInterface::MARKUP_FIELD_BODY);
	}

	$engine->process();

	$parser->setMarkupEngine($engine);

	$spec = $request->getStr('range');
	list($range_s, $range_e, $mask) =
	DifferentialChangesetParser::parseRangeSpecification($spec);
	$output = $parser->render($range_s, $range_e, $mask);

	return id(new PhabricatorChangesetResponse())
	->setRenderedChangeset($output);
	}
	}
	diff --git a/src/applications/diffusion/data/DiffusionPathChange.php b/src/applications/diffusion/data/DiffusionPathChange.php
	index e4f6fa182a..b1d7286fdd 100644
	--- a/src/applications/diffusion/data/DiffusionPathChange.php
	+++ b/src/applications/diffusion/data/DiffusionPathChange.php
	@@ -1,201 +1,202 @@
	<?php

	final class DiffusionPathChange {

	private $path;
	private $commitIdentifier;
	private $commit;
	private $commitData;

	private $changeType;
	private $fileType;
	private $targetPath;
	private $targetCommitIdentifier;
	private $awayPaths = array();

	final public function setPath($path) {
	$this->path = $path;
	return $this;
	}

	final public function getPath() {
	return $this->path;
	}

	public function setChangeType($change_type) {
	$this->changeType = $change_type;
	return $this;
	}

	public function getChangeType() {
	return $this->changeType;
	}

	public function setFileType($file_type) {
	$this->fileType = $file_type;
	return $this;
	}

	public function getFileType() {
	return $this->fileType;
	}

	public function setTargetPath($target_path) {
	$this->targetPath = $target_path;
	return $this;
	}

	public function getTargetPath() {
	return $this->targetPath;
	}

	public function setAwayPaths(array $away_paths) {
	$this->awayPaths = $away_paths;
	return $this;
	}

	public function getAwayPaths() {
	return $this->awayPaths;
	}

	final public function setCommitIdentifier($commit) {
	$this->commitIdentifier = $commit;
	return $this;
	}

	final public function getCommitIdentifier() {
	return $this->commitIdentifier;
	}

	final public function setTargetCommitIdentifier($target_commit_identifier) {
	$this->targetCommitIdentifier = $target_commit_identifier;
	return $this;
	}

	final public function getTargetCommitIdentifier() {
	return $this->targetCommitIdentifier;
	}

	final public function setCommit($commit) {
	$this->commit = $commit;
	return $this;
	}

	final public function getCommit() {
	return $this->commit;
	}

	final public function setCommitData($commit_data) {
	$this->commitData = $commit_data;
	return $this;
	}

	final public function getCommitData() {
	return $this->commitData;
	}


	final public function getEpoch() {
	if ($this->getCommit()) {
	return $this->getCommit()->getEpoch();
	}
	return null;
	}

	final public function getAuthorName() {
	if ($this->getCommitData()) {
	return $this->getCommitData()->getAuthorName();
	}
	return null;
	}

	final public function getSummary() {
	if (!$this->getCommitData()) {
	return null;
	}
	$message = $this->getCommitData()->getCommitMessage();
	$first = idx(explode("\n", $message), 0);
	return substr($first, 0, 80);
	}

	final public static function convertToArcanistChanges(array $changes) {
	assert_instances_of($changes, 'DiffusionPathChange');
	$direct = array();
	$result = array();
	foreach ($changes as $path) {
	$change = new ArcanistDiffChange();
	$change->setCurrentPath($path->getPath());
	$direct[] = $path->getPath();
	$change->setType($path->getChangeType());
	$file_type = $path->getFileType();
	if ($file_type == DifferentialChangeType::FILE_NORMAL) {
	$file_type = DifferentialChangeType::FILE_TEXT;
	}
	$change->setFileType($file_type);
	$change->setOldPath($path->getTargetPath());
	foreach ($path->getAwayPaths() as $away_path) {
	$change->addAwayPath($away_path);
	}
	$result[$path->getPath()] = $change;
	}

	return array_select_keys($result, $direct);
	}

	final public static function convertToDifferentialChangesets(
	PhabricatorUser $user,
	array $changes) {
	assert_instances_of($changes, 'DiffusionPathChange');
	$arcanist_changes = self::convertToArcanistChanges($changes);
	- $diff = DifferentialDiff::newFromRawChanges($user, $arcanist_changes);
	+ $diff = DifferentialDiff::newEphemeralFromRawChanges(
	+ $arcanist_changes);
	return $diff->getChangesets();
	}

	public function toDictionary() {
	$commit = $this->getCommit();
	if ($commit) {
	$commit_dict = $commit->toDictionary();
	} else {
	$commit_dict = array();
	}
	$commit_data = $this->getCommitData();
	if ($commit_data) {
	$commit_data_dict = $commit_data->toDictionary();
	} else {
	$commit_data_dict = array();
	}
	return array(
	'path' => $this->getPath(),
	'commitIdentifier' => $this->getCommitIdentifier(),
	'commit' => $commit_dict,
	'commitData' => $commit_data_dict,
	'fileType' => $this->getFileType(),
	'changeType' => $this->getChangeType(),
	'targetPath' => $this->getTargetPath(),
	'targetCommitIdentifier' => $this->getTargetCommitIdentifier(),
	'awayPaths' => $this->getAwayPaths(),
	);
	}

	public static function newFromConduit(array $dicts) {
	$results = array();
	foreach ($dicts as $dict) {
	$commit = PhabricatorRepositoryCommit::newFromDictionary($dict['commit']);
	$commit_data =
	PhabricatorRepositoryCommitData::newFromDictionary(
	$dict['commitData']);
	$results[] = id(new DiffusionPathChange())
	->setPath($dict['path'])
	->setCommitIdentifier($dict['commitIdentifier'])
	->setCommit($commit)
	->setCommitData($commit_data)
	->setFileType($dict['fileType'])
	->setChangeType($dict['changeType'])
	->setTargetPath($dict['targetPath'])
	->setTargetCommitIdentifier($dict['targetCommitIdentifier'])
	->setAwayPaths($dict['awayPaths']);
	}
	return $results;
	}

	}
	diff --git a/src/applications/diffusion/engine/DiffusionCommitHookEngine.php b/src/applications/diffusion/engine/DiffusionCommitHookEngine.php
	index 9e7d5ccef9..8dd7ab81e0 100644
	--- a/src/applications/diffusion/engine/DiffusionCommitHookEngine.php
	+++ b/src/applications/diffusion/engine/DiffusionCommitHookEngine.php
	@@ -1,1188 +1,1187 @@
	<?php

	/**
	* @task config Configuring the Hook Engine
	* @task hook Hook Execution
	* @task git Git Hooks
	* @task hg Mercurial Hooks
	* @task svn Subversion Hooks
	* @task internal Internals
	*/
	final class DiffusionCommitHookEngine extends Phobject {

	const ENV_USER = 'PHABRICATOR_USER';
	const ENV_REMOTE_ADDRESS = 'PHABRICATOR_REMOTE_ADDRESS';
	const ENV_REMOTE_PROTOCOL = 'PHABRICATOR_REMOTE_PROTOCOL';

	const EMPTY_HASH = '0000000000000000000000000000000000000000';

	private $viewer;
	private $repository;
	private $stdin;
	private $originalArgv;
	private $subversionTransaction;
	private $subversionRepository;
	private $remoteAddress;
	private $remoteProtocol;
	private $transactionKey;
	private $mercurialHook;
	private $mercurialCommits = array();
	private $gitCommits = array();

	private $heraldViewerProjects;
	private $rejectCode = PhabricatorRepositoryPushLog::REJECT_BROKEN;
	private $rejectDetails;
	private $emailPHIDs = array();


	/* -( Config )------------------------------------------------------------- */


	public function setRemoteProtocol($remote_protocol) {
	$this->remoteProtocol = $remote_protocol;
	return $this;
	}

	public function getRemoteProtocol() {
	return $this->remoteProtocol;
	}

	public function setRemoteAddress($remote_address) {
	$this->remoteAddress = $remote_address;
	return $this;
	}

	public function getRemoteAddress() {
	return $this->remoteAddress;
	}

	private function getRemoteAddressForLog() {
	// If whatever we have here isn't a valid IPv4 address, just store `null`.
	// Older versions of PHP return `-1` on failure instead of `false`.
	$remote_address = $this->getRemoteAddress();
	$remote_address = max(0, ip2long($remote_address));
	$remote_address = nonempty($remote_address, null);
	return $remote_address;
	}

	public function setSubversionTransactionInfo($transaction, $repository) {
	$this->subversionTransaction = $transaction;
	$this->subversionRepository = $repository;
	return $this;
	}

	public function setStdin($stdin) {
	$this->stdin = $stdin;
	return $this;
	}

	public function getStdin() {
	return $this->stdin;
	}

	public function setOriginalArgv(array $original_argv) {
	$this->originalArgv = $original_argv;
	return $this;
	}

	public function getOriginalArgv() {
	return $this->originalArgv;
	}

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

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

	public function setViewer(PhabricatorUser $viewer) {
	$this->viewer = $viewer;
	return $this;
	}

	public function getViewer() {
	return $this->viewer;
	}

	public function setMercurialHook($mercurial_hook) {
	$this->mercurialHook = $mercurial_hook;
	return $this;
	}

	public function getMercurialHook() {
	return $this->mercurialHook;
	}


	/* -( Hook Execution )----------------------------------------------------- */


	public function execute() {
	$ref_updates = $this->findRefUpdates();
	$all_updates = $ref_updates;

	$caught = null;
	try {

	try {
	$this->rejectDangerousChanges($ref_updates);
	} catch (DiffusionCommitHookRejectException $ex) {
	// If we're rejecting dangerous changes, flag everything that we've
	// seen as rejected so it's clear that none of it was accepted.
	$this->rejectCode = PhabricatorRepositoryPushLog::REJECT_DANGEROUS;
	throw $ex;
	}

	$this->applyHeraldRefRules($ref_updates, $all_updates);

	$content_updates = $this->findContentUpdates($ref_updates);
	$all_updates = array_merge($all_updates, $content_updates);

	$this->applyHeraldContentRules($content_updates, $all_updates);

	// Run custom scripts in `hook.d/` directories.
	$this->applyCustomHooks($all_updates);

	// If we make it this far, we're accepting these changes. Mark all the
	// logs as accepted.
	$this->rejectCode = PhabricatorRepositoryPushLog::REJECT_ACCEPT;
	} catch (Exception $ex) {
	// We'll throw this again in a minute, but we want to save all the logs
	// first.
	$caught = $ex;
	}

	// Save all the logs no matter what the outcome was.
	$event = $this->newPushEvent();

	$event->setRejectCode($this->rejectCode);
	$event->setRejectDetails($this->rejectDetails);

	$event->openTransaction();
	$event->save();
	foreach ($all_updates as $update) {
	$update->setPushEventPHID($event->getPHID());
	$update->save();
	}
	$event->saveTransaction();

	if ($caught) {
	throw $caught;
	}

	if ($this->emailPHIDs) {
	// If Herald rules triggered email to users, queue a worker to send the
	// mail. We do this out-of-process so that we block pushes as briefly
	// as possible.

	// (We do need to pull some commit info here because the commit objects
	// may not exist yet when this worker runs, which could be immediately.)

	PhabricatorWorker::scheduleTask(
	'PhabricatorRepositoryPushMailWorker',
	array(
	'eventPHID' => $event->getPHID(),
	'emailPHIDs' => array_values($this->emailPHIDs),
	'info' => $this->loadCommitInfoForWorker($all_updates),
	),
	PhabricatorWorker::PRIORITY_ALERTS);
	}

	return 0;
	}

	private function findRefUpdates() {
	$type = $this->getRepository()->getVersionControlSystem();
	switch ($type) {
	case PhabricatorRepositoryType::REPOSITORY_TYPE_GIT:
	return $this->findGitRefUpdates();
	case PhabricatorRepositoryType::REPOSITORY_TYPE_MERCURIAL:
	return $this->findMercurialRefUpdates();
	case PhabricatorRepositoryType::REPOSITORY_TYPE_SVN:
	return $this->findSubversionRefUpdates();
	default:
	throw new Exception(pht('Unsupported repository type "%s"!', $type));
	}
	}

	private function rejectDangerousChanges(array $ref_updates) {
	assert_instances_of($ref_updates, 'PhabricatorRepositoryPushLog');

	$repository = $this->getRepository();
	if ($repository->shouldAllowDangerousChanges()) {
	return;
	}

	$flag_dangerous = PhabricatorRepositoryPushLog::CHANGEFLAG_DANGEROUS;

	foreach ($ref_updates as $ref_update) {
	if (!$ref_update->hasChangeFlags($flag_dangerous)) {
	// This is not a dangerous change.
	continue;
	}

	// We either have a branch deletion or a non fast-forward branch update.
	// Format a message and reject the push.

	$message = pht(
	"DANGEROUS CHANGE: %s\n".
	"Dangerous change protection is enabled for this repository.\n".
	"Edit the repository configuration before making dangerous changes.",
	$ref_update->getDangerousChangeDescription());

	throw new DiffusionCommitHookRejectException($message);
	}
	}

	private function findContentUpdates(array $ref_updates) {
	assert_instances_of($ref_updates, 'PhabricatorRepositoryPushLog');

	$type = $this->getRepository()->getVersionControlSystem();
	switch ($type) {
	case PhabricatorRepositoryType::REPOSITORY_TYPE_GIT:
	return $this->findGitContentUpdates($ref_updates);
	case PhabricatorRepositoryType::REPOSITORY_TYPE_MERCURIAL:
	return $this->findMercurialContentUpdates($ref_updates);
	case PhabricatorRepositoryType::REPOSITORY_TYPE_SVN:
	return $this->findSubversionContentUpdates($ref_updates);
	default:
	throw new Exception(pht('Unsupported repository type "%s"!', $type));
	}
	}


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

	private function applyHeraldRefRules(
	array $ref_updates,
	array $all_updates) {
	$this->applyHeraldRules(
	$ref_updates,
	new HeraldPreCommitRefAdapter(),
	$all_updates);
	}

	private function applyHeraldContentRules(
	array $content_updates,
	array $all_updates) {
	$this->applyHeraldRules(
	$content_updates,
	new HeraldPreCommitContentAdapter(),
	$all_updates);
	}

	private function applyHeraldRules(
	array $updates,
	HeraldAdapter $adapter_template,
	array $all_updates) {

	if (!$updates) {
	return;
	}

	$adapter_template->setHookEngine($this);

	$engine = new HeraldEngine();
	$rules = null;
	$blocking_effect = null;
	$blocked_update = null;
	foreach ($updates as $update) {
	$adapter = id(clone $adapter_template)
	->setPushLog($update);

	if ($rules === null) {
	$rules = $engine->loadRulesForAdapter($adapter);
	}

	$effects = $engine->applyRules($rules, $adapter);
	$engine->applyEffects($effects, $adapter, $rules);
	$xscript = $engine->getTranscript();

	// Store any PHIDs we want to send email to for later.
	foreach ($adapter->getEmailPHIDs() as $email_phid) {
	$this->emailPHIDs[$email_phid] = $email_phid;
	}

	if ($blocking_effect === null) {
	foreach ($effects as $effect) {
	if ($effect->getAction() == HeraldAdapter::ACTION_BLOCK) {
	$blocking_effect = $effect;
	$blocked_update = $update;
	break;
	}
	}
	}
	}

	if ($blocking_effect) {
	$this->rejectCode = PhabricatorRepositoryPushLog::REJECT_HERALD;
	$this->rejectDetails = $blocking_effect->getRulePHID();

	$message = $blocking_effect->getTarget();
	if (!strlen($message)) {
	$message = pht('(None.)');
	}

	$rules = mpull($rules, null, 'getID');
	$rule = idx($rules, $effect->getRuleID());
	if ($rule && strlen($rule->getName())) {
	$rule_name = $rule->getName();
	} else {
	$rule_name = pht('Unnamed Herald Rule');
	}

	$blocked_ref_name = coalesce(
	$blocked_update->getRefName(),
	$blocked_update->getRefNewShort());
	$blocked_name = $blocked_update->getRefType().'/'.$blocked_ref_name;

	throw new DiffusionCommitHookRejectException(
	pht(
	"This push was rejected by Herald push rule %s.\n".
	"Change: %s\n".
	" Rule: %s\n".
	"Reason: %s",
	'H'.$blocking_effect->getRuleID(),
	$blocked_name,
	$rule_name,
	$message));
	}
	}

	public function loadViewerProjectPHIDsForHerald() {
	// This just caches the viewer's projects so we don't need to load them
	// over and over again when applying Herald rules.
	if ($this->heraldViewerProjects === null) {
	$this->heraldViewerProjects = id(new PhabricatorProjectQuery())
	->setViewer($this->getViewer())
	->withMemberPHIDs(array($this->getViewer()->getPHID()))
	->execute();
	}

	return mpull($this->heraldViewerProjects, 'getPHID');
	}


	/* -( Git )---------------------------------------------------------------- */


	private function findGitRefUpdates() {
	$ref_updates = array();

	// First, parse stdin, which lists all the ref changes. The input looks
	// like this:
	//
	// <old hash> <new hash> <ref>

	$stdin = $this->getStdin();
	$lines = phutil_split_lines($stdin, $retain_endings = false);
	foreach ($lines as $line) {
	$parts = explode(' ', $line, 3);
	if (count($parts) != 3) {
	throw new Exception(pht('Expected "old new ref", got "%s".', $line));
	}

	$ref_old = $parts[0];
	$ref_new = $parts[1];
	$ref_raw = $parts[2];

	if (preg_match('(^refs/heads/)', $ref_raw)) {
	$ref_type = PhabricatorRepositoryPushLog::REFTYPE_BRANCH;
	$ref_raw = substr($ref_raw, strlen('refs/heads/'));
	} else if (preg_match('(^refs/tags/)', $ref_raw)) {
	$ref_type = PhabricatorRepositoryPushLog::REFTYPE_TAG;
	$ref_raw = substr($ref_raw, strlen('refs/tags/'));
	} else {
	throw new Exception(
	pht(
	"Unable to identify the reftype of '%s'. Rejecting push.",
	$ref_raw));
	}

	$ref_update = $this->newPushLog()
	->setRefType($ref_type)
	->setRefName($ref_raw)
	->setRefOld($ref_old)
	->setRefNew($ref_new);

	$ref_updates[] = $ref_update;
	}

	$this->findGitMergeBases($ref_updates);
	$this->findGitChangeFlags($ref_updates);

	return $ref_updates;
	}


	private function findGitMergeBases(array $ref_updates) {
	assert_instances_of($ref_updates, 'PhabricatorRepositoryPushLog');

	$futures = array();
	foreach ($ref_updates as $key => $ref_update) {
	// If the old hash is "00000...", the ref is being created (either a new
	// branch, or a new tag). If the new hash is "00000...", the ref is being
	// deleted. If both are nonempty, the ref is being updated. For updates,
	// we'll figure out the `merge-base` of the old and new objects here. This
	// lets us reject non-FF changes cheaply; later, we'll figure out exactly
	// which commits are new.
	$ref_old = $ref_update->getRefOld();
	$ref_new = $ref_update->getRefNew();

	if (($ref_old === self::EMPTY_HASH) \|\|
	($ref_new === self::EMPTY_HASH)) {
	continue;
	}

	$futures[$key] = $this->getRepository()->getLocalCommandFuture(
	'merge-base %s %s',
	$ref_old,
	$ref_new);
	}

	foreach (Futures($futures)->limit(8) as $key => $future) {

	// If 'old' and 'new' have no common ancestors (for example, a force push
	// which completely rewrites a ref), `git merge-base` will exit with
	// an error and no output. It would be nice to find a positive test
	// for this instead, but I couldn't immediately come up with one. See
	// T4224. Assume this means there are no ancestors.

	list($err, $stdout) = $future->resolve();

	if ($err) {
	$merge_base = null;
	} else {
	$merge_base = rtrim($stdout, "\n");
	}

	$ref_update = $ref_updates[$key];
	$ref_update->setMergeBase($merge_base);
	}

	return $ref_updates;
	}


	private function findGitChangeFlags(array $ref_updates) {
	assert_instances_of($ref_updates, 'PhabricatorRepositoryPushLog');

	foreach ($ref_updates as $key => $ref_update) {
	$ref_old = $ref_update->getRefOld();
	$ref_new = $ref_update->getRefNew();
	$ref_type = $ref_update->getRefType();

	$ref_flags = 0;
	$dangerous = null;

	if (($ref_old === self::EMPTY_HASH) && ($ref_new === self::EMPTY_HASH)) {
	// This happens if you try to delete a tag or branch which does not
	// exist by pushing directly to the ref. Git will warn about it but
	// allow it. Just call it a delete, without flagging it as dangerous.
	$ref_flags \|= PhabricatorRepositoryPushLog::CHANGEFLAG_DELETE;
	} else if ($ref_old === self::EMPTY_HASH) {
	$ref_flags \|= PhabricatorRepositoryPushLog::CHANGEFLAG_ADD;
	} else if ($ref_new === self::EMPTY_HASH) {
	$ref_flags \|= PhabricatorRepositoryPushLog::CHANGEFLAG_DELETE;
	if ($ref_type == PhabricatorRepositoryPushLog::REFTYPE_BRANCH) {
	$ref_flags \|= PhabricatorRepositoryPushLog::CHANGEFLAG_DANGEROUS;
	$dangerous = pht(
	"The change you're attempting to push deletes the branch '%s'.",
	$ref_update->getRefName());
	}
	} else {
	$merge_base = $ref_update->getMergeBase();
	if ($merge_base == $ref_old) {
	// This is a fast-forward update to an existing branch.
	// These are safe.
	$ref_flags \|= PhabricatorRepositoryPushLog::CHANGEFLAG_APPEND;
	} else {
	$ref_flags \|= PhabricatorRepositoryPushLog::CHANGEFLAG_REWRITE;

	// For now, we don't consider deleting or moving tags to be a
	// "dangerous" update. It's way harder to get wrong and should be easy
	// to recover from once we have better logging. Only add the dangerous
	// flag if this ref is a branch.

	if ($ref_type == PhabricatorRepositoryPushLog::REFTYPE_BRANCH) {
	$ref_flags \|= PhabricatorRepositoryPushLog::CHANGEFLAG_DANGEROUS;

	$dangerous = pht(
	"The change you're attempting to push updates the branch '%s' ".
	"from '%s' to '%s', but this is not a fast-forward. Pushes ".
	"which rewrite published branch history are dangerous.",
	$ref_update->getRefName(),
	$ref_update->getRefOldShort(),
	$ref_update->getRefNewShort());
	}
	}
	}

	$ref_update->setChangeFlags($ref_flags);
	if ($dangerous !== null) {
	$ref_update->attachDangerousChangeDescription($dangerous);
	}
	}

	return $ref_updates;
	}


	private function findGitContentUpdates(array $ref_updates) {
	$flag_delete = PhabricatorRepositoryPushLog::CHANGEFLAG_DELETE;

	$futures = array();
	foreach ($ref_updates as $key => $ref_update) {
	if ($ref_update->hasChangeFlags($flag_delete)) {
	// Deleting a branch or tag can never create any new commits.
	continue;
	}

	// NOTE: This piece of magic finds all new commits, by walking backward
	// from the new value to the value of any existing ref in the
	// repository. Particularly, this will cover the cases of a new branch, a
	// completely moved tag, etc.
	$futures[$key] = $this->getRepository()->getLocalCommandFuture(
	'log --format=%s %s --not --all',
	'%H',
	$ref_update->getRefNew());
	}

	$content_updates = array();
	foreach (Futures($futures)->limit(8) as $key => $future) {
	list($stdout) = $future->resolvex();

	if (!strlen(trim($stdout))) {
	// This change doesn't have any new commits. One common case of this
	// is creating a new tag which points at an existing commit.
	continue;
	}

	$commits = phutil_split_lines($stdout, $retain_newlines = false);

	// If we're looking at a branch, mark all of the new commits as on that
	// branch. It's only possible for these commits to be on updated branches,
	// since any other branch heads are necessarily behind them.
	$branch_name = null;
	$ref_update = $ref_updates[$key];
	$type_branch = PhabricatorRepositoryPushLog::REFTYPE_BRANCH;
	if ($ref_update->getRefType() == $type_branch) {
	$branch_name = $ref_update->getRefName();
	}

	foreach ($commits as $commit) {
	if ($branch_name) {
	$this->gitCommits[$commit][] = $branch_name;
	}
	$content_updates[$commit] = $this->newPushLog()
	->setRefType(PhabricatorRepositoryPushLog::REFTYPE_COMMIT)
	->setRefNew($commit)
	->setChangeFlags(PhabricatorRepositoryPushLog::CHANGEFLAG_ADD);
	}
	}

	return $content_updates;
	}

	/* -( Custom )------------------------------------------------------------- */

	private function applyCustomHooks(array $updates) {
	$args = $this->getOriginalArgv();
	$stdin = $this->getStdin();
	$console = PhutilConsole::getConsole();

	$env = array(
	'PHABRICATOR_REPOSITORY' => $this->getRepository()->getCallsign(),
	self::ENV_USER => $this->getViewer()->getUsername(),
	self::ENV_REMOTE_PROTOCOL => $this->getRemoteProtocol(),
	self::ENV_REMOTE_ADDRESS => $this->getRemoteAddress(),
	);

	$directories = $this->getRepository()->getHookDirectories();
	foreach ($directories as $directory) {
	$hooks = $this->getExecutablesInDirectory($directory);
	sort($hooks);
	foreach ($hooks as $hook) {
	// NOTE: We're explicitly running the hooks in sequential order to
	// make this more predictable.
	$future = id(new ExecFuture('%s %Ls', $hook, $args))
	->setEnv($env, $wipe_process_env = false)
	->write($stdin);

	list($err, $stdout, $stderr) = $future->resolve();
	if (!$err) {
	// This hook ran OK, but echo its output in case there was something
	// informative.
	$console->writeOut('%s', $stdout);
	$console->writeErr('%s', $stderr);
	continue;
	}

	$this->rejectCode = PhabricatorRepositoryPushLog::REJECT_EXTERNAL;
	$this->rejectDetails = basename($hook);

	throw new DiffusionCommitHookRejectException(
	pht(
	"This push was rejected by custom hook script '%s':\n\n%s%s",
	basename($hook),
	$stdout,
	$stderr));
	}
	}
	}

	private function getExecutablesInDirectory($directory) {
	$executables = array();

	if (!Filesystem::pathExists($directory)) {
	return $executables;
	}

	foreach (Filesystem::listDirectory($directory) as $path) {
	$full_path = $directory.DIRECTORY_SEPARATOR.$path;
	if (!is_executable($full_path)) {
	// Don't include non-executable files.
	continue;
	}

	if (basename($full_path) == 'README') {
	// Don't include README, even if it is marked as executable. It almost
	// certainly got caught in the crossfire of a sweeping `chmod`, since
	// users do this with some frequency.
	continue;
	}

	$executables[] = $full_path;
	}

	return $executables;
	}


	/* -( Mercurial )---------------------------------------------------------- */


	private function findMercurialRefUpdates() {
	$hook = $this->getMercurialHook();
	switch ($hook) {
	case 'pretxnchangegroup':
	return $this->findMercurialChangegroupRefUpdates();
	case 'prepushkey':
	return $this->findMercurialPushKeyRefUpdates();
	default:
	throw new Exception(pht('Unrecognized hook "%s"!', $hook));
	}
	}

	private function findMercurialChangegroupRefUpdates() {
	$hg_node = getenv('HG_NODE');
	if (!$hg_node) {
	throw new Exception(pht('Expected HG_NODE in environment!'));
	}

	// NOTE: We need to make sure this is passed to subprocesses, or they won't
	// be able to see new commits. Mercurial uses this as a marker to determine
	// whether the pending changes are visible or not.
	$_ENV['HG_PENDING'] = getenv('HG_PENDING');
	$repository = $this->getRepository();

	$futures = array();

	foreach (array('old', 'new') as $key) {
	$futures[$key] = $repository->getLocalCommandFuture(
	'heads --template %s',
	'{node}\1{branch}\2');
	}
	// Wipe HG_PENDING out of the old environment so we see the pre-commit
	// state of the repository.
	$futures['old']->updateEnv('HG_PENDING', null);

	$futures['commits'] = $repository->getLocalCommandFuture(
	'log --rev %s --template %s',
	hgsprintf('%s:%s', $hg_node, 'tip'),
	'{node}\1{branch}\2');

	// Resolve all of the futures now. We don't need the 'commits' future yet,
	// but it simplifies the logic to just get it out of the way.
	foreach (Futures($futures) as $future) {
	$future->resolve();
	}

	list($commit_raw) = $futures['commits']->resolvex();
	$commit_map = $this->parseMercurialCommits($commit_raw);
	$this->mercurialCommits = $commit_map;

	// NOTE: `hg heads` exits with an error code and no output if the repository
	// has no heads. Most commonly this happens on a new repository. We know
	// we can run `hg` successfully since the `hg log` above didn't error, so
	// just ignore the error code.

	list($err, $old_raw) = $futures['old']->resolve();
	$old_refs = $this->parseMercurialHeads($old_raw);

	list($err, $new_raw) = $futures['new']->resolve();
	$new_refs = $this->parseMercurialHeads($new_raw);

	$all_refs = array_keys($old_refs + $new_refs);

	$ref_updates = array();
	foreach ($all_refs as $ref) {
	$old_heads = idx($old_refs, $ref, array());
	$new_heads = idx($new_refs, $ref, array());

	sort($old_heads);
	sort($new_heads);

	if (!$old_heads && !$new_heads) {
	// This should never be possible, as it makes no sense. Explode.
	throw new Exception(
	pht(
	'Mercurial repository has no new or old heads for branch "%s" '.
	'after push. This makes no sense; rejecting change.',
	$ref));
	}

	if ($old_heads === $new_heads) {
	// No changes to this branch, so skip it.
	continue;
	}

	$stray_heads = array();

	if ($old_heads && !$new_heads) {
	// This is a branch deletion with "--close-branch".
	$head_map = array();
	foreach ($old_heads as $old_head) {
	$head_map[$old_head] = array(self::EMPTY_HASH);
	}
	} else if (count($old_heads) > 1) {
	// HORRIBLE: In Mercurial, branches can have multiple heads. If the
	// old branch had multiple heads, we need to figure out which new
	// heads descend from which old heads, so we can tell whether you're
	// actively creating new heads (dangerous) or just working in a
	// repository that's already full of garbage (strongly discouraged but
	// not as inherently dangerous). These cases should be very uncommon.

	// NOTE: We're only looking for heads on the same branch. The old
	// tip of the branch may be the branchpoint for other branches, but that
	// is OK.

	$dfutures = array();
	foreach ($old_heads as $old_head) {
	$dfutures[$old_head] = $repository->getLocalCommandFuture(
	'log --branch %s --rev %s --template %s',
	$ref,
	hgsprintf('(descendants(%s) and head())', $old_head),
	'{node}\1');
	}

	$head_map = array();
	foreach (Futures($dfutures) as $future_head => $dfuture) {
	list($stdout) = $dfuture->resolvex();
	$descendant_heads = array_filter(explode("\1", $stdout));
	if ($descendant_heads) {
	// This old head has at least one descendant in the push.
	$head_map[$future_head] = $descendant_heads;
	} else {
	// This old head has no descendants, so it is being deleted.
	$head_map[$future_head] = array(self::EMPTY_HASH);
	}
	}

	// Now, find all the new stray heads this push creates, if any. These
	// are new heads which do not descend from the old heads.
	$seen = array_fuse(array_mergev($head_map));
	foreach ($new_heads as $new_head) {
	if ($new_head === self::EMPTY_HASH) {
	// If a branch head is being deleted, don't insert it as an add.
	continue;
	}
	if (empty($seen[$new_head])) {
	$head_map[self::EMPTY_HASH][] = $new_head;
	}
	}
	} else if ($old_heads) {
	$head_map[head($old_heads)] = $new_heads;
	} else {
	$head_map[self::EMPTY_HASH] = $new_heads;
	}

	foreach ($head_map as $old_head => $child_heads) {
	foreach ($child_heads as $new_head) {
	if ($new_head === $old_head) {
	continue;
	}

	$ref_flags = 0;
	$dangerous = null;
	if ($old_head == self::EMPTY_HASH) {
	$ref_flags \|= PhabricatorRepositoryPushLog::CHANGEFLAG_ADD;
	} else {
	$ref_flags \|= PhabricatorRepositoryPushLog::CHANGEFLAG_APPEND;
	}


	$deletes_existing_head = ($new_head == self::EMPTY_HASH);
	$splits_existing_head = (count($child_heads) > 1);
	$creates_duplicate_head = ($old_head == self::EMPTY_HASH) &&
	(count($head_map) > 1);

	if ($splits_existing_head \|\| $creates_duplicate_head) {
	$readable_child_heads = array();
	foreach ($child_heads as $child_head) {
	$readable_child_heads[] = substr($child_head, 0, 12);
	}

	$ref_flags \|= PhabricatorRepositoryPushLog::CHANGEFLAG_DANGEROUS;

	if ($splits_existing_head) {
	// We're splitting an existing head into two or more heads.
	// This is dangerous, and a super bad idea. Note that we're only
	// raising this if you're actively splitting a branch head. If a
	// head split in the past, we don't consider appends to it
	// to be dangerous.
	$dangerous = pht(
	"The change you're attempting to push splits the head of ".
	"branch '%s' into multiple heads: %s. This is inadvisable ".
	"and dangerous.",
	$ref,
	implode(', ', $readable_child_heads));
	} else {
	// We're adding a second (or more) head to a branch. The new
	// head is not a descendant of any old head.
	$dangerous = pht(
	"The change you're attempting to push creates new, divergent ".
	"heads for the branch '%s': %s. This is inadvisable and ".
	"dangerous.",
	$ref,
	implode(', ', $readable_child_heads));
	}
	}

	if ($deletes_existing_head) {
	// TODO: Somewhere in here we should be setting CHANGEFLAG_REWRITE
	// if we are also creating at least one other head to replace
	// this one.

	// NOTE: In Git, this is a dangerous change, but it is not dangerous
	// in Mercurial. Mercurial branches are version controlled, and
	// Mercurial does not prompt you for any special flags when pushing
	// a `--close-branch` commit by default.

	$ref_flags \|= PhabricatorRepositoryPushLog::CHANGEFLAG_DELETE;
	}

	$ref_update = $this->newPushLog()
	->setRefType(PhabricatorRepositoryPushLog::REFTYPE_BRANCH)
	->setRefName($ref)
	->setRefOld($old_head)
	->setRefNew($new_head)
	->setChangeFlags($ref_flags);

	if ($dangerous !== null) {
	$ref_update->attachDangerousChangeDescription($dangerous);
	}

	$ref_updates[] = $ref_update;
	}
	}
	}

	return $ref_updates;
	}

	private function findMercurialPushKeyRefUpdates() {
	$key_namespace = getenv('HG_NAMESPACE');

	if ($key_namespace === 'phases') {
	// Mercurial changes commit phases as part of normal push operations. We
	// just ignore these, as they don't seem to represent anything
	// interesting.
	return array();
	}

	$key_name = getenv('HG_KEY');

	$key_old = getenv('HG_OLD');
	if (!strlen($key_old)) {
	$key_old = null;
	}

	$key_new = getenv('HG_NEW');
	if (!strlen($key_new)) {
	$key_new = null;
	}

	if ($key_namespace !== 'bookmarks') {
	throw new Exception(
	pht(
	"Unknown Mercurial key namespace '%s', with key '%s' (%s -> %s). ".
	"Rejecting push.",
	$key_namespace,
	$key_name,
	coalesce($key_old, pht('null')),
	coalesce($key_new, pht('null'))));
	}

	if ($key_old === $key_new) {
	// We get a callback when the bookmark doesn't change. Just ignore this,
	// as it's a no-op.
	return array();
	}

	$ref_flags = 0;
	$merge_base = null;
	if ($key_old === null) {
	$ref_flags \|= PhabricatorRepositoryPushLog::CHANGEFLAG_ADD;
	} else if ($key_new === null) {
	$ref_flags \|= PhabricatorRepositoryPushLog::CHANGEFLAG_DELETE;
	} else {
	list($merge_base_raw) = $this->getRepository()->execxLocalCommand(
	'log --template %s --rev %s',
	'{node}',
	hgsprintf('ancestor(%s, %s)', $key_old, $key_new));

	if (strlen(trim($merge_base_raw))) {
	$merge_base = trim($merge_base_raw);
	}

	if ($merge_base && ($merge_base === $key_old)) {
	$ref_flags \|= PhabricatorRepositoryPushLog::CHANGEFLAG_APPEND;
	} else {
	$ref_flags \|= PhabricatorRepositoryPushLog::CHANGEFLAG_REWRITE;
	}
	}

	$ref_update = $this->newPushLog()
	->setRefType(PhabricatorRepositoryPushLog::REFTYPE_BOOKMARK)
	->setRefName($key_name)
	->setRefOld(coalesce($key_old, self::EMPTY_HASH))
	->setRefNew(coalesce($key_new, self::EMPTY_HASH))
	->setChangeFlags($ref_flags);

	return array($ref_update);
	}

	private function findMercurialContentUpdates(array $ref_updates) {
	$content_updates = array();

	foreach ($this->mercurialCommits as $commit => $branches) {
	$content_updates[$commit] = $this->newPushLog()
	->setRefType(PhabricatorRepositoryPushLog::REFTYPE_COMMIT)
	->setRefNew($commit)
	->setChangeFlags(PhabricatorRepositoryPushLog::CHANGEFLAG_ADD);
	}

	return $content_updates;
	}

	private function parseMercurialCommits($raw) {
	$commits_lines = explode("\2", $raw);
	$commits_lines = array_filter($commits_lines);
	$commit_map = array();
	foreach ($commits_lines as $commit_line) {
	list($node, $branch) = explode("\1", $commit_line);
	$commit_map[$node] = array($branch);
	}

	return $commit_map;
	}

	private function parseMercurialHeads($raw) {
	$heads_map = $this->parseMercurialCommits($raw);

	$heads = array();
	foreach ($heads_map as $commit => $branches) {
	foreach ($branches as $branch) {
	$heads[$branch][] = $commit;
	}
	}

	return $heads;
	}


	/* -( Subversion )--------------------------------------------------------- */


	private function findSubversionRefUpdates() {
	// Subversion doesn't have any kind of mutable ref metadata.
	return array();
	}

	private function findSubversionContentUpdates(array $ref_updates) {
	list($youngest) = execx(
	'svnlook youngest %s',
	$this->subversionRepository);
	$ref_new = (int)$youngest + 1;

	$ref_flags = 0;
	$ref_flags \|= PhabricatorRepositoryPushLog::CHANGEFLAG_ADD;
	$ref_flags \|= PhabricatorRepositoryPushLog::CHANGEFLAG_APPEND;

	$ref_content = $this->newPushLog()
	->setRefType(PhabricatorRepositoryPushLog::REFTYPE_COMMIT)
	->setRefNew($ref_new)
	->setChangeFlags($ref_flags);

	return array($ref_content);
	}


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


	private function newPushLog() {
	// NOTE: We generate PHIDs up front so the Herald transcripts can pick them
	// up.
	$phid = id(new PhabricatorRepositoryPushLog())->generatePHID();

	return PhabricatorRepositoryPushLog::initializeNewLog($this->getViewer())
	->setPHID($phid)
	->setRepositoryPHID($this->getRepository()->getPHID())
	->attachRepository($this->getRepository())
	->setEpoch(time());
	}

	private function newPushEvent() {
	$viewer = $this->getViewer();
	return PhabricatorRepositoryPushEvent::initializeNewEvent($viewer)
	->setRepositoryPHID($this->getRepository()->getPHID())
	->setRemoteAddress($this->getRemoteAddressForLog())
	->setRemoteProtocol($this->getRemoteProtocol())
	->setEpoch(time());
	}

	public function loadChangesetsForCommit($identifier) {
	$byte_limit = HeraldCommitAdapter::getEnormousByteLimit();
	$time_limit = HeraldCommitAdapter::getEnormousTimeLimit();

	$vcs = $this->getRepository()->getVersionControlSystem();
	switch ($vcs) {
	case PhabricatorRepositoryType::REPOSITORY_TYPE_GIT:
	case PhabricatorRepositoryType::REPOSITORY_TYPE_MERCURIAL:
	// For git and hg, we can use normal commands.
	$drequest = DiffusionRequest::newFromDictionary(
	array(
	'repository' => $this->getRepository(),
	'user' => $this->getViewer(),
	'commit' => $identifier,
	));

	$raw_diff = DiffusionRawDiffQuery::newFromDiffusionRequest($drequest)
	->setTimeout($time_limit)
	->setByteLimit($byte_limit)
	->setLinesOfContext(0)
	->loadRawDiff();
	break;
	case PhabricatorRepositoryType::REPOSITORY_TYPE_SVN:
	// TODO: This diff has 3 lines of context, which produces slightly
	// incorrect "added file content" and "removed file content" results.
	// This may also choke on binaries, but "svnlook diff" does not support
	// the "--diff-cmd" flag.

	// For subversion, we need to use `svnlook`.
	$future = new ExecFuture(
	'svnlook diff -t %s %s',
	$this->subversionTransaction,
	$this->subversionRepository);

	$future->setTimeout($time_limit);
	$future->setStdoutSizeLimit($byte_limit);
	$future->setStderrSizeLimit($byte_limit);

	list($raw_diff) = $future->resolvex();
	break;
	default:
	throw new Exception(pht("Unknown VCS '%s!'", $vcs));
	}

	if (strlen($raw_diff) >= $byte_limit) {
	throw new Exception(
	pht(
	'The raw text of this change is enormous (larger than %d '.
	'bytes). Herald can not process it.',
	$byte_limit));
	}

	if (!strlen($raw_diff)) {
	// If the commit is actually empty, just return no changesets.
	return array();
	}

	$parser = new ArcanistDiffParser();
	$changes = $parser->parseDiff($raw_diff);
	- $diff = DifferentialDiff::newFromRawChanges(
	- $this->getViewer(),
	+ $diff = DifferentialDiff::newEphemeralFromRawChanges(
	$changes);
	return $diff->getChangesets();
	}

	public function loadCommitRefForCommit($identifier) {
	$repository = $this->getRepository();
	$vcs = $repository->getVersionControlSystem();
	switch ($vcs) {
	case PhabricatorRepositoryType::REPOSITORY_TYPE_GIT:
	case PhabricatorRepositoryType::REPOSITORY_TYPE_MERCURIAL:
	return id(new DiffusionLowLevelCommitQuery())
	->setRepository($repository)
	->withIdentifier($identifier)
	->execute();
	case PhabricatorRepositoryType::REPOSITORY_TYPE_SVN:
	// For subversion, we need to use `svnlook`.
	list($message) = execx(
	'svnlook log -t %s %s',
	$this->subversionTransaction,
	$this->subversionRepository);

	return id(new DiffusionCommitRef())
	->setMessage($message);
	break;
	default:
	throw new Exception(pht("Unknown VCS '%s!'", $vcs));
	}
	}

	public function loadBranches($identifier) {
	$repository = $this->getRepository();
	$vcs = $repository->getVersionControlSystem();
	switch ($vcs) {
	case PhabricatorRepositoryType::REPOSITORY_TYPE_GIT:
	return idx($this->gitCommits, $identifier, array());
	case PhabricatorRepositoryType::REPOSITORY_TYPE_MERCURIAL:
	// NOTE: This will be "the branch the commit was made to", not
	// "a list of all branch heads which descend from the commit".
	// This is consistent with Mercurial, but possibly confusing.
	return idx($this->mercurialCommits, $identifier, array());
	case PhabricatorRepositoryType::REPOSITORY_TYPE_SVN:
	// Subversion doesn't have branches.
	return array();
	}
	}

	private function loadCommitInfoForWorker(array $all_updates) {
	$type_commit = PhabricatorRepositoryPushLog::REFTYPE_COMMIT;

	$map = array();
	foreach ($all_updates as $update) {
	if ($update->getRefType() != $type_commit) {
	continue;
	}
	$map[$update->getRefNew()] = array();
	}

	foreach ($map as $identifier => $info) {
	$ref = $this->loadCommitRefForCommit($identifier);
	$map[$identifier] += array(
	'summary' => $ref->getSummary(),
	'branches' => $this->loadBranches($identifier),
	);
	}

	return $map;
	}

	}
	diff --git a/src/applications/herald/adapter/HeraldCommitAdapter.php b/src/applications/herald/adapter/HeraldCommitAdapter.php
	index 35e93f5916..9b9c1f8ddd 100644
	--- a/src/applications/herald/adapter/HeraldCommitAdapter.php
	+++ b/src/applications/herald/adapter/HeraldCommitAdapter.php
	@@ -1,564 +1,563 @@
	<?php

	final class HeraldCommitAdapter extends HeraldAdapter {

	const FIELD_NEED_AUDIT_FOR_PACKAGE = 'need-audit-for-package';
	const FIELD_REPOSITORY_AUTOCLOSE_BRANCH = 'repository-autoclose-branch';

	protected $diff;
	protected $revision;

	protected $repository;
	protected $commit;
	protected $commitData;
	private $commitDiff;

	protected $emailPHIDs = array();
	protected $addCCPHIDs = array();
	protected $auditMap = array();
	protected $buildPlans = array();

	protected $affectedPaths;
	protected $affectedRevision;
	protected $affectedPackages;
	protected $auditNeededPackages;

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

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

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

	public function getAdapterContentName() {
	return pht('Commits');
	}

	public function getAdapterContentDescription() {
	return pht(
	"React to new commits appearing in tracked repositories.\n".
	"Commit rules can send email, flag commits, trigger audits, ".
	"and run build plans.");
	}

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

	public function canTriggerOnObject($object) {
	if ($object instanceof PhabricatorRepository) {
	return true;
	}
	if ($object instanceof PhabricatorProject) {
	return true;
	}
	return false;
	}

	public function getTriggerObjectPHIDs() {
	return array_merge(
	array(
	$this->repository->getPHID(),
	$this->getPHID(),
	),
	$this->repository->getProjectPHIDs());
	}

	public function explainValidTriggerObjects() {
	return pht('This rule can trigger for repositories and projects.');
	}

	public function getFieldNameMap() {
	return array(
	self::FIELD_NEED_AUDIT_FOR_PACKAGE =>
	pht('Affected packages that need audit'),
	self::FIELD_REPOSITORY_AUTOCLOSE_BRANCH
	=> pht('Commit is on closing branch'),
	) + parent::getFieldNameMap();
	}

	public function getFields() {
	return array_merge(
	array(
	self::FIELD_BODY,
	self::FIELD_AUTHOR,
	self::FIELD_COMMITTER,
	self::FIELD_REVIEWER,
	self::FIELD_REPOSITORY,
	self::FIELD_REPOSITORY_PROJECTS,
	self::FIELD_DIFF_FILE,
	self::FIELD_DIFF_CONTENT,
	self::FIELD_DIFF_ADDED_CONTENT,
	self::FIELD_DIFF_REMOVED_CONTENT,
	self::FIELD_DIFF_ENORMOUS,
	self::FIELD_AFFECTED_PACKAGE,
	self::FIELD_AFFECTED_PACKAGE_OWNER,
	self::FIELD_NEED_AUDIT_FOR_PACKAGE,
	self::FIELD_DIFFERENTIAL_REVISION,
	self::FIELD_DIFFERENTIAL_ACCEPTED,
	self::FIELD_DIFFERENTIAL_REVIEWERS,
	self::FIELD_DIFFERENTIAL_CCS,
	self::FIELD_BRANCHES,
	self::FIELD_REPOSITORY_AUTOCLOSE_BRANCH,
	),
	parent::getFields());
	}

	public function getConditionsForField($field) {
	switch ($field) {
	case self::FIELD_NEED_AUDIT_FOR_PACKAGE:
	return array(
	self::CONDITION_INCLUDE_ANY,
	self::CONDITION_INCLUDE_NONE,
	);
	case self::FIELD_REPOSITORY_AUTOCLOSE_BRANCH:
	return array(
	self::CONDITION_UNCONDITIONALLY,
	);
	}
	return parent::getConditionsForField($field);
	}

	public function getActions($rule_type) {
	switch ($rule_type) {
	case HeraldRuleTypeConfig::RULE_TYPE_GLOBAL:
	case HeraldRuleTypeConfig::RULE_TYPE_OBJECT:
	return array_merge(
	array(
	self::ACTION_ADD_CC,
	self::ACTION_EMAIL,
	self::ACTION_AUDIT,
	self::ACTION_APPLY_BUILD_PLANS,
	self::ACTION_NOTHING,
	),
	parent::getActions($rule_type));
	case HeraldRuleTypeConfig::RULE_TYPE_PERSONAL:
	return array_merge(
	array(
	self::ACTION_ADD_CC,
	self::ACTION_EMAIL,
	self::ACTION_FLAG,
	self::ACTION_AUDIT,
	self::ACTION_NOTHING,
	),
	parent::getActions($rule_type));
	}
	}

	public function getValueTypeForFieldAndCondition($field, $condition) {
	switch ($field) {
	case self::FIELD_DIFFERENTIAL_CCS:
	return self::VALUE_EMAIL;
	case self::FIELD_NEED_AUDIT_FOR_PACKAGE:
	return self::VALUE_OWNERS_PACKAGE;
	}

	return parent::getValueTypeForFieldAndCondition($field, $condition);
	}

	public static function newLegacyAdapter(
	PhabricatorRepository $repository,
	PhabricatorRepositoryCommit $commit,
	PhabricatorRepositoryCommitData $commit_data) {

	$object = new HeraldCommitAdapter();

	$commit->attachRepository($repository);

	$object->repository = $repository;
	$object->commit = $commit;
	$object->commitData = $commit_data;

	return $object;
	}

	public function setCommit(PhabricatorRepositoryCommit $commit) {
	$viewer = PhabricatorUser::getOmnipotentUser();

	$repository = id(new PhabricatorRepositoryQuery())
	->setViewer($viewer)
	->withIDs(array($commit->getRepositoryID()))
	->needProjectPHIDs(true)
	->executeOne();
	if (!$repository) {
	throw new Exception(pht('Unable to load repository!'));
	}

	$data = id(new PhabricatorRepositoryCommitData())->loadOneWhere(
	'commitID = %d',
	$commit->getID());
	if (!$data) {
	throw new Exception(pht('Unable to load commit data!'));
	}

	$this->commit = clone $commit;
	$this->commit->attachRepository($repository);
	$this->commit->attachCommitData($data);

	$this->repository = $repository;
	$this->commitData = $data;

	return $this;
	}

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

	public function getEmailPHIDs() {
	return array_keys($this->emailPHIDs);
	}

	public function getAddCCMap() {
	return $this->addCCPHIDs;
	}

	public function getAuditMap() {
	return $this->auditMap;
	}

	public function getBuildPlans() {
	return $this->buildPlans;
	}

	public function getHeraldName() {
	return
	'r'.
	$this->repository->getCallsign().
	$this->commit->getCommitIdentifier();
	}

	public function loadAffectedPaths() {
	if ($this->affectedPaths === null) {
	$result = PhabricatorOwnerPathQuery::loadAffectedPaths(
	$this->repository,
	$this->commit,
	PhabricatorUser::getOmnipotentUser());
	$this->affectedPaths = $result;
	}
	return $this->affectedPaths;
	}

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

	public function loadAuditNeededPackage() {
	if ($this->auditNeededPackages === null) {
	$status_arr = array(
	PhabricatorAuditStatusConstants::AUDIT_REQUIRED,
	PhabricatorAuditStatusConstants::CONCERNED,
	);
	$requests = id(new PhabricatorRepositoryAuditRequest())
	->loadAllWhere(
	'commitPHID = %s AND auditStatus IN (%Ls)',
	$this->commit->getPHID(),
	$status_arr);

	$packages = mpull($requests, 'getAuditorPHID');
	$this->auditNeededPackages = $packages;
	}
	return $this->auditNeededPackages;
	}

	public function loadDifferentialRevision() {
	if ($this->affectedRevision === null) {
	$this->affectedRevision = false;
	$data = $this->commitData;
	$revision_id = $data->getCommitDetail('differential.revisionID');
	if ($revision_id) {
	// NOTE: The Herald rule owner might not actually have access to
	// the revision, and can control which revision a commit is
	// associated with by putting text in the commit message. However,
	// the rules they can write against revisions don't actually expose
	// anything interesting, so it seems reasonable to load unconditionally
	// here.

	$revision = id(new DifferentialRevisionQuery())
	->withIDs(array($revision_id))
	->setViewer(PhabricatorUser::getOmnipotentUser())
	->needRelationships(true)
	->needReviewerStatus(true)
	->executeOne();
	if ($revision) {
	$this->affectedRevision = $revision;
	}
	}
	}
	return $this->affectedRevision;
	}

	public static function getEnormousByteLimit() {
	return 1024 * 1024 * 1024; // 1GB
	}

	public static function getEnormousTimeLimit() {
	return 60 * 15; // 15 Minutes
	}

	private function loadCommitDiff() {
	$drequest = DiffusionRequest::newFromDictionary(
	array(
	'user' => PhabricatorUser::getOmnipotentUser(),
	'repository' => $this->repository,
	'commit' => $this->commit->getCommitIdentifier(),
	));

	$byte_limit = self::getEnormousByteLimit();

	$raw = DiffusionQuery::callConduitWithDiffusionRequest(
	PhabricatorUser::getOmnipotentUser(),
	$drequest,
	'diffusion.rawdiffquery',
	array(
	'commit' => $this->commit->getCommitIdentifier(),
	'timeout' => self::getEnormousTimeLimit(),
	'byteLimit' => $byte_limit,
	'linesOfContext' => 0,
	));

	if (strlen($raw) >= $byte_limit) {
	throw new Exception(
	pht(
	'The raw text of this change is enormous (larger than %d bytes). '.
	'Herald can not process it.',
	$byte_limit));
	}

	$parser = new ArcanistDiffParser();
	$changes = $parser->parseDiff($raw);

	- $diff = DifferentialDiff::newFromRawChanges(
	- PhabricatorUser::getOmnipotentUser(),
	+ $diff = DifferentialDiff::newEphemeralFromRawChanges(
	$changes);
	return $diff;
	}

	private function getDiffContent($type) {
	if ($this->commitDiff === null) {
	try {
	$this->commitDiff = $this->loadCommitDiff();
	} catch (Exception $ex) {
	$this->commitDiff = $ex;
	phlog($ex);
	}
	}

	if ($this->commitDiff instanceof Exception) {
	$ex = $this->commitDiff;
	$ex_class = get_class($ex);
	$ex_message = pht('Failed to load changes: %s', $ex->getMessage());

	return array(
	'<'.$ex_class.'>' => $ex_message,
	);
	}

	$changes = $this->commitDiff->getChangesets();

	$result = array();
	foreach ($changes as $change) {
	$lines = array();
	foreach ($change->getHunks() as $hunk) {
	switch ($type) {
	case '-':
	$lines[] = $hunk->makeOldFile();
	break;
	case '+':
	$lines[] = $hunk->makeNewFile();
	break;
	case '*':
	$lines[] = $hunk->makeChanges();
	break;
	default:
	throw new Exception("Unknown content selection '{$type}'!");
	}
	}
	$result[$change->getFilename()] = implode("\n", $lines);
	}

	return $result;
	}

	public function getHeraldField($field) {
	$data = $this->commitData;
	switch ($field) {
	case self::FIELD_BODY:
	return $data->getCommitMessage();
	case self::FIELD_AUTHOR:
	return $data->getCommitDetail('authorPHID');
	case self::FIELD_COMMITTER:
	return $data->getCommitDetail('committerPHID');
	case self::FIELD_REVIEWER:
	return $data->getCommitDetail('reviewerPHID');
	case self::FIELD_DIFF_FILE:
	return $this->loadAffectedPaths();
	case self::FIELD_REPOSITORY:
	return $this->repository->getPHID();
	case self::FIELD_REPOSITORY_PROJECTS:
	return $this->repository->getProjectPHIDs();
	case self::FIELD_DIFF_CONTENT:
	return $this->getDiffContent('*');
	case self::FIELD_DIFF_ADDED_CONTENT:
	return $this->getDiffContent('+');
	case self::FIELD_DIFF_REMOVED_CONTENT:
	return $this->getDiffContent('-');
	case self::FIELD_DIFF_ENORMOUS:
	$this->getDiffContent('*');
	return ($this->commitDiff instanceof Exception);
	case self::FIELD_AFFECTED_PACKAGE:
	$packages = $this->loadAffectedPackages();
	return mpull($packages, 'getPHID');
	case self::FIELD_AFFECTED_PACKAGE_OWNER:
	$packages = $this->loadAffectedPackages();
	$owners = PhabricatorOwnersOwner::loadAllForPackages($packages);
	return mpull($owners, 'getUserPHID');
	case self::FIELD_NEED_AUDIT_FOR_PACKAGE:
	return $this->loadAuditNeededPackage();
	case self::FIELD_DIFFERENTIAL_REVISION:
	$revision = $this->loadDifferentialRevision();
	if (!$revision) {
	return null;
	}
	return $revision->getID();
	case self::FIELD_DIFFERENTIAL_ACCEPTED:
	$revision = $this->loadDifferentialRevision();
	if (!$revision) {
	return null;
	}

	$status = $data->getCommitDetail(
	'precommitRevisionStatus',
	$revision->getStatus());
	switch ($status) {
	case ArcanistDifferentialRevisionStatus::ACCEPTED:
	case ArcanistDifferentialRevisionStatus::CLOSED:
	return $revision->getPHID();
	}

	return null;
	case self::FIELD_DIFFERENTIAL_REVIEWERS:
	$revision = $this->loadDifferentialRevision();
	if (!$revision) {
	return array();
	}
	return $revision->getReviewers();
	case self::FIELD_DIFFERENTIAL_CCS:
	$revision = $this->loadDifferentialRevision();
	if (!$revision) {
	return array();
	}
	return $revision->getCCPHIDs();
	case self::FIELD_BRANCHES:
	$params = array(
	'callsign' => $this->repository->getCallsign(),
	'contains' => $this->commit->getCommitIdentifier(),
	);

	$result = id(new ConduitCall('diffusion.branchquery', $params))
	->setUser(PhabricatorUser::getOmnipotentUser())
	->execute();

	$refs = DiffusionRepositoryRef::loadAllFromDictionaries($result);
	return mpull($refs, 'getShortName');
	case self::FIELD_REPOSITORY_AUTOCLOSE_BRANCH:
	return $this->repository->shouldAutocloseCommit($this->commit);
	}

	return parent::getHeraldField($field);
	}

	public function applyHeraldEffects(array $effects) {
	assert_instances_of($effects, 'HeraldEffect');

	$result = array();
	foreach ($effects as $effect) {
	$action = $effect->getAction();
	switch ($action) {
	case self::ACTION_NOTHING:
	$result[] = new HeraldApplyTranscript(
	$effect,
	true,
	pht('Great success at doing nothing.'));
	break;
	case self::ACTION_EMAIL:
	foreach ($effect->getTarget() as $phid) {
	$this->emailPHIDs[$phid] = true;
	}
	$result[] = new HeraldApplyTranscript(
	$effect,
	true,
	pht('Added address to email targets.'));
	break;
	case self::ACTION_ADD_CC:
	foreach ($effect->getTarget() as $phid) {
	if (empty($this->addCCPHIDs[$phid])) {
	$this->addCCPHIDs[$phid] = array();
	}
	$this->addCCPHIDs[$phid][] = $effect->getRuleID();
	}
	$result[] = new HeraldApplyTranscript(
	$effect,
	true,
	pht('Added address to CC.'));
	break;
	case self::ACTION_AUDIT:
	foreach ($effect->getTarget() as $phid) {
	if (empty($this->auditMap[$phid])) {
	$this->auditMap[$phid] = array();
	}
	$this->auditMap[$phid][] = $effect->getRuleID();
	}
	$result[] = new HeraldApplyTranscript(
	$effect,
	true,
	pht('Triggered an audit.'));
	break;
	case self::ACTION_APPLY_BUILD_PLANS:
	foreach ($effect->getTarget() as $phid) {
	$this->buildPlans[] = $phid;
	}
	$result[] = new HeraldApplyTranscript(
	$effect,
	true,
	pht('Applied build plans.'));
	break;
	case self::ACTION_FLAG:
	$result[] = parent::applyFlagEffect(
	$effect,
	$this->commit->getPHID());
	break;
	default:
	$custom_result = parent::handleCustomHeraldEffect($effect);
	if ($custom_result === null) {
	throw new Exception(pht(
	"No rules to handle action '%s'.",
	$action));
	}

	$result[] = $custom_result;
	break;
	}
	}
	return $result;
	}

	}
	diff --git a/src/infrastructure/diff/PhabricatorDifferenceEngine.php b/src/infrastructure/diff/PhabricatorDifferenceEngine.php
	index b7b22d7da0..6db867722f 100644
	--- a/src/infrastructure/diff/PhabricatorDifferenceEngine.php
	+++ b/src/infrastructure/diff/PhabricatorDifferenceEngine.php
	@@ -1,172 +1,171 @@
	<?php

	/**
	* Utility class which encapsulates some shared behavior between different
	* applications which render diffs.
	*
	* @task config Configuring the Engine
	* @task diff Generating Diffs
	*/
	final class PhabricatorDifferenceEngine {


	private $ignoreWhitespace;
	private $oldName;
	private $newName;


	/* -( Configuring the Engine )--------------------------------------------- */


	/**
	* If true, ignore whitespace when computing differences.
	*
	* @param bool Ignore whitespace?
	* @return this
	* @task config
	*/
	public function setIgnoreWhitespace($ignore_whitespace) {
	$this->ignoreWhitespace = $ignore_whitespace;
	return $this;
	}


	/**
	* Set the name to identify the old file with. Primarily cosmetic.
	*
	* @param string Old file name.
	* @return this
	* @task config
	*/
	public function setOldName($old_name) {
	$this->oldName = $old_name;
	return $this;
	}


	/**
	* Set the name to identify the new file with. Primarily cosmetic.
	*
	* @param string New file name.
	* @return this
	* @task config
	*/
	public function setNewName($new_name) {
	$this->newName = $new_name;
	return $this;
	}


	/* -( Generating Diffs )--------------------------------------------------- */


	/**
	* Generate a raw diff from two raw files. This is a lower-level API than
	* @{method:generateChangesetFromFileContent}, but may be useful if you need
	* to use a custom parser configuration, as with Diffusion.
	*
	* @param string Entire previous file content.
	* @param string Entire current file content.
	* @return string Raw diff between the two files.
	* @task diff
	*/
	public function generateRawDiffFromFileContent($old, $new) {

	$options = array();
	if ($this->ignoreWhitespace) {
	$options[] = '-bw';
	}

	// Generate diffs with full context.
	$options[] = '-U65535';

	$old_name = nonempty($this->oldName, '/dev/universe').' 9999-99-99';
	$new_name = nonempty($this->newName, '/dev/universe').' 9999-99-99';

	$options[] = '-L';
	$options[] = $old_name;
	$options[] = '-L';
	$options[] = $new_name;

	$old_tmp = new TempFile();
	$new_tmp = new TempFile();

	Filesystem::writeFile($old_tmp, $old);
	Filesystem::writeFile($new_tmp, $new);
	list($err, $diff) = exec_manual(
	'diff %Ls %s %s',
	$options,
	$old_tmp,
	$new_tmp);

	if (!$err) {
	// This indicates that the two files are the same (or, possibly, the
	// same modulo whitespace differences, which is why we can't do this
	// check trivially before running `diff`). Build a synthetic, changeless
	// diff so that we can still render the raw, unchanged file instead of
	// being forced to just say "this file didn't change" since we don't have
	// the content.

	$entire_file = explode("\n", $old);
	foreach ($entire_file as $k => $line) {
	$entire_file[$k] = ' '.$line;
	}

	$len = count($entire_file);
	$entire_file = implode("\n", $entire_file);

	// TODO: If both files were identical but missing newlines, we probably
	// get this wrong. Unclear if it ever matters.

	// This is a bit hacky but the diff parser can handle it.
	$diff = "--- {$old_name}\n".
	"+++ {$new_name}\n".
	"@@ -1,{$len} +1,{$len} @@\n".
	$entire_file."\n";
	} else {
	if ($this->ignoreWhitespace) {

	// Under "-bw", `diff` is inconsistent about emitting "\ No newline
	// at end of file". For instance, a long file with a change in the
	// middle will emit a contextless "\ No newline..." at the end if a
	// newline is removed, but not if one is added. A file with a change
	// at the end will emit the "old" "\ No newline..." block only, even
	// if the newline was not removed. Since we're ostensibly ignoring
	// whitespace changes, just drop these lines if they appear anywhere
	// in the diff.

	$lines = explode("\n", $diff);
	foreach ($lines as $key => $line) {
	if (isset($line[0]) && $line[0] == '\\') {
	unset($lines[$key]);
	}
	}
	$diff = implode("\n", $lines);
	}
	}

	return $diff;
	}


	/**
	* Generate an @{class:DifferentialChangeset} from two raw files. This is
	* principally useful because you can feed the output to
	* @{class:DifferentialChangesetParser} in order to render it.
	*
	* @param string Entire previous file content.
	* @param string Entire current file content.
	* @return @{class:DifferentialChangeset} Synthetic changeset.
	* @task diff
	*/
	public function generateChangesetFromFileContent($old, $new) {
	$diff = $this->generateRawDiffFromFileContent($old, $new);

	$changes = id(new ArcanistDiffParser())->parseDiff($diff);
	- $diff = DifferentialDiff::newFromRawChanges(
	- PhabricatorUser::getOmnipotentUser(),
	+ $diff = DifferentialDiff::newEphemeralFromRawChanges(
	$changes);
	return head($diff->getChangesets());
	}

	}

File Metadata

Mime Type: text/x-diff
Expires: Sun, Sep 7, 7:11 AM (14 h, 32 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 222498
Default Alt Text: (91 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions