No OneTemporary
Actions

Size

87 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/src/applications/audit/editor/PhabricatorAuditCommentEditor.php b/src/applications/audit/editor/PhabricatorAuditCommentEditor.php
	index 8a17999ee0..988311d74c 100644
	--- a/src/applications/audit/editor/PhabricatorAuditCommentEditor.php
	+++ b/src/applications/audit/editor/PhabricatorAuditCommentEditor.php
	@@ -1,53 +1,17 @@
	<?php

	final class PhabricatorAuditCommentEditor extends PhabricatorEditor {

	- /**
	- * Load the PHIDs for all objects the user has the authority to act as an
	- * audit for. This includes themselves, and any packages they are an owner
	- * of.
	- */
	- public static function loadAuditPHIDsForUser(PhabricatorUser $user) {
	- $phids = array();
	-
	- // TODO: This method doesn't really use the right viewer, but in practice we
	- // never issue this query of this type on behalf of another user and are
	- // unlikely to do so in the future. This entire method should be refactored
	- // into a Query class, however, and then we should use a proper viewer.
	-
	- // The user can audit on their own behalf.
	- $phids[$user->getPHID()] = true;
	-
	- $owned_packages = id(new PhabricatorOwnersPackageQuery())
	- ->setViewer($user)
	- ->withAuthorityPHIDs(array($user->getPHID()))
	- ->execute();
	- foreach ($owned_packages as $package) {
	- $phids[$package->getPHID()] = true;
	- }
	-
	- // The user can audit on behalf of all projects they are a member of.
	- $projects = id(new PhabricatorProjectQuery())
	- ->setViewer($user)
	- ->withMemberPHIDs(array($user->getPHID()))
	- ->execute();
	- foreach ($projects as $project) {
	- $phids[$project->getPHID()] = true;
	- }
	-
	- return array_keys($phids);
	- }
	-
	public static function getMailThreading(
	PhabricatorRepository $repository,
	PhabricatorRepositoryCommit $commit) {

	return array(
	'diffusion-audit-'.$commit->getPHID(),
	pht(
	'Commit %s',
	$commit->getMonogram()),
	);
	}

	}
	diff --git a/src/applications/audit/editor/PhabricatorAuditEditor.php b/src/applications/audit/editor/PhabricatorAuditEditor.php
	index 99190d808a..2e7efd4c87 100644
	--- a/src/applications/audit/editor/PhabricatorAuditEditor.php
	+++ b/src/applications/audit/editor/PhabricatorAuditEditor.php
	@@ -1,874 +1,878 @@
	<?php

	final class PhabricatorAuditEditor
	extends PhabricatorApplicationTransactionEditor {

	const MAX_FILES_SHOWN_IN_EMAIL = 1000;

	private $auditReasonMap = array();
	private $affectedFiles;
	private $rawPatch;
	private $auditorPHIDs = array();

	private $didExpandInlineState = false;

	public function addAuditReason($phid, $reason) {
	if (!isset($this->auditReasonMap[$phid])) {
	$this->auditReasonMap[$phid] = array();
	}
	$this->auditReasonMap[$phid][] = $reason;
	return $this;
	}

	private function getAuditReasons($phid) {
	if (isset($this->auditReasonMap[$phid])) {
	return $this->auditReasonMap[$phid];
	}
	if ($this->getIsHeraldEditor()) {
	$name = 'herald';
	} else {
	$name = $this->getActor()->getUsername();
	}
	return array(pht('Added by %s.', $name));
	}

	public function setRawPatch($patch) {
	$this->rawPatch = $patch;
	return $this;
	}

	public function getRawPatch() {
	return $this->rawPatch;
	}

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

	public function getEditorObjectsDescription() {
	return pht('Audits');
	}

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

	$types[] = PhabricatorTransactions::TYPE_COMMENT;
	$types[] = PhabricatorTransactions::TYPE_EDGE;
	$types[] = PhabricatorTransactions::TYPE_INLINESTATE;

	$types[] = PhabricatorAuditTransaction::TYPE_COMMIT;

	// TODO: These will get modernized eventually, but that can happen one
	// at a time later on.
	$types[] = PhabricatorAuditActionConstants::INLINE;
	$types[] = PhabricatorAuditActionConstants::ADD_AUDITORS;

	return $types;
	}

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

	foreach ($xactions as $xaction) {
	switch ($xaction->getTransactionType()) {
	case PhabricatorTransactions::TYPE_INLINESTATE:
	$this->didExpandInlineState = true;
	break;
	}
	}

	+ $object->loadAndAttachAuditAuthority(
	+ $this->getActor(),
	+ $this->getActingAsPHID());
	+
	return parent::expandTransactions($object, $xactions);
	}

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

	switch ($xaction->getTransactionType()) {
	case PhabricatorAuditActionConstants::INLINE:
	return $xaction->hasComment();
	}

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

	protected function getCustomTransactionOldValue(
	PhabricatorLiskDAO $object,
	PhabricatorApplicationTransaction $xaction) {
	switch ($xaction->getTransactionType()) {
	case PhabricatorAuditActionConstants::INLINE:
	case PhabricatorAuditTransaction::TYPE_COMMIT:
	return null;
	case PhabricatorAuditActionConstants::ADD_AUDITORS:
	// TODO: For now, just record the added PHIDs. Eventually, turn these
	// into real edge transactions, probably?
	return array();
	}

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

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

	switch ($xaction->getTransactionType()) {
	case PhabricatorAuditActionConstants::INLINE:
	case PhabricatorAuditActionConstants::ADD_AUDITORS:
	case PhabricatorAuditTransaction::TYPE_COMMIT:
	return $xaction->getNewValue();
	}

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

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

	switch ($xaction->getTransactionType()) {
	case PhabricatorAuditActionConstants::INLINE:
	case PhabricatorAuditActionConstants::ADD_AUDITORS:
	case PhabricatorAuditTransaction::TYPE_COMMIT:
	return;
	}

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

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

	switch ($xaction->getTransactionType()) {
	case PhabricatorAuditTransaction::TYPE_COMMIT:
	return;
	case PhabricatorAuditActionConstants::INLINE:
	$reply = $xaction->getComment()->getReplyToComment();
	if ($reply && !$reply->getHasReplies()) {
	$reply->setHasReplies(1)->save();
	}
	return;
	case PhabricatorAuditActionConstants::ADD_AUDITORS:
	$new = $xaction->getNewValue();
	if (!is_array($new)) {
	$new = array();
	}

	$old = $xaction->getOldValue();
	if (!is_array($old)) {
	$old = array();
	}

	$add = array_diff_key($new, $old);

	$actor = $this->requireActor();

	$requests = $object->getAudits();
	$requests = mpull($requests, null, 'getAuditorPHID');
	foreach ($add as $phid) {
	if (isset($requests[$phid])) {
	$request = $requests[$phid];

	// Only update an existing request if the current status is not
	// an interesting status.
	if ($request->isInteresting()) {
	continue;
	}
	} else {
	$request = id(new PhabricatorRepositoryAuditRequest())
	->setCommitPHID($object->getPHID())
	->setAuditorPHID($phid);
	}

	if ($this->getIsHeraldEditor()) {
	$audit_requested = $xaction->getMetadataValue('auditStatus');
	$audit_reason_map = $xaction->getMetadataValue('auditReasonMap');
	$audit_reason = $audit_reason_map[$phid];
	} else {
	$audit_requested = PhabricatorAuditStatusConstants::AUDIT_REQUESTED;
	$audit_reason = $this->getAuditReasons($phid);
	}

	$request
	->setAuditStatus($audit_requested)
	->setAuditReasons($audit_reason)
	->save();

	$requests[$phid] = $request;
	}

	$object->attachAudits($requests);
	return;
	}

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

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

	switch ($xaction->getTransactionType()) {
	case PhabricatorTransactions::TYPE_INLINESTATE:
	$table = new PhabricatorAuditTransactionComment();
	$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 auditors explicitly; we may not have them if the caller was a
	// generic piece of infrastructure.

	$commit = id(new DiffusionCommitQuery())
	->setViewer($this->requireActor())
	->withIDs(array($object->getID()))
	->needAuditRequests(true)
	->executeOne();
	if (!$commit) {
	throw new Exception(
	pht('Failed to load commit during transaction finalization!'));
	}
	$object->attachAudits($commit->getAudits());

	$status_concerned = PhabricatorAuditStatusConstants::CONCERNED;
	$status_closed = PhabricatorAuditStatusConstants::CLOSED;
	$status_resigned = PhabricatorAuditStatusConstants::RESIGNED;
	$status_accepted = PhabricatorAuditStatusConstants::ACCEPTED;
	$status_concerned = PhabricatorAuditStatusConstants::CONCERNED;

	$actor_phid = $this->getActingAsPHID();
	$actor_is_author = ($object->getAuthorPHID()) &&
	($actor_phid == $object->getAuthorPHID());

	$import_status_flag = null;
	foreach ($xactions as $xaction) {
	switch ($xaction->getTransactionType()) {
	case PhabricatorAuditTransaction::TYPE_COMMIT:
	$import_status_flag = PhabricatorRepositoryCommit::IMPORTED_HERALD;
	break;
	}
	}

	$old_status = $object->getAuditStatus();

	$requests = $object->getAudits();
	$object->updateAuditStatus($requests);

	$new_status = $object->getAuditStatus();

	$object->save();

	if ($import_status_flag) {
	$object->writeImportStatusFlag($import_status_flag);
	}

	$partial_status = PhabricatorAuditCommitStatusConstants::PARTIALLY_AUDITED;

	// If the commit has changed state after this edit, add an informational
	// transaction about the state change.
	if ($old_status !== $new_status) {
	if ($new_status === $partial_status) {
	// This state isn't interesting enough to get a transaction. The
	// best way we could lead the user forward is something like "This
	// commit still requires additional audits." but that's redundant and
	// probably not very useful.
	} else {
	$xaction = $object->getApplicationTransactionTemplate()
	->setTransactionType(DiffusionCommitStateTransaction::TRANSACTIONTYPE)
	->setOldValue($old_status)
	->setNewValue($new_status);

	$xaction = $this->populateTransaction($object, $xaction);

	$xaction->save();
	}
	}

	// Collect auditor PHIDs for building mail.
	$this->auditorPHIDs = mpull($object->getAudits(), 'getAuditorPHID');

	return $xactions;
	}

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

	$xactions = parent::expandTransaction($object, $xaction);
	switch ($xaction->getTransactionType()) {
	case PhabricatorAuditTransaction::TYPE_COMMIT:
	$request = $this->createAuditRequestTransactionFromCommitMessage(
	$object);
	if ($request) {
	$xactions[] = $request;
	$this->setUnmentionablePHIDMap($request->getNewValue());
	}
	break;
	default:
	break;
	}

	if (!$this->didExpandInlineState) {
	switch ($xaction->getTransactionType()) {
	case PhabricatorTransactions::TYPE_COMMENT:
	$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 DiffusionDiffInlineCommentQuery())
	->setViewer($this->getActor())
	->withCommitPHIDs(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];
	}

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

	return $xactions;
	}

	private function createAuditRequestTransactionFromCommitMessage(
	PhabricatorRepositoryCommit $commit) {

	$data = $commit->getCommitData();
	$message = $data->getCommitMessage();

	$matches = null;
	if (!preg_match('/^Auditors?:\s(.)$/im', $message, $matches)) {
	return array();
	}

	$phids = id(new PhabricatorObjectListQuery())
	->setViewer($this->getActor())
	->setAllowPartialResults(true)
	->setAllowedTypes(
	array(
	PhabricatorPeopleUserPHIDType::TYPECONST,
	PhabricatorProjectProjectPHIDType::TYPECONST,
	))
	->setObjectList($matches[1])
	->execute();

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

	foreach ($phids as $phid) {
	$this->addAuditReason($phid, pht('Requested by Author'));
	}
	return id(new PhabricatorAuditTransaction())
	->setTransactionType(PhabricatorAuditActionConstants::ADD_AUDITORS)
	->setNewValue(array_fuse($phids));
	}

	protected function sortTransactions(array $xactions) {
	$xactions = parent::sortTransactions($xactions);

	$head = array();
	$tail = array();

	foreach ($xactions as $xaction) {
	$type = $xaction->getTransactionType();
	if ($type == PhabricatorAuditActionConstants::INLINE) {
	$tail[] = $xaction;
	} else {
	$head[] = $xaction;
	}
	}

	return array_values(array_merge($head, $tail));
	}

	protected function supportsSearch() {
	return true;
	}

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

	// we are only really trying to find unmentionable phids here...
	// don't bother with this outside initial commit (i.e. create)
	// transaction
	$is_commit = false;
	foreach ($xactions as $xaction) {
	switch ($xaction->getTransactionType()) {
	case PhabricatorAuditTransaction::TYPE_COMMIT:
	$is_commit = true;
	break;
	}
	}

	// "result" is always an array....
	$result = array();
	if (!$is_commit) {
	return $result;
	}

	$flat_blocks = mpull($changes, 'getNewValue');
	$huge_block = implode("\n\n", $flat_blocks);
	$phid_map = array();
	$phid_map[] = $this->getUnmentionablePHIDMap();
	$monograms = array();

	$task_refs = id(new ManiphestCustomFieldStatusParser())
	->parseCorpus($huge_block);
	foreach ($task_refs as $match) {
	foreach ($match['monograms'] as $monogram) {
	$monograms[] = $monogram;
	}
	}

	$rev_refs = id(new DifferentialCustomFieldDependsOnParser())
	->parseCorpus($huge_block);
	foreach ($rev_refs as $match) {
	foreach ($match['monograms'] as $monogram) {
	$monograms[] = $monogram;
	}
	}

	$objects = id(new PhabricatorObjectQuery())
	->setViewer($this->getActor())
	->withNames($monograms)
	->execute();
	$phid_map[] = mpull($objects, 'getPHID', 'getPHID');
	$phid_map = array_mergev($phid_map);
	$this->setUnmentionablePHIDMap($phid_map);

	return $result;
	}

	protected function buildReplyHandler(PhabricatorLiskDAO $object) {
	$reply_handler = new PhabricatorAuditReplyHandler();
	$reply_handler->setMailReceiver($object);
	return $reply_handler;
	}

	protected function getMailSubjectPrefix() {
	return PhabricatorEnv::getEnvConfig('metamta.diffusion.subject-prefix');
	}

	protected function getMailThreadID(PhabricatorLiskDAO $object) {
	// For backward compatibility, use this legacy thread ID.
	return 'diffusion-audit-'.$object->getPHID();
	}

	protected function buildMailTemplate(PhabricatorLiskDAO $object) {
	$identifier = $object->getCommitIdentifier();
	$repository = $object->getRepository();
	$monogram = $repository->getMonogram();

	$summary = $object->getSummary();
	$name = $repository->formatCommitName($identifier);

	$subject = "{$name}: {$summary}";
	$thread_topic = "Commit {$monogram}{$identifier}";

	$template = id(new PhabricatorMetaMTAMail())
	->setSubject($subject)
	->addHeader('Thread-Topic', $thread_topic);

	$this->attachPatch(
	$template,
	$object);

	return $template;
	}

	protected function getMailTo(PhabricatorLiskDAO $object) {
	$phids = array();

	if ($object->getAuthorPHID()) {
	$phids[] = $object->getAuthorPHID();
	}

	$status_resigned = PhabricatorAuditStatusConstants::RESIGNED;
	foreach ($object->getAudits() as $audit) {
	if (!$audit->isInteresting()) {
	// Don't send mail to uninteresting auditors, like packages which
	// own this code but which audits have not triggered for.
	continue;
	}

	if ($audit->getAuditStatus() != $status_resigned) {
	$phids[] = $audit->getAuditorPHID();
	}
	}

	$phids[] = $this->getActingAsPHID();

	return $phids;
	}

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

	$body = parent::buildMailBody($object, $xactions);

	$type_inline = PhabricatorAuditActionConstants::INLINE;
	$type_push = PhabricatorAuditTransaction::TYPE_COMMIT;

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

	if ($inlines) {
	$body->addTextSection(
	pht('INLINE COMMENTS'),
	$this->renderInlineCommentsForMail($object, $inlines));
	}

	if ($is_commit) {
	$data = $object->getCommitData();
	$body->addTextSection(pht('AFFECTED FILES'), $this->affectedFiles);
	$this->inlinePatch(
	$body,
	$object);
	}

	$data = $object->getCommitData();

	$user_phids = array();

	$author_phid = $object->getAuthorPHID();
	if ($author_phid) {
	$user_phids[$author_phid][] = pht('Author');
	}

	$committer_phid = $data->getCommitDetail('committerPHID');
	if ($committer_phid && ($committer_phid != $author_phid)) {
	$user_phids[$committer_phid][] = pht('Committer');
	}

	foreach ($this->auditorPHIDs as $auditor_phid) {
	$user_phids[$auditor_phid][] = pht('Auditor');
	}

	// TODO: It would be nice to show pusher here too, but that information
	// is a little tricky to get at right now.

	if ($user_phids) {
	$handle_phids = array_keys($user_phids);
	$handles = id(new PhabricatorHandleQuery())
	->setViewer($this->requireActor())
	->withPHIDs($handle_phids)
	->execute();

	$user_info = array();
	foreach ($user_phids as $phid => $roles) {
	$user_info[] = pht(
	'%s (%s)',
	$handles[$phid]->getName(),
	implode(', ', $roles));
	}

	$body->addTextSection(
	pht('USERS'),
	implode("\n", $user_info));
	}

	$monogram = $object->getRepository()->formatCommitName(
	$object->getCommitIdentifier());

	$body->addLinkSection(
	pht('COMMIT'),
	PhabricatorEnv::getProductionURI('/'.$monogram));

	return $body;
	}

	private function attachPatch(
	PhabricatorMetaMTAMail $template,
	PhabricatorRepositoryCommit $commit) {

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

	$attach_key = 'metamta.diffusion.attach-patches';
	$attach_patches = PhabricatorEnv::getEnvConfig($attach_key);
	if (!$attach_patches) {
	return;
	}

	$repository = $commit->getRepository();
	$encoding = $repository->getDetail('encoding', 'UTF-8');

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

	$template->addAttachment(
	new PhabricatorMetaMTAAttachment(
	$raw_patch,
	$commit_name.'.patch',
	'text/x-patch; charset='.$encoding));
	}

	private function inlinePatch(
	PhabricatorMetaMTAMailBody $body,
	PhabricatorRepositoryCommit $commit) {

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

	$inline_key = 'metamta.diffusion.inline-patches';
	$inline_patches = PhabricatorEnv::getEnvConfig($inline_key);
	if (!$inline_patches) {
	return;
	}

	$repository = $commit->getRepository();
	$raw_patch = $this->getRawPatch();
	$result = null;
	$len = substr_count($raw_patch, "\n");
	if ($len <= $inline_patches) {
	// We send email as utf8, so we need to convert the text to utf8 if
	// we can.
	$encoding = $repository->getDetail('encoding', 'UTF-8');
	if ($encoding) {
	$raw_patch = phutil_utf8_convert($raw_patch, 'UTF-8', $encoding);
	}
	$result = phutil_utf8ize($raw_patch);
	}

	if ($result) {
	$result = "PATCH\n\n{$result}\n";
	}
	$body->addRawSection($result);
	}

	private function renderInlineCommentsForMail(
	PhabricatorLiskDAO $object,
	array $inline_xactions) {

	$inlines = mpull($inline_xactions, 'getComment');

	$block = array();

	$path_map = id(new DiffusionPathQuery())
	->withPathIDs(mpull($inlines, 'getPathID'))
	->execute();
	$path_map = ipull($path_map, 'path', 'id');

	foreach ($inlines as $inline) {
	$path = idx($path_map, $inline->getPathID());
	if ($path === null) {
	continue;
	}

	$start = $inline->getLineNumber();
	$len = $inline->getLineLength();
	if ($len) {
	$range = $start.'-'.($start + $len);
	} else {
	$range = $start;
	}

	$content = $inline->getContent();
	$block[] = "{$path}:{$range} {$content}";
	}

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

	public function getMailTagsMap() {
	return array(
	PhabricatorAuditTransaction::MAILTAG_COMMIT =>
	pht('A commit is created.'),
	PhabricatorAuditTransaction::MAILTAG_ACTION_CONCERN =>
	pht('A commit has a concerned raised against it.'),
	PhabricatorAuditTransaction::MAILTAG_ACTION_ACCEPT =>
	pht('A commit is accepted.'),
	PhabricatorAuditTransaction::MAILTAG_ACTION_RESIGN =>
	pht('A commit has an auditor resign.'),
	PhabricatorAuditTransaction::MAILTAG_ACTION_CLOSE =>
	pht('A commit is closed.'),
	PhabricatorAuditTransaction::MAILTAG_ADD_AUDITORS =>
	pht('A commit has auditors added.'),
	PhabricatorAuditTransaction::MAILTAG_ADD_CCS =>
	pht("A commit's subscribers change."),
	PhabricatorAuditTransaction::MAILTAG_PROJECTS =>
	pht("A commit's projects change."),
	PhabricatorAuditTransaction::MAILTAG_COMMENT =>
	pht('Someone comments on a commit.'),
	PhabricatorAuditTransaction::MAILTAG_OTHER =>
	pht('Other commit activity not listed above occurs.'),
	);
	}

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

	foreach ($xactions as $xaction) {
	switch ($xaction->getTransactionType()) {
	case PhabricatorAuditTransaction::TYPE_COMMIT:
	$repository = $object->getRepository();
	if (!$repository->shouldPublish()) {
	return false;
	}
	return true;
	default:
	break;
	}
	}
	return parent::shouldApplyHeraldRules($object, $xactions);
	}

	protected function buildHeraldAdapter(
	PhabricatorLiskDAO $object,
	array $xactions) {
	return id(new HeraldCommitAdapter())
	->setObject($object);
	}

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

	$limit = self::MAX_FILES_SHOWN_IN_EMAIL;
	$files = $adapter->loadAffectedPaths();
	sort($files);
	if (count($files) > $limit) {
	array_splice($files, $limit);
	$files[] = pht(
	'(This commit affected more than %d files. Only %d are shown here '.
	'and additional ones are truncated.)',
	$limit,
	$limit);
	}
	$this->affectedFiles = implode("\n", $files);

	return array();
	}

	private function isCommitMostlyImported(PhabricatorLiskDAO $object) {
	$has_message = PhabricatorRepositoryCommit::IMPORTED_MESSAGE;
	$has_changes = PhabricatorRepositoryCommit::IMPORTED_CHANGE;

	// Don't publish feed stories or email about events which occur during
	// import. In particular, this affects tasks being attached when they are
	// closed by "Fixes Txxxx" in a commit message. See T5851.

	$mask = ($has_message \| $has_changes);

	return $object->isPartiallyImported($mask);
	}


	private function shouldPublishRepositoryActivity(
	PhabricatorLiskDAO $object,
	array $xactions) {

	// not every code path loads the repository so tread carefully
	// TODO: They should, and then we should simplify this.
	$repository = $object->getRepository($assert_attached = false);
	if ($repository != PhabricatorLiskDAO::ATTACHABLE) {
	if (!$repository->shouldPublish()) {
	return false;
	}
	}

	return $this->isCommitMostlyImported($object);
	}

	protected function shouldSendMail(
	PhabricatorLiskDAO $object,
	array $xactions) {
	return $this->shouldPublishRepositoryActivity($object, $xactions);
	}

	protected function shouldEnableMentions(
	PhabricatorLiskDAO $object,
	array $xactions) {
	return $this->shouldPublishRepositoryActivity($object, $xactions);
	}

	protected function shouldPublishFeedStory(
	PhabricatorLiskDAO $object,
	array $xactions) {
	return $this->shouldPublishRepositoryActivity($object, $xactions);
	}

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

	protected function getCustomWorkerStateEncoding() {
	return array(
	'rawPatch' => self::STORAGE_ENCODING_BINARY,
	);
	}

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

	protected function willPublish(PhabricatorLiskDAO $object, array $xactions) {
	return id(new DiffusionCommitQuery())
	->setViewer($this->requireActor())
	->withIDs(array($object->getID()))
	->needAuditRequests(true)
	->needCommitData(true)
	->executeOne();
	}

	}
	diff --git a/src/applications/diffusion/controller/DiffusionCommitController.php b/src/applications/diffusion/controller/DiffusionCommitController.php
	index f308892790..f88c463633 100644
	--- a/src/applications/diffusion/controller/DiffusionCommitController.php
	+++ b/src/applications/diffusion/controller/DiffusionCommitController.php
	@@ -1,1132 +1,1124 @@
	<?php

	final class DiffusionCommitController extends DiffusionController {

	const CHANGES_LIMIT = 100;

	- private $auditAuthorityPHIDs;
	- private $highlightedAudits;
	-
	private $commitParents;
	private $commitRefs;
	private $commitMerges;
	private $commitErrors;
	private $commitExists;

	public function shouldAllowPublic() {
	return true;
	}

	public function handleRequest(AphrontRequest $request) {
	$response = $this->loadDiffusionContext();
	if ($response) {
	return $response;
	}

	$drequest = $this->getDiffusionRequest();
	$viewer = $request->getUser();

	if ($request->getStr('diff')) {
	return $this->buildRawDiffResponse($drequest);
	}

	$repository = $drequest->getRepository();

	$commit = id(new DiffusionCommitQuery())
	->setViewer($viewer)
	->withRepository($repository)
	->withIdentifiers(array($drequest->getCommit()))
	->needCommitData(true)
	->needAuditRequests(true)
	->executeOne();

	$crumbs = $this->buildCrumbs(array(
	'commit' => true,
	));
	$crumbs->setBorder(true);

	if (!$commit) {
	if (!$this->getCommitExists()) {
	return new Aphront404Response();
	}

	$error = id(new PHUIInfoView())
	->setTitle(pht('Commit Still Parsing'))
	->appendChild(
	pht(
	'Failed to load the commit because the commit has not been '.
	'parsed yet.'));

	$title = pht('Commit Still Parsing');

	return $this->newPage()
	->setTitle($title)
	->setCrumbs($crumbs)
	->appendChild($error);

	}

	$audit_requests = $commit->getAudits();
	- $this->auditAuthorityPHIDs =
	- PhabricatorAuditCommentEditor::loadAuditPHIDsForUser($viewer);
	+ $commit->loadAndAttachAuditAuthority($viewer);

	$commit_data = $commit->getCommitData();
	$is_foreign = $commit_data->getCommitDetail('foreign-svn-stub');
	$error_panel = null;

	$hard_limit = 1000;

	if ($commit->isImported()) {
	$change_query = DiffusionPathChangeQuery::newFromDiffusionRequest(
	$drequest);
	$change_query->setLimit($hard_limit + 1);
	$changes = $change_query->loadChanges();
	} else {
	$changes = array();
	}

	$was_limited = (count($changes) > $hard_limit);
	if ($was_limited) {
	$changes = array_slice($changes, 0, $hard_limit);
	}

	$count = count($changes);

	$is_unreadable = false;
	$hint = null;
	if (!$count \|\| $commit->isUnreachable()) {
	$hint = id(new DiffusionCommitHintQuery())
	->setViewer($viewer)
	->withRepositoryPHIDs(array($repository->getPHID()))
	->withOldCommitIdentifiers(array($commit->getCommitIdentifier()))
	->executeOne();
	if ($hint) {
	$is_unreadable = $hint->isUnreadable();
	}
	}

	if ($is_foreign) {
	$subpath = $commit_data->getCommitDetail('svn-subpath');

	$error_panel = new PHUIInfoView();
	$error_panel->setTitle(pht('Commit Not Tracked'));
	$error_panel->setSeverity(PHUIInfoView::SEVERITY_WARNING);
	$error_panel->appendChild(
	pht(
	"This Diffusion repository is configured to track only one ".
	"subdirectory of the entire Subversion repository, and this commit ".
	"didn't affect the tracked subdirectory ('%s'), so no ".
	"information is available.",
	$subpath));
	} else {
	$engine = PhabricatorMarkupEngine::newDifferentialMarkupEngine();
	$engine->setConfig('viewer', $viewer);

	$commit_tag = $this->renderCommitHashTag($drequest);
	$header = id(new PHUIHeaderView())
	->setHeader(nonempty($commit->getSummary(), pht('Commit Detail')))
	->setHeaderIcon('fa-code-fork')
	->addTag($commit_tag);

	if ($commit->getAuditStatus()) {
	$icon = PhabricatorAuditCommitStatusConstants::getStatusIcon(
	$commit->getAuditStatus());
	$color = PhabricatorAuditCommitStatusConstants::getStatusColor(
	$commit->getAuditStatus());
	$status = PhabricatorAuditCommitStatusConstants::getStatusName(
	$commit->getAuditStatus());

	$header->setStatus($icon, $color, $status);
	}

	$curtain = $this->buildCurtain($commit, $repository);
	$subheader = $this->buildSubheaderView($commit, $commit_data);
	$details = $this->buildPropertyListView(
	$commit,
	$commit_data,
	$audit_requests);

	$message = $commit_data->getCommitMessage();

	$revision = $commit->getCommitIdentifier();
	$message = $this->linkBugtraq($message);
	$message = $engine->markupText($message);

	$detail_list = new PHUIPropertyListView();
	$detail_list->addTextContent(
	phutil_tag(
	'div',
	array(
	'class' => 'diffusion-commit-message phabricator-remarkup',
	),
	$message));

	if ($commit->isUnreachable()) {
	$did_rewrite = false;
	if ($hint) {
	if ($hint->isRewritten()) {
	$rewritten = id(new DiffusionCommitQuery())
	->setViewer($viewer)
	->withRepository($repository)
	->withIdentifiers(array($hint->getNewCommitIdentifier()))
	->executeOne();
	if ($rewritten) {
	$did_rewrite = true;
	$rewritten_uri = $rewritten->getURI();
	$rewritten_name = $rewritten->getLocalName();

	$rewritten_link = phutil_tag(
	'a',
	array(
	'href' => $rewritten_uri,
	),
	$rewritten_name);

	$this->commitErrors[] = pht(
	'This commit was rewritten after it was published, which '.
	'changed the commit hash. This old version of the commit is '.
	'no longer reachable from any branch, tag or ref. The new '.
	'version of this commit is %s.',
	$rewritten_link);
	}
	}
	}

	if (!$did_rewrite) {
	$this->commitErrors[] = pht(
	'This commit has been deleted in the repository: it is no longer '.
	'reachable from any branch, tag, or ref.');
	}
	}

	if ($this->getCommitErrors()) {
	$error_panel = id(new PHUIInfoView())
	->appendChild($this->getCommitErrors())
	->setSeverity(PHUIInfoView::SEVERITY_WARNING);
	}
	}

	$timeline = $this->buildComments($commit);
	$merge_table = $this->buildMergesTable($commit);

	- $highlighted_audits = $commit->getAuthorityAudits(
	- $viewer,
	- $this->auditAuthorityPHIDs);
	-
	$show_changesets = false;
	$info_panel = null;
	$change_list = null;
	$change_table = null;
	if ($is_unreadable) {
	$info_panel = $this->renderStatusMessage(
	pht('Unreadable Commit'),
	pht(
	'This commit has been marked as unreadable by an administrator. '.
	'It may have been corrupted or created improperly by an external '.
	'tool.'));
	} else if ($is_foreign) {
	// Don't render anything else.
	} else if (!$commit->isImported()) {
	$info_panel = $this->renderStatusMessage(
	pht('Still Importing...'),
	pht(
	'This commit is still importing. Changes will be visible once '.
	'the import finishes.'));
	} else if (!count($changes)) {
	$info_panel = $this->renderStatusMessage(
	pht('Empty Commit'),
	pht(
	'This commit is empty and does not affect any paths.'));
	} else if ($was_limited) {
	$info_panel = $this->renderStatusMessage(
	pht('Enormous Commit'),
	pht(
	'This commit is enormous, and affects more than %d files. '.
	'Changes are not shown.',
	$hard_limit));
	} else if (!$this->getCommitExists()) {
	$info_panel = $this->renderStatusMessage(
	pht('Commit No Longer Exists'),
	pht('This commit no longer exists in the repository.'));
	} else {
	$show_changesets = true;

	// The user has clicked "Show All Changes", and we should show all the
	// changes inline even if there are more than the soft limit.
	$show_all_details = $request->getBool('show_all');

	$change_header = id(new PHUIHeaderView())
	->setHeader(pht('Changes (%s)', new PhutilNumber($count)));

	$warning_view = null;
	if ($count > self::CHANGES_LIMIT && !$show_all_details) {
	$button = id(new PHUIButtonView())
	->setText(pht('Show All Changes'))
	->setHref('?show_all=true')
	->setTag('a')
	->setIcon('fa-files-o');

	$warning_view = id(new PHUIInfoView())
	->setSeverity(PHUIInfoView::SEVERITY_WARNING)
	->setTitle(pht('Very Large Commit'))
	->appendChild(
	pht('This commit is very large. Load each file individually.'));

	$change_header->addActionLink($button);
	}

	$changesets = DiffusionPathChange::convertToDifferentialChangesets(
	$viewer,
	$changes);

	// TODO: This table and panel shouldn't really be separate, but we need
	// to clean up the "Load All Files" interaction first.
	$change_table = $this->buildTableOfContents(
	$changesets,
	$change_header,
	$warning_view);

	$vcs = $repository->getVersionControlSystem();
	switch ($vcs) {
	case PhabricatorRepositoryType::REPOSITORY_TYPE_SVN:
	$vcs_supports_directory_changes = true;
	break;
	case PhabricatorRepositoryType::REPOSITORY_TYPE_GIT:
	case PhabricatorRepositoryType::REPOSITORY_TYPE_MERCURIAL:
	$vcs_supports_directory_changes = false;
	break;
	default:
	throw new Exception(pht('Unknown VCS.'));
	}

	$references = array();
	foreach ($changesets as $key => $changeset) {
	$file_type = $changeset->getFileType();
	if ($file_type == DifferentialChangeType::FILE_DIRECTORY) {
	if (!$vcs_supports_directory_changes) {
	unset($changesets[$key]);
	continue;
	}
	}

	$references[$key] = $drequest->generateURI(
	array(
	'action' => 'rendering-ref',
	'path' => $changeset->getFilename(),
	));
	}

	// TODO: Some parts of the views still rely on properties of the
	// DifferentialChangeset. Make the objects ephemeral to make sure we don't
	// accidentally save them, and then set their ID to the appropriate ID for
	// this application (the path IDs).
	$path_ids = array_flip(mpull($changes, 'getPath'));
	foreach ($changesets as $changeset) {
	$changeset->makeEphemeral();
	$changeset->setID($path_ids[$changeset->getFilename()]);
	}

	if ($count <= self::CHANGES_LIMIT \|\| $show_all_details) {
	$visible_changesets = $changesets;
	} else {
	$visible_changesets = array();
	$inlines = PhabricatorAuditInlineComment::loadDraftAndPublishedComments(
	$viewer,
	$commit->getPHID());
	$path_ids = mpull($inlines, null, 'getPathID');
	foreach ($changesets as $key => $changeset) {
	if (array_key_exists($changeset->getID(), $path_ids)) {
	$visible_changesets[$key] = $changeset;
	}
	}
	}

	$change_list_title = $commit->getDisplayName();

	$change_list = new DifferentialChangesetListView();
	$change_list->setTitle($change_list_title);
	$change_list->setChangesets($changesets);
	$change_list->setVisibleChangesets($visible_changesets);
	$change_list->setRenderingReferences($references);
	$change_list->setRenderURI($repository->getPathURI('diff/'));
	$change_list->setRepository($repository);
	$change_list->setUser($viewer);
	$change_list->setBackground(PHUIObjectBoxView::BLUE_PROPERTY);

	// TODO: Try to setBranch() to something reasonable here?

	$change_list->setStandaloneURI(
	$repository->getPathURI('diff/'));

	$change_list->setRawFileURIs(
	// TODO: Implement this, somewhat tricky if there's an octopus merge
	// or whatever?
	null,
	$repository->getPathURI('diff/?view=r'));

	$change_list->setInlineCommentControllerURI(
	'/diffusion/inline/edit/'.phutil_escape_uri($commit->getPHID()).'/');

	}

	$add_comment = $this->renderAddCommentPanel(
	$commit,
	$timeline);

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

	$pref_collapse = PhabricatorFiletreeVisibleSetting::SETTINGKEY;
	$collapsed = $viewer->getUserSetting($pref_collapse);

	$nav = null;
	if ($show_changesets && $filetree_on) {
	$nav = id(new DifferentialChangesetFileTreeSideNavBuilder())
	->setTitle($commit->getDisplayName())
	->setBaseURI(new PhutilURI($commit->getURI()))
	->build($changesets)
	->setCrumbs($crumbs)
	->setCollapsed((bool)$collapsed);
	}

	$view = id(new PHUITwoColumnView())
	->setHeader($header)
	->setSubheader($subheader)
	->setMainColumn(array(
	$error_panel,
	$timeline,
	$merge_table,
	$info_panel,
	))
	->setFooter(array(
	$change_table,
	$change_list,
	$add_comment,
	))
	->addPropertySection(pht('Description'), $detail_list)
	->addPropertySection(pht('Details'), $details)
	->setCurtain($curtain);

	$page = $this->newPage()
	->setTitle($commit->getDisplayName())
	->setCrumbs($crumbs)
	->setPageObjectPHIDS(array($commit->getPHID()))
	->appendChild(
	array(
	$view,
	));

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

	return $page;

	}

	private function buildPropertyListView(
	PhabricatorRepositoryCommit $commit,
	PhabricatorRepositoryCommitData $data,
	array $audit_requests) {

	$viewer = $this->getViewer();
	$commit_phid = $commit->getPHID();
	$drequest = $this->getDiffusionRequest();
	$repository = $drequest->getRepository();

	$view = id(new PHUIPropertyListView())
	->setUser($this->getRequest()->getUser());

	$edge_query = id(new PhabricatorEdgeQuery())
	->withSourcePHIDs(array($commit_phid))
	->withEdgeTypes(array(
	DiffusionCommitHasTaskEdgeType::EDGECONST,
	DiffusionCommitHasRevisionEdgeType::EDGECONST,
	DiffusionCommitRevertsCommitEdgeType::EDGECONST,
	DiffusionCommitRevertedByCommitEdgeType::EDGECONST,
	));

	$edges = $edge_query->execute();

	$task_phids = array_keys(
	$edges[$commit_phid][DiffusionCommitHasTaskEdgeType::EDGECONST]);
	$revision_phid = key(
	$edges[$commit_phid][DiffusionCommitHasRevisionEdgeType::EDGECONST]);

	$reverts_phids = array_keys(
	$edges[$commit_phid][DiffusionCommitRevertsCommitEdgeType::EDGECONST]);
	$reverted_by_phids = array_keys(
	$edges[$commit_phid][DiffusionCommitRevertedByCommitEdgeType::EDGECONST]);

	$phids = $edge_query->getDestinationPHIDs(array($commit_phid));

	if ($data->getCommitDetail('authorPHID')) {
	$phids[] = $data->getCommitDetail('authorPHID');
	}
	if ($data->getCommitDetail('reviewerPHID')) {
	$phids[] = $data->getCommitDetail('reviewerPHID');
	}
	if ($data->getCommitDetail('committerPHID')) {
	$phids[] = $data->getCommitDetail('committerPHID');
	}

	// NOTE: We should never normally have more than a single push log, but
	// it can occur naturally if a commit is pushed, then the branch it was
	// on is deleted, then the commit is pushed again (or through other similar
	// chains of events). This should be rare, but does not indicate a bug
	// or data issue.

	// NOTE: We never query push logs in SVN because the commiter is always
	// the pusher and the commit time is always the push time; the push log
	// is redundant and we save a query by skipping it.

	$push_logs = array();
	if ($repository->isHosted() && !$repository->isSVN()) {
	$push_logs = id(new PhabricatorRepositoryPushLogQuery())
	->setViewer($viewer)
	->withRepositoryPHIDs(array($repository->getPHID()))
	->withNewRefs(array($commit->getCommitIdentifier()))
	->withRefTypes(array(PhabricatorRepositoryPushLog::REFTYPE_COMMIT))
	->execute();
	foreach ($push_logs as $log) {
	$phids[] = $log->getPusherPHID();
	}
	}

	$handles = array();
	if ($phids) {
	$handles = $this->loadViewerHandles($phids);
	}

	$props = array();

	if ($audit_requests) {
	$user_requests = array();
	$other_requests = array();

	foreach ($audit_requests as $audit_request) {
	if (!$audit_request->isInteresting()) {
	continue;
	}

	if ($audit_request->isUser()) {
	$user_requests[] = $audit_request;
	} else {
	$other_requests[] = $audit_request;
	}
	}

	if ($user_requests) {
	$view->addProperty(
	pht('Auditors'),
	- $this->renderAuditStatusView($user_requests));
	+ $this->renderAuditStatusView($commit, $user_requests));
	}

	if ($other_requests) {
	$view->addProperty(
	pht('Group Auditors'),
	- $this->renderAuditStatusView($other_requests));
	+ $this->renderAuditStatusView($commit, $other_requests));
	}
	}

	$author_phid = $data->getCommitDetail('authorPHID');
	$author_name = $data->getAuthorName();
	$author_epoch = $data->getCommitDetail('authorEpoch');

	$committed_info = id(new PHUIStatusItemView())
	->setNote(phabricator_datetime($commit->getEpoch(), $viewer));

	$committer_phid = $data->getCommitDetail('committerPHID');
	$committer_name = $data->getCommitDetail('committer');
	if ($committer_phid) {
	$committed_info->setTarget($handles[$committer_phid]->renderLink());
	} else if (strlen($committer_name)) {
	$committed_info->setTarget($committer_name);
	} else if ($author_phid) {
	$committed_info->setTarget($handles[$author_phid]->renderLink());
	} else if (strlen($author_name)) {
	$committed_info->setTarget($author_name);
	}

	$committed_list = new PHUIStatusListView();
	$committed_list->addItem($committed_info);
	$view->addProperty(
	pht('Committed'),
	$committed_list);

	if ($push_logs) {
	$pushed_list = new PHUIStatusListView();

	foreach ($push_logs as $push_log) {
	$pushed_item = id(new PHUIStatusItemView())
	->setTarget($handles[$push_log->getPusherPHID()]->renderLink())
	->setNote(phabricator_datetime($push_log->getEpoch(), $viewer));
	$pushed_list->addItem($pushed_item);
	}

	$view->addProperty(
	pht('Pushed'),
	$pushed_list);
	}

	$reviewer_phid = $data->getCommitDetail('reviewerPHID');
	if ($reviewer_phid) {
	$view->addProperty(
	pht('Reviewer'),
	$handles[$reviewer_phid]->renderLink());
	}

	if ($revision_phid) {
	$view->addProperty(
	pht('Differential Revision'),
	$handles[$revision_phid]->renderLink());
	}

	$parents = $this->getCommitParents();
	if ($parents) {
	$view->addProperty(
	pht('Parents'),
	$viewer->renderHandleList(mpull($parents, 'getPHID')));
	}

	if ($this->getCommitExists()) {
	$view->addProperty(
	pht('Branches'),
	phutil_tag(
	'span',
	array(
	'id' => 'commit-branches',
	),
	pht('Unknown')));

	$view->addProperty(
	pht('Tags'),
	phutil_tag(
	'span',
	array(
	'id' => 'commit-tags',
	),
	pht('Unknown')));

	$identifier = $commit->getCommitIdentifier();
	$root = $repository->getPathURI("commit/{$identifier}");
	Javelin::initBehavior(
	'diffusion-commit-branches',
	array(
	$root.'/branches/' => 'commit-branches',
	$root.'/tags/' => 'commit-tags',
	));
	}

	$refs = $this->getCommitRefs();
	if ($refs) {
	$ref_links = array();
	foreach ($refs as $ref_data) {
	$ref_links[] = phutil_tag(
	'a',
	array(
	'href' => $ref_data['href'],
	),
	$ref_data['ref']);
	}
	$view->addProperty(
	pht('References'),
	phutil_implode_html(', ', $ref_links));
	}

	if ($reverts_phids) {
	$view->addProperty(
	pht('Reverts'),
	$viewer->renderHandleList($reverts_phids));
	}

	if ($reverted_by_phids) {
	$view->addProperty(
	pht('Reverted By'),
	$viewer->renderHandleList($reverted_by_phids));
	}

	if ($task_phids) {
	$task_list = array();
	foreach ($task_phids as $phid) {
	$task_list[] = $handles[$phid]->renderLink();
	}
	$task_list = phutil_implode_html(phutil_tag('br'), $task_list);
	$view->addProperty(
	pht('Tasks'),
	$task_list);
	}

	return $view;
	}

	private function buildSubheaderView(
	PhabricatorRepositoryCommit $commit,
	PhabricatorRepositoryCommitData $data) {

	$viewer = $this->getViewer();
	$drequest = $this->getDiffusionRequest();
	$repository = $drequest->getRepository();

	if ($repository->isSVN()) {
	return null;
	}

	$author_phid = $data->getCommitDetail('authorPHID');
	$author_name = $data->getAuthorName();
	$author_epoch = $data->getCommitDetail('authorEpoch');
	$date = null;
	if ($author_epoch !== null) {
	$date = phabricator_datetime($author_epoch, $viewer);
	}

	if ($author_phid) {
	$handles = $viewer->loadHandles(array($author_phid));
	$image_uri = $handles[$author_phid]->getImageURI();
	$image_href = $handles[$author_phid]->getURI();
	$author = $handles[$author_phid]->renderLink();
	} else if (strlen($author_name)) {
	$author = $author_name;
	$image_uri = null;
	$image_href = null;
	} else {
	return null;
	}

	$author = phutil_tag('strong', array(), $author);
	if ($date) {
	$content = pht('Authored by %s on %s.', $author, $date);
	} else {
	$content = pht('Authored by %s.', $author);
	}

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

	}


	private function buildComments(PhabricatorRepositoryCommit $commit) {
	$timeline = $this->buildTransactionTimeline(
	$commit,
	new PhabricatorAuditTransactionQuery());
	$commit->willRenderTimeline($timeline, $this->getRequest());
	return $timeline;
	}

	private function renderAddCommentPanel(
	PhabricatorRepositoryCommit $commit,
	$timeline) {

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

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

	// TODO: This is pretty awkward, unify the CSS between Diffusion and
	// Differential better.
	require_celerity_resource('differential-core-view-css');

	$comment_view = id(new DiffusionCommitEditEngine())
	->setViewer($viewer)
	->buildEditEngineCommentView($commit);

	$comment_view->setTransactionTimeline($timeline);

	return $comment_view;
	}

	private function buildMergesTable(PhabricatorRepositoryCommit $commit) {
	$viewer = $this->getViewer();
	$drequest = $this->getDiffusionRequest();
	$repository = $drequest->getRepository();

	$merges = $this->getCommitMerges();
	if (!$merges) {
	return null;
	}

	$limit = $this->getMergeDisplayLimit();

	$caption = null;
	if (count($merges) > $limit) {
	$merges = array_slice($merges, 0, $limit);
	$caption = new PHUIInfoView();
	$caption->setSeverity(PHUIInfoView::SEVERITY_NOTICE);
	$caption->appendChild(
	pht(
	'This commit merges a very large number of changes. '.
	'Only the first %s are shown.',
	new PhutilNumber($limit)));
	}

	$history_table = id(new DiffusionHistoryTableView())
	->setUser($viewer)
	->setDiffusionRequest($drequest)
	->setHistory($merges);

	$history_table->loadRevisions();

	$panel = id(new PHUIObjectBoxView())
	->setHeaderText(pht('Merged Changes'))
	->setBackground(PHUIObjectBoxView::BLUE_PROPERTY)
	->setTable($history_table);
	if ($caption) {
	$panel->setInfoView($caption);
	}

	return $panel;
	}

	private function buildCurtain(
	PhabricatorRepositoryCommit $commit,
	PhabricatorRepository $repository) {

	$request = $this->getRequest();
	$viewer = $this->getViewer();
	$curtain = $this->newCurtainView($commit);

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

	$id = $commit->getID();
	$edit_uri = $this->getApplicationURI("/commit/edit/{$id}/");

	$action = id(new PhabricatorActionView())
	->setName(pht('Edit Commit'))
	->setHref($edit_uri)
	->setIcon('fa-pencil')
	->setDisabled(!$can_edit)
	->setWorkflow(!$can_edit);
	$curtain->addAction($action);

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

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

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

	return $curtain;
	}

	private function buildRawDiffResponse(DiffusionRequest $drequest) {
	$diff_info = $this->callConduitWithDiffusionRequest(
	'diffusion.rawdiffquery',
	array(
	'commit' => $drequest->getCommit(),
	'path' => $drequest->getPath(),
	));

	$file_phid = $diff_info['filePHID'];

	$file = id(new PhabricatorFileQuery())
	->setViewer($this->getViewer())
	->withPHIDs(array($file_phid))
	->executeOne();
	if (!$file) {
	throw new Exception(
	pht(
	'Failed to load file ("%s") returned by "%s".',
	$file_phid,
	'diffusion.rawdiffquery'));
	}

	return $file->getRedirectResponse();
	}

	- private function renderAuditStatusView(array $audit_requests) {
	+ private function renderAuditStatusView(
	+ PhabricatorRepositoryCommit $commit,
	+ array $audit_requests) {
	assert_instances_of($audit_requests, 'PhabricatorRepositoryAuditRequest');
	$viewer = $this->getViewer();

	- $authority_map = array_fill_keys($this->auditAuthorityPHIDs, true);
	-
	$view = new PHUIStatusListView();
	foreach ($audit_requests as $request) {
	$code = $request->getAuditStatus();
	$item = new PHUIStatusItemView();
	$item->setIcon(
	PhabricatorAuditStatusConstants::getStatusIcon($code),
	PhabricatorAuditStatusConstants::getStatusColor($code),
	PhabricatorAuditStatusConstants::getStatusName($code));

	$note = array();
	foreach ($request->getAuditReasons() as $reason) {
	$note[] = phutil_tag('div', array(), $reason);
	}
	$item->setNote($note);

	$auditor_phid = $request->getAuditorPHID();
	$target = $viewer->renderHandle($auditor_phid);
	$item->setTarget($target);

	- if (isset($authority_map[$auditor_phid])) {
	+ if ($commit->hasAuditAuthority($viewer, $request)) {
	$item->setHighlighted(true);
	}

	$view->addItem($item);
	}

	return $view;
	}

	private function linkBugtraq($corpus) {
	$url = PhabricatorEnv::getEnvConfig('bugtraq.url');
	if (!strlen($url)) {
	return $corpus;
	}

	$regexes = PhabricatorEnv::getEnvConfig('bugtraq.logregex');
	if (!$regexes) {
	return $corpus;
	}

	$parser = id(new PhutilBugtraqParser())
	->setBugtraqPattern("[[ {$url} \| %BUGID% ]]")
	->setBugtraqCaptureExpression(array_shift($regexes));

	$select = array_shift($regexes);
	if ($select) {
	$parser->setBugtraqSelectExpression($select);
	}

	return $parser->processCorpus($corpus);
	}

	private function buildTableOfContents(
	array $changesets,
	$header,
	$info_view) {

	$drequest = $this->getDiffusionRequest();
	$viewer = $this->getViewer();

	$toc_view = id(new PHUIDiffTableOfContentsListView())
	->setUser($viewer)
	->setHeader($header)
	->setBackground(PHUIObjectBoxView::BLUE_PROPERTY);

	if ($info_view) {
	$toc_view->setInfoView($info_view);
	}

	// TODO: This is hacky, we just want access to the linkX() methods on
	// DiffusionView.
	$diffusion_view = id(new DiffusionEmptyResultView())
	->setDiffusionRequest($drequest);

	$have_owners = PhabricatorApplication::isClassInstalledForViewer(
	'PhabricatorOwnersApplication',
	$viewer);

	if (!$changesets) {
	$have_owners = false;
	}

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

	$repository = $drequest->getRepository();
	$repository_phid = $repository->getPHID();

	$control_query = id(new PhabricatorOwnersPackageQuery())
	->setViewer($viewer)
	->withStatuses(array(PhabricatorOwnersPackage::STATUS_ACTIVE))
	->withControl($repository_phid, mpull($changesets, 'getFilename'));
	$control_query->execute();
	}

	foreach ($changesets as $changeset_id => $changeset) {
	$path = $changeset->getFilename();
	$anchor = substr(md5($path), 0, 8);

	$history_link = $diffusion_view->linkHistory($path);
	$browse_link = $diffusion_view->linkBrowse(
	$path,
	array(
	'type' => $changeset->getFileType(),
	));

	$item = id(new PHUIDiffTableOfContentsItemView())
	->setChangeset($changeset)
	->setAnchor($anchor)
	->setContext(
	array(
	$history_link,
	' ',
	$browse_link,
	));

	if ($have_owners) {
	$packages = $control_query->getControllingPackagesForPath(
	$repository_phid,
	$changeset->getFilename());
	$item->setPackages($packages);
	}

	$toc_view->addItem($item);
	}

	return $toc_view;
	}

	private function loadCommitState() {
	$viewer = $this->getViewer();
	$drequest = $this->getDiffusionRequest();
	$repository = $drequest->getRepository();
	$commit = $drequest->getCommit();

	// TODO: We could use futures here and resolve these calls in parallel.

	$exceptions = array();

	try {
	$parent_refs = $this->callConduitWithDiffusionRequest(
	'diffusion.commitparentsquery',
	array(
	'commit' => $commit,
	));

	if ($parent_refs) {
	$parents = id(new DiffusionCommitQuery())
	->setViewer($viewer)
	->withRepository($repository)
	->withIdentifiers($parent_refs)
	->execute();
	} else {
	$parents = array();
	}

	$this->commitParents = $parents;
	} catch (Exception $ex) {
	$this->commitParents = false;
	$exceptions[] = $ex;
	}

	$merge_limit = $this->getMergeDisplayLimit();

	try {
	if ($repository->isSVN()) {
	$this->commitMerges = array();
	} else {
	$merges = $this->callConduitWithDiffusionRequest(
	'diffusion.mergedcommitsquery',
	array(
	'commit' => $commit,
	'limit' => $merge_limit + 1,
	));
	$this->commitMerges = DiffusionPathChange::newFromConduit($merges);
	}
	} catch (Exception $ex) {
	$this->commitMerges = false;
	$exceptions[] = $ex;
	}


	try {
	if ($repository->isGit()) {
	$refs = $this->callConduitWithDiffusionRequest(
	'diffusion.refsquery',
	array(
	'commit' => $commit,
	));
	} else {
	$refs = array();
	}

	$this->commitRefs = $refs;
	} catch (Exception $ex) {
	$this->commitRefs = false;
	$exceptions[] = $ex;
	}

	if ($exceptions) {
	$exists = $this->callConduitWithDiffusionRequest(
	'diffusion.existsquery',
	array(
	'commit' => $commit,
	));

	if ($exists) {
	$this->commitExists = true;
	foreach ($exceptions as $exception) {
	$this->commitErrors[] = $exception->getMessage();
	}
	} else {
	$this->commitExists = false;
	$this->commitErrors[] = pht(
	'This commit no longer exists in the repository. It may have '.
	'been part of a branch which was deleted.');
	}
	} else {
	$this->commitExists = true;
	$this->commitErrors = array();
	}
	}

	private function getMergeDisplayLimit() {
	return 50;
	}

	private function getCommitExists() {
	if ($this->commitExists === null) {
	$this->loadCommitState();
	}

	return $this->commitExists;
	}

	private function getCommitParents() {
	if ($this->commitParents === null) {
	$this->loadCommitState();
	}

	return $this->commitParents;
	}

	private function getCommitRefs() {
	if ($this->commitRefs === null) {
	$this->loadCommitState();
	}

	return $this->commitRefs;
	}

	private function getCommitMerges() {
	if ($this->commitMerges === null) {
	$this->loadCommitState();
	}

	return $this->commitMerges;
	}

	private function getCommitErrors() {
	if ($this->commitErrors === null) {
	$this->loadCommitState();
	}

	return $this->commitErrors;
	}


	}
	diff --git a/src/applications/diffusion/xaction/DiffusionCommitAuditTransaction.php b/src/applications/diffusion/xaction/DiffusionCommitAuditTransaction.php
	index 86656d85a6..99d2ebb1d2 100644
	--- a/src/applications/diffusion/xaction/DiffusionCommitAuditTransaction.php
	+++ b/src/applications/diffusion/xaction/DiffusionCommitAuditTransaction.php
	@@ -1,118 +1,117 @@
	<?php

	abstract class DiffusionCommitAuditTransaction
	extends DiffusionCommitActionTransaction {

	protected function getCommitActionGroupKey() {
	return DiffusionCommitEditEngine::ACTIONGROUP_AUDIT;
	}

	protected function isViewerAnyAuditor(
	PhabricatorRepositoryCommit $commit,
	PhabricatorUser $viewer) {
	return ($this->getViewerAuditStatus($commit, $viewer) !== null);
	}

	protected function isViewerAnyActiveAuditor(
	PhabricatorRepositoryCommit $commit,
	PhabricatorUser $viewer) {

	// This omits various inactive states like "Resigned" and "Not Required".

	return $this->isViewerAuditStatusAmong(
	$commit,
	$viewer,
	array(
	PhabricatorAuditStatusConstants::AUDIT_REQUIRED,
	PhabricatorAuditStatusConstants::CONCERNED,
	PhabricatorAuditStatusConstants::ACCEPTED,
	PhabricatorAuditStatusConstants::AUDIT_REQUESTED,
	));
	}

	protected function isViewerAcceptingAuditor(
	PhabricatorRepositoryCommit $commit,
	PhabricatorUser $viewer) {
	return $this->isViewerAuditStatusAmong(
	$commit,
	$viewer,
	array(
	PhabricatorAuditStatusConstants::ACCEPTED,
	));
	}

	protected function isViewerRejectingAuditor(
	PhabricatorRepositoryCommit $commit,
	PhabricatorUser $viewer) {
	return $this->isViewerAuditStatusAmong(
	$commit,
	$viewer,
	array(
	PhabricatorAuditStatusConstants::CONCERNED,
	));
	}

	protected function getViewerAuditStatus(
	PhabricatorRepositoryCommit $commit,
	PhabricatorUser $viewer) {

	if (!$viewer->getPHID()) {
	return null;
	}

	foreach ($commit->getAudits() as $audit) {
	if ($audit->getAuditorPHID() != $viewer->getPHID()) {
	continue;
	}

	return $audit->getAuditStatus();
	}

	return null;
	}

	protected function isViewerAuditStatusAmong(
	PhabricatorRepositoryCommit $commit,
	PhabricatorUser $viewer,
	array $status_list) {

	$status = $this->getViewerAuditStatus($commit, $viewer);
	if ($status === null) {
	return false;
	}

	$status_map = array_fuse($status_list);
	return isset($status_map[$status]);
	}

	protected function applyAuditorEffect(
	PhabricatorRepositoryCommit $commit,
	PhabricatorUser $viewer,
	$value,
	$status) {

	+ $actor = $this->getActor();
	+ $acting_phid = $this->getActingAsPHID();
	+
	$audits = $commit->getAudits();
	$audits = mpull($audits, null, 'getAuditorPHID');

	$map = array();

	$with_authority = ($status != PhabricatorAuditStatusConstants::RESIGNED);
	if ($with_authority) {
	- $has_authority = PhabricatorAuditCommentEditor::loadAuditPHIDsForUser(
	- $viewer);
	- $has_authority = array_fuse($has_authority);
	foreach ($audits as $audit) {
	- $auditor_phid = $audit->getAuditorPHID();
	- if (isset($has_authority[$auditor_phid])) {
	- $map[$auditor_phid] = $status;
	+ if ($commit->hasAuditAuthority($actor, $audit, $acting_phid)) {
	+ $map[$audit->getAuditorPHID()] = $status;
	}
	}
	}

	// In all cases, you affect yourself.
	$map[$viewer->getPHID()] = $status;

	$this->updateAudits($commit, $map);
	}

	}
	diff --git a/src/applications/repository/storage/PhabricatorRepositoryCommit.php b/src/applications/repository/storage/PhabricatorRepositoryCommit.php
	index 7f617069ec..3536cfbd0d 100644
	--- a/src/applications/repository/storage/PhabricatorRepositoryCommit.php
	+++ b/src/applications/repository/storage/PhabricatorRepositoryCommit.php
	@@ -1,625 +1,681 @@
	<?php

	final class PhabricatorRepositoryCommit
	extends PhabricatorRepositoryDAO
	implements
	PhabricatorPolicyInterface,
	PhabricatorFlaggableInterface,
	PhabricatorProjectInterface,
	PhabricatorTokenReceiverInterface,
	PhabricatorSubscribableInterface,
	PhabricatorMentionableInterface,
	HarbormasterBuildableInterface,
	HarbormasterCircleCIBuildableInterface,
	PhabricatorCustomFieldInterface,
	PhabricatorApplicationTransactionInterface,
	PhabricatorFulltextInterface,
	PhabricatorConduitResultInterface,
	PhabricatorDraftInterface {

	protected $repositoryID;
	protected $phid;
	protected $commitIdentifier;
	protected $epoch;
	protected $mailKey;
	protected $authorPHID;
	protected $auditStatus = PhabricatorAuditCommitStatusConstants::NONE;
	protected $summary = '';
	protected $importStatus = 0;

	const IMPORTED_MESSAGE = 1;
	const IMPORTED_CHANGE = 2;
	const IMPORTED_OWNERS = 4;
	const IMPORTED_HERALD = 8;
	const IMPORTED_ALL = 15;

	const IMPORTED_CLOSEABLE = 1024;
	const IMPORTED_UNREACHABLE = 2048;

	private $commitData = self::ATTACHABLE;
	private $audits = self::ATTACHABLE;
	private $repository = self::ATTACHABLE;
	private $customFields = self::ATTACHABLE;
	private $drafts = array();
	+ private $auditAuthorityPHIDs = array();

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

	public function getRepository($assert_attached = true) {
	if ($assert_attached) {
	return $this->assertAttached($this->repository);
	}
	return $this->repository;
	}

	public function isPartiallyImported($mask) {
	return (($mask & $this->getImportStatus()) == $mask);
	}

	public function isImported() {
	return $this->isPartiallyImported(self::IMPORTED_ALL);
	}

	public function isUnreachable() {
	return $this->isPartiallyImported(self::IMPORTED_UNREACHABLE);
	}

	public function writeImportStatusFlag($flag) {
	return $this->adjustImportStatusFlag($flag, true);
	}

	public function clearImportStatusFlag($flag) {
	return $this->adjustImportStatusFlag($flag, false);
	}

	private function adjustImportStatusFlag($flag, $set) {
	$conn_w = $this->establishConnection('w');
	$table_name = $this->getTableName();
	$id = $this->getID();

	if ($set) {
	queryfx(
	$conn_w,
	'UPDATE %T SET importStatus = (importStatus \| %d) WHERE id = %d',
	$table_name,
	$flag,
	$id);

	$this->setImportStatus($this->getImportStatus() \| $flag);
	} else {
	queryfx(
	$conn_w,
	'UPDATE %T SET importStatus = (importStatus & ~%d) WHERE id = %d',
	$table_name,
	$flag,
	$id);

	$this->setImportStatus($this->getImportStatus() & ~$flag);
	}

	return $this;
	}

	protected function getConfiguration() {
	return array(
	self::CONFIG_AUX_PHID => true,
	self::CONFIG_TIMESTAMPS => false,
	self::CONFIG_COLUMN_SCHEMA => array(
	'commitIdentifier' => 'text40',
	'mailKey' => 'bytes20',
	'authorPHID' => 'phid?',
	'auditStatus' => 'uint32',
	'summary' => 'text255',
	'importStatus' => 'uint32',
	),
	self::CONFIG_KEY_SCHEMA => array(
	'key_phid' => null,
	'phid' => array(
	'columns' => array('phid'),
	'unique' => true,
	),
	'repositoryID' => array(
	'columns' => array('repositoryID', 'importStatus'),
	),
	'authorPHID' => array(
	'columns' => array('authorPHID', 'auditStatus', 'epoch'),
	),
	'repositoryID_2' => array(
	'columns' => array('repositoryID', 'epoch'),
	),
	'key_commit_identity' => array(
	'columns' => array('commitIdentifier', 'repositoryID'),
	'unique' => true,
	),
	'key_epoch' => array(
	'columns' => array('epoch'),
	),
	'key_author' => array(
	'columns' => array('authorPHID', 'epoch'),
	),
	),
	self::CONFIG_NO_MUTATE => array(
	'importStatus',
	),
	) + parent::getConfiguration();
	}

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

	public function loadCommitData() {
	if (!$this->getID()) {
	return null;
	}
	return id(new PhabricatorRepositoryCommitData())->loadOneWhere(
	'commitID = %d',
	$this->getID());
	}

	public function attachCommitData(
	PhabricatorRepositoryCommitData $data = null) {
	$this->commitData = $data;
	return $this;
	}

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

	public function attachAudits(array $audits) {
	assert_instances_of($audits, 'PhabricatorRepositoryAuditRequest');
	$this->audits = $audits;
	return $this;
	}

	public function getAudits() {
	return $this->assertAttached($this->audits);
	}

	- public function getAuthorityAudits(
	- PhabricatorUser $user,
	- array $authority_phids) {
	+ public function loadAndAttachAuditAuthority(
	+ PhabricatorUser $viewer,
	+ $actor_phid = null) {

	- $authority = array_fill_keys($authority_phids, true);
	- $audits = $this->getAudits();
	- $authority_audits = array();
	- foreach ($audits as $audit) {
	- $has_authority = !empty($authority[$audit->getAuditorPHID()]);
	- if ($has_authority) {
	- $commit_author = $this->getAuthorPHID();
	+ if ($actor_phid === null) {
	+ $actor_phid = $viewer->getPHID();
	+ }
	+
	+ // TODO: This method is a little weird and sketchy, but worlds better than
	+ // what came before it. Eventually, this should probably live in a Query
	+ // class.

	- // You don't have authority over package and project audits on your
	- // own commits.
	+ // Figure out which requests the actor has authority over: these are user
	+ // requests where they are the auditor, and packages and projects they are
	+ // a member of.

	- $auditor_is_user = ($audit->getAuditorPHID() == $user->getPHID());
	- $user_is_author = ($commit_author == $user->getPHID());
	+ if (!$actor_phid) {
	+ $attach_key = $viewer->getCacheFragment();
	+ $phids = array();
	+ } else {
	+ $attach_key = $actor_phid;
	+ // At least currently, when modifying your own commits, you act only on
	+ // behalf of yourself, not your packages/projects -- the idea being that
	+ // you can't accept your own commits. This may change or depend on
	+ // config.
	+ $actor_is_author = ($actor_phid == $this->getAuthorPHID());
	+ if ($actor_is_author) {
	+ $phids = array($actor_phid);
	+ } else {
	+ $phids = array();
	+ $phids[$actor_phid] = true;
	+
	+ $owned_packages = id(new PhabricatorOwnersPackageQuery())
	+ ->setViewer($viewer)
	+ ->withAuthorityPHIDs(array($actor_phid))
	+ ->execute();
	+ foreach ($owned_packages as $package) {
	+ $phids[$package->getPHID()] = true;
	+ }

	- if ($auditor_is_user \|\| !$user_is_author) {
	- $authority_audits[$audit->getID()] = $audit;
	+ $projects = id(new PhabricatorProjectQuery())
	+ ->setViewer($viewer)
	+ ->withMemberPHIDs(array($actor_phid))
	+ ->execute();
	+ foreach ($projects as $project) {
	+ $phids[$project->getPHID()] = true;
	}
	+
	+ $phids = array_keys($phids);
	}
	}
	- return $authority_audits;
	+
	+ $this->auditAuthorityPHIDs[$attach_key] = array_fuse($phids);
	+
	+ return $this;
	+ }
	+
	+ public function hasAuditAuthority(
	+ PhabricatorUser $viewer,
	+ PhabricatorRepositoryAuditRequest $audit,
	+ $actor_phid = null) {
	+
	+ if ($actor_phid === null) {
	+ $actor_phid = $viewer->getPHID();
	+ }
	+
	+ if (!$actor_phid) {
	+ $attach_key = $viewer->getCacheFragment();
	+ } else {
	+ $attach_key = $actor_phid;
	+ }
	+
	+ $map = $this->assertAttachedKey($this->auditAuthorityPHIDs, $attach_key);
	+
	+ if (!$actor_phid) {
	+ return false;
	+ }
	+
	+ return isset($map[$audit->getAuditorPHID()]);
	}

	public function getAuditorPHIDsForEdit() {
	$audits = $this->getAudits();
	return mpull($audits, 'getAuditorPHID');
	}

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

	public function delete() {
	$data = $this->loadCommitData();
	$audits = id(new PhabricatorRepositoryAuditRequest())
	->loadAllWhere('commitPHID = %s', $this->getPHID());
	$this->openTransaction();

	if ($data) {
	$data->delete();
	}
	foreach ($audits as $audit) {
	$audit->delete();
	}
	$result = parent::delete();

	$this->saveTransaction();
	return $result;
	}

	public function getDateCreated() {
	// This is primarily to make analysis of commits with the Fact engine work.
	return $this->getEpoch();
	}

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

	/**
	* Synchronize a commit's overall audit status with the individual audit
	* triggers.
	*/
	public function updateAuditStatus(array $requests) {
	assert_instances_of($requests, 'PhabricatorRepositoryAuditRequest');

	$any_concern = false;
	$any_accept = false;
	$any_need = false;

	foreach ($requests as $request) {
	switch ($request->getAuditStatus()) {
	case PhabricatorAuditStatusConstants::AUDIT_REQUIRED:
	case PhabricatorAuditStatusConstants::AUDIT_REQUESTED:
	$any_need = true;
	break;
	case PhabricatorAuditStatusConstants::ACCEPTED:
	$any_accept = true;
	break;
	case PhabricatorAuditStatusConstants::CONCERNED:
	$any_concern = true;
	break;
	}
	}

	if ($any_concern) {
	$status = PhabricatorAuditCommitStatusConstants::CONCERN_RAISED;
	} else if ($any_accept) {
	if ($any_need) {
	$status = PhabricatorAuditCommitStatusConstants::PARTIALLY_AUDITED;
	} else {
	$status = PhabricatorAuditCommitStatusConstants::FULLY_AUDITED;
	}
	} else if ($any_need) {
	$status = PhabricatorAuditCommitStatusConstants::NEEDS_AUDIT;
	} else {
	$status = PhabricatorAuditCommitStatusConstants::NONE;
	}

	return $this->setAuditStatus($status);
	}

	public function getMonogram() {
	$repository = $this->getRepository();
	$callsign = $repository->getCallsign();
	$identifier = $this->getCommitIdentifier();
	if ($callsign !== null) {
	return "r{$callsign}{$identifier}";
	} else {
	$id = $repository->getID();
	return "R{$id}:{$identifier}";
	}
	}

	public function getDisplayName() {
	$repository = $this->getRepository();
	$identifier = $this->getCommitIdentifier();
	return $repository->formatCommitName($identifier);
	}

	/**
	* Return a local display name for use in the context of the containing
	* repository.
	*
	* In Git and Mercurial, this returns only a short hash, like "abcdef012345".
	* See @{method:getDisplayName} for a short name that always includes
	* repository context.
	*
	* @return string Short human-readable name for use inside a repository.
	*/
	public function getLocalName() {
	$repository = $this->getRepository();
	$identifier = $this->getCommitIdentifier();
	return $repository->formatCommitName($identifier, $local = true);
	}

	public function renderAuthorLink($handles) {
	$author_phid = $this->getAuthorPHID();
	if ($author_phid && isset($handles[$author_phid])) {
	return $handles[$author_phid]->renderLink();
	}

	return $this->renderAuthorShortName($handles);
	}

	public function renderAuthorShortName($handles) {
	$author_phid = $this->getAuthorPHID();
	if ($author_phid && isset($handles[$author_phid])) {
	return $handles[$author_phid]->getName();
	}

	$data = $this->getCommitData();
	$name = $data->getAuthorName();

	$parsed = new PhutilEmailAddress($name);
	return nonempty($parsed->getDisplayName(), $parsed->getAddress());
	}


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

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

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

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

	public function describeAutomaticCapability($capability) {
	return pht(
	'Commits inherit the policies of the repository they belong to.');
	}


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

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

	/* -( Stuff for serialization )---------------------------------------------- */

	/**
	* NOTE: this is not a complete serialization; only the 'protected' fields are
	* involved. This is due to ease of (ab)using the Lisk abstraction to get this
	* done, as well as complexity of the other fields.
	*/
	public function toDictionary() {
	return array(
	'repositoryID' => $this->getRepositoryID(),
	'phid' => $this->getPHID(),
	'commitIdentifier' => $this->getCommitIdentifier(),
	'epoch' => $this->getEpoch(),
	'mailKey' => $this->getMailKey(),
	'authorPHID' => $this->getAuthorPHID(),
	'auditStatus' => $this->getAuditStatus(),
	'summary' => $this->getSummary(),
	'importStatus' => $this->getImportStatus(),
	);
	}

	public static function newFromDictionary(array $dict) {
	return id(new PhabricatorRepositoryCommit())
	->loadFromArray($dict);
	}


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


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

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

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

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

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

	$results['buildable.commit'] = $this->getCommitIdentifier();
	$repo = $this->getRepository();

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

	return $results;
	}

	public function getAvailableBuildVariables() {
	return array(
	'buildable.commit' => pht('The commit identifier, 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.'),
	);
	}


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


	public function getCircleCIGitHubRepositoryURI() {
	$repository = $this->getRepository();

	$commit_phid = $this->getPHID();
	$repository_phid = $repository->getPHID();

	if ($repository->isHosted()) {
	throw new Exception(
	pht(
	'This commit ("%s") is associated with a hosted repository '.
	'("%s"). Repositories must be imported from GitHub to be built '.
	'with CircleCI.',
	$commit_phid,
	$repository_phid));
	}

	$remote_uri = $repository->getRemoteURI();
	$path = HarbormasterCircleCIBuildStepImplementation::getGitHubPath(
	$remote_uri);
	if (!$path) {
	throw new Exception(
	pht(
	'This commit ("%s") is associated with a repository ("%s") that '.
	'with a remote URI ("%s") that does not appear to be hosted on '.
	'GitHub. Repositories must be hosted on GitHub to be built with '.
	'CircleCI.',
	$commit_phid,
	$repository_phid,
	$remote_uri));
	}

	return $remote_uri;
	}

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

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


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


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

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

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

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


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


	public function isAutomaticallySubscribed($phid) {

	// TODO: This should also list auditors, but handling that is a bit messy
	// right now because we are not guaranteed to have the data.

	return ($phid == $this->getAuthorPHID());
	}


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


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

	public function getApplicationTransactionObject() {
	return $this;
	}

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

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

	$xactions = $timeline->getTransactions();

	$path_ids = array();
	foreach ($xactions as $xaction) {
	if ($xaction->hasComment()) {
	$path_id = $xaction->getComment()->getPathID();
	if ($path_id) {
	$path_ids[] = $path_id;
	}
	}
	}

	$path_map = array();
	if ($path_ids) {
	$path_map = id(new DiffusionPathQuery())
	->withPathIDs($path_ids)
	->execute();
	$path_map = ipull($path_map, 'path', 'id');
	}

	return $timeline->setPathMap($path_map);
	}

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


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


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

	public function getFieldSpecificationsForConduit() {
	return array(
	id(new PhabricatorConduitSearchFieldSpecification())
	->setKey('identifier')
	->setType('string')
	->setDescription(pht('The commit identifier.')),
	);
	}

	public function getFieldValuesForConduit() {
	return array(
	'identifier' => $this->getCommitIdentifier(),
	);
	}

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


	/* -( PhabricatorDraftInterface )------------------------------------------ */

	public function newDraftEngine() {
	return new DiffusionCommitDraftEngine();
	}

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

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

	}

File Metadata

Mime Type: text/x-diff
Expires: Sun, Mar 16, 12:11 AM (1 d, 11 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 72123
Default Alt Text: (87 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions