No OneTemporary
Actions

Size

59 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/src/applications/differential/controller/DifferentialController.php b/src/applications/differential/controller/DifferentialController.php
	index 0ae33f4e59..eed059e265 100644
	--- a/src/applications/differential/controller/DifferentialController.php
	+++ b/src/applications/differential/controller/DifferentialController.php
	@@ -1,53 +1,95 @@
	<?php

	abstract class DifferentialController extends PhabricatorController {

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

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

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

	$nav->selectFilter(null);

	return $nav;
	}

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

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

	$toc_view = id(new PHUIDiffTableOfContentsListView())
	->setUser($viewer);

	+ $have_owners = PhabricatorApplication::isClassInstalledForViewer(
	+ 'PhabricatorOwnersApplication',
	+ $viewer);
	+ if ($have_owners) {
	+ $repository_phid = null;
	+ if ($changesets) {
	+ $changeset = head($changesets);
	+ $diff = $changeset->getDiff();
	+ $repository_phid = $diff->getRepositoryPHID();
	+ }
	+
	+ if (!$repository_phid) {
	+ $have_owners = false;
	+ } else {
	+ if ($viewer->getPHID()) {
	+ $packages = id(new PhabricatorOwnersPackageQuery())
	+ ->setViewer($viewer)
	+ ->withAuthorityPHIDs(array($viewer->getPHID()))
	+ ->execute();
	+ $toc_view->setAuthorityPackages($packages);
	+ }
	+
	+ // TODO: For Subversion, we should adjust these paths to be relative to
	+ // the repository root where possible.
	+ $paths = mpull($changesets, 'getFilename');
	+
	+ $control_query = id(new PhabricatorOwnersPackageQuery())
	+ ->setViewer($viewer)
	+ ->withControl($repository_phid, $paths);
	+ $control_query->execute();
	+ }
	+ }
	+
	foreach ($changesets as $changeset_id => $changeset) {
	$is_visible = isset($visible_changesets[$changeset_id]);
	$anchor = $changeset->getAnchorName();

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

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

	+ if ($have_owners) {
	+ $package = $control_query->getControllingPackageForPath(
	+ $repository_phid,
	+ $changeset->getFilename());
	+ if ($package) {
	+ $item->setPackage($package);
	+ }
	+ }
	+
	$toc_view->addItem($item);
	}

	return $toc_view;
	}

	}
	diff --git a/src/applications/differential/storage/DifferentialDiff.php b/src/applications/differential/storage/DifferentialDiff.php
	index e48ed5630d..7a5bc24203 100644
	--- a/src/applications/differential/storage/DifferentialDiff.php
	+++ b/src/applications/differential/storage/DifferentialDiff.php
	@@ -1,510 +1,516 @@
	<?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 $creationMethod;
	protected $repositoryUUID;

	protected $description;

	protected $viewPolicy;

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

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

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

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

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

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

	return $diff;
	}

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

	assert_instances_of($changes, 'ArcanistDiffChange');

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

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

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

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

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

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

	$changeset = new DifferentialChangeset();
	$add_lines = 0;
	$del_lines = 0;
	$first_line = PHP_INT_MAX;
	$hunks = $change->getHunks();
	if ($hunks) {
	foreach ($hunks as $hunk) {
	$dhunk = new DifferentialModernHunk();
	$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(),
	);

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

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

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

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

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

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

	return $target_phids;
	}

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

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

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

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

	return $map;
	}

	/* -( 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();
	if ($this->revisionID) {
	$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/DiffusionCommitController.php b/src/applications/diffusion/controller/DiffusionCommitController.php
	index 927ad7f453..b91a7dc804 100644
	--- a/src/applications/diffusion/controller/DiffusionCommitController.php
	+++ b/src/applications/diffusion/controller/DiffusionCommitController.php
	@@ -1,1104 +1,1138 @@
	<?php

	final class DiffusionCommitController extends DiffusionController {

	const CHANGES_LIMIT = 100;

	private $auditAuthorityPHIDs;
	private $highlightedAudits;

	public function shouldAllowPublic() {
	return true;
	}

	protected function shouldLoadDiffusionRequest() {
	return false;
	}

	protected function processDiffusionRequest(AphrontRequest $request) {
	$user = $request->getUser();
	// This controller doesn't use blob/path stuff, just pass the dictionary
	// in directly instead of using the AphrontRequest parsing mechanism.
	$data = $request->getURIMap();
	$data['user'] = $user;
	$drequest = DiffusionRequest::newFromDictionary($data);
	$this->diffusionRequest = $drequest;

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

	$repository = $drequest->getRepository();
	$callsign = $repository->getCallsign();

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

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

	if (!$commit) {
	$exists = $this->callConduitWithDiffusionRequest(
	'diffusion.existsquery',
	array('commit' => $drequest->getCommit()));
	if (!$exists) {
	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.'));

	return $this->buildApplicationPage(
	array(
	$crumbs,
	$error,
	),
	array(
	'title' => pht('Commit Still Parsing'),
	));
	}

	$audit_requests = $commit->getAudits();
	$this->auditAuthorityPHIDs =
	PhabricatorAuditCommentEditor::loadAuditPHIDsForUser($user);

	$commit_data = $commit->getCommitData();
	$is_foreign = $commit_data->getCommitDetail('foreign-svn-stub');
	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));
	$content[] = $error_panel;
	} else {
	$engine = PhabricatorMarkupEngine::newDifferentialMarkupEngine();
	$engine->setConfig('viewer', $user);

	require_celerity_resource('phabricator-remarkup-css');

	$parents = $this->callConduitWithDiffusionRequest(
	'diffusion.commitparentsquery',
	array('commit' => $drequest->getCommit()));

	if ($parents) {
	$parents = id(new DiffusionCommitQuery())
	->setViewer($user)
	->withRepository($repository)
	->withIdentifiers($parents)
	->execute();
	}

	$headsup_view = id(new PHUIHeaderView())
	->setHeader(nonempty($commit->getSummary(), pht('Commit Detail')));

	$headsup_actions = $this->renderHeadsupActionList($commit, $repository);

	$commit_properties = $this->loadCommitProperties(
	$commit,
	$commit_data,
	$parents,
	$audit_requests);
	$property_list = id(new PHUIPropertyListView())
	->setHasKeyboardShortcuts(true)
	->setUser($user)
	->setObject($commit);
	foreach ($commit_properties as $key => $value) {
	$property_list->addProperty($key, $value);
	}

	$message = $commit_data->getCommitMessage();

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

	$message = $engine->markupText($message);

	$property_list->invokeWillRenderEvent();
	$property_list->setActionList($headsup_actions);

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

	$headsup_view->setTall(true);
	$object_box = id(new PHUIObjectBoxView())
	->setHeader($headsup_view)
	->addPropertyList($property_list)
	->addPropertyList($detail_list);

	$content[] = $object_box;
	}

	$content[] = $this->buildComments($commit);

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

	$content[] = $this->buildMergesTable($commit);

	$highlighted_audits = $commit->getAuthorityAudits(
	$user,
	$this->auditAuthorityPHIDs);

	$count = count($changes);

	$bad_commit = null;
	if ($count == 0) {
	$bad_commit = queryfx_one(
	id(new PhabricatorRepository())->establishConnection('r'),
	'SELECT * FROM %T WHERE fullCommitName = %s',
	PhabricatorRepository::TABLE_BADCOMMIT,
	'r'.$callsign.$commit->getCommitIdentifier());
	}

	$show_changesets = false;
	if ($bad_commit) {
	$content[] = $this->renderStatusMessage(
	pht('Bad Commit'),
	$bad_commit['description']);
	} else if ($is_foreign) {
	// Don't render anything else.
	} else if (!$commit->isImported()) {
	$content[] = $this->renderStatusMessage(
	pht('Still Importing...'),
	pht(
	'This commit is still importing. Changes will be visible once '.
	'the import finishes.'));
	} else if (!count($changes)) {
	$content[] = $this->renderStatusMessage(
	pht('Empty Commit'),
	pht(
	'This commit is empty and does not affect any paths.'));
	} else if ($was_limited) {
	$content[] = $this->renderStatusMessage(
	pht('Enormous Commit'),
	pht(
	'This commit is enormous, and affects more than %d files. '.
	'Changes are not shown.',
	$hard_limit));
	} 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_panel = new PHUIObjectBoxView();
	$header = new PHUIHeaderView();
	$header->setHeader(pht('Changes (%s)', new PhutilNumber($count)));
	$change_panel->setID('toc');

	if ($count > self::CHANGES_LIMIT && !$show_all_details) {
	$icon = id(new PHUIIconView())
	->setIconFont('fa-files-o');

	$button = id(new PHUIButtonView())
	->setText(pht('Show All Changes'))
	->setHref('?show_all=true')
	->setTag('a')
	->setIcon($icon);

	$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_panel->setInfoView($warning_view);
	$header->addActionLink($button);
	}

	$changesets = DiffusionPathChange::convertToDifferentialChangesets(
	$user,
	$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_panel->setTable($change_table);
	$change_panel->setHeader($header);

	$content[] = $change_panel;

	$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(
	$user,
	$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 = DiffusionView::nameCommit(
	$repository,
	$commit->getCommitIdentifier());
	$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('/diffusion/'.$callsign.'/diff/');
	$change_list->setRepository($repository);
	$change_list->setUser($user);

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

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

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

	$content[] = $change_list->render();
	}

	$content[] = $this->renderAddCommentPanel($commit, $audit_requests);

	$commit_id = 'r'.$callsign.$commit->getCommitIdentifier();
	$short_name = DiffusionView::nameCommit(
	$repository,
	$commit->getCommitIdentifier());

	$prefs = $user->loadPreferences();
	$pref_filetree = PhabricatorUserPreferences::PREFERENCE_DIFF_FILETREE;
	$pref_collapse = PhabricatorUserPreferences::PREFERENCE_NAV_COLLAPSED;
	$show_filetree = $prefs->getPreference($pref_filetree);
	$collapsed = $prefs->getPreference($pref_collapse);

	if ($show_changesets && $show_filetree) {
	$nav = id(new DifferentialChangesetFileTreeSideNavBuilder())
	->setTitle($short_name)
	->setBaseURI(new PhutilURI('/'.$commit_id))
	->build($changesets)
	->setCrumbs($crumbs)
	->setCollapsed((bool)$collapsed)
	->appendChild($content);
	$content = $nav;
	} else {
	$content = array($crumbs, $content);
	}

	return $this->buildApplicationPage(
	$content,
	array(
	'title' => $commit_id,
	'pageObjects' => array($commit->getPHID()),
	));
	}

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

	assert_instances_of($parents, 'PhabricatorRepositoryCommit');
	$viewer = $this->getRequest()->getUser();
	$commit_phid = $commit->getPHID();
	$drequest = $this->getDiffusionRequest();
	$repository = $drequest->getRepository();

	$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');
	}
	if ($parents) {
	foreach ($parents as $parent) {
	$phids[] = $parent->getPHID();
	}
	}

	// 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 ($commit->getAuditStatus()) {
	$status = PhabricatorAuditCommitStatusConstants::getStatusName(
	$commit->getAuditStatus());
	$tag = id(new PHUITagView())
	->setType(PHUITagView::TYPE_STATE)
	->setName($status);

	switch ($commit->getAuditStatus()) {
	case PhabricatorAuditCommitStatusConstants::NEEDS_AUDIT:
	$tag->setBackgroundColor(PHUITagView::COLOR_ORANGE);
	break;
	case PhabricatorAuditCommitStatusConstants::CONCERN_RAISED:
	$tag->setBackgroundColor(PHUITagView::COLOR_RED);
	break;
	case PhabricatorAuditCommitStatusConstants::PARTIALLY_AUDITED:
	$tag->setBackgroundColor(PHUITagView::COLOR_BLUE);
	break;
	case PhabricatorAuditCommitStatusConstants::FULLY_AUDITED:
	$tag->setBackgroundColor(PHUITagView::COLOR_GREEN);
	break;
	}

	$props['Status'] = $tag;
	}

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

	if ($user_requests) {
	$props['Auditors'] = $this->renderAuditStatusView(
	$user_requests);
	}

	if ($other_requests) {
	$props['Project/Package Auditors'] = $this->renderAuditStatusView(
	$other_requests);
	}
	}

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

	if (!$repository->isSVN()) {
	$authored_info = id(new PHUIStatusItemView());
	// TODO: In Git, a distinct authorship date is available. When present,
	// we should show it here.

	if ($author_phid) {
	$authored_info->setTarget($handles[$author_phid]->renderLink());
	} else if (strlen($author_name)) {
	$authored_info->setTarget($author_name);
	}

	$props['Authored'] = id(new PHUIStatusListView())
	->addItem($authored_info);
	}

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

	$props['Committed'] = id(new PHUIStatusListView())
	->addItem($committed_info);

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

	$props['Pushed'] = $pushed_list;
	}

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

	if ($revision_phid) {
	$props['Differential Revision'] = $handles[$revision_phid]->renderLink();
	}

	if ($parents) {
	$parent_links = array();
	foreach ($parents as $parent) {
	$parent_links[] = $handles[$parent->getPHID()]->renderLink();
	}
	$props['Parents'] = phutil_implode_html(" \xC2\xB7 ", $parent_links);
	}

	$props['Branches'] = phutil_tag(
	'span',
	array(
	'id' => 'commit-branches',
	),
	pht('Unknown'));
	$props['Tags'] = phutil_tag(
	'span',
	array(
	'id' => 'commit-tags',
	),
	pht('Unknown'));

	$callsign = $repository->getCallsign();
	$root = '/diffusion/'.$callsign.'/commit/'.$commit->getCommitIdentifier();
	Javelin::initBehavior(
	'diffusion-commit-branches',
	array(
	$root.'/branches/' => 'commit-branches',
	$root.'/tags/' => 'commit-tags',
	));

	$refs = $this->buildRefs($drequest);
	if ($refs) {
	$props['References'] = $refs;
	}

	if ($reverts_phids) {
	$props[pht('Reverts')] = $viewer->renderHandleList($reverts_phids);
	}

	if ($reverted_by_phids) {
	$props[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);
	$props['Tasks'] = $task_list;
	}

	return $props;
	}

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

	private function renderAddCommentPanel(
	PhabricatorRepositoryCommit $commit,
	array $audit_requests) {
	assert_instances_of($audit_requests, 'PhabricatorRepositoryAuditRequest');

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

	if (!$user->isLoggedIn()) {
	return id(new PhabricatorApplicationTransactionCommentView())
	->setUser($user)
	->setRequestURI($request->getRequestURI());
	}

	$is_serious = PhabricatorEnv::getEnvConfig('phabricator.serious-business');

	$pane_id = celerity_generate_unique_node_id();
	Javelin::initBehavior(
	'differential-keyboard-navigation',
	array(
	'haunt' => $pane_id,
	));

	$draft = id(new PhabricatorDraft())->loadOneWhere(
	'authorPHID = %s AND draftKey = %s',
	$user->getPHID(),
	'diffusion-audit-'.$commit->getID());
	if ($draft) {
	$draft = $draft->getDraft();
	} else {
	$draft = null;
	}

	$actions = $this->getAuditActions($commit, $audit_requests);

	$mailable_source = new PhabricatorMetaMTAMailableDatasource();
	$auditor_source = new DiffusionAuditorDatasource();

	$form = id(new AphrontFormView())
	->setUser($user)
	->setAction('/audit/addcomment/')
	->addHiddenInput('commit', $commit->getPHID())
	->appendChild(
	id(new AphrontFormSelectControl())
	->setLabel(pht('Action'))
	->setName('action')
	->setID('audit-action')
	->setOptions($actions))
	->appendControl(
	id(new AphrontFormTokenizerControl())
	->setLabel(pht('Add Auditors'))
	->setName('auditors')
	->setControlID('add-auditors')
	->setControlStyle('display: none')
	->setID('add-auditors-tokenizer')
	->setDisableBehavior(true)
	->setDatasource($auditor_source))
	->appendControl(
	id(new AphrontFormTokenizerControl())
	->setLabel(pht('Add CCs'))
	->setName('ccs')
	->setControlID('add-ccs')
	->setControlStyle('display: none')
	->setID('add-ccs-tokenizer')
	->setDisableBehavior(true)
	->setDatasource($mailable_source))
	->appendChild(
	id(new PhabricatorRemarkupControl())
	->setLabel(pht('Comments'))
	->setName('content')
	->setValue($draft)
	->setID('audit-content')
	->setUser($user))
	->appendChild(
	id(new AphrontFormSubmitControl())
	->setValue(pht('Submit')));

	$header = new PHUIHeaderView();
	$header->setHeader(
	$is_serious ? pht('Audit Commit') : pht('Creative Accounting'));

	Javelin::initBehavior(
	'differential-add-reviewers-and-ccs',
	array(
	'dynamic' => array(
	'add-auditors-tokenizer' => array(
	'actions' => array('add_auditors' => 1),
	'src' => $auditor_source->getDatasourceURI(),
	'row' => 'add-auditors',
	'placeholder' => $auditor_source->getPlaceholderText(),
	),
	'add-ccs-tokenizer' => array(
	'actions' => array('add_ccs' => 1),
	'src' => $mailable_source->getDatasourceURI(),
	'row' => 'add-ccs',
	'placeholder' => $mailable_source->getPlaceholderText(),
	),
	),
	'select' => 'audit-action',
	));

	Javelin::initBehavior('differential-feedback-preview', array(
	'uri' => '/audit/preview/'.$commit->getID().'/',
	'preview' => 'audit-preview',
	'content' => 'audit-content',
	'action' => 'audit-action',
	'previewTokenizers' => array(
	'auditors' => 'add-auditors-tokenizer',
	'ccs' => 'add-ccs-tokenizer',
	),
	'inline' => 'inline-comment-preview',
	'inlineuri' => '/diffusion/inline/preview/'.$commit->getPHID().'/',
	));

	$loading = phutil_tag_div(
	'aphront-panel-preview-loading-text',
	pht('Loading preview...'));

	$preview_panel = phutil_tag_div(
	'aphront-panel-preview aphront-panel-flush',
	array(
	phutil_tag('div', array('id' => 'audit-preview'), $loading),
	phutil_tag('div', array('id' => 'inline-comment-preview')),
	));

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

	$anchor = id(new PhabricatorAnchorView())
	->setAnchorName('comment')
	->setNavigationMarker(true)
	->render();

	$comment_box = id(new PHUIObjectBoxView())
	->setHeader($header)
	->appendChild($form);

	return phutil_tag(
	'div',
	array(
	'id' => $pane_id,
	),
	phutil_tag_div(
	'differential-add-comment-panel',
	array($anchor, $comment_box, $preview_panel)));
	}

	/**
	* Return a map of available audit actions for rendering into a <select />.
	* This shows the user valid actions, and does not show nonsense/invalid
	* actions (like closing an already-closed commit, or resigning from a commit
	* you have no association with).
	*/
	private function getAuditActions(
	PhabricatorRepositoryCommit $commit,
	array $audit_requests) {
	assert_instances_of($audit_requests, 'PhabricatorRepositoryAuditRequest');
	$user = $this->getRequest()->getUser();

	$user_is_author = ($commit->getAuthorPHID() == $user->getPHID());

	$user_request = null;
	foreach ($audit_requests as $audit_request) {
	if ($audit_request->getAuditorPHID() == $user->getPHID()) {
	$user_request = $audit_request;
	break;
	}
	}

	$actions = array();
	$actions[PhabricatorAuditActionConstants::COMMENT] = true;
	$actions[PhabricatorAuditActionConstants::ADD_CCS] = true;
	$actions[PhabricatorAuditActionConstants::ADD_AUDITORS] = true;

	// We allow you to accept your own commits. A use case here is that you
	// notice an issue with your own commit and "Raise Concern" as an indicator
	// to other auditors that you're on top of the issue, then later resolve it
	// and "Accept". You can not accept on behalf of projects or packages,
	// however.
	$actions[PhabricatorAuditActionConstants::ACCEPT] = true;
	$actions[PhabricatorAuditActionConstants::CONCERN] = true;


	// To resign, a user must have authority on some request and not be the
	// commit's author.
	if (!$user_is_author) {
	$may_resign = false;

	$authority_map = array_fill_keys($this->auditAuthorityPHIDs, true);
	foreach ($audit_requests as $request) {
	if (empty($authority_map[$request->getAuditorPHID()])) {
	continue;
	}
	$may_resign = true;
	break;
	}

	// If the user has already resigned, don't show "Resign...".
	$status_resigned = PhabricatorAuditStatusConstants::RESIGNED;
	if ($user_request) {
	if ($user_request->getAuditStatus() == $status_resigned) {
	$may_resign = false;
	}
	}

	if ($may_resign) {
	$actions[PhabricatorAuditActionConstants::RESIGN] = true;
	}
	}

	$status_concern = PhabricatorAuditCommitStatusConstants::CONCERN_RAISED;
	$concern_raised = ($commit->getAuditStatus() == $status_concern);
	$can_close_option = PhabricatorEnv::getEnvConfig(
	'audit.can-author-close-audit');
	if ($can_close_option && $user_is_author && $concern_raised) {
	$actions[PhabricatorAuditActionConstants::CLOSE] = true;
	}

	foreach ($actions as $constant => $ignored) {
	$actions[$constant] =
	PhabricatorAuditActionConstants::getActionName($constant);
	}

	return $actions;
	}

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

	$vcs = $repository->getVersionControlSystem();
	switch ($vcs) {
	case PhabricatorRepositoryType::REPOSITORY_TYPE_SVN:
	// These aren't supported under SVN.
	return null;
	}

	$limit = 50;

	$merges = $this->callConduitWithDiffusionRequest(
	'diffusion.mergedcommitsquery',
	array(
	'commit' => $drequest->getCommit(),
	'limit' => $limit + 1,
	));

	if (!$merges) {
	return null;
	}
	$merges = DiffusionPathChange::newFromConduit($merges);

	$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 = new DiffusionHistoryTableView();
	$history_table->setUser($this->getRequest()->getUser());
	$history_table->setDiffusionRequest($drequest);
	$history_table->setHistory($merges);
	$history_table->loadRevisions();

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

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

	return $panel;
	}

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

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

	$actions = id(new PhabricatorActionListView())
	->setUser($user)
	->setObject($commit)
	->setObjectURI($request->getRequestURI());

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

	$uri = '/diffusion/'.$repository->getCallsign().'/commit/'.
	$commit->getCommitIdentifier().'/edit/';

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

	require_celerity_resource('phabricator-object-selector-css');
	require_celerity_resource('javelin-behavior-phabricator-object-selector');

	$maniphest = 'PhabricatorManiphestApplication';
	if (PhabricatorApplication::isClassInstalled($maniphest)) {
	$action = id(new PhabricatorActionView())
	->setName(pht('Edit Maniphest Tasks'))
	->setIcon('fa-anchor')
	->setHref('/search/attach/'.$commit->getPHID().'/TASK/edge/')
	->setWorkflow(true)
	->setDisabled(!$can_edit);
	$actions->addAction($action);
	}

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

	return $actions;
	}

	private function buildRefs(DiffusionRequest $request) {
	// this is git-only, so save a conduit round trip and just get out of
	// here if the repository isn't git
	$type_git = PhabricatorRepositoryType::REPOSITORY_TYPE_GIT;
	$repository = $request->getRepository();
	if ($repository->getVersionControlSystem() != $type_git) {
	return null;
	}

	$results = $this->callConduitWithDiffusionRequest(
	'diffusion.refsquery',
	array('commit' => $request->getCommit()));
	$ref_links = array();
	foreach ($results as $ref_data) {
	$ref_links[] = phutil_tag('a',
	array('href' => $ref_data['href']),
	$ref_data['ref']);
	}
	return phutil_implode_html(', ', $ref_links);
	}

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

	$file = PhabricatorFile::buildFromFileDataOrHash(
	$raw_diff,
	array(
	'name' => $drequest->getCommit().'.diff',
	'ttl' => (60 * 60 * 24),
	'viewPolicy' => PhabricatorPolicies::POLICY_NOONE,
	));

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

	return $file->getRedirectResponse();
	}

	private function renderAuditStatusView(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])) {
	$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) {
	+ $drequest = $this->getDiffusionRequest();
	$viewer = $this->getViewer();

	$toc_view = id(new PHUIDiffTableOfContentsListView())
	->setUser($viewer);

	// TODO: This is hacky, we just want access to the linkX() methods on
	// DiffusionView.
	$diffusion_view = id(new DiffusionEmptyResultView())
	- ->setDiffusionRequest($this->getDiffusionRequest());
	+ ->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)
	+ ->withAuthorityPHIDs(array($viewer->getPHID()))
	+ ->execute();
	+ $toc_view->setAuthorityPackages($packages);
	+ }

	- // TODO: Restore package stuff here.
	+ $repository = $drequest->getRepository();
	+ $repository_phid = $repository->getPHID();
	+
	+ $control_query = id(new PhabricatorOwnersPackageQuery())
	+ ->setViewer($viewer)
	+ ->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);

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

	+ if ($have_owners) {
	+ $package = $control_query->getControllingPackageForPath(
	+ $repository_phid,
	+ $changeset->getFilename());
	+ if ($package) {
	+ $item->setPackage($package);
	+ }
	+ }
	+
	$toc_view->addItem($item);
	}

	return $toc_view;
	}

	}
	diff --git a/src/infrastructure/diff/view/PHUIDiffTableOfContentsListView.php b/src/infrastructure/diff/view/PHUIDiffTableOfContentsListView.php
	index 66677ee598..a7e3270c6e 100644
	--- a/src/infrastructure/diff/view/PHUIDiffTableOfContentsListView.php
	+++ b/src/infrastructure/diff/view/PHUIDiffTableOfContentsListView.php
	@@ -1,119 +1,153 @@
	<?php

	final class PHUIDiffTableOfContentsListView extends AphrontView {

	private $items = array();
	+ private $authorityPackages;

	public function addItem(PHUIDiffTableOfContentsItemView $item) {
	$this->items[] = $item;
	return $this;
	}

	+ public function setAuthorityPackages(array $authority_packages) {
	+ assert_instances_of($authority_packages, 'PhabricatorOwnersPackage');
	+ $this->authorityPackages = $authority_packages;
	+ return $this;
	+ }
	+
	+ public function getAuthorityPackages() {
	+ return $this->authorityPackages;
	+ }
	+
	public function render() {
	$this->requireResource('differential-core-view-css');
	$this->requireResource('differential-table-of-contents-css');
	$this->requireResource('phui-text-css');

	Javelin::initBehavior('phabricator-tooltips');

	+ if ($this->getAuthorityPackages()) {
	+ $authority = mpull($this->getAuthorityPackages(), null, 'getPHID');
	+ } else {
	+ $authority = array();
	+ }
	+
	$items = $this->items;

	$rows = array();
	+ $rowc = array();
	foreach ($items as $item) {
	$item->setUser($this->getUser());
	$rows[] = $item->render();
	+
	+ $have_authority = false;
	+
	+ $package = $item->getPackage();
	+ if ($package) {
	+ if (isset($authority[$package->getPHID()])) {
	+ $have_authority = true;
	+ }
	+ }
	+
	+ if ($have_authority) {
	+ $rowc[] = 'highlighted';
	+ } else {
	+ $rowc[] = null;
	+ }
	}

	// Check if any item has content in these columns. If no item does, we'll
	// just hide them.
	$any_coverage = false;
	$any_context = false;
	$any_package = false;
	foreach ($items as $item) {
	if ($item->getContext() !== null) {
	$any_context = true;
	}

	if (strlen($item->getCoverage())) {
	$any_coverage = true;
	}

	if ($item->getPackage() !== null) {
	$any_package = true;
	}
	}

	$reveal_link = javelin_tag(
	'a',
	array(
	'sigil' => 'differential-reveal-all',
	'mustcapture' => true,
	'class' => 'button differential-toc-reveal-all',
	),
	pht('Show All Context'));

	$buttons = phutil_tag(
	'div',
	array(
	'class' => 'differential-toc-buttons grouped',
	),
	$reveal_link);

	$table = id(new AphrontTableView($rows))
	+ ->setRowClasses($rowc)
	->setHeaders(
	array(
	null,
	null,
	null,
	null,
	pht('Path'),
	pht('Coverage (All)'),
	pht('Coverage (Touched)'),
	- null,
	+ pht('Package'),
	))
	->setColumnClasses(
	array(
	'center',
	'differential-toc-char center',
	'differential-toc-prop center',
	'differential-toc-ftype center',
	'differential-toc-file wide',
	'differential-toc-cov',
	'differential-toc-cov',
	- 'center',
	+ null,
	))
	->setColumnVisibility(
	array(
	$any_context,
	true,
	true,
	true,
	true,
	$any_coverage,
	$any_coverage,
	$any_package,
	))
	->setDeviceVisibility(
	array(
	true,
	true,
	true,
	true,
	true,
	false,
	false,
	true,
	));

	$anchor = id(new PhabricatorAnchorView())
	->setAnchorName('toc')
	->setNavigationMarker(true);

	return id(new PHUIObjectBoxView())
	->setHeaderText(pht('Table of Contents'))
	->setTable($table)
	->appendChild($anchor)
	->appendChild($buttons);
	}

	}

File Metadata

Mime Type: text/x-diff
Expires: Wed, Feb 4, 7:05 AM (1 d, 13 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 738986
Default Alt Text: (59 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions