No OneTemporary
Actions

Size

195 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/src/applications/diffusion/controller/DiffusionChangeController.php b/src/applications/diffusion/controller/DiffusionChangeController.php
	index 1ffa4e0120..064e5cc750 100644
	--- a/src/applications/diffusion/controller/DiffusionChangeController.php
	+++ b/src/applications/diffusion/controller/DiffusionChangeController.php
	@@ -1,162 +1,162 @@
	<?php

	final class DiffusionChangeController extends DiffusionController {

	public function shouldAllowPublic() {
	return true;
	}

	protected function processDiffusionRequest(AphrontRequest $request) {
	$drequest = $this->diffusionRequest;
	$viewer = $request->getUser();

	$content = array();

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

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

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

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

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

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

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

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

	- $changeset_view->setRenderURI('/diffusion/'.$callsign.'/diff/');
	+ $changeset_view->setRenderURI($repository->getPathURI('diff/'));
	+
	$changeset_view->setWhitespace(
	DifferentialChangesetParser::WHITESPACE_SHOW_ALL);
	$changeset_view->setUser($viewer);

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

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

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

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

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

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

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

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

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

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

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

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

	return $view;
	}

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

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

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

	$stable_commit = $drequest->getStableCommit();

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

	return $view;
	}

	}
	diff --git a/src/applications/diffusion/controller/DiffusionCommitController.php b/src/applications/diffusion/controller/DiffusionCommitController.php
	index 6f47820501..42a64f416f 100644
	--- a/src/applications/diffusion/controller/DiffusionCommitController.php
	+++ b/src/applications/diffusion/controller/DiffusionCommitController.php
	@@ -1,1235 +1,1236 @@
	<?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;
	}

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

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

	$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,
	$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)
	->setFormErrors($this->getCommitErrors())
	->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,
	$commit->getMonogram());
	}

	$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 if (!$this->getCommitExists()) {
	$content[] = $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_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 = $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('/diffusion/'.$callsign.'/diff/');
	+ $change_list->setRenderURI(
	+ $repository->getPathURI('diff/'));
	$change_list->setRepository($repository);
	$change_list->setUser($user);

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

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

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

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

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

	$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($commit->getDisplayName())
	->setBaseURI(new PhutilURI($commit->getURI()))
	->build($changesets)
	->setCrumbs($crumbs)
	->setCollapsed((bool)$collapsed)
	->appendChild($content);
	$content = $nav;
	} else {
	$content = array($crumbs, $content);
	}

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

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

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

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

	$parents = $this->getCommitParents();
	if ($parents) {
	$props['Parents'] = $viewer->renderHandleList(mpull($parents, 'getPHID'));
	}

	if ($this->getCommitExists()) {
	$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();
	+ $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']);
	}
	$props['References'] = phutil_implode_html(', ', $ref_links);
	}

	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) {
	$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 = 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);

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

	- $uri = '/diffusion/'.$repository->getCallsign().'/commit/'.
	- $commit->getCommitIdentifier().'/edit/';
	+ $identifier = $commit->getCommitIdentifier();
	+ $uri = $repository->getPathURI("commit/{$identifier}/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 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($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/controller/DiffusionController.php b/src/applications/diffusion/controller/DiffusionController.php
	index 1d0d27216b..89446e132f 100644
	--- a/src/applications/diffusion/controller/DiffusionController.php
	+++ b/src/applications/diffusion/controller/DiffusionController.php
	@@ -1,252 +1,248 @@
	<?php

	abstract class DiffusionController extends PhabricatorController {

	protected $diffusionRequest;

	public function setDiffusionRequest(DiffusionRequest $request) {
	$this->diffusionRequest = $request;
	return $this;
	}

	protected function getDiffusionRequest() {
	if (!$this->diffusionRequest) {
	throw new Exception(pht('No Diffusion request object!'));
	}
	return $this->diffusionRequest;
	}

	public function willBeginExecution() {
	$request = $this->getRequest();

	// Check if this is a VCS request, e.g. from "git clone", "hg clone", or
	// "svn checkout". If it is, we jump off into repository serving code to
	// process the request.
	if (DiffusionServeController::isVCSRequest($request)) {
	$serve_controller = id(new DiffusionServeController())
	->setCurrentApplication($this->getCurrentApplication());
	return $this->delegateToController($serve_controller);
	}

	return parent::willBeginExecution();
	}

	protected function shouldLoadDiffusionRequest() {
	return true;
	}

	final public function handleRequest(AphrontRequest $request) {
	if ($request->getURIData('callsign') &&
	$this->shouldLoadDiffusionRequest()) {
	try {
	$drequest = DiffusionRequest::newFromAphrontRequestDictionary(
	$request->getURIMap(),
	$request);
	} catch (Exception $ex) {
	return id(new Aphront404Response())
	->setRequest($request);
	}
	$this->setDiffusionRequest($drequest);
	}
	return $this->processDiffusionRequest($request);
	}

	abstract protected function processDiffusionRequest(AphrontRequest $request);

	public function buildCrumbs(array $spec = array()) {
	$crumbs = $this->buildApplicationCrumbs();
	$crumb_list = $this->buildCrumbList($spec);
	foreach ($crumb_list as $crumb) {
	$crumbs->addCrumb($crumb);
	}
	return $crumbs;
	}

	private function buildCrumbList(array $spec = array()) {

	$spec = $spec + array(
	'commit' => null,
	'tags' => null,
	'branches' => null,
	'view' => null,
	);

	$crumb_list = array();

	// On the home page, we don't have a DiffusionRequest.
	if ($this->diffusionRequest) {
	$drequest = $this->getDiffusionRequest();
	$repository = $drequest->getRepository();
	} else {
	$drequest = null;
	$repository = null;
	}

	if (!$repository) {
	return $crumb_list;
	}

	- $callsign = $repository->getCallsign();
	$repository_name = $repository->getName();

	if (!$spec['commit'] && !$spec['tags'] && !$spec['branches']) {
	$branch_name = $drequest->getBranch();
	if ($branch_name) {
	$repository_name .= ' ('.$branch_name.')';
	}
	}

	$crumb = id(new PHUICrumbView())
	->setName($repository_name);
	if (!$spec['view'] && !$spec['commit'] &&
	!$spec['tags'] && !$spec['branches']) {
	$crumb_list[] = $crumb;
	return $crumb_list;
	}
	$crumb->setHref(
	$drequest->generateURI(
	array(
	'action' => 'branch',
	'path' => '/',
	)));
	$crumb_list[] = $crumb;

	$stable_commit = $drequest->getStableCommit();
	+ $commit_name = $repository->formatCommitName($stable_commit);
	+ $commit_uri = $repository->getCommitURI($stable_commit);

	if ($spec['tags']) {
	$crumb = new PHUICrumbView();
	if ($spec['commit']) {
	- $crumb->setName(
	- pht('Tags for %s', 'r'.$callsign.$stable_commit));
	- $crumb->setHref($drequest->generateURI(
	- array(
	- 'action' => 'commit',
	- 'commit' => $drequest->getStableCommit(),
	- )));
	+ $crumb->setName(pht('Tags for %s', $commit_name));
	+ $crumb->setHref($commit_uri);
	} else {
	$crumb->setName(pht('Tags'));
	}
	$crumb_list[] = $crumb;
	return $crumb_list;
	}

	if ($spec['branches']) {
	$crumb = id(new PHUICrumbView())
	->setName(pht('Branches'));
	$crumb_list[] = $crumb;
	return $crumb_list;
	}

	if ($spec['commit']) {
	$crumb = id(new PHUICrumbView())
	- ->setName("r{$callsign}{$stable_commit}")
	- ->setHref("r{$callsign}{$stable_commit}");
	+ ->setName($commit_name)
	+ ->setHref($commit_uri);
	$crumb_list[] = $crumb;
	return $crumb_list;
	}

	$crumb = new PHUICrumbView();
	$view = $spec['view'];

	switch ($view) {
	case 'history':
	$view_name = pht('History');
	break;
	case 'browse':
	$view_name = pht('Browse');
	break;
	case 'lint':
	$view_name = pht('Lint');
	break;
	case 'change':
	$view_name = pht('Change');
	break;
	}

	$crumb = id(new PHUICrumbView())
	->setName($view_name);

	$crumb_list[] = $crumb;
	return $crumb_list;
	}

	protected function callConduitWithDiffusionRequest(
	$method,
	array $params = array()) {

	$user = $this->getRequest()->getUser();
	$drequest = $this->getDiffusionRequest();

	return DiffusionQuery::callConduitWithDiffusionRequest(
	$user,
	$drequest,
	$method,
	$params);
	}

	protected function getRepositoryControllerURI(
	PhabricatorRepository $repository,
	$path) {
	- return $this->getApplicationURI($repository->getCallsign().'/'.$path);
	+ return $repository->getPathURI($path);
	}

	protected function renderPathLinks(DiffusionRequest $drequest, $action) {
	$path = $drequest->getPath();
	$path_parts = array_filter(explode('/', trim($path, '/')));

	$divider = phutil_tag(
	'span',
	array(
	'class' => 'phui-header-divider',
	),
	'/');

	$links = array();
	if ($path_parts) {
	$links[] = phutil_tag(
	'a',
	array(
	'href' => $drequest->generateURI(
	array(
	'action' => $action,
	'path' => '',
	)),
	),
	$drequest->getRepository()->getDisplayName());
	$links[] = $divider;
	$accum = '';
	$last_key = last_key($path_parts);
	foreach ($path_parts as $key => $part) {
	$accum .= '/'.$part;
	if ($key === $last_key) {
	$links[] = $part;
	} else {
	$links[] = phutil_tag(
	'a',
	array(
	'href' => $drequest->generateURI(
	array(
	'action' => $action,
	'path' => $accum.'/',
	)),
	),
	$part);
	$links[] = $divider;
	}
	}
	} else {
	$links[] = $drequest->getRepository()->getDisplayName();
	$links[] = $divider;
	}

	return $links;
	}

	protected function renderStatusMessage($title, $body) {
	return id(new PHUIInfoView())
	->setSeverity(PHUIInfoView::SEVERITY_WARNING)
	->setTitle($title)
	->appendChild($body);
	}

	}
	diff --git a/src/applications/diffusion/controller/DiffusionExternalController.php b/src/applications/diffusion/controller/DiffusionExternalController.php
	index 011865dc3f..8faa9275d1 100644
	--- a/src/applications/diffusion/controller/DiffusionExternalController.php
	+++ b/src/applications/diffusion/controller/DiffusionExternalController.php
	@@ -1,147 +1,147 @@
	<?php

	final class DiffusionExternalController extends DiffusionController {

	public function shouldAllowPublic() {
	return true;
	}

	protected function shouldLoadDiffusionRequest() {
	return false;
	}

	protected function processDiffusionRequest(AphrontRequest $request) {

	$uri = $request->getStr('uri');
	$id = $request->getStr('id');

	$repositories = id(new PhabricatorRepositoryQuery())
	->setViewer($request->getUser())
	->execute();

	if ($uri) {
	$uri_path = id(new PhutilURI($uri))->getPath();
	$matches = array();

	// Try to figure out which tracked repository this external lives in by
	// comparing repository metadata. We look for an exact match, but accept
	// a partial match.

	foreach ($repositories as $key => $repository) {
	$remote_uri = new PhutilURI($repository->getRemoteURI());
	if ($remote_uri->getPath() == $uri_path) {
	$matches[$key] = 1;
	}
	if ($repository->getPublicCloneURI() == $uri) {
	$matches[$key] = 2;
	}
	if ($repository->getRemoteURI() == $uri) {
	$matches[$key] = 3;
	}
	}

	arsort($matches);
	$best_match = head_key($matches);

	if ($best_match) {
	$repository = $repositories[$best_match];
	$redirect = DiffusionRequest::generateDiffusionURI(
	array(
	'action' => 'browse',
	- 'callsign' => $repository->getCallsign(),
	+ 'repository' => $repository,
	'branch' => $repository->getDefaultBranch(),
	'commit' => $id,
	));
	return id(new AphrontRedirectResponse())->setURI($redirect);
	}
	}

	// TODO: This is a rare query but does a table scan, add a key?

	$commits = id(new PhabricatorRepositoryCommit())->loadAllWhere(
	'commitIdentifier = %s',
	$id);

	if (empty($commits)) {
	$desc = null;
	if ($uri) {
	$desc = $uri.', at ';
	}
	$desc .= $id;

	$content = id(new PHUIInfoView())
	->setTitle(pht('Unknown External'))
	->setSeverity(PHUIInfoView::SEVERITY_WARNING)
	->appendChild(phutil_tag(
	'p',
	array(),
	pht(
	'This external (%s) does not appear in any tracked '.
	'repository. It may exist in an untracked repository that '.
	'Diffusion does not know about.',
	$desc)));
	} else if (count($commits) == 1) {
	$commit = head($commits);
	$repo = $repositories[$commit->getRepositoryID()];
	$redirect = DiffusionRequest::generateDiffusionURI(
	array(
	'action' => 'browse',
	- 'callsign' => $repo->getCallsign(),
	+ 'repository' => $repo,
	'branch' => $repo->getDefaultBranch(),
	'commit' => $commit->getCommitIdentifier(),
	));
	return id(new AphrontRedirectResponse())->setURI($redirect);
	} else {

	$rows = array();
	foreach ($commits as $commit) {
	$repo = $repositories[$commit->getRepositoryID()];
	$href = DiffusionRequest::generateDiffusionURI(
	array(
	'action' => 'browse',
	- 'callsign' => $repo->getCallsign(),
	+ 'repository' => $repo,
	'branch' => $repo->getDefaultBranch(),
	'commit' => $commit->getCommitIdentifier(),
	));
	$rows[] = array(
	phutil_tag(
	'a',
	array(
	'href' => $href,
	),
	$commit->getMonogram()),
	$commit->loadCommitData()->getSummary(),
	);
	}

	$table = new AphrontTableView($rows);
	$table->setHeaders(
	array(
	pht('Commit'),
	pht('Description'),
	));
	$table->setColumnClasses(
	array(
	'pri',
	'wide',
	));

	$caption = id(new PHUIInfoView())
	->setSeverity(PHUIInfoView::SEVERITY_NOTICE)
	->appendChild(
	pht('This external reference matches multiple known commits.'));

	$content = new PHUIObjectBoxView();
	$content->setHeaderText(pht('Multiple Matching Commits'));
	$content->setInfoView($caption);
	$content->setTable($table);
	}

	return $this->buildApplicationPage(
	$content,
	array(
	'title' => pht('Unresolvable External'),
	));
	}

	}
	diff --git a/src/applications/diffusion/controller/DiffusionRepositoryController.php b/src/applications/diffusion/controller/DiffusionRepositoryController.php
	index cd469c1424..21606e04ae 100644
	--- a/src/applications/diffusion/controller/DiffusionRepositoryController.php
	+++ b/src/applications/diffusion/controller/DiffusionRepositoryController.php
	@@ -1,740 +1,740 @@
	<?php

	final class DiffusionRepositoryController extends DiffusionController {

	public function shouldAllowPublic() {
	return true;
	}

	protected function processDiffusionRequest(AphrontRequest $request) {
	$viewer = $request->getUser();

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

	$content = array();

	$crumbs = $this->buildCrumbs();
	$content[] = $crumbs;

	$content[] = $this->buildPropertiesTable($drequest->getRepository());

	// Before we do any work, make sure we're looking at a some content: we're
	// on a valid branch, and the repository is not empty.
	$page_has_content = false;
	$empty_title = null;
	$empty_message = null;

	// If this VCS supports branches, check that the selected branch actually
	// exists.
	if ($drequest->supportsBranches()) {
	// NOTE: Mercurial may have multiple branch heads with the same name.
	$ref_cursors = id(new PhabricatorRepositoryRefCursorQuery())
	->setViewer($viewer)
	->withRepositoryPHIDs(array($repository->getPHID()))
	->withRefTypes(array(PhabricatorRepositoryRefCursor::TYPE_BRANCH))
	->withRefNames(array($drequest->getBranch()))
	->execute();
	if ($ref_cursors) {
	// This is a valid branch, so we necessarily have some content.
	$page_has_content = true;
	} else {
	$empty_title = pht('No Such Branch');
	$empty_message = pht(
	'There is no branch named "%s" in this repository.',
	$drequest->getBranch());
	}
	}

	// If we didn't find any branches, check if there are any commits at all.
	// This can tailor the message for empty repositories.
	if (!$page_has_content) {
	$any_commit = id(new DiffusionCommitQuery())
	->setViewer($viewer)
	->withRepository($repository)
	->setLimit(1)
	->execute();
	if ($any_commit) {
	if (!$drequest->supportsBranches()) {
	$page_has_content = true;
	}
	} else {
	$empty_title = pht('Empty Repository');
	$empty_message = pht('This repository does not have any commits yet.');
	}
	}

	if ($page_has_content) {
	$content[] = $this->buildNormalContent($drequest);
	} else {
	$content[] = id(new PHUIInfoView())
	->setTitle($empty_title)
	->setSeverity(PHUIInfoView::SEVERITY_WARNING)
	->setErrors(array($empty_message));
	}

	return $this->buildApplicationPage(
	$content,
	array(
	'title' => $drequest->getRepository()->getName(),
	));
	}


	private function buildNormalContent(DiffusionRequest $drequest) {
	$repository = $drequest->getRepository();

	$phids = array();
	$content = array();

	try {
	$history_results = $this->callConduitWithDiffusionRequest(
	'diffusion.historyquery',
	array(
	'commit' => $drequest->getCommit(),
	'path' => $drequest->getPath(),
	'offset' => 0,
	'limit' => 15,
	));
	$history = DiffusionPathChange::newFromConduit(
	$history_results['pathChanges']);

	foreach ($history as $item) {
	$data = $item->getCommitData();
	if ($data) {
	if ($data->getCommitDetail('authorPHID')) {
	$phids[$data->getCommitDetail('authorPHID')] = true;
	}
	if ($data->getCommitDetail('committerPHID')) {
	$phids[$data->getCommitDetail('committerPHID')] = true;
	}
	}
	}
	$history_exception = null;
	} catch (Exception $ex) {
	$history_results = null;
	$history = null;
	$history_exception = $ex;
	}

	try {
	$browse_results = DiffusionBrowseResultSet::newFromConduit(
	$this->callConduitWithDiffusionRequest(
	'diffusion.browsequery',
	array(
	'path' => $drequest->getPath(),
	'commit' => $drequest->getCommit(),
	)));
	$browse_paths = $browse_results->getPaths();

	foreach ($browse_paths as $item) {
	$data = $item->getLastCommitData();
	if ($data) {
	if ($data->getCommitDetail('authorPHID')) {
	$phids[$data->getCommitDetail('authorPHID')] = true;
	}
	if ($data->getCommitDetail('committerPHID')) {
	$phids[$data->getCommitDetail('committerPHID')] = true;
	}
	}
	}

	$browse_exception = null;
	} catch (Exception $ex) {
	$browse_results = null;
	$browse_paths = null;
	$browse_exception = $ex;
	}

	$phids = array_keys($phids);
	$handles = $this->loadViewerHandles($phids);

	$readme = null;
	if ($browse_results) {
	$readme_path = $browse_results->getReadmePath();
	if ($readme_path) {
	$readme_content = $this->callConduitWithDiffusionRequest(
	'diffusion.filecontentquery',
	array(
	'path' => $readme_path,
	'commit' => $drequest->getStableCommit(),
	));
	if ($readme_content) {
	$readme = id(new DiffusionReadmeView())
	->setUser($this->getViewer())
	->setPath($readme_path)
	->setContent($readme_content['corpus']);
	}
	}
	}

	$content[] = $this->buildBrowseTable(
	$browse_results,
	$browse_paths,
	$browse_exception,
	$handles);

	$content[] = $this->buildHistoryTable(
	$history_results,
	$history,
	$history_exception);

	try {
	$content[] = $this->buildTagListTable($drequest);
	} catch (Exception $ex) {
	if (!$repository->isImporting()) {
	$content[] = $this->renderStatusMessage(
	pht('Unable to Load Tags'),
	$ex->getMessage());
	}
	}

	try {
	$content[] = $this->buildBranchListTable($drequest);
	} catch (Exception $ex) {
	if (!$repository->isImporting()) {
	$content[] = $this->renderStatusMessage(
	pht('Unable to Load Branches'),
	$ex->getMessage());
	}
	}

	if ($readme) {
	$content[] = $readme;
	}

	return $content;
	}

	private function buildPropertiesTable(PhabricatorRepository $repository) {
	$user = $this->getRequest()->getUser();

	$header = id(new PHUIHeaderView())
	->setHeader($repository->getName())
	->setUser($user)
	->setPolicyObject($repository);

	if (!$repository->isTracked()) {
	$header->setStatus('fa-ban', 'dark', pht('Inactive'));
	} else if ($repository->isImporting()) {
	$header->setStatus('fa-clock-o', 'indigo', pht('Importing...'));
	} else {
	$header->setStatus('fa-check', 'bluegrey', pht('Active'));
	}


	$actions = $this->buildActionList($repository);

	$view = id(new PHUIPropertyListView())
	->setObject($repository)
	->setUser($user);

	if ($repository->isHosted()) {
	$ssh_uri = $repository->getSSHCloneURIObject();
	if ($ssh_uri) {
	$clone_uri = $this->renderCloneCommand(
	$repository,
	$ssh_uri,
	$repository->getServeOverSSH(),
	'/settings/panel/ssh/');

	$view->addProperty(
	$repository->isSVN()
	? pht('Checkout (SSH)')
	: pht('Clone (SSH)'),
	$clone_uri);
	}

	$http_uri = $repository->getHTTPCloneURIObject();
	if ($http_uri) {
	$clone_uri = $this->renderCloneCommand(
	$repository,
	$http_uri,
	$repository->getServeOverHTTP(),
	PhabricatorEnv::getEnvConfig('diffusion.allow-http-auth')
	? '/settings/panel/vcspassword/'
	: null);

	$view->addProperty(
	$repository->isSVN()
	? pht('Checkout (HTTP)')
	: pht('Clone (HTTP)'),
	$clone_uri);
	}
	} else {
	switch ($repository->getVersionControlSystem()) {
	case PhabricatorRepositoryType::REPOSITORY_TYPE_GIT:
	case PhabricatorRepositoryType::REPOSITORY_TYPE_MERCURIAL:
	$view->addProperty(
	pht('Clone'),
	$this->renderCloneCommand(
	$repository,
	$repository->getPublicCloneURI()));
	break;
	case PhabricatorRepositoryType::REPOSITORY_TYPE_SVN:
	$view->addProperty(
	pht('Checkout'),
	$this->renderCloneCommand(
	$repository,
	$repository->getPublicCloneURI()));
	break;
	}
	}

	$view->invokeWillRenderEvent();

	$description = $repository->getDetail('description');
	if (strlen($description)) {
	$description = PhabricatorMarkupEngine::renderOneObject(
	$repository,
	'description',
	$user);
	$view->addSectionHeader(
	pht('Description'), PHUIPropertyListView::ICON_SUMMARY);
	$view->addTextContent($description);
	}

	$view->setActionList($actions);

	$box = id(new PHUIObjectBoxView())
	->setHeader($header)
	->addPropertyList($view);

	$info = null;
	$drequest = $this->getDiffusionRequest();

	// Try to load alternatives. This may fail for repositories which have not
	// cloned yet. If it does, just ignore it and continue.
	try {
	$alternatives = $drequest->getRefAlternatives();
	} catch (ConduitClientException $ex) {
	$alternatives = array();
	}

	if ($alternatives) {
	$message = array(
	pht(
	'The ref "%s" is ambiguous in this repository.',
	$drequest->getBranch()),
	' ',
	phutil_tag(
	'a',
	array(
	'href' => $drequest->generateURI(
	array(
	'action' => 'refs',
	)),
	),
	pht('View Alternatives')),
	);

	$messages = array($message);

	$info = id(new PHUIInfoView())
	->setSeverity(PHUIInfoView::SEVERITY_WARNING)
	->setErrors(array($message));

	$box->setInfoView($info);
	}


	return $box;
	}

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

	if ($drequest->getBranch() === null) {
	return null;
	}

	$limit = 15;

	$branches = $this->callConduitWithDiffusionRequest(
	'diffusion.branchquery',
	array(
	'closed' => false,
	'limit' => $limit + 1,
	));
	if (!$branches) {
	return null;
	}

	$more_branches = (count($branches) > $limit);
	$branches = array_slice($branches, 0, $limit);

	$branches = DiffusionRepositoryRef::loadAllFromDictionaries($branches);

	$commits = id(new DiffusionCommitQuery())
	->setViewer($viewer)
	->withIdentifiers(mpull($branches, 'getCommitIdentifier'))
	->withRepository($drequest->getRepository())
	->execute();

	$table = id(new DiffusionBranchTableView())
	->setUser($viewer)
	->setDiffusionRequest($drequest)
	->setBranches($branches)
	->setCommits($commits);

	$panel = new PHUIObjectBoxView();
	$header = new PHUIHeaderView();
	$header->setHeader(pht('Branches'));

	if ($more_branches) {
	$header->setSubHeader(pht('Showing %d branches.', $limit));
	}

	$icon = id(new PHUIIconView())
	->setIconFont('fa-code-fork');

	$button = new PHUIButtonView();
	$button->setText(pht('Show All Branches'));
	$button->setTag('a');
	$button->setIcon($icon);
	$button->setHref($drequest->generateURI(
	array(
	'action' => 'branches',
	)));

	$header->addActionLink($button);
	$panel->setHeader($header);
	$panel->setTable($table);

	return $panel;
	}

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

	switch ($repository->getVersionControlSystem()) {
	case PhabricatorRepositoryType::REPOSITORY_TYPE_SVN:
	// no tags in SVN
	return null;
	}
	$tag_limit = 15;
	$tags = array();
	$tags = DiffusionRepositoryTag::newFromConduit(
	$this->callConduitWithDiffusionRequest(
	'diffusion.tagsquery',
	array(
	// On the home page, we want to find tags on any branch.
	'commit' => null,
	'limit' => $tag_limit + 1,
	)));

	if (!$tags) {
	return null;
	}

	$more_tags = (count($tags) > $tag_limit);
	$tags = array_slice($tags, 0, $tag_limit);

	$commits = id(new DiffusionCommitQuery())
	->setViewer($viewer)
	->withIdentifiers(mpull($tags, 'getCommitIdentifier'))
	->withRepository($repository)
	->needCommitData(true)
	->execute();

	$view = id(new DiffusionTagListView())
	->setUser($viewer)
	->setDiffusionRequest($drequest)
	->setTags($tags)
	->setCommits($commits);

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

	$panel = new PHUIObjectBoxView();
	$header = new PHUIHeaderView();
	$header->setHeader(pht('Tags'));

	if ($more_tags) {
	$header->setSubHeader(
	pht('Showing the %d most recent tags.', $tag_limit));
	}

	$icon = id(new PHUIIconView())
	->setIconFont('fa-tag');

	$button = new PHUIButtonView();
	$button->setText(pht('Show All Tags'));
	$button->setTag('a');
	$button->setIcon($icon);
	$button->setHref($drequest->generateURI(
	array(
	'action' => 'tags',
	)));

	$header->addActionLink($button);

	$panel->setHeader($header);
	$panel->setTable($view);

	return $panel;
	}

	private function buildActionList(PhabricatorRepository $repository) {
	$viewer = $this->getRequest()->getUser();

	- $edit_uri = $this->getApplicationURI($repository->getCallsign().'/edit/');
	+ $edit_uri = $repository->getPathURI('edit/');

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

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

	$view->addAction(
	id(new PhabricatorActionView())
	->setName(pht('Edit Repository'))
	->setIcon('fa-pencil')
	->setHref($edit_uri)
	->setWorkflow(!$can_edit)
	->setDisabled(!$can_edit));

	if ($repository->isHosted()) {
	$push_uri = $this->getApplicationURI(
	'pushlog/?repositories='.$repository->getMonogram());

	$view->addAction(
	id(new PhabricatorActionView())
	->setName(pht('View Push Logs'))
	->setIcon('fa-list-alt')
	->setHref($push_uri));
	}

	return $view;
	}

	private function buildHistoryTable(
	$history_results,
	$history,
	$history_exception) {

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

	if ($history_exception) {
	if ($repository->isImporting()) {
	return $this->renderStatusMessage(
	pht('Still Importing...'),
	pht(
	'This repository is still importing. History is not yet '.
	'available.'));
	} else {
	return $this->renderStatusMessage(
	pht('Unable to Retrieve History'),
	$history_exception->getMessage());
	}
	}

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

	// TODO: Super sketchy.
	$history_table->loadRevisions();

	if ($history_results) {
	$history_table->setParents($history_results['parents']);
	}

	$history_table->setIsHead(true);

	$icon = id(new PHUIIconView())
	->setIconFont('fa-list-alt');

	$button = id(new PHUIButtonView())
	->setText(pht('View Full History'))
	->setHref($drequest->generateURI(
	array(
	'action' => 'history',
	)))
	->setTag('a')
	->setIcon($icon);

	$panel = new PHUIObjectBoxView();
	$header = id(new PHUIHeaderView())
	->setHeader(pht('Recent Commits'))
	->addActionLink($button);
	$panel->setHeader($header);
	$panel->setTable($history_table);

	return $panel;
	}

	private function buildBrowseTable(
	$browse_results,
	$browse_paths,
	$browse_exception,
	array $handles) {

	require_celerity_resource('diffusion-icons-css');

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

	if ($browse_exception) {
	if ($repository->isImporting()) {
	// The history table renders a useful message.
	return null;
	} else {
	return $this->renderStatusMessage(
	pht('Unable to Retrieve Paths'),
	$browse_exception->getMessage());
	}
	}

	$browse_table = id(new DiffusionBrowseTableView())
	->setUser($viewer)
	->setDiffusionRequest($drequest)
	->setHandles($handles);
	if ($browse_paths) {
	$browse_table->setPaths($browse_paths);
	} else {
	$browse_table->setPaths(array());
	}

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

	$browse_panel = new PHUIObjectBoxView();
	$header = id(new PHUIHeaderView())
	->setHeader(pht('Repository'));

	$icon = id(new PHUIIconView())
	->setIconFont('fa-folder-open');

	$button = new PHUIButtonView();
	$button->setText(pht('Browse Repository'));
	$button->setTag('a');
	$button->setIcon($icon);
	$button->setHref($browse_uri);

	$header->addActionLink($button);
	$browse_panel->setHeader($header);

	$locate_panel = null;
	if ($repository->canUsePathTree()) {
	Javelin::initBehavior(
	'diffusion-locate-file',
	array(
	'controlID' => 'locate-control',
	'inputID' => 'locate-input',
	'browseBaseURI' => (string)$drequest->generateURI(
	array(
	'action' => 'browse',
	)),
	'uri' => (string)$drequest->generateURI(
	array(
	'action' => 'pathtree',
	)),
	));

	$form = id(new AphrontFormView())
	->setUser($viewer)
	->appendChild(
	id(new AphrontFormTypeaheadControl())
	->setHardpointID('locate-control')
	->setID('locate-input')
	->setLabel(pht('Locate File')));
	$form_box = id(new PHUIBoxView())
	->appendChild($form->buildLayoutView());
	$locate_panel = id(new PHUIObjectBoxView())
	->setHeaderText('Locate File')
	->appendChild($form_box);
	}

	$browse_panel->setTable($browse_table);

	return array($locate_panel, $browse_panel);
	}

	private function renderCloneCommand(
	PhabricatorRepository $repository,
	$uri,
	$serve_mode = null,
	$manage_uri = null) {

	require_celerity_resource('diffusion-icons-css');

	Javelin::initBehavior('select-on-click');

	switch ($repository->getVersionControlSystem()) {
	case PhabricatorRepositoryType::REPOSITORY_TYPE_GIT:
	$command = csprintf(
	'git clone %R',
	$uri);
	break;
	case PhabricatorRepositoryType::REPOSITORY_TYPE_MERCURIAL:
	$command = csprintf(
	'hg clone %R',
	$uri);
	break;
	case PhabricatorRepositoryType::REPOSITORY_TYPE_SVN:
	if ($repository->isHosted()) {
	$command = csprintf(
	'svn checkout %R %R',
	$uri,
	$repository->getCloneName());
	} else {
	$command = csprintf(
	'svn checkout %R',
	$uri);
	}
	break;
	}

	$input = javelin_tag(
	'input',
	array(
	'type' => 'text',
	'value' => (string)$command,
	'class' => 'diffusion-clone-uri',
	'sigil' => 'select-on-click',
	'readonly' => 'true',
	));

	$extras = array();
	if ($serve_mode) {
	if ($serve_mode === PhabricatorRepository::SERVE_READONLY) {
	$extras[] = pht('(Read Only)');
	}
	}

	if ($manage_uri) {
	if ($this->getRequest()->getUser()->isLoggedIn()) {
	$extras[] = phutil_tag(
	'a',
	array(
	'href' => $manage_uri,
	),
	pht('Manage Credentials'));
	}
	}

	if ($extras) {
	$extras = phutil_implode_html(' ', $extras);
	$extras = phutil_tag(
	'div',
	array(
	'class' => 'diffusion-clone-extras',
	),
	$extras);
	}

	return array($input, $extras);
	}

	}
	diff --git a/src/applications/diffusion/herald/DiffusionCommitBranchesHeraldField.php b/src/applications/diffusion/herald/DiffusionCommitBranchesHeraldField.php
	index dec0a05f0d..03c4e3be62 100644
	--- a/src/applications/diffusion/herald/DiffusionCommitBranchesHeraldField.php
	+++ b/src/applications/diffusion/herald/DiffusionCommitBranchesHeraldField.php
	@@ -1,34 +1,34 @@
	<?php

	final class DiffusionCommitBranchesHeraldField
	extends DiffusionCommitHeraldField {

	const FIELDCONST = 'diffusion.commit.branches';

	public function getHeraldFieldName() {
	return pht('Branches');
	}

	public function getHeraldFieldValue($object) {
	$commit = $object;
	$repository = $object->getRepository();

	$params = array(
	- 'callsign' => $repository->getCallsign(),
	+ 'repository' => $repository->getPHID(),
	'contains' => $commit->getCommitIdentifier(),
	);

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

	$refs = DiffusionRepositoryRef::loadAllFromDictionaries($result);

	return mpull($refs, 'getShortName');
	}

	protected function getHeraldFieldStandardType() {
	return self::STANDARD_TEXT_LIST;
	}

	}
	diff --git a/src/applications/diffusion/query/DiffusionQuery.php b/src/applications/diffusion/query/DiffusionQuery.php
	index a180a61f5a..409bf68980 100644
	--- a/src/applications/diffusion/query/DiffusionQuery.php
	+++ b/src/applications/diffusion/query/DiffusionQuery.php
	@@ -1,217 +1,217 @@
	<?php

	abstract class DiffusionQuery extends PhabricatorQuery {

	private $request;

	final protected function __construct() {
	// <protected>
	}

	protected static function newQueryObject(
	$base_class,
	DiffusionRequest $request) {

	$repository = $request->getRepository();

	$obj = self::initQueryObject($base_class, $repository);
	$obj->request = $request;

	return $obj;
	}

	final protected static function initQueryObject(
	$base_class,
	PhabricatorRepository $repository) {

	$map = array(
	PhabricatorRepositoryType::REPOSITORY_TYPE_GIT => 'Git',
	PhabricatorRepositoryType::REPOSITORY_TYPE_MERCURIAL => 'Mercurial',
	PhabricatorRepositoryType::REPOSITORY_TYPE_SVN => 'Svn',
	);

	$name = idx($map, $repository->getVersionControlSystem());
	if (!$name) {
	throw new Exception(pht('Unsupported VCS!'));
	}

	$class = str_replace('Diffusion', 'Diffusion'.$name, $base_class);
	$obj = new $class();
	return $obj;
	}

	final protected function getRequest() {
	return $this->request;
	}

	final public static function callConduitWithDiffusionRequest(
	PhabricatorUser $user,
	DiffusionRequest $drequest,
	$method,
	array $params = array()) {

	$repository = $drequest->getRepository();

	$core_params = array(
	- 'callsign' => $repository->getCallsign(),
	+ 'repository' => $repository->getPHID(),
	);

	if ($drequest->getBranch() !== null) {
	$core_params['branch'] = $drequest->getBranch();
	}

	// If the method we're calling doesn't actually take some of the implicit
	// parameters we derive from the DiffusionRequest, omit them.
	$method_object = ConduitAPIMethod::getConduitMethod($method);
	$method_params = $method_object->getParamTypes();
	foreach ($core_params as $key => $value) {
	if (empty($method_params[$key])) {
	unset($core_params[$key]);
	}
	}

	$params = $params + $core_params;

	$client = $repository->newConduitClient(
	$user,
	$drequest->getIsClusterRequest());
	if (!$client) {
	return id(new ConduitCall($method, $params))
	->setUser($user)
	->execute();
	} else {
	return $client->callMethodSynchronous($method, $params);
	}
	}

	public function execute() {
	return $this->executeQuery();
	}

	abstract protected function executeQuery();


	/* -( Query Utilities )---------------------------------------------------- */


	final public static function loadCommitsByIdentifiers(
	array $identifiers,
	DiffusionRequest $drequest) {
	if (!$identifiers) {
	return array();
	}

	$commits = array();
	$commit_data = array();

	$repository = $drequest->getRepository();

	$commits = id(new PhabricatorRepositoryCommit())->loadAllWhere(
	'repositoryID = %d AND commitIdentifier IN (%Ls)',
	$repository->getID(),
	$identifiers);
	$commits = mpull($commits, null, 'getCommitIdentifier');

	// Build empty commit objects for every commit, so we can show unparsed
	// commits in history views (as "Importing") instead of not showing them.
	// This makes the process of importing and parsing commits clearer to the
	// user.

	$commit_list = array();
	foreach ($identifiers as $identifier) {
	$commit_obj = idx($commits, $identifier);
	if (!$commit_obj) {
	$commit_obj = new PhabricatorRepositoryCommit();
	$commit_obj->setRepositoryID($repository->getID());
	$commit_obj->setCommitIdentifier($identifier);
	$commit_obj->makeEphemeral();
	}
	$commit_list[$identifier] = $commit_obj;
	}
	$commits = $commit_list;

	$commit_ids = array_filter(mpull($commits, 'getID'));
	if ($commit_ids) {
	$commit_data = id(new PhabricatorRepositoryCommitData())->loadAllWhere(
	'commitID in (%Ld)',
	$commit_ids);
	$commit_data = mpull($commit_data, null, 'getCommitID');
	}

	foreach ($commits as $commit) {
	if (!$commit->getID()) {
	continue;
	}
	if (idx($commit_data, $commit->getID())) {
	$commit->attachCommitData($commit_data[$commit->getID()]);
	}
	}

	return $commits;
	}

	final public static function loadHistoryForCommitIdentifiers(
	array $identifiers,
	DiffusionRequest $drequest) {

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

	$repository = $drequest->getRepository();
	$commits = self::loadCommitsByIdentifiers($identifiers, $drequest);

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

	$path = $drequest->getPath();

	$conn_r = $repository->establishConnection('r');

	$path_normal = DiffusionPathIDQuery::normalizePath($path);
	$paths = queryfx_all(
	$conn_r,
	'SELECT id, path FROM %T WHERE pathHash IN (%Ls)',
	PhabricatorRepository::TABLE_PATH,
	array(md5($path_normal)));
	$paths = ipull($paths, 'id', 'path');
	$path_id = idx($paths, $path_normal);

	$commit_ids = array_filter(mpull($commits, 'getID'));

	$path_changes = array();
	if ($path_id && $commit_ids) {
	$path_changes = queryfx_all(
	$conn_r,
	'SELECT * FROM %T WHERE commitID IN (%Ld) AND pathID = %d',
	PhabricatorRepository::TABLE_PATHCHANGE,
	$commit_ids,
	$path_id);
	$path_changes = ipull($path_changes, null, 'commitID');
	}

	$history = array();
	foreach ($identifiers as $identifier) {
	$item = new DiffusionPathChange();
	$item->setCommitIdentifier($identifier);
	$commit = idx($commits, $identifier);
	if ($commit) {
	$item->setCommit($commit);
	try {
	$item->setCommitData($commit->getCommitData());
	} catch (Exception $ex) {
	// Ignore, commit just doesn't have data.
	}
	$change = idx($path_changes, $commit->getID());
	if ($change) {
	$item->setChangeType($change['changeType']);
	$item->setFileType($change['fileType']);
	}
	}
	$history[] = $item;
	}

	return $history;
	}
	}
	diff --git a/src/applications/diffusion/request/DiffusionRequest.php b/src/applications/diffusion/request/DiffusionRequest.php
	index fe28364f5d..9df5efc2c8 100644
	--- a/src/applications/diffusion/request/DiffusionRequest.php
	+++ b/src/applications/diffusion/request/DiffusionRequest.php
	@@ -1,871 +1,879 @@
	<?php

	/**
	* Contains logic to parse Diffusion requests, which have a complicated URI
	* structure.
	*
	* @task new Creating Requests
	* @task uri Managing Diffusion URIs
	*/
	abstract class DiffusionRequest extends Phobject {

	protected $path;
	protected $line;
	protected $branch;
	protected $lint;

	protected $symbolicCommit;
	protected $symbolicType;
	protected $stableCommit;

	protected $repository;
	protected $repositoryCommit;
	protected $repositoryCommitData;

	private $isClusterRequest = false;
	private $initFromConduit = true;
	private $user;
	private $branchObject = false;
	private $refAlternatives;

	abstract public function supportsBranches();
	abstract protected function isStableCommit($symbol);

	protected function didInitialize() {
	return null;
	}


	/* -( Creating Requests )-------------------------------------------------- */


	/**
	* Create a new synthetic request from a parameter dictionary. If you need
	* a @{class:DiffusionRequest} object in order to issue a DiffusionQuery, you
	* can use this method to build one.
	*
	* Parameters are:
	*
	* - `repository` Repository object or identifier.
	* - `user` Viewing user. Required if `repository` is an identifier.
	* - `branch` Optional, branch name.
	* - `path` Optional, file path.
	* - `commit` Optional, commit identifier.
	* - `line` Optional, line range.
	*
	* @param map See documentation.
	* @return DiffusionRequest New request object.
	* @task new
	*/
	final public static function newFromDictionary(array $data) {
	$repository_key = 'repository';
	$identifier_key = 'callsign';
	$viewer_key = 'user';

	$repository = idx($data, $repository_key);
	$identifier = idx($data, $identifier_key);

	$have_repository = ($repository !== null);
	$have_identifier = ($identifier !== null);

	if ($have_repository && $have_identifier) {
	throw new Exception(
	pht(
	'Specify "%s" or "%s", but not both.',
	$repository_key,
	$identifier_key));
	}

	if (!$have_repository && !$have_identifier) {
	throw new Exception(
	pht(
	'One of "%s" and "%s" is required.',
	$repository_key,
	$identifier_key));
	}

	if ($have_repository) {
	if (!($repository instanceof PhabricatorRepository)) {
	if (empty($data[$viewer_key])) {
	throw new Exception(
	pht(
	'Parameter "%s" is required if "%s" is provided.',
	$viewer_key,
	$identifier_key));
	}

	$identifier = $repository;
	$repository = null;
	}
	}

	if ($identifier !== null) {
	$object = self::newFromIdentifier($identifier, $data[$viewer_key]);
	} else {
	$object = self::newFromRepository($repository);
	}

	$object->initializeFromDictionary($data);

	return $object;
	}


	/**
	* Create a new request from an Aphront request dictionary. This is an
	* internal method that you generally should not call directly; instead,
	* call @{method:newFromDictionary}.
	*
	* @param map Map of Aphront request data.
	* @return DiffusionRequest New request object.
	* @task new
	*/
	final public static function newFromAphrontRequestDictionary(
	array $data,
	AphrontRequest $request) {

	$identifier = phutil_unescape_uri_path_component(idx($data, 'callsign'));
	$object = self::newFromIdentifier($identifier, $request->getUser());

	$use_branches = $object->supportsBranches();

	if (isset($data['dblob'])) {
	$parsed = self::parseRequestBlob(idx($data, 'dblob'), $use_branches);
	} else {
	$parsed = array(
	'commit' => idx($data, 'commit'),
	'path' => idx($data, 'path'),
	'line' => idx($data, 'line'),
	'branch' => idx($data, 'branch'),
	);
	}

	$object->setUser($request->getUser());
	$object->initializeFromDictionary($parsed);
	$object->lint = $request->getStr('lint');
	return $object;
	}


	/**
	* Internal.
	*
	* @task new
	*/
	final private function __construct() {
	// <private>
	}


	/**
	* Internal. Use @{method:newFromDictionary}, not this method.
	*
	* @param string Repository identifier.
	* @param PhabricatorUser Viewing user.
	* @return DiffusionRequest New request object.
	* @task new
	*/
	final private static function newFromIdentifier(
	$identifier,
	PhabricatorUser $viewer) {

	$repository = id(new PhabricatorRepositoryQuery())
	->setViewer($viewer)
	->withIdentifiers(array($identifier))
	->executeOne();

	if (!$repository) {
	throw new Exception(pht("No such repository '%s'.", $identifier));
	}

	return self::newFromRepository($repository);
	}


	/**
	* Internal. Use @{method:newFromDictionary}, not this method.
	*
	* @param PhabricatorRepository Repository object.
	* @return DiffusionRequest New request object.
	* @task new
	*/
	final private static function newFromRepository(
	PhabricatorRepository $repository) {

	$map = array(
	PhabricatorRepositoryType::REPOSITORY_TYPE_GIT => 'DiffusionGitRequest',
	PhabricatorRepositoryType::REPOSITORY_TYPE_SVN => 'DiffusionSvnRequest',
	PhabricatorRepositoryType::REPOSITORY_TYPE_MERCURIAL =>
	'DiffusionMercurialRequest',
	);

	$class = idx($map, $repository->getVersionControlSystem());

	if (!$class) {
	throw new Exception(pht('Unknown version control system!'));
	}

	$object = new $class();

	$object->repository = $repository;

	return $object;
	}


	/**
	* Internal. Use @{method:newFromDictionary}, not this method.
	*
	* @param map Map of parsed data.
	* @return void
	* @task new
	*/
	final private function initializeFromDictionary(array $data) {
	$this->path = idx($data, 'path');
	$this->line = idx($data, 'line');
	$this->initFromConduit = idx($data, 'initFromConduit', true);

	$this->symbolicCommit = idx($data, 'commit');
	if ($this->supportsBranches()) {
	$this->branch = idx($data, 'branch');
	}

	if (!$this->getUser()) {
	$user = idx($data, 'user');
	if (!$user) {
	throw new Exception(
	pht(
	'You must provide a %s in the dictionary!',
	'PhabricatorUser'));
	}
	$this->setUser($user);
	}

	$this->didInitialize();
	}

	final public function setUser(PhabricatorUser $user) {
	$this->user = $user;
	return $this;
	}
	final public function getUser() {
	return $this->user;
	}

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

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

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

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

	public function getLine() {
	return $this->line;
	}

	public function getCommit() {

	// TODO: Probably remove all of this.

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

	return $this->getStableCommit();
	}

	/**
	* Get the symbolic commit associated with this request.
	*
	* A symbolic commit may be a commit hash, an abbreviated commit hash, a
	* branch name, a tag name, or an expression like "HEAD^^^". The symbolic
	* commit may also be absent.
	*
	* This method always returns the symbol present in the original request,
	* in unmodified form.
	*
	* See also @{method:getStableCommit}.
	*
	* @return string\|null Symbolic commit, if one was present in the request.
	*/
	public function getSymbolicCommit() {
	return $this->symbolicCommit;
	}


	/**
	* Modify the request to move the symbolic commit elsewhere.
	*
	* @param string New symbolic commit.
	* @return this
	*/
	public function updateSymbolicCommit($symbol) {
	$this->symbolicCommit = $symbol;
	$this->symbolicType = null;
	$this->stableCommit = null;
	return $this;
	}


	/**
	* Get the ref type (`commit` or `tag`) of the location associated with this
	* request.
	*
	* If a symbolic commit is present in the request, this method identifies
	* the type of the symbol. Otherwise, it identifies the type of symbol of
	* the location the request is implicitly associated with. This will probably
	* always be `commit`.
	*
	* @return string Symbolic commit type (`commit` or `tag`).
	*/
	public function getSymbolicType() {
	if ($this->symbolicType === null) {
	// As a side effect, this resolves the symbolic type.
	$this->getStableCommit();
	}
	return $this->symbolicType;
	}


	/**
	* Retrieve the stable, permanent commit name identifying the repository
	* location associated with this request.
	*
	* This returns a non-symbolic identifier for the current commit: in Git and
	* Mercurial, a 40-character SHA1; in SVN, a revision number.
	*
	* See also @{method:getSymbolicCommit}.
	*
	* @return string Stable commit name, like a git hash or SVN revision. Not
	* a symbolic commit reference.
	*/
	public function getStableCommit() {
	if (!$this->stableCommit) {
	if ($this->isStableCommit($this->symbolicCommit)) {
	$this->stableCommit = $this->symbolicCommit;
	$this->symbolicType = 'commit';
	} else {
	$this->queryStableCommit();
	}
	}
	return $this->stableCommit;
	}


	public function getBranch() {
	return $this->branch;
	}

	public function getLint() {
	return $this->lint;
	}

	protected function getArcanistBranch() {
	return $this->getBranch();
	}

	public function loadBranch() {
	// TODO: Get rid of this and do real Queries on real objects.

	if ($this->branchObject === false) {
	$this->branchObject = PhabricatorRepositoryBranch::loadBranch(
	$this->getRepository()->getID(),
	$this->getArcanistBranch());
	}

	return $this->branchObject;
	}

	public function loadCoverage() {
	// TODO: This should also die.
	$branch = $this->loadBranch();
	if (!$branch) {
	return;
	}

	$path = $this->getPath();
	$path_map = id(new DiffusionPathIDQuery(array($path)))->loadPathIDs();

	$coverage_row = queryfx_one(
	id(new PhabricatorRepository())->establishConnection('r'),
	'SELECT * FROM %T WHERE branchID = %d AND pathID = %d
	ORDER BY commitID DESC LIMIT 1',
	'repository_coverage',
	$branch->getID(),
	$path_map[$path]);

	if (!$coverage_row) {
	return null;
	}

	return idx($coverage_row, 'coverage');
	}


	public function loadCommit() {
	if (empty($this->repositoryCommit)) {
	$repository = $this->getRepository();

	$commit = id(new DiffusionCommitQuery())
	->setViewer($this->getUser())
	->withRepository($repository)
	->withIdentifiers(array($this->getStableCommit()))
	->executeOne();
	if ($commit) {
	$commit->attachRepository($repository);
	}
	$this->repositoryCommit = $commit;
	}
	return $this->repositoryCommit;
	}

	public function loadCommitData() {
	if (empty($this->repositoryCommitData)) {
	$commit = $this->loadCommit();
	$data = id(new PhabricatorRepositoryCommitData())->loadOneWhere(
	'commitID = %d',
	$commit->getID());
	if (!$data) {
	$data = new PhabricatorRepositoryCommitData();
	$data->setCommitMessage(
	pht('(This commit has not been fully parsed yet.)'));
	}
	$this->repositoryCommitData = $data;
	}
	return $this->repositoryCommitData;
	}

	/* -( Managing Diffusion URIs )-------------------------------------------- */


	/**
	* Generate a Diffusion URI using this request to provide defaults. See
	* @{method:generateDiffusionURI} for details. This method is the same, but
	* preserves the request parameters if they are not overridden.
	*
	* @param map See @{method:generateDiffusionURI}.
	* @return PhutilURI Generated URI.
	* @task uri
	*/
	public function generateURI(array $params) {
	if (empty($params['stable'])) {
	$default_commit = $this->getSymbolicCommit();
	} else {
	$default_commit = $this->getStableCommit();
	}

	$defaults = array(
	- 'callsign' => $this->getCallsign(),
	+ 'repository' => $this->getRepository(),
	'path' => $this->getPath(),
	'branch' => $this->getBranch(),
	'commit' => $default_commit,
	'lint' => idx($params, 'lint', $this->getLint()),
	);
	foreach ($defaults as $key => $val) {
	if (!isset($params[$key])) { // Overwrite NULL.
	$params[$key] = $val;
	}
	}
	return self::generateDiffusionURI($params);
	}


	/**
	* Generate a Diffusion URI from a parameter map. Applies the correct encoding
	* and formatting to the URI. Parameters are:
	*
	* - `action` One of `history`, `browse`, `change`, `lastmodified`,
	* `branch`, `tags`, `branches`, or `revision-ref`. The action specified
	* by the URI.
	+ * - `repository` Repository.
	* - `callsign` Repository callsign.
	* - `branch` Optional if action is not `branch`, branch name.
	* - `path` Optional, path to file.
	* - `commit` Optional, commit identifier.
	* - `line` Optional, line range.
	* - `lint` Optional, lint code.
	* - `params` Optional, query parameters.
	*
	* The function generates the specified URI and returns it.
	*
	* @param map See documentation.
	* @return PhutilURI Generated URI.
	* @task uri
	*/
	public static function generateDiffusionURI(array $params) {
	$action = idx($params, 'action');

	- $callsign = idx($params, 'callsign');
	+ $repository = idx($params, 'repository');
	+
	+ if ($repository) {
	+ $callsign = $repository->getCallsign();
	+ } else {
	+ $callsign = idx($params, 'callsign');
	+ }
	+
	$path = idx($params, 'path');
	$branch = idx($params, 'branch');
	$commit = idx($params, 'commit');
	$line = idx($params, 'line');

	if (strlen($callsign)) {
	$callsign = phutil_escape_uri_path_component($callsign).'/';
	}

	if (strlen($branch)) {
	$branch = phutil_escape_uri_path_component($branch).'/';
	}

	if (strlen($path)) {
	$path = ltrim($path, '/');
	$path = str_replace(array(';', '$'), array(';;', '$$'), $path);
	$path = phutil_escape_uri($path);
	}

	$path = "{$branch}{$path}";

	if (strlen($commit)) {
	$commit = str_replace('$', '$$', $commit);
	$commit = ';'.phutil_escape_uri($commit);
	}

	if (strlen($line)) {
	$line = '$'.phutil_escape_uri($line);
	}

	$req_callsign = false;
	$req_branch = false;
	$req_commit = false;

	switch ($action) {
	case 'history':
	case 'browse':
	case 'change':
	case 'lastmodified':
	case 'tags':
	case 'branches':
	case 'lint':
	case 'refs':
	$req_callsign = true;
	break;
	case 'branch':
	$req_callsign = true;
	$req_branch = true;
	break;
	case 'commit':
	$req_callsign = true;
	$req_commit = true;
	break;
	}

	if ($req_callsign && !strlen($callsign)) {
	throw new Exception(
	pht(
	"Diffusion URI action '%s' requires callsign!",
	$action));
	}

	if ($req_commit && !strlen($commit)) {
	throw new Exception(
	pht(
	"Diffusion URI action '%s' requires commit!",
	$action));
	}

	switch ($action) {
	case 'change':
	case 'history':
	case 'browse':
	case 'lastmodified':
	case 'tags':
	case 'branches':
	case 'lint':
	case 'pathtree':
	case 'refs':
	$uri = "/diffusion/{$callsign}{$action}/{$path}{$commit}{$line}";
	break;
	case 'branch':
	if (strlen($path)) {
	$uri = "/diffusion/{$callsign}repository/{$path}";
	} else {
	$uri = "/diffusion/{$callsign}";
	}
	break;
	case 'external':
	$commit = ltrim($commit, ';');
	$uri = "/diffusion/external/{$commit}/";
	break;
	case 'rendering-ref':
	// This isn't a real URI per se, it's passed as a query parameter to
	// the ajax changeset stuff but then we parse it back out as though
	// it came from a URI.
	$uri = rawurldecode("{$path}{$commit}");
	break;
	case 'commit':
	$commit = ltrim($commit, ';');
	$callsign = rtrim($callsign, '/');
	$uri = "/r{$callsign}{$commit}";
	break;
	default:
	throw new Exception(pht("Unknown Diffusion URI action '%s'!", $action));
	}

	if ($action == 'rendering-ref') {
	return $uri;
	}

	$uri = new PhutilURI($uri);

	if (isset($params['lint'])) {
	$params['params'] = idx($params, 'params', array()) + array(
	'lint' => $params['lint'],
	);
	}

	if (idx($params, 'params')) {
	$uri->setQueryParams($params['params']);
	}

	return $uri;
	}


	/**
	* Internal. Public only for unit tests.
	*
	* Parse the request URI into components.
	*
	* @param string URI blob.
	* @param bool True if this VCS supports branches.
	* @return map Parsed URI.
	*
	* @task uri
	*/
	public static function parseRequestBlob($blob, $supports_branches) {
	$result = array(
	'branch' => null,
	'path' => null,
	'commit' => null,
	'line' => null,
	);

	$matches = null;

	if ($supports_branches) {
	// Consume the front part of the URI, up to the first "/". This is the
	// path-component encoded branch name.
	if (preg_match('@^([^/]+)/@', $blob, $matches)) {
	$result['branch'] = phutil_unescape_uri_path_component($matches[1]);
	$blob = substr($blob, strlen($matches[1]) + 1);
	}
	}

	// Consume the back part of the URI, up to the first "$". Use a negative
	// lookbehind to prevent matching '$$'. We double the '$' symbol when
	// encoding so that files with names like "money/$100" will survive.
	$pattern = '@(?:(?:^\|[^$])(?:[$][$])*)[$]([\d-,]+)$@';
	if (preg_match($pattern, $blob, $matches)) {
	$result['line'] = $matches[1];
	$blob = substr($blob, 0, -(strlen($matches[1]) + 1));
	}

	// We've consumed the line number if it exists, so unescape "$" in the
	// rest of the string.
	$blob = str_replace('$$', '$', $blob);

	// Consume the commit name, stopping on ';;'. We allow any character to
	// appear in commits names, as they can sometimes be symbolic names (like
	// tag names or refs).
	if (preg_match('@(?:(?:^\|[^;])(?:;;));([^;].)$@', $blob, $matches)) {
	$result['commit'] = $matches[1];
	$blob = substr($blob, 0, -(strlen($matches[1]) + 1));
	}

	// We've consumed the commit if it exists, so unescape ";" in the rest
	// of the string.
	$blob = str_replace(';;', ';', $blob);

	if (strlen($blob)) {
	$result['path'] = $blob;
	}

	$parts = explode('/', $result['path']);
	foreach ($parts as $part) {
	// Prevent any hyjinx since we're ultimately shipping this to the
	// filesystem under a lot of workflows.
	if ($part == '..') {
	throw new Exception(pht('Invalid path URI.'));
	}
	}

	return $result;
	}

	/**
	* Check that the working copy of the repository is present and readable.
	*
	* @param string Path to the working copy.
	*/
	protected function validateWorkingCopy($path) {
	if (!is_readable(dirname($path))) {
	$this->raisePermissionException();
	}

	if (!Filesystem::pathExists($path)) {
	$this->raiseCloneException();
	}
	}

	protected function raisePermissionException() {
	$host = php_uname('n');
	throw new DiffusionSetupException(
	pht(
	'The clone of this repository ("%s") on the local machine ("%s") '.
	'could not be read. Ensure that the repository is in a '.
	'location where the web server has read permissions.',
	$this->getRepository()->getDisplayName(),
	$host));
	}

	protected function raiseCloneException() {
	$host = php_uname('n');
	throw new DiffusionSetupException(
	pht(
	'The working copy for this repository ("%s") has not been cloned yet '.
	'on this machine ("%s"). Make sure you havestarted the Phabricator '.
	'daemons. If this problem persists for longer than a clone should '.
	'take, check the daemon logs (in the Daemon Console) to see if there '.
	'were errors cloning the repository. Consult the "Diffusion User '.
	'Guide" in the documentation for help setting up repositories.',
	$this->getRepository()->getDisplayName(),
	$host));
	}

	private function queryStableCommit() {
	$types = array();
	if ($this->symbolicCommit) {
	$ref = $this->symbolicCommit;
	} else {
	if ($this->supportsBranches()) {
	$ref = $this->getBranch();
	$types = array(
	PhabricatorRepositoryRefCursor::TYPE_BRANCH,
	);
	} else {
	$ref = 'HEAD';
	}
	}

	$results = $this->resolveRefs(array($ref), $types);

	$matches = idx($results, $ref, array());
	if (!$matches) {
	$message = pht(
	'Ref "%s" does not exist in this repository.',
	$ref);
	throw id(new DiffusionRefNotFoundException($message))
	->setRef($ref);
	}

	if (count($matches) > 1) {
	$match = $this->chooseBestRefMatch($ref, $matches);
	} else {
	$match = head($matches);
	}

	$this->stableCommit = $match['identifier'];
	$this->symbolicType = $match['type'];
	}

	public function getRefAlternatives() {
	// Make sure we've resolved the reference into a stable commit first.
	try {
	$this->getStableCommit();
	} catch (DiffusionRefNotFoundException $ex) {
	// If we have a bad reference, just return the empty set of
	// alternatives.
	}
	return $this->refAlternatives;
	}

	private function chooseBestRefMatch($ref, array $results) {
	// First, filter out less-desirable matches.
	$candidates = array();
	foreach ($results as $result) {
	// Exclude closed heads.
	if ($result['type'] == 'branch') {
	if (idx($result, 'closed')) {
	continue;
	}
	}

	$candidates[] = $result;
	}

	// If we filtered everything, undo the filtering.
	if (!$candidates) {
	$candidates = $results;
	}

	// TODO: Do a better job of selecting the best match?
	$match = head($candidates);

	// After choosing the best alternative, save all the alternatives so the
	// UI can show them to the user.
	if (count($candidates) > 1) {
	$this->refAlternatives = $candidates;
	}

	return $match;
	}

	private function resolveRefs(array $refs, array $types) {
	// First, try to resolve refs from fast cache sources.
	$cached_query = id(new DiffusionCachedResolveRefsQuery())
	->setRepository($this->getRepository())
	->withRefs($refs);

	if ($types) {
	$cached_query->withTypes($types);
	}

	$cached_results = $cached_query->execute();

	// Throw away all the refs we resolved. Hopefully, we'll throw away
	// everything here.
	foreach ($refs as $key => $ref) {
	if (isset($cached_results[$ref])) {
	unset($refs[$key]);
	}
	}

	// If we couldn't pull everything out of the cache, execute the underlying
	// VCS operation.
	if ($refs) {
	$vcs_results = DiffusionQuery::callConduitWithDiffusionRequest(
	$this->getUser(),
	$this,
	'diffusion.resolverefs',
	array(
	'types' => $types,
	'refs' => $refs,
	));
	} else {
	$vcs_results = array();
	}

	return $vcs_results + $cached_results;
	}

	public function setIsClusterRequest($is_cluster_request) {
	$this->isClusterRequest = $is_cluster_request;
	return $this;
	}

	public function getIsClusterRequest() {
	return $this->isClusterRequest;
	}

	}
	diff --git a/src/applications/harbormaster/step/HarbormasterWaitForPreviousBuildStepImplementation.php b/src/applications/harbormaster/step/HarbormasterWaitForPreviousBuildStepImplementation.php
	index f4e965b6c2..7f63eda072 100644
	--- a/src/applications/harbormaster/step/HarbormasterWaitForPreviousBuildStepImplementation.php
	+++ b/src/applications/harbormaster/step/HarbormasterWaitForPreviousBuildStepImplementation.php
	@@ -1,115 +1,115 @@
	<?php

	final class HarbormasterWaitForPreviousBuildStepImplementation
	extends HarbormasterBuildStepImplementation {

	public function getName() {
	return pht('Wait for Previous Commits to Build');
	}

	public function getGenericDescription() {
	return pht(
	'Wait for previous commits to finish building the current plan '.
	'before continuing.');
	}

	public function getBuildStepGroupKey() {
	return HarbormasterPrototypeBuildStepGroup::GROUPKEY;
	}

	public function execute(
	HarbormasterBuild $build,
	HarbormasterBuildTarget $build_target) {

	// We can only wait when building against commits.
	$buildable = $build->getBuildable();
	$object = $buildable->getBuildableObject();
	if (!($object instanceof PhabricatorRepositoryCommit)) {
	return;
	}

	// Block until all previous builds of the same build plan have
	// finished.
	$plan = $build->getBuildPlan();

	$existing_logs = id(new HarbormasterBuildLogQuery())
	->setViewer(PhabricatorUser::getOmnipotentUser())
	->withBuildTargetPHIDs(array($build_target->getPHID()))
	->execute();

	if ($existing_logs) {
	$log = head($existing_logs);
	} else {
	$log = $build->createLog($build_target, 'waiting', 'blockers');
	}

	$blockers = $this->getBlockers($object, $plan, $build);
	if ($blockers) {
	$log->start();
	$log->append(pht("Blocked by: %s\n", implode(',', $blockers)));
	$log->finalize();
	}

	if ($blockers) {
	throw new PhabricatorWorkerYieldException(15);
	}
	}

	private function getBlockers(
	PhabricatorRepositoryCommit $commit,
	HarbormasterBuildPlan $plan,
	HarbormasterBuild $source) {

	$call = new ConduitCall(
	'diffusion.commitparentsquery',
	array(
	- 'commit' => $commit->getCommitIdentifier(),
	- 'callsign' => $commit->getRepository()->getCallsign(),
	+ 'commit' => $commit->getCommitIdentifier(),
	+ 'repository' => $commit->getRepository()->getPHID(),
	));
	$call->setUser(PhabricatorUser::getOmnipotentUser());
	$parents = $call->execute();

	$parents = id(new DiffusionCommitQuery())
	->setViewer(PhabricatorUser::getOmnipotentUser())
	->withRepository($commit->getRepository())
	->withIdentifiers($parents)
	->execute();

	$blockers = array();

	$build_objects = array();
	foreach ($parents as $parent) {
	if (!$parent->isImported()) {
	$blockers[] = pht('Commit %s', $parent->getCommitIdentifier());
	} else {
	$build_objects[] = $parent->getPHID();
	}
	}

	if ($build_objects) {
	$buildables = id(new HarbormasterBuildableQuery())
	->setViewer(PhabricatorUser::getOmnipotentUser())
	->withBuildablePHIDs($build_objects)
	->withManualBuildables(false)
	->execute();
	$buildable_phids = mpull($buildables, 'getPHID');

	if ($buildable_phids) {
	$builds = id(new HarbormasterBuildQuery())
	->setViewer(PhabricatorUser::getOmnipotentUser())
	->withBuildablePHIDs($buildable_phids)
	->withBuildPlanPHIDs(array($plan->getPHID()))
	->execute();

	foreach ($builds as $build) {
	if (!$build->isComplete()) {
	$blockers[] = pht('Build %d', $build->getID());
	}
	}
	}
	}

	return $blockers;
	}

	}
	diff --git a/src/applications/owners/controller/PhabricatorOwnersDetailController.php b/src/applications/owners/controller/PhabricatorOwnersDetailController.php
	index 6193e5b367..f87a4bb59b 100644
	--- a/src/applications/owners/controller/PhabricatorOwnersDetailController.php
	+++ b/src/applications/owners/controller/PhabricatorOwnersDetailController.php
	@@ -1,330 +1,330 @@
	<?php

	final class PhabricatorOwnersDetailController
	extends PhabricatorOwnersController {

	public function shouldAllowPublic() {
	return true;
	}

	public function handleRequest(AphrontRequest $request) {
	$viewer = $this->getViewer();

	$package = id(new PhabricatorOwnersPackageQuery())
	->setViewer($viewer)
	->withIDs(array($request->getURIData('id')))
	->needPaths(true)
	->executeOne();
	if (!$package) {
	return new Aphront404Response();
	}

	$paths = $package->getPaths();

	$repository_phids = array();
	foreach ($paths as $path) {
	$repository_phids[$path->getRepositoryPHID()] = true;
	}

	if ($repository_phids) {
	$repositories = id(new PhabricatorRepositoryQuery())
	->setViewer($viewer)
	->withPHIDs(array_keys($repository_phids))
	->execute();
	$repositories = mpull($repositories, null, 'getPHID');
	} else {
	$repositories = array();
	}

	$field_list = PhabricatorCustomField::getObjectFields(
	$package,
	PhabricatorCustomField::ROLE_VIEW);
	$field_list
	->setViewer($viewer)
	->readFieldsFromStorage($package);

	$actions = $this->buildPackageActionView($package);
	$properties = $this->buildPackagePropertyView($package, $field_list);
	$properties->setActionList($actions);

	if ($package->isArchived()) {
	$header_icon = 'fa-ban';
	$header_name = pht('Archived');
	$header_color = 'dark';
	} else {
	$header_icon = 'fa-check';
	$header_name = pht('Active');
	$header_color = 'bluegrey';
	}

	$header = id(new PHUIHeaderView())
	->setUser($viewer)
	->setHeader($package->getName())
	->setStatus($header_icon, $header_color, $header_name)
	->setPolicyObject($package);

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

	$commit_views = array();

	$commit_uri = id(new PhutilURI('/audit/'))
	->setQueryParams(
	array(
	'auditorPHIDs' => $package->getPHID(),
	));

	$status_concern = DiffusionCommitQuery::AUDIT_STATUS_CONCERN;

	$attention_commits = id(new DiffusionCommitQuery())
	->setViewer($request->getUser())
	->withAuditorPHIDs(array($package->getPHID()))
	->withAuditStatus($status_concern)
	->needCommitData(true)
	->setLimit(10)
	->execute();
	$view = id(new PhabricatorAuditListView())
	->setUser($viewer)
	->setNoDataString(pht('This package has no open problem commits.'))
	->setCommits($attention_commits);

	$commit_views[] = array(
	'view' => $view,
	'header' => pht('Commits in this Package that Need Attention'),
	'button' => id(new PHUIButtonView())
	->setTag('a')
	->setHref($commit_uri->alter('status', $status_concern))
	->setText(pht('View All Problem Commits')),
	);

	$all_commits = id(new DiffusionCommitQuery())
	->setViewer($request->getUser())
	->withAuditorPHIDs(array($package->getPHID()))
	->needCommitData(true)
	->setLimit(100)
	->execute();

	$view = id(new PhabricatorAuditListView())
	->setUser($viewer)
	->setCommits($all_commits)
	->setNoDataString(pht('No commits in this package.'));

	$commit_views[] = array(
	'view' => $view,
	'header' => pht('Recent Commits in Package'),
	'button' => id(new PHUIButtonView())
	->setTag('a')
	->setHref($commit_uri)
	->setText(pht('View All Package Commits')),
	);

	$phids = array();
	foreach ($commit_views as $commit_view) {
	$phids[] = $commit_view['view']->getRequiredHandlePHIDs();
	}
	$phids = array_mergev($phids);
	$handles = $this->loadViewerHandles($phids);

	$commit_panels = array();
	foreach ($commit_views as $commit_view) {
	$commit_panel = new PHUIObjectBoxView();
	$header = new PHUIHeaderView();
	$header->setHeader($commit_view['header']);
	if (isset($commit_view['button'])) {
	$header->addActionLink($commit_view['button']);
	}
	$commit_view['view']->setHandles($handles);
	$commit_panel->setHeader($header);
	$commit_panel->appendChild($commit_view['view']);

	$commit_panels[] = $commit_panel;
	}

	$crumbs = $this->buildApplicationCrumbs();
	$crumbs->addTextCrumb($package->getName());

	$timeline = $this->buildTransactionTimeline(
	$package,
	new PhabricatorOwnersPackageTransactionQuery());
	$timeline->setShouldTerminate(true);

	return $this->buildApplicationPage(
	array(
	$crumbs,
	$panel,
	$this->renderPathsTable($paths, $repositories),
	$commit_panels,
	$timeline,
	),
	array(
	'title' => $package->getName(),
	));
	}


	private function buildPackagePropertyView(
	PhabricatorOwnersPackage $package,
	PhabricatorCustomFieldList $field_list) {

	$viewer = $this->getViewer();

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

	$owners = $package->getOwners();
	if ($owners) {
	$owner_list = $viewer->renderHandleList(mpull($owners, 'getUserPHID'));
	} else {
	$owner_list = phutil_tag('em', array(), pht('None'));
	}
	$view->addProperty(pht('Owners'), $owner_list);

	if ($package->getAuditingEnabled()) {
	$auditing = pht('Enabled');
	} else {
	$auditing = pht('Disabled');
	}
	$view->addProperty(pht('Auditing'), $auditing);

	$description = $package->getDescription();
	if (strlen($description)) {
	$view->addSectionHeader(
	pht('Description'), PHUIPropertyListView::ICON_SUMMARY);
	$view->addTextContent(
	$output = PhabricatorMarkupEngine::renderOneObject(
	id(new PhabricatorMarkupOneOff())->setContent($description),
	'default',
	$viewer));
	}

	$view->invokeWillRenderEvent();

	$field_list->appendFieldsToPropertyList(
	$package,
	$viewer,
	$view);

	return $view;
	}

	private function buildPackageActionView(PhabricatorOwnersPackage $package) {
	$viewer = $this->getViewer();

	// TODO: Implement this capability.
	$can_edit = true;

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

	$action_list = id(new PhabricatorActionListView())
	->setUser($viewer)
	->setObject($package);

	$action_list->addAction(
	id(new PhabricatorActionView())
	->setName(pht('Edit Package'))
	->setIcon('fa-pencil')
	->setDisabled(!$can_edit)
	->setWorkflow(!$can_edit)
	->setHref($edit_uri));

	if ($package->isArchived()) {
	$action_list->addAction(
	id(new PhabricatorActionView())
	->setName(pht('Activate Package'))
	->setIcon('fa-check')
	->setDisabled(!$can_edit)
	->setWorkflow($can_edit)
	->setHref($this->getApplicationURI("/archive/{$id}/")));
	} else {
	$action_list->addAction(
	id(new PhabricatorActionView())
	->setName(pht('Archive Package'))
	->setIcon('fa-ban')
	->setDisabled(!$can_edit)
	->setWorkflow($can_edit)
	->setHref($this->getApplicationURI("/archive/{$id}/")));
	}

	$action_list->addAction(
	id(new PhabricatorActionView())
	->setName(pht('Edit Paths'))
	->setIcon('fa-folder-open')
	->setDisabled(!$can_edit)
	->setWorkflow(!$can_edit)
	->setHref($paths_uri));

	return $action_list;
	}

	private function renderPathsTable(array $paths, array $repositories) {
	$viewer = $this->getViewer();

	$rows = array();
	foreach ($paths as $path) {
	$repo = idx($repositories, $path->getRepositoryPHID());
	if (!$repo) {
	continue;
	}
	$href = DiffusionRequest::generateDiffusionURI(
	array(
	- 'callsign' => $repo->getCallsign(),
	+ 'repository' => $repo,
	'branch' => $repo->getDefaultBranch(),
	'path' => $path->getPath(),
	'action' => 'browse',
	));

	$path_link = phutil_tag(
	'a',
	array(
	'href' => (string)$href,
	),
	$path->getPath());

	$rows[] = array(
	($path->getExcluded() ? '-' : '+'),
	$repo->getName(),
	$path_link,
	);
	}

	$info = null;
	if (!$paths) {
	$info = id(new PHUIInfoView())
	->setSeverity(PHUIInfoView::SEVERITY_WARNING)
	->setErrors(
	array(
	pht(
	'This package does not contain any paths yet. Use '.
	'"Edit Paths" to add some.'),
	));
	}

	$table = id(new AphrontTableView($rows))
	->setHeaders(
	array(
	null,
	pht('Repository'),
	pht('Path'),
	))
	->setColumnClasses(
	array(
	null,
	null,
	'wide',
	));

	$box = id(new PHUIObjectBoxView())
	->setHeaderText(pht('Paths'))
	->setTable($table);

	if ($info) {
	$box->setInfoView($info);
	}

	return $box;
	}

	}
	diff --git a/src/applications/repository/customfield/PhabricatorCommitBranchesField.php b/src/applications/repository/customfield/PhabricatorCommitBranchesField.php
	index 63a807ea55..b018e32e34 100644
	--- a/src/applications/repository/customfield/PhabricatorCommitBranchesField.php
	+++ b/src/applications/repository/customfield/PhabricatorCommitBranchesField.php
	@@ -1,53 +1,53 @@
	<?php

	final class PhabricatorCommitBranchesField
	extends PhabricatorCommitCustomField {

	public function getFieldKey() {
	return 'diffusion:branches';
	}

	public function getFieldName() {
	return pht('Branches');
	}

	public function getFieldDescription() {
	return pht('Shows branches a commit appears on in email.');
	}

	public function shouldAppearInTransactionMail() {
	return true;
	}

	public function updateTransactionMailBody(
	PhabricatorMetaMTAMailBody $body,
	PhabricatorApplicationTransactionEditor $editor,
	array $xactions) {

	$params = array(
	'contains' => $this->getObject()->getCommitIdentifier(),
	- 'callsign' => $this->getObject()->getRepository()->getCallsign(),
	+ 'repository' => $this->getObject()->getRepository()->getPHID(),
	);

	try {
	$branches_raw = id(new ConduitCall('diffusion.branchquery', $params))
	->setUser($this->getViewer())
	->execute();

	$branches = DiffusionRepositoryRef::loadAllFromDictionaries(
	$branches_raw);
	if (!$branches) {
	return;
	}

	$branch_names = mpull($branches, 'getShortName');
	sort($branch_names);
	$branch_text = implode(', ', $branch_names);
	} catch (Exception $ex) {
	$branch_text = pht('<%s: %s>', get_class($ex), $ex->getMessage());
	}

	$body->addTextSection(pht('BRANCHES'), $branch_text);
	}

	}
	diff --git a/src/applications/repository/customfield/PhabricatorCommitMergedCommitsField.php b/src/applications/repository/customfield/PhabricatorCommitMergedCommitsField.php
	index 267b440dce..c8a53b387d 100644
	--- a/src/applications/repository/customfield/PhabricatorCommitMergedCommitsField.php
	+++ b/src/applications/repository/customfield/PhabricatorCommitMergedCommitsField.php
	@@ -1,74 +1,74 @@
	<?php

	final class PhabricatorCommitMergedCommitsField
	extends PhabricatorCommitCustomField {

	public function getFieldKey() {
	return 'diffusion:mergedcommits';
	}

	public function getFieldName() {
	return pht('Merged Commits');
	}

	public function getFieldDescription() {
	return pht('For merge commits, shows merged changes in email.');
	}

	public function shouldDisableByDefault() {
	return true;
	}

	public function shouldAppearInTransactionMail() {
	return true;
	}

	public function updateTransactionMailBody(
	PhabricatorMetaMTAMailBody $body,
	PhabricatorApplicationTransactionEditor $editor,
	array $xactions) {

	// Put all the merged commits info int the mail body if this is a merge
	$merges_caption = '';
	// TODO: Make this limit configurable after T6030
	$limit = 50;
	$commit = $this->getObject();

	try {
	$merges = DiffusionPathChange::newFromConduit(
	id(new ConduitCall('diffusion.mergedcommitsquery', array(
	'commit' => $commit->getCommitIdentifier(),
	'limit' => $limit + 1,
	- 'callsign' => $commit->getRepository()->getCallsign(),
	+ 'repository' => $commit->getRepository()->getPHID(),
	)))
	->setUser($this->getViewer())
	->execute());

	if (count($merges) > $limit) {
	$merges = array_slice($merges, 0, $limit);
	$merges_caption =
	pht("This commit merges more than %d changes. Only the first ".
	"%d are shown.\n", $limit, $limit);
	}

	if ($merges) {
	$merge_commits = array();
	foreach ($merges as $merge) {
	$merge_commits[] = $merge->getAuthorName().
	': '.
	$merge->getSummary();
	}
	$body->addTextSection(
	pht('MERGED COMMITS'),
	$merges_caption.implode("\n", $merge_commits));
	}
	} catch (ConduitException $ex) {
	// Log the exception into the email body
	$body->addTextSection(
	pht('MERGED COMMITS'),
	pht('Error generating merged commits: ').$ex->getMessage());
	}

	}

	}
	diff --git a/src/applications/repository/customfield/PhabricatorCommitTagsField.php b/src/applications/repository/customfield/PhabricatorCommitTagsField.php
	index 001d81e960..5f8e1448c2 100644
	--- a/src/applications/repository/customfield/PhabricatorCommitTagsField.php
	+++ b/src/applications/repository/customfield/PhabricatorCommitTagsField.php
	@@ -1,51 +1,51 @@
	<?php

	final class PhabricatorCommitTagsField
	extends PhabricatorCommitCustomField {

	public function getFieldKey() {
	return 'diffusion:tags';
	}

	public function getFieldName() {
	return pht('Tags');
	}

	public function getFieldDescription() {
	return pht('Shows commit tags in email.');
	}

	public function shouldAppearInTransactionMail() {
	return true;
	}

	public function updateTransactionMailBody(
	PhabricatorMetaMTAMailBody $body,
	PhabricatorApplicationTransactionEditor $editor,
	array $xactions) {

	$params = array(
	'commit' => $this->getObject()->getCommitIdentifier(),
	- 'callsign' => $this->getObject()->getRepository()->getCallsign(),
	+ 'repository' => $this->getObject()->getRepository()->getPHID(),
	);

	try {
	$tags_raw = id(new ConduitCall('diffusion.tagsquery', $params))
	->setUser($this->getViewer())
	->execute();

	$tags = DiffusionRepositoryTag::newFromConduit($tags_raw);
	if (!$tags) {
	return;
	}
	$tag_names = mpull($tags, 'getName');
	sort($tag_names);
	$tag_names = implode(', ', $tag_names);
	} catch (Exception $ex) {
	$tag_names = pht('<%s: %s>', get_class($ex), $ex->getMessage());
	}

	$body->addTextSection(pht('TAGS'), $tag_names);
	}

	}
	diff --git a/src/applications/repository/query/PhabricatorRepositorySearchEngine.php b/src/applications/repository/query/PhabricatorRepositorySearchEngine.php
	index 1abc964f6c..1e15228630 100644
	--- a/src/applications/repository/query/PhabricatorRepositorySearchEngine.php
	+++ b/src/applications/repository/query/PhabricatorRepositorySearchEngine.php
	@@ -1,263 +1,263 @@
	<?php

	final class PhabricatorRepositorySearchEngine
	extends PhabricatorApplicationSearchEngine {

	public function getResultTypeDescription() {
	return pht('Repositories');
	}

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

	public function newQuery() {
	return id(new PhabricatorRepositoryQuery())
	->needProjectPHIDs(true)
	->needCommitCounts(true)
	->needMostRecentCommits(true);
	}

	protected function buildCustomSearchFields() {
	return array(
	id(new PhabricatorSearchStringListField())
	->setLabel(pht('Callsigns'))
	->setKey('callsigns'),
	id(new PhabricatorSearchTextField())
	->setLabel(pht('Name Contains'))
	->setKey('name'),
	id(new PhabricatorSearchSelectField())
	->setLabel(pht('Status'))
	->setKey('status')
	->setOptions($this->getStatusOptions()),
	id(new PhabricatorSearchSelectField())
	->setLabel(pht('Hosted'))
	->setKey('hosted')
	->setOptions($this->getHostedOptions()),
	id(new PhabricatorSearchCheckboxesField())
	->setLabel(pht('Types'))
	->setKey('types')
	->setOptions(PhabricatorRepositoryType::getAllRepositoryTypes()),
	);
	}

	protected function buildQueryFromParameters(array $map) {
	$query = $this->newQuery();

	if ($map['callsigns']) {
	$query->withCallsigns($map['callsigns']);
	}

	if ($map['status']) {
	$status = idx($this->getStatusValues(), $map['status']);
	if ($status) {
	$query->withStatus($status);
	}
	}

	if ($map['hosted']) {
	$hosted = idx($this->getHostedValues(), $map['hosted']);
	if ($hosted) {
	$query->withHosted($hosted);
	}
	}

	if ($map['types']) {
	$query->withTypes($map['types']);
	}

	if (strlen($map['name'])) {
	$query->withNameContains($map['name']);
	}

	return $query;
	}

	protected function getURI($path) {
	return '/diffusion/'.$path;
	}

	protected function getBuiltinQueryNames() {
	$names = array(
	'active' => pht('Active Repositories'),
	'all' => pht('All Repositories'),
	);

	return $names;
	}

	public function buildSavedQueryFromBuiltin($query_key) {

	$query = $this->newSavedQuery();
	$query->setQueryKey($query_key);

	switch ($query_key) {
	case 'active':
	return $query->setParameter('status', 'open');
	case 'all':
	return $query;
	}

	return parent::buildSavedQueryFromBuiltin($query_key);
	}

	private function getStatusOptions() {
	return array(
	'' => pht('Active and Inactive Repositories'),
	'open' => pht('Active Repositories'),
	'closed' => pht('Inactive Repositories'),
	);
	}

	private function getStatusValues() {
	return array(
	'' => PhabricatorRepositoryQuery::STATUS_ALL,
	'open' => PhabricatorRepositoryQuery::STATUS_OPEN,
	'closed' => PhabricatorRepositoryQuery::STATUS_CLOSED,
	);
	}

	private function getHostedOptions() {
	return array(
	'' => pht('Hosted and Remote Repositories'),
	'phabricator' => pht('Hosted Repositories'),
	'remote' => pht('Remote Repositories'),
	);
	}

	private function getHostedValues() {
	return array(
	'' => PhabricatorRepositoryQuery::HOSTED_ALL,
	'phabricator' => PhabricatorRepositoryQuery::HOSTED_PHABRICATOR,
	'remote' => PhabricatorRepositoryQuery::HOSTED_REMOTE,
	);
	}

	protected function getRequiredHandlePHIDsForResultList(
	array $repositories,
	PhabricatorSavedQuery $query) {
	return array_mergev(mpull($repositories, 'getProjectPHIDs'));
	}

	protected function renderResultList(
	array $repositories,
	PhabricatorSavedQuery $query,
	array $handles) {
	assert_instances_of($repositories, 'PhabricatorRepository');

	$viewer = $this->requireViewer();

	$list = new PHUIObjectItemListView();
	foreach ($repositories as $repository) {
	$id = $repository->getID();

	$item = id(new PHUIObjectItemView())
	->setUser($viewer)
	->setObject($repository)
	->setHeader($repository->getName())
	->setObjectName($repository->getMonogram())
	->setHref($repository->getURI());

	$commit = $repository->getMostRecentCommit();
	if ($commit) {
	$commit_link = DiffusionView::linkCommit(
	$repository,
	$commit->getCommitIdentifier(),
	$commit->getSummary());
	$item->setSubhead($commit_link);
	$item->setEpoch($commit->getEpoch());
	}

	$item->addIcon(
	'none',
	PhabricatorRepositoryType::getNameForRepositoryType(
	$repository->getVersionControlSystem()));

	$size = $repository->getCommitCount();
	if ($size) {
	$history_uri = DiffusionRequest::generateDiffusionURI(
	array(
	- 'callsign' => $repository->getCallsign(),
	+ 'repository' => $repository,
	'action' => 'history',
	));

	$item->addAttribute(
	phutil_tag(
	'a',
	array(
	'href' => $history_uri,
	),
	pht('%s Commit(s)', new PhutilNumber($size))));
	} else {
	$item->addAttribute(pht('No Commits'));
	}

	$project_handles = array_select_keys(
	$handles,
	$repository->getProjectPHIDs());
	if ($project_handles) {
	$item->addAttribute(
	id(new PHUIHandleTagListView())
	->setSlim(true)
	->setHandles($project_handles));
	}

	if (!$repository->isTracked()) {
	$item->setDisabled(true);
	$item->addIcon('disable-grey', pht('Inactive'));
	}

	$list->addItem($item);
	}

	$result = new PhabricatorApplicationSearchResultView();
	$result->setObjectList($list);
	$result->setNoDataString(pht('No repositories found for this query.'));

	return $result;
	}

	protected function willUseSavedQuery(PhabricatorSavedQuery $saved) {
	$project_phids = $saved->getParameter('projectPHIDs', array());

	$old = $saved->getParameter('projects', array());
	foreach ($old as $phid) {
	$project_phids[] = $phid;
	}

	$any = $saved->getParameter('anyProjectPHIDs', array());
	foreach ($any as $project) {
	$project_phids[] = 'any('.$project.')';
	}

	$saved->setParameter('projectPHIDs', $project_phids);
	}

	protected function getNewUserBody() {

	$import_button = id(new PHUIButtonView())
	->setTag('a')
	->setText(pht('Import Repository'))
	->setHref('/diffusion/import/')
	->setColor(PHUIButtonView::GREEN);

	$create_button = id(new PHUIButtonView())
	->setTag('a')
	->setText(pht('Create Repository'))
	->setHref('/diffusion/create/')
	->setColor(PHUIButtonView::GREEN);

	$icon = $this->getApplication()->getFontIcon();
	$app_name = $this->getApplication()->getName();
	$view = id(new PHUIBigInfoView())
	->setIcon($icon)
	->setTitle(pht('Welcome to %s', $app_name))
	->setDescription(
	pht('Import, create, or just browse repositories in Diffusion.'))
	->addAction($import_button)
	->addAction($create_button);

	return $view;
	}

	}
	diff --git a/src/applications/repository/storage/PhabricatorRepository.php b/src/applications/repository/storage/PhabricatorRepository.php
	index 1002fb9491..6996571b94 100644
	--- a/src/applications/repository/storage/PhabricatorRepository.php
	+++ b/src/applications/repository/storage/PhabricatorRepository.php
	@@ -1,1996 +1,2000 @@
	<?php

	/**
	* @task uri Repository URI Management
	* @task autoclose Autoclose
	*/
	final class PhabricatorRepository extends PhabricatorRepositoryDAO
	implements
	PhabricatorApplicationTransactionInterface,
	PhabricatorPolicyInterface,
	PhabricatorFlaggableInterface,
	PhabricatorMarkupInterface,
	PhabricatorDestructibleInterface,
	PhabricatorProjectInterface,
	PhabricatorSpacesInterface {

	/**
	* Shortest hash we'll recognize in raw "a829f32" form.
	*/
	const MINIMUM_UNQUALIFIED_HASH = 7;

	/**
	* Shortest hash we'll recognize in qualified "rXab7ef2f8" form.
	*/
	const MINIMUM_QUALIFIED_HASH = 5;

	const TABLE_PATH = 'repository_path';
	const TABLE_PATHCHANGE = 'repository_pathchange';
	const TABLE_FILESYSTEM = 'repository_filesystem';
	const TABLE_SUMMARY = 'repository_summary';
	const TABLE_BADCOMMIT = 'repository_badcommit';
	const TABLE_LINTMESSAGE = 'repository_lintmessage';
	const TABLE_PARENTS = 'repository_parents';
	const TABLE_COVERAGE = 'repository_coverage';

	const SERVE_OFF = 'off';
	const SERVE_READONLY = 'readonly';
	const SERVE_READWRITE = 'readwrite';

	const BECAUSE_REPOSITORY_IMPORTING = 'auto/importing';
	const BECAUSE_AUTOCLOSE_DISABLED = 'auto/disabled';
	const BECAUSE_NOT_ON_AUTOCLOSE_BRANCH = 'auto/nobranch';
	const BECAUSE_BRANCH_UNTRACKED = 'auto/notrack';
	const BECAUSE_BRANCH_NOT_AUTOCLOSE = 'auto/noclose';
	const BECAUSE_AUTOCLOSE_FORCED = 'auto/forced';

	protected $name;
	protected $callsign;
	protected $uuid;
	protected $viewPolicy;
	protected $editPolicy;
	protected $pushPolicy;

	protected $versionControlSystem;
	protected $details = array();
	protected $credentialPHID;
	protected $almanacServicePHID;
	protected $spacePHID;

	private $commitCount = self::ATTACHABLE;
	private $mostRecentCommit = self::ATTACHABLE;
	private $projectPHIDs = self::ATTACHABLE;

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

	$view_policy = $app->getPolicy(DiffusionDefaultViewCapability::CAPABILITY);
	$edit_policy = $app->getPolicy(DiffusionDefaultEditCapability::CAPABILITY);
	$push_policy = $app->getPolicy(DiffusionDefaultPushCapability::CAPABILITY);

	$repository = id(new PhabricatorRepository())
	->setViewPolicy($view_policy)
	->setEditPolicy($edit_policy)
	->setPushPolicy($push_policy)
	->setSpacePHID($actor->getDefaultSpacePHID());

	// Put the repository in "Importing" mode until we finish
	// parsing it.
	$repository->setDetail('importing', true);

	return $repository;
	}

	protected function getConfiguration() {
	return array(
	self::CONFIG_AUX_PHID => true,
	self::CONFIG_SERIALIZATION => array(
	'details' => self::SERIALIZATION_JSON,
	),
	self::CONFIG_COLUMN_SCHEMA => array(
	'name' => 'sort255',
	'callsign' => 'sort32',
	'versionControlSystem' => 'text32',
	'uuid' => 'text64?',
	'pushPolicy' => 'policy',
	'credentialPHID' => 'phid?',
	'almanacServicePHID' => 'phid?',
	),
	self::CONFIG_KEY_SCHEMA => array(
	'key_phid' => null,
	'phid' => array(
	'columns' => array('phid'),
	'unique' => true,
	),
	'callsign' => array(
	'columns' => array('callsign'),
	'unique' => true,
	),
	'key_name' => array(
	'columns' => array('name(128)'),
	),
	'key_vcs' => array(
	'columns' => array('versionControlSystem'),
	),
	),
	) + parent::getConfiguration();
	}

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

	public function toDictionary() {
	return array(
	'id' => $this->getID(),
	'name' => $this->getName(),
	'phid' => $this->getPHID(),
	'callsign' => $this->getCallsign(),
	'monogram' => $this->getMonogram(),
	'vcs' => $this->getVersionControlSystem(),
	'uri' => PhabricatorEnv::getProductionURI($this->getURI()),
	'remoteURI' => (string)$this->getRemoteURI(),
	'description' => $this->getDetail('description'),
	'isActive' => $this->isTracked(),
	'isHosted' => $this->isHosted(),
	'isImporting' => $this->isImporting(),
	'encoding' => $this->getDetail('encoding'),
	'staging' => array(
	'supported' => $this->supportsStaging(),
	'prefix' => 'phabricator',
	'uri' => $this->getStagingURI(),
	),
	);
	}

	public function getMonogram() {
	return 'r'.$this->getCallsign();
	}

	public function getDisplayName() {
	// TODO: This is intended to produce a human-readable name that is not
	// necessarily a global, unique identifier. Eventually, it may just return
	// a string like "skynet" instead of "rSKYNET".
	return $this->getMonogram();
	}

	public function getAllMonograms() {
	$monograms = array();

	$monograms[] = 'R'.$this->getID();

	$callsign = $this->getCallsign();
	if (strlen($callsign)) {
	$monograms[] = 'r'.$callsign;
	}

	return $monograms;
	}

	public function getDetail($key, $default = null) {
	return idx($this->details, $key, $default);
	}

	public function getHumanReadableDetail($key, $default = null) {
	$value = $this->getDetail($key, $default);

	switch ($key) {
	case 'branch-filter':
	case 'close-commits-filter':
	$value = array_keys($value);
	$value = implode(', ', $value);
	break;
	}

	return $value;
	}

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

	public function attachCommitCount($count) {
	$this->commitCount = $count;
	return $this;
	}

	public function getCommitCount() {
	return $this->assertAttached($this->commitCount);
	}

	public function attachMostRecentCommit(
	PhabricatorRepositoryCommit $commit = null) {
	$this->mostRecentCommit = $commit;
	return $this;
	}

	public function getMostRecentCommit() {
	return $this->assertAttached($this->mostRecentCommit);
	}

	public function getDiffusionBrowseURIForPath(
	PhabricatorUser $user,
	$path,
	$line = null,
	$branch = null) {

	$drequest = DiffusionRequest::newFromDictionary(
	array(
	'user' => $user,
	'repository' => $this,
	'path' => $path,
	'branch' => $branch,
	));

	return $drequest->generateURI(
	array(
	'action' => 'browse',
	'line' => $line,
	));
	}

	public function getLocalPath() {
	return $this->getDetail('local-path');
	}

	public function getSubversionBaseURI($commit = null) {
	$subpath = $this->getDetail('svn-subpath');
	if (!strlen($subpath)) {
	$subpath = null;
	}
	return $this->getSubversionPathURI($subpath, $commit);
	}

	public function getSubversionPathURI($path = null, $commit = null) {
	$vcs = $this->getVersionControlSystem();
	if ($vcs != PhabricatorRepositoryType::REPOSITORY_TYPE_SVN) {
	throw new Exception(pht('Not a subversion repository!'));
	}

	if ($this->isHosted()) {
	$uri = 'file://'.$this->getLocalPath();
	} else {
	$uri = $this->getDetail('remote-uri');
	}

	$uri = rtrim($uri, '/');

	if (strlen($path)) {
	$path = rawurlencode($path);
	$path = str_replace('%2F', '/', $path);
	$uri = $uri.'/'.ltrim($path, '/');
	}

	if ($path !== null \|\| $commit !== null) {
	$uri .= '@';
	}

	if ($commit !== null) {
	$uri .= $commit;
	}

	return $uri;
	}

	public function attachProjectPHIDs(array $project_phids) {
	$this->projectPHIDs = $project_phids;
	return $this;
	}

	public function getProjectPHIDs() {
	return $this->assertAttached($this->projectPHIDs);
	}


	/**
	* Get the name of the directory this repository should clone or checkout
	* into. For example, if the repository name is "Example Repository", a
	* reasonable name might be "example-repository". This is used to help users
	* get reasonable results when cloning repositories, since they generally do
	* not want to clone into directories called "X/" or "Example Repository/".
	*
	* @return string
	*/
	public function getCloneName() {
	$name = $this->getDetail('clone-name');

	// Make some reasonable effort to produce reasonable default directory
	// names from repository names.
	if (!strlen($name)) {
	$name = $this->getName();
	$name = phutil_utf8_strtolower($name);
	$name = preg_replace('@[/ -:]+@', '-', $name);
	$name = trim($name, '-');
	if (!strlen($name)) {
	$name = $this->getCallsign();
	}
	}

	return $name;
	}


	/* -( Remote Command Execution )------------------------------------------- */


	public function execRemoteCommand($pattern /* , $arg, ... */) {
	$args = func_get_args();
	return $this->newRemoteCommandFuture($args)->resolve();
	}

	public function execxRemoteCommand($pattern /* , $arg, ... */) {
	$args = func_get_args();
	return $this->newRemoteCommandFuture($args)->resolvex();
	}

	public function getRemoteCommandFuture($pattern /* , $arg, ... */) {
	$args = func_get_args();
	return $this->newRemoteCommandFuture($args);
	}

	public function passthruRemoteCommand($pattern /* , $arg, ... */) {
	$args = func_get_args();
	return $this->newRemoteCommandPassthru($args)->execute();
	}

	private function newRemoteCommandFuture(array $argv) {
	$argv = $this->formatRemoteCommand($argv);
	$future = newv('ExecFuture', $argv);
	$future->setEnv($this->getRemoteCommandEnvironment());
	return $future;
	}

	private function newRemoteCommandPassthru(array $argv) {
	$argv = $this->formatRemoteCommand($argv);
	$passthru = newv('PhutilExecPassthru', $argv);
	$passthru->setEnv($this->getRemoteCommandEnvironment());
	return $passthru;
	}


	/* -( Local Command Execution )-------------------------------------------- */


	public function execLocalCommand($pattern /* , $arg, ... */) {
	$args = func_get_args();
	return $this->newLocalCommandFuture($args)->resolve();
	}

	public function execxLocalCommand($pattern /* , $arg, ... */) {
	$args = func_get_args();
	return $this->newLocalCommandFuture($args)->resolvex();
	}

	public function getLocalCommandFuture($pattern /* , $arg, ... */) {
	$args = func_get_args();
	return $this->newLocalCommandFuture($args);
	}

	public function passthruLocalCommand($pattern /* , $arg, ... */) {
	$args = func_get_args();
	return $this->newLocalCommandPassthru($args)->execute();
	}

	private function newLocalCommandFuture(array $argv) {
	$this->assertLocalExists();

	$argv = $this->formatLocalCommand($argv);
	$future = newv('ExecFuture', $argv);
	$future->setEnv($this->getLocalCommandEnvironment());

	if ($this->usesLocalWorkingCopy()) {
	$future->setCWD($this->getLocalPath());
	}

	return $future;
	}

	private function newLocalCommandPassthru(array $argv) {
	$this->assertLocalExists();

	$argv = $this->formatLocalCommand($argv);
	$future = newv('PhutilExecPassthru', $argv);
	$future->setEnv($this->getLocalCommandEnvironment());

	if ($this->usesLocalWorkingCopy()) {
	$future->setCWD($this->getLocalPath());
	}

	return $future;
	}


	/* -( Command Infrastructure )--------------------------------------------- */


	private function getSSHWrapper() {
	$root = dirname(phutil_get_library_root('phabricator'));
	return $root.'/bin/ssh-connect';
	}

	private function getCommonCommandEnvironment() {
	$env = array(
	// NOTE: Force the language to "en_US.UTF-8", which overrides locale
	// settings. This makes stuff print in English instead of, e.g., French,
	// so we can parse the output of some commands, error messages, etc.
	'LANG' => 'en_US.UTF-8',

	// Propagate PHABRICATOR_ENV explicitly. For discussion, see T4155.
	'PHABRICATOR_ENV' => PhabricatorEnv::getSelectedEnvironmentName(),
	);

	switch ($this->getVersionControlSystem()) {
	case PhabricatorRepositoryType::REPOSITORY_TYPE_SVN:
	break;
	case PhabricatorRepositoryType::REPOSITORY_TYPE_GIT:
	// NOTE: See T2965. Some time after Git 1.7.5.4, Git started fataling if
	// it can not read $HOME. For many users, $HOME points at /root (this
	// seems to be a default result of Apache setup). Instead, explicitly
	// point $HOME at a readable, empty directory so that Git looks for the
	// config file it's after, fails to locate it, and moves on. This is
	// really silly, but seems like the least damaging approach to
	// mitigating the issue.

	$root = dirname(phutil_get_library_root('phabricator'));
	$env['HOME'] = $root.'/support/empty/';
	break;
	case PhabricatorRepositoryType::REPOSITORY_TYPE_MERCURIAL:
	// NOTE: This overrides certain configuration, extensions, and settings
	// which make Mercurial commands do random unusual things.
	$env['HGPLAIN'] = 1;
	break;
	default:
	throw new Exception(pht('Unrecognized version control system.'));
	}

	return $env;
	}

	private function getLocalCommandEnvironment() {
	return $this->getCommonCommandEnvironment();
	}

	private function getRemoteCommandEnvironment() {
	$env = $this->getCommonCommandEnvironment();

	if ($this->shouldUseSSH()) {
	// NOTE: This is read by `bin/ssh-connect`, and tells it which credentials
	// to use.
	$env['PHABRICATOR_CREDENTIAL'] = $this->getCredentialPHID();
	switch ($this->getVersionControlSystem()) {
	case PhabricatorRepositoryType::REPOSITORY_TYPE_SVN:
	// Force SVN to use `bin/ssh-connect`.
	$env['SVN_SSH'] = $this->getSSHWrapper();
	break;
	case PhabricatorRepositoryType::REPOSITORY_TYPE_GIT:
	// Force Git to use `bin/ssh-connect`.
	$env['GIT_SSH'] = $this->getSSHWrapper();
	break;
	case PhabricatorRepositoryType::REPOSITORY_TYPE_MERCURIAL:
	// We force Mercurial through `bin/ssh-connect` too, but it uses a
	// command-line flag instead of an environmental variable.
	break;
	default:
	throw new Exception(pht('Unrecognized version control system.'));
	}
	}

	return $env;
	}

	private function formatRemoteCommand(array $args) {
	$pattern = $args[0];
	$args = array_slice($args, 1);

	switch ($this->getVersionControlSystem()) {
	case PhabricatorRepositoryType::REPOSITORY_TYPE_SVN:
	if ($this->shouldUseHTTP() \|\| $this->shouldUseSVNProtocol()) {
	$flags = array();
	$flag_args = array();
	$flags[] = '--non-interactive';
	$flags[] = '--no-auth-cache';
	if ($this->shouldUseHTTP()) {
	$flags[] = '--trust-server-cert';
	}

	$credential_phid = $this->getCredentialPHID();
	if ($credential_phid) {
	$key = PassphrasePasswordKey::loadFromPHID(
	$credential_phid,
	PhabricatorUser::getOmnipotentUser());
	$flags[] = '--username %P';
	$flags[] = '--password %P';
	$flag_args[] = $key->getUsernameEnvelope();
	$flag_args[] = $key->getPasswordEnvelope();
	}

	$flags = implode(' ', $flags);
	$pattern = "svn {$flags} {$pattern}";
	$args = array_mergev(array($flag_args, $args));
	} else {
	$pattern = "svn --non-interactive {$pattern}";
	}
	break;
	case PhabricatorRepositoryType::REPOSITORY_TYPE_GIT:
	$pattern = "git {$pattern}";
	break;
	case PhabricatorRepositoryType::REPOSITORY_TYPE_MERCURIAL:
	if ($this->shouldUseSSH()) {
	$pattern = "hg --config ui.ssh=%s {$pattern}";
	array_unshift(
	$args,
	$this->getSSHWrapper());
	} else {
	$pattern = "hg {$pattern}";
	}
	break;
	default:
	throw new Exception(pht('Unrecognized version control system.'));
	}

	array_unshift($args, $pattern);

	return $args;
	}

	private function formatLocalCommand(array $args) {
	$pattern = $args[0];
	$args = array_slice($args, 1);

	switch ($this->getVersionControlSystem()) {
	case PhabricatorRepositoryType::REPOSITORY_TYPE_SVN:
	$pattern = "svn --non-interactive {$pattern}";
	break;
	case PhabricatorRepositoryType::REPOSITORY_TYPE_GIT:
	$pattern = "git {$pattern}";
	break;
	case PhabricatorRepositoryType::REPOSITORY_TYPE_MERCURIAL:
	$pattern = "hg {$pattern}";
	break;
	default:
	throw new Exception(pht('Unrecognized version control system.'));
	}

	array_unshift($args, $pattern);

	return $args;
	}

	/**
	* Sanitize output of an `hg` command invoked with the `--debug` flag to make
	* it usable.
	*
	* @param string Output from `hg --debug ...`
	* @return string Usable output.
	*/
	public static function filterMercurialDebugOutput($stdout) {
	// When hg commands are run with `--debug` and some config file isn't
	// trusted, Mercurial prints out a warning to stdout, twice, after Feb 2011.
	//
	// http://selenic.com/pipermail/mercurial-devel/2011-February/028541.html
	//
	// After Jan 2015, it may also fail to write to a revision branch cache.

	$ignore = array(
	'ignoring untrusted configuration option',
	"couldn't write revision branch cache:",
	);

	foreach ($ignore as $key => $pattern) {
	$ignore[$key] = preg_quote($pattern, '/');
	}

	$ignore = '('.implode('\|', $ignore).')';

	$lines = preg_split('/(?<=\n)/', $stdout);
	$regex = '/'.$ignore.'.*\n$/';

	foreach ($lines as $key => $line) {
	$lines[$key] = preg_replace($regex, '', $line);
	}

	return implode('', $lines);
	}

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

	+ public function getPathURI($path) {
	+ return $this->getURI().$path;
	+ }
	+
	public function getCommitURI($identifier) {
	$callsign = $this->getCallsign();
	return "/r{$callsign}{$identifier}";
	}

	public function getNormalizedPath() {
	$uri = (string)$this->getCloneURIObject();

	switch ($this->getVersionControlSystem()) {
	case PhabricatorRepositoryType::REPOSITORY_TYPE_GIT:
	$normalized_uri = new PhabricatorRepositoryURINormalizer(
	PhabricatorRepositoryURINormalizer::TYPE_GIT,
	$uri);
	break;
	case PhabricatorRepositoryType::REPOSITORY_TYPE_SVN:
	$normalized_uri = new PhabricatorRepositoryURINormalizer(
	PhabricatorRepositoryURINormalizer::TYPE_SVN,
	$uri);
	break;
	case PhabricatorRepositoryType::REPOSITORY_TYPE_MERCURIAL:
	$normalized_uri = new PhabricatorRepositoryURINormalizer(
	PhabricatorRepositoryURINormalizer::TYPE_MERCURIAL,
	$uri);
	break;
	default:
	throw new Exception(pht('Unrecognized version control system.'));
	}

	return $normalized_uri->getNormalizedPath();
	}

	public function isTracked() {
	return $this->getDetail('tracking-enabled', false);
	}

	public function getDefaultBranch() {
	$default = $this->getDetail('default-branch');
	if (strlen($default)) {
	return $default;
	}

	$default_branches = array(
	PhabricatorRepositoryType::REPOSITORY_TYPE_GIT => 'master',
	PhabricatorRepositoryType::REPOSITORY_TYPE_MERCURIAL => 'default',
	);

	return idx($default_branches, $this->getVersionControlSystem());
	}

	public function getDefaultArcanistBranch() {
	return coalesce($this->getDefaultBranch(), 'svn');
	}

	private function isBranchInFilter($branch, $filter_key) {
	$vcs = $this->getVersionControlSystem();

	$is_git = ($vcs == PhabricatorRepositoryType::REPOSITORY_TYPE_GIT);

	$use_filter = ($is_git);
	if (!$use_filter) {
	// If this VCS doesn't use filters, pass everything through.
	return true;
	}


	$filter = $this->getDetail($filter_key, array());

	// If there's no filter set, let everything through.
	if (!$filter) {
	return true;
	}

	// If this branch isn't literally named `regexp(...)`, and it's in the
	// filter list, let it through.
	if (isset($filter[$branch])) {
	if (self::extractBranchRegexp($branch) === null) {
	return true;
	}
	}

	// If the branch matches a regexp, let it through.
	foreach ($filter as $pattern => $ignored) {
	$regexp = self::extractBranchRegexp($pattern);
	if ($regexp !== null) {
	if (preg_match($regexp, $branch)) {
	return true;
	}
	}
	}

	// Nothing matched, so filter this branch out.
	return false;
	}

	public static function extractBranchRegexp($pattern) {
	$matches = null;
	if (preg_match('/^regexp\$(.*)\$\z/', $pattern, $matches)) {
	return $matches[1];
	}
	return null;
	}

	public function shouldTrackBranch($branch) {
	return $this->isBranchInFilter($branch, 'branch-filter');
	}

	public function formatCommitName($commit_identifier) {
	$vcs = $this->getVersionControlSystem();

	$type_git = PhabricatorRepositoryType::REPOSITORY_TYPE_GIT;
	$type_hg = PhabricatorRepositoryType::REPOSITORY_TYPE_MERCURIAL;

	$is_git = ($vcs == $type_git);
	$is_hg = ($vcs == $type_hg);
	if ($is_git \|\| $is_hg) {
	$short_identifier = substr($commit_identifier, 0, 12);
	} else {
	$short_identifier = $commit_identifier;
	}

	return 'r'.$this->getCallsign().$short_identifier;
	}

	public function isImporting() {
	return (bool)$this->getDetail('importing', false);
	}


	/**
	* Should this repository publish feed, notifications, audits, and email?
	*
	* We do not publish information about repositories during initial import,
	* or if the repository has been set not to publish.
	*/
	public function shouldPublish() {
	if ($this->isImporting()) {
	return false;
	}

	if ($this->getDetail('herald-disabled')) {
	return false;
	}

	return true;
	}


	/* -( Autoclose )---------------------------------------------------------- */


	/**
	* Determine if autoclose is active for a branch.
	*
	* For more details about why, use @{method:shouldSkipAutocloseBranch}.
	*
	* @param string Branch name to check.
	* @return bool True if autoclose is active for the branch.
	* @task autoclose
	*/
	public function shouldAutocloseBranch($branch) {
	return ($this->shouldSkipAutocloseBranch($branch) === null);
	}

	/**
	* Determine if autoclose is active for a commit.
	*
	* For more details about why, use @{method:shouldSkipAutocloseCommit}.
	*
	* @param PhabricatorRepositoryCommit Commit to check.
	* @return bool True if autoclose is active for the commit.
	* @task autoclose
	*/
	public function shouldAutocloseCommit(PhabricatorRepositoryCommit $commit) {
	return ($this->shouldSkipAutocloseCommit($commit) === null);
	}


	/**
	* Determine why autoclose should be skipped for a branch.
	*
	* This method gives a detailed reason why autoclose will be skipped. To
	* perform a simple test, use @{method:shouldAutocloseBranch}.
	*
	* @param string Branch name to check.
	* @return const\|null Constant identifying reason to skip this branch, or null
	* if autoclose is active.
	* @task autoclose
	*/
	public function shouldSkipAutocloseBranch($branch) {
	$all_reason = $this->shouldSkipAllAutoclose();
	if ($all_reason) {
	return $all_reason;
	}

	if (!$this->shouldTrackBranch($branch)) {
	return self::BECAUSE_BRANCH_UNTRACKED;
	}

	if (!$this->isBranchInFilter($branch, 'close-commits-filter')) {
	return self::BECAUSE_BRANCH_NOT_AUTOCLOSE;
	}

	return null;
	}


	/**
	* Determine why autoclose should be skipped for a commit.
	*
	* This method gives a detailed reason why autoclose will be skipped. To
	* perform a simple test, use @{method:shouldAutocloseCommit}.
	*
	* @param PhabricatorRepositoryCommit Commit to check.
	* @return const\|null Constant identifying reason to skip this commit, or null
	* if autoclose is active.
	* @task autoclose
	*/
	public function shouldSkipAutocloseCommit(
	PhabricatorRepositoryCommit $commit) {

	$all_reason = $this->shouldSkipAllAutoclose();
	if ($all_reason) {
	return $all_reason;
	}

	switch ($this->getVersionControlSystem()) {
	case PhabricatorRepositoryType::REPOSITORY_TYPE_SVN:
	case PhabricatorRepositoryType::REPOSITORY_TYPE_MERCURIAL:
	return null;
	case PhabricatorRepositoryType::REPOSITORY_TYPE_GIT:
	break;
	default:
	throw new Exception(pht('Unrecognized version control system.'));
	}

	$closeable_flag = PhabricatorRepositoryCommit::IMPORTED_CLOSEABLE;
	if (!$commit->isPartiallyImported($closeable_flag)) {
	return self::BECAUSE_NOT_ON_AUTOCLOSE_BRANCH;
	}

	return null;
	}


	/**
	* Determine why all autoclose operations should be skipped for this
	* repository.
	*
	* @return const\|null Constant identifying reason to skip all autoclose
	* operations, or null if autoclose operations are not blocked at the
	* repository level.
	* @task autoclose
	*/
	private function shouldSkipAllAutoclose() {
	if ($this->isImporting()) {
	return self::BECAUSE_REPOSITORY_IMPORTING;
	}

	if ($this->getDetail('disable-autoclose', false)) {
	return self::BECAUSE_AUTOCLOSE_DISABLED;
	}

	return null;
	}


	/* -( Repository URI Management )------------------------------------------ */


	/**
	* Get the remote URI for this repository.
	*
	* @return string
	* @task uri
	*/
	public function getRemoteURI() {
	return (string)$this->getRemoteURIObject();
	}


	/**
	* Get the remote URI for this repository, including credentials if they're
	* used by this repository.
	*
	* @return PhutilOpaqueEnvelope URI, possibly including credentials.
	* @task uri
	*/
	public function getRemoteURIEnvelope() {
	$uri = $this->getRemoteURIObject();

	$remote_protocol = $this->getRemoteProtocol();
	if ($remote_protocol == 'http' \|\| $remote_protocol == 'https') {
	// For SVN, we use `--username` and `--password` flags separately, so
	// don't add any credentials here.
	if (!$this->isSVN()) {
	$credential_phid = $this->getCredentialPHID();
	if ($credential_phid) {
	$key = PassphrasePasswordKey::loadFromPHID(
	$credential_phid,
	PhabricatorUser::getOmnipotentUser());

	$uri->setUser($key->getUsernameEnvelope()->openEnvelope());
	$uri->setPass($key->getPasswordEnvelope()->openEnvelope());
	}
	}
	}

	return new PhutilOpaqueEnvelope((string)$uri);
	}


	/**
	* Get the clone (or checkout) URI for this repository, without authentication
	* information.
	*
	* @return string Repository URI.
	* @task uri
	*/
	public function getPublicCloneURI() {
	$uri = $this->getCloneURIObject();

	// Make sure we don't leak anything if this repo is using HTTP Basic Auth
	// with the credentials in the URI or something zany like that.

	// If repository is not accessed over SSH we remove both username and
	// password.
	if (!$this->isHosted()) {
	if (!$this->shouldUseSSH()) {
	$uri->setUser(null);

	// This might be a Git URI or a normal URI. If it's Git, there's no
	// password support.
	if ($uri instanceof PhutilURI) {
	$uri->setPass(null);
	}
	}
	}

	return (string)$uri;
	}


	/**
	* Get the protocol for the repository's remote.
	*
	* @return string Protocol, like "ssh" or "git".
	* @task uri
	*/
	public function getRemoteProtocol() {
	$uri = $this->getRemoteURIObject();

	if ($uri instanceof PhutilGitURI) {
	return 'ssh';
	} else {
	return $uri->getProtocol();
	}
	}


	/**
	* Get a parsed object representation of the repository's remote URI. This
	* may be a normal URI (returned as a @{class@libphutil:PhutilURI}) or a git
	* URI (returned as a @{class@libphutil:PhutilGitURI}).
	*
	* @return wild A @{class@libphutil:PhutilURI} or
	* @{class@libphutil:PhutilGitURI}.
	* @task uri
	*/
	public function getRemoteURIObject() {
	$raw_uri = $this->getDetail('remote-uri');
	if (!$raw_uri) {
	return new PhutilURI('');
	}

	if (!strncmp($raw_uri, '/', 1)) {
	return new PhutilURI('file://'.$raw_uri);
	}

	$uri = new PhutilURI($raw_uri);
	if ($uri->getProtocol()) {
	return $uri;
	}

	$uri = new PhutilGitURI($raw_uri);
	if ($uri->getDomain()) {
	return $uri;
	}

	throw new Exception(pht("Remote URI '%s' could not be parsed!", $raw_uri));
	}


	/**
	* Get the "best" clone/checkout URI for this repository, on any protocol.
	*/
	public function getCloneURIObject() {
	if (!$this->isHosted()) {
	if ($this->isSVN()) {
	// Make sure we pick up the "Import Only" path for Subversion, so
	// the user clones the repository starting at the correct path, not
	// from the root.
	$base_uri = $this->getSubversionBaseURI();
	$base_uri = new PhutilURI($base_uri);
	$path = $base_uri->getPath();
	if (!$path) {
	$path = '/';
	}

	// If the trailing "@" is not required to escape the URI, strip it for
	// readability.
	if (!preg_match('/@.*@/', $path)) {
	$path = rtrim($path, '@');
	}

	$base_uri->setPath($path);
	return $base_uri;
	} else {
	return $this->getRemoteURIObject();
	}
	}

	// Choose the best URI: pick a read/write URI over a URI which is not
	// read/write, and SSH over HTTP.

	$serve_ssh = $this->getServeOverSSH();
	$serve_http = $this->getServeOverHTTP();

	if ($serve_ssh === self::SERVE_READWRITE) {
	return $this->getSSHCloneURIObject();
	} else if ($serve_http === self::SERVE_READWRITE) {
	return $this->getHTTPCloneURIObject();
	} else if ($serve_ssh !== self::SERVE_OFF) {
	return $this->getSSHCloneURIObject();
	} else if ($serve_http !== self::SERVE_OFF) {
	return $this->getHTTPCloneURIObject();
	} else {
	return null;
	}
	}


	/**
	* Get the repository's SSH clone/checkout URI, if one exists.
	*/
	public function getSSHCloneURIObject() {
	if (!$this->isHosted()) {
	if ($this->shouldUseSSH()) {
	return $this->getRemoteURIObject();
	} else {
	return null;
	}
	}

	$serve_ssh = $this->getServeOverSSH();
	if ($serve_ssh === self::SERVE_OFF) {
	return null;
	}

	$uri = new PhutilURI(PhabricatorEnv::getProductionURI($this->getURI()));

	if ($this->isSVN()) {
	$uri->setProtocol('svn+ssh');
	} else {
	$uri->setProtocol('ssh');
	}

	if ($this->isGit()) {
	$uri->setPath($uri->getPath().$this->getCloneName().'.git');
	} else if ($this->isHg()) {
	$uri->setPath($uri->getPath().$this->getCloneName().'/');
	}

	$ssh_user = PhabricatorEnv::getEnvConfig('diffusion.ssh-user');
	if ($ssh_user) {
	$uri->setUser($ssh_user);
	}

	$ssh_host = PhabricatorEnv::getEnvConfig('diffusion.ssh-host');
	if (strlen($ssh_host)) {
	$uri->setDomain($ssh_host);
	}

	$uri->setPort(PhabricatorEnv::getEnvConfig('diffusion.ssh-port'));

	return $uri;
	}


	/**
	* Get the repository's HTTP clone/checkout URI, if one exists.
	*/
	public function getHTTPCloneURIObject() {
	if (!$this->isHosted()) {
	if ($this->shouldUseHTTP()) {
	return $this->getRemoteURIObject();
	} else {
	return null;
	}
	}

	$serve_http = $this->getServeOverHTTP();
	if ($serve_http === self::SERVE_OFF) {
	return null;
	}

	$uri = PhabricatorEnv::getProductionURI($this->getURI());
	$uri = new PhutilURI($uri);

	if ($this->isGit()) {
	$uri->setPath($uri->getPath().$this->getCloneName().'.git');
	} else if ($this->isHg()) {
	$uri->setPath($uri->getPath().$this->getCloneName().'/');
	}

	return $uri;
	}


	/**
	* Determine if we should connect to the remote using SSH flags and
	* credentials.
	*
	* @return bool True to use the SSH protocol.
	* @task uri
	*/
	private function shouldUseSSH() {
	if ($this->isHosted()) {
	return false;
	}

	$protocol = $this->getRemoteProtocol();
	if ($this->isSSHProtocol($protocol)) {
	return true;
	}

	return false;
	}


	/**
	* Determine if we should connect to the remote using HTTP flags and
	* credentials.
	*
	* @return bool True to use the HTTP protocol.
	* @task uri
	*/
	private function shouldUseHTTP() {
	if ($this->isHosted()) {
	return false;
	}

	$protocol = $this->getRemoteProtocol();
	return ($protocol == 'http' \|\| $protocol == 'https');
	}


	/**
	* Determine if we should connect to the remote using SVN flags and
	* credentials.
	*
	* @return bool True to use the SVN protocol.
	* @task uri
	*/
	private function shouldUseSVNProtocol() {
	if ($this->isHosted()) {
	return false;
	}

	$protocol = $this->getRemoteProtocol();
	return ($protocol == 'svn');
	}


	/**
	* Determine if a protocol is SSH or SSH-like.
	*
	* @param string A protocol string, like "http" or "ssh".
	* @return bool True if the protocol is SSH-like.
	* @task uri
	*/
	private function isSSHProtocol($protocol) {
	return ($protocol == 'ssh' \|\| $protocol == 'svn+ssh');
	}

	public function delete() {
	$this->openTransaction();

	$paths = id(new PhabricatorOwnersPath())
	->loadAllWhere('repositoryPHID = %s', $this->getPHID());
	foreach ($paths as $path) {
	$path->delete();
	}

	queryfx(
	$this->establishConnection('w'),
	'DELETE FROM %T WHERE repositoryPHID = %s',
	id(new PhabricatorRepositorySymbol())->getTableName(),
	$this->getPHID());

	$commits = id(new PhabricatorRepositoryCommit())
	->loadAllWhere('repositoryID = %d', $this->getID());
	foreach ($commits as $commit) {
	// note PhabricatorRepositoryAuditRequests and
	// PhabricatorRepositoryCommitData are deleted here too.
	$commit->delete();
	}

	$mirrors = id(new PhabricatorRepositoryMirror())
	->loadAllWhere('repositoryPHID = %s', $this->getPHID());
	foreach ($mirrors as $mirror) {
	$mirror->delete();
	}

	$ref_cursors = id(new PhabricatorRepositoryRefCursor())
	->loadAllWhere('repositoryPHID = %s', $this->getPHID());
	foreach ($ref_cursors as $cursor) {
	$cursor->delete();
	}

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

	queryfx(
	$conn_w,
	'DELETE FROM %T WHERE repositoryID = %d',
	self::TABLE_FILESYSTEM,
	$this->getID());

	queryfx(
	$conn_w,
	'DELETE FROM %T WHERE repositoryID = %d',
	self::TABLE_PATHCHANGE,
	$this->getID());

	queryfx(
	$conn_w,
	'DELETE FROM %T WHERE repositoryID = %d',
	self::TABLE_SUMMARY,
	$this->getID());

	$result = parent::delete();

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

	public function isGit() {
	$vcs = $this->getVersionControlSystem();
	return ($vcs == PhabricatorRepositoryType::REPOSITORY_TYPE_GIT);
	}

	public function isSVN() {
	$vcs = $this->getVersionControlSystem();
	return ($vcs == PhabricatorRepositoryType::REPOSITORY_TYPE_SVN);
	}

	public function isHg() {
	$vcs = $this->getVersionControlSystem();
	return ($vcs == PhabricatorRepositoryType::REPOSITORY_TYPE_MERCURIAL);
	}

	public function isHosted() {
	return (bool)$this->getDetail('hosting-enabled', false);
	}

	public function setHosted($enabled) {
	return $this->setDetail('hosting-enabled', $enabled);
	}

	public function getServeOverHTTP() {
	if ($this->isSVN()) {
	return self::SERVE_OFF;
	}
	$serve = $this->getDetail('serve-over-http', self::SERVE_OFF);
	return $this->normalizeServeConfigSetting($serve);
	}

	public function setServeOverHTTP($mode) {
	return $this->setDetail('serve-over-http', $mode);
	}

	public function getServeOverSSH() {
	$serve = $this->getDetail('serve-over-ssh', self::SERVE_OFF);
	return $this->normalizeServeConfigSetting($serve);
	}

	public function setServeOverSSH($mode) {
	return $this->setDetail('serve-over-ssh', $mode);
	}

	public static function getProtocolAvailabilityName($constant) {
	switch ($constant) {
	case self::SERVE_OFF:
	return pht('Off');
	case self::SERVE_READONLY:
	return pht('Read Only');
	case self::SERVE_READWRITE:
	return pht('Read/Write');
	default:
	return pht('Unknown');
	}
	}

	private function normalizeServeConfigSetting($value) {
	switch ($value) {
	case self::SERVE_OFF:
	case self::SERVE_READONLY:
	return $value;
	case self::SERVE_READWRITE:
	if ($this->isHosted()) {
	return self::SERVE_READWRITE;
	} else {
	return self::SERVE_READONLY;
	}
	default:
	return self::SERVE_OFF;
	}
	}


	/**
	* Raise more useful errors when there are basic filesystem problems.
	*/
	private function assertLocalExists() {
	if (!$this->usesLocalWorkingCopy()) {
	return;
	}

	$local = $this->getLocalPath();
	Filesystem::assertExists($local);
	Filesystem::assertIsDirectory($local);
	Filesystem::assertReadable($local);
	}

	/**
	* Determine if the working copy is bare or not. In Git, this corresponds
	* to `--bare`. In Mercurial, `--noupdate`.
	*/
	public function isWorkingCopyBare() {
	switch ($this->getVersionControlSystem()) {
	case PhabricatorRepositoryType::REPOSITORY_TYPE_SVN:
	case PhabricatorRepositoryType::REPOSITORY_TYPE_MERCURIAL:
	return false;
	case PhabricatorRepositoryType::REPOSITORY_TYPE_GIT:
	$local = $this->getLocalPath();
	if (Filesystem::pathExists($local.'/.git')) {
	return false;
	} else {
	return true;
	}
	}
	}

	public function usesLocalWorkingCopy() {
	switch ($this->getVersionControlSystem()) {
	case PhabricatorRepositoryType::REPOSITORY_TYPE_SVN:
	return $this->isHosted();
	case PhabricatorRepositoryType::REPOSITORY_TYPE_GIT:
	case PhabricatorRepositoryType::REPOSITORY_TYPE_MERCURIAL:
	return true;
	}
	}

	public function getHookDirectories() {
	$directories = array();
	if (!$this->isHosted()) {
	return $directories;
	}

	$root = $this->getLocalPath();

	switch ($this->getVersionControlSystem()) {
	case PhabricatorRepositoryType::REPOSITORY_TYPE_GIT:
	if ($this->isWorkingCopyBare()) {
	$directories[] = $root.'/hooks/pre-receive-phabricator.d/';
	} else {
	$directories[] = $root.'/.git/hooks/pre-receive-phabricator.d/';
	}
	break;
	case PhabricatorRepositoryType::REPOSITORY_TYPE_SVN:
	$directories[] = $root.'/hooks/pre-commit-phabricator.d/';
	break;
	case PhabricatorRepositoryType::REPOSITORY_TYPE_MERCURIAL:
	// NOTE: We don't support custom Mercurial hooks for now because they're
	// messy and we can't easily just drop a `hooks.d/` directory next to
	// the hooks.
	break;
	}

	return $directories;
	}

	public function canDestroyWorkingCopy() {
	if ($this->isHosted()) {
	// Never destroy hosted working copies.
	return false;
	}

	$default_path = PhabricatorEnv::getEnvConfig(
	'repository.default-local-path');
	return Filesystem::isDescendant($this->getLocalPath(), $default_path);
	}

	public function canUsePathTree() {
	return !$this->isSVN();
	}

	public function canMirror() {
	if ($this->isGit() \|\| $this->isHg()) {
	return true;
	}

	return false;
	}

	public function canAllowDangerousChanges() {
	if (!$this->isHosted()) {
	return false;
	}

	if ($this->isGit() \|\| $this->isHg()) {
	return true;
	}

	return false;
	}

	public function shouldAllowDangerousChanges() {
	return (bool)$this->getDetail('allow-dangerous-changes');
	}

	public function writeStatusMessage(
	$status_type,
	$status_code,
	array $parameters = array()) {

	$table = new PhabricatorRepositoryStatusMessage();
	$conn_w = $table->establishConnection('w');
	$table_name = $table->getTableName();

	if ($status_code === null) {
	queryfx(
	$conn_w,
	'DELETE FROM %T WHERE repositoryID = %d AND statusType = %s',
	$table_name,
	$this->getID(),
	$status_type);
	} else {
	queryfx(
	$conn_w,
	'INSERT INTO %T
	(repositoryID, statusType, statusCode, parameters, epoch)
	VALUES (%d, %s, %s, %s, %d)
	ON DUPLICATE KEY UPDATE
	statusCode = VALUES(statusCode),
	parameters = VALUES(parameters),
	epoch = VALUES(epoch)',
	$table_name,
	$this->getID(),
	$status_type,
	$status_code,
	json_encode($parameters),
	time());
	}

	return $this;
	}

	public static function getRemoteURIProtocol($raw_uri) {
	$uri = new PhutilURI($raw_uri);
	if ($uri->getProtocol()) {
	return strtolower($uri->getProtocol());
	}

	$git_uri = new PhutilGitURI($raw_uri);
	if (strlen($git_uri->getDomain()) && strlen($git_uri->getPath())) {
	return 'ssh';
	}

	return null;
	}

	public static function assertValidRemoteURI($uri) {
	if (trim($uri) != $uri) {
	throw new Exception(
	pht('The remote URI has leading or trailing whitespace.'));
	}

	$protocol = self::getRemoteURIProtocol($uri);

	// Catch confusion between Git/SCP-style URIs and normal URIs. See T3619
	// for discussion. This is usually a user adding "ssh://" to an implicit
	// SSH Git URI.
	if ($protocol == 'ssh') {
	if (preg_match('(^[^:@]+://[^/:]+:[^\d])', $uri)) {
	throw new Exception(
	pht(
	"The remote URI is not formatted correctly. Remote URIs ".
	"with an explicit protocol should be in the form ".
	"'%s', not '%s'. The '%s' syntax is only valid in SCP-style URIs.",
	'proto://domain/path',
	'proto://domain:/path',
	':/path'));
	}
	}

	switch ($protocol) {
	case 'ssh':
	case 'http':
	case 'https':
	case 'git':
	case 'svn':
	case 'svn+ssh':
	break;
	default:
	// NOTE: We're explicitly rejecting 'file://' because it can be
	// used to clone from the working copy of another repository on disk
	// that you don't normally have permission to access.

	throw new Exception(
	pht(
	"The URI protocol is unrecognized. It should begin ".
	"'%s', '%s', '%s', '%s', '%s', '%s', or be in the form '%s'.",
	'ssh://',
	'http://',
	'https://',
	'git://',
	'svn://',
	'svn+ssh://',
	'git@domain.com:path'));
	}

	return true;
	}


	/**
	* Load the pull frequency for this repository, based on the time since the
	* last activity.
	*
	* We pull rarely used repositories less frequently. This finds the most
	* recent commit which is older than the current time (which prevents us from
	* spinning on repositories with a silly commit post-dated to some time in
	* 2037). We adjust the pull frequency based on when the most recent commit
	* occurred.
	*
	* @param int The minimum update interval to use, in seconds.
	* @return int Repository update interval, in seconds.
	*/
	public function loadUpdateInterval($minimum = 15) {
	// If a repository is still importing, always pull it as frequently as
	// possible. This prevents us from hanging for a long time at 99.9% when
	// importing an inactive repository.
	if ($this->isImporting()) {
	return $minimum;
	}

	$window_start = (PhabricatorTime::getNow() + $minimum);

	$table = id(new PhabricatorRepositoryCommit());
	$last_commit = queryfx_one(
	$table->establishConnection('r'),
	'SELECT epoch FROM %T
	WHERE repositoryID = %d AND epoch <= %d
	ORDER BY epoch DESC LIMIT 1',
	$table->getTableName(),
	$this->getID(),
	$window_start);
	if ($last_commit) {
	$time_since_commit = ($window_start - $last_commit['epoch']);

	$last_few_days = phutil_units('3 days in seconds');

	if ($time_since_commit <= $last_few_days) {
	// For repositories with activity in the recent past, we wait one
	// extra second for every 10 minutes since the last commit. This
	// shorter backoff is intended to handle weekends and other short
	// breaks from development.
	$smart_wait = ($time_since_commit / 600);
	} else {
	// For repositories without recent activity, we wait one extra second
	// for every 4 minutes since the last commit. This longer backoff
	// handles rarely used repositories, up to the maximum.
	$smart_wait = ($time_since_commit / 240);
	}

	// We'll never wait more than 6 hours to pull a repository.
	$longest_wait = phutil_units('6 hours in seconds');
	$smart_wait = min($smart_wait, $longest_wait);

	$smart_wait = max($minimum, $smart_wait);
	} else {
	$smart_wait = $minimum;
	}

	return $smart_wait;
	}


	/**
	* Retrieve the sevice URI for the device hosting this repository.
	*
	* See @{method:newConduitClient} for a general discussion of interacting
	* with repository services. This method provides lower-level resolution of
	* services, returning raw URIs.
	*
	* @param PhabricatorUser Viewing user.
	* @param bool `true` to throw if a remote URI would be returned.
	* @param list<string> List of allowable protocols.
	* @return string\|null URI, or `null` for local repositories.
	*/
	public function getAlmanacServiceURI(
	PhabricatorUser $viewer,
	$never_proxy,
	array $protocols) {

	$service_phid = $this->getAlmanacServicePHID();
	if (!$service_phid) {
	// No service, so this is a local repository.
	return null;
	}

	$service = id(new AlmanacServiceQuery())
	->setViewer(PhabricatorUser::getOmnipotentUser())
	->withPHIDs(array($service_phid))
	->needBindings(true)
	->executeOne();
	if (!$service) {
	throw new Exception(
	pht(
	'The Almanac service for this repository is invalid or could not '.
	'be loaded.'));
	}

	$service_type = $service->getServiceType();
	if (!($service_type instanceof AlmanacClusterRepositoryServiceType)) {
	throw new Exception(
	pht(
	'The Almanac service for this repository does not have the correct '.
	'service type.'));
	}

	$bindings = $service->getBindings();
	if (!$bindings) {
	throw new Exception(
	pht(
	'The Almanac service for this repository is not bound to any '.
	'interfaces.'));
	}

	$local_device = AlmanacKeys::getDeviceID();

	if ($never_proxy && !$local_device) {
	throw new Exception(
	pht(
	'Unable to handle proxied service request. This device is not '.
	'registered, so it can not identify local services. Register '.
	'this device before sending requests here.'));
	}

	$protocol_map = array_fuse($protocols);

	$uris = array();
	foreach ($bindings as $binding) {
	$iface = $binding->getInterface();

	// If we're never proxying this and it's locally satisfiable, return
	// `null` to tell the caller to handle it locally. If we're allowed to
	// proxy, we skip this check and may proxy the request to ourselves.
	// (That proxied request will end up here with proxying forbidden,
	// return `null`, and then the request will actually run.)

	if ($local_device && $never_proxy) {
	if ($iface->getDevice()->getName() == $local_device) {
	return null;
	}
	}

	$protocol = $binding->getAlmanacPropertyValue('protocol');
	if ($protocol === null) {
	$protocol = 'https';
	}

	if (empty($protocol_map[$protocol])) {
	continue;
	}

	$uris[] = $protocol.'://'.$iface->renderDisplayAddress().'/';
	}

	if (!$uris) {
	throw new Exception(
	pht(
	'The Almanac service for this repository is not bound to any '.
	'interfaces which support the required protocols (%s).',
	implode(', ', $protocols)));
	}

	if ($never_proxy) {
	throw new Exception(
	pht(
	'Refusing to proxy a repository request from a cluster host. '.
	'Cluster hosts must correctly route their intracluster requests.'));
	}

	shuffle($uris);
	return head($uris);
	}


	/**
	* Build a new Conduit client in order to make a service call to this
	* repository.
	*
	* If the repository is hosted locally, this method may return `null`. The
	* caller should use `ConduitCall` or other local logic to complete the
	* request.
	*
	* By default, we will return a @{class:ConduitClient} for any repository with
	* a service, even if that service is on the current device.
	*
	* We do this because this configuration does not make very much sense in a
	* production context, but is very common in a test/development context
	* (where the developer's machine is both the web host and the repository
	* service). By proxying in development, we get more consistent behavior
	* between development and production, and don't have a major untested
	* codepath.
	*
	* The `$never_proxy` parameter can be used to prevent this local proxying.
	* If the flag is passed:
	*
	* - The method will return `null` (implying a local service call)
	* if the repository service is hosted on the current device.
	* - The method will throw if it would need to return a client.
	*
	* This is used to prevent loops in Conduit: the first request will proxy,
	* even in development, but the second request will be identified as a
	* cluster request and forced not to proxy.
	*
	* For lower-level service resolution, see @{method:getAlmanacServiceURI}.
	*
	* @param PhabricatorUser Viewing user.
	* @param bool `true` to throw if a client would be returned.
	* @return ConduitClient\|null Client, or `null` for local repositories.
	*/
	public function newConduitClient(
	PhabricatorUser $viewer,
	$never_proxy = false) {

	$uri = $this->getAlmanacServiceURI(
	$viewer,
	$never_proxy,
	array(
	'http',
	'https',
	));
	if ($uri === null) {
	return null;
	}

	$domain = id(new PhutilURI(PhabricatorEnv::getURI('/')))->getDomain();

	$client = id(new ConduitClient($uri))
	->setHost($domain);

	if ($viewer->isOmnipotent()) {
	// If the caller is the omnipotent user (normally, a daemon), we will
	// sign the request with this host's asymmetric keypair.

	$public_path = AlmanacKeys::getKeyPath('device.pub');
	try {
	$public_key = Filesystem::readFile($public_path);
	} catch (Exception $ex) {
	throw new PhutilAggregateException(
	pht(
	'Unable to read device public key while attempting to make '.
	'authenticated method call within the Phabricator cluster. '.
	'Use `%s` to register keys for this device. Exception: %s',
	'bin/almanac register',
	$ex->getMessage()),
	array($ex));
	}

	$private_path = AlmanacKeys::getKeyPath('device.key');
	try {
	$private_key = Filesystem::readFile($private_path);
	$private_key = new PhutilOpaqueEnvelope($private_key);
	} catch (Exception $ex) {
	throw new PhutilAggregateException(
	pht(
	'Unable to read device private key while attempting to make '.
	'authenticated method call within the Phabricator cluster. '.
	'Use `%s` to register keys for this device. Exception: %s',
	'bin/almanac register',
	$ex->getMessage()),
	array($ex));
	}

	$client->setSigningKeys($public_key, $private_key);
	} else {
	// If the caller is a normal user, we generate or retrieve a cluster
	// API token.

	$token = PhabricatorConduitToken::loadClusterTokenForUser($viewer);
	if ($token) {
	$client->setConduitToken($token->getToken());
	}
	}

	return $client;
	}


	/* -( Symbols )-------------------------------------------------------------*/

	public function getSymbolSources() {
	return $this->getDetail('symbol-sources', array());
	}

	public function getSymbolLanguages() {
	return $this->getDetail('symbol-languages', array());
	}


	/* -( Staging )------------------------------------------------------------ */


	public function supportsStaging() {
	return $this->isGit();
	}


	public function getStagingURI() {
	if (!$this->supportsStaging()) {
	return null;
	}
	return $this->getDetail('staging-uri', null);
	}


	/* -( Automation )--------------------------------------------------------- */


	public function supportsAutomation() {
	return $this->isGit();
	}

	public function canPerformAutomation() {
	if (!$this->supportsAutomation()) {
	return false;
	}

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

	return true;
	}

	public function getAutomationBlueprintPHIDs() {
	if (!$this->supportsAutomation()) {
	return array();
	}
	return $this->getDetail('automation.blueprintPHIDs', array());
	}


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


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

	public function getApplicationTransactionObject() {
	return $this;
	}

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

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

	return $timeline;
	}


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


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

	public function getPolicy($capability) {
	switch ($capability) {
	case PhabricatorPolicyCapability::CAN_VIEW:
	return $this->getViewPolicy();
	case PhabricatorPolicyCapability::CAN_EDIT:
	return $this->getEditPolicy();
	case DiffusionPushCapability::CAPABILITY:
	return $this->getPushPolicy();
	}
	}

	public function hasAutomaticCapability($capability, PhabricatorUser $user) {
	return false;
	}

	public function describeAutomaticCapability($capability) {
	return null;
	}



	/* -( PhabricatorMarkupInterface )----------------------------------------- */


	public function getMarkupFieldKey($field) {
	$hash = PhabricatorHash::digestForIndex($this->getMarkupText($field));
	return "repo:{$hash}";
	}

	public function newMarkupEngine($field) {
	return PhabricatorMarkupEngine::newMarkupEngine(array());
	}

	public function getMarkupText($field) {
	return $this->getDetail('description');
	}

	public function didMarkupText(
	$field,
	$output,
	PhutilMarkupEngine $engine) {
	require_celerity_resource('phabricator-remarkup-css');
	return phutil_tag(
	'div',
	array(
	'class' => 'phabricator-remarkup',
	),
	$output);
	}

	public function shouldUseMarkupCache($field) {
	return true;
	}


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


	public function destroyObjectPermanently(
	PhabricatorDestructionEngine $engine) {

	$this->openTransaction();

	$this->delete();

	$books = id(new DivinerBookQuery())
	->setViewer($engine->getViewer())
	->withRepositoryPHIDs(array($this->getPHID()))
	->execute();
	foreach ($books as $book) {
	$engine->destroyObject($book);
	}

	$atoms = id(new DivinerAtomQuery())
	->setViewer($engine->getViewer())
	->withRepositoryPHIDs(array($this->getPHID()))
	->execute();
	foreach ($atoms as $atom) {
	$engine->destroyObject($atom);
	}

	$this->saveTransaction();
	}


	/* -( PhabricatorSpacesInterface )----------------------------------------- */


	public function getSpacePHID() {
	return $this->spacePHID;
	}

	}

File Metadata

Mime Type: text/x-diff
Expires: Fri, Aug 15, 11:49 AM (6 d, 9 h ago)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 196308
Default Alt Text: (195 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions