No OneTemporary
Actions

Size

93 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/src/applications/diffusion/controller/DiffusionCommitEditController.php b/src/applications/diffusion/controller/DiffusionCommitEditController.php
	index 8ce41bb600..5515f3e322 100644
	--- a/src/applications/diffusion/controller/DiffusionCommitEditController.php
	+++ b/src/applications/diffusion/controller/DiffusionCommitEditController.php
	@@ -1,97 +1,139 @@
	<?php

	final class DiffusionCommitEditController extends DiffusionController {

	public function willProcessRequest(array $data) {
	$data['user'] = $this->getRequest()->getUser();
	$this->diffusionRequest = DiffusionRequest::newFromDictionary($data);
	}

	public function processRequest() {
	-
	$request = $this->getRequest();
	$user = $request->getUser();
	$drequest = $this->getDiffusionRequest();
	$callsign = $drequest->getRepository()->getCallsign();
	$repository = $drequest->getRepository();
	$commit = $drequest->loadCommit();
	+ $data = $commit->loadCommitData();
	$page_title = pht('Edit Diffusion Commit');

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

	$commit_phid = $commit->getPHID();
	$edge_type = PhabricatorEdgeConfig::TYPE_COMMIT_HAS_PROJECT;
	$current_proj_phids = PhabricatorEdgeQuery::loadDestinationPHIDs(
	$commit_phid,
	$edge_type);
	$handles = $this->loadViewerHandles($current_proj_phids);
	$proj_t_values = $handles;

	if ($request->isFormPost()) {
	$proj_phids = $request->getArr('projects');
	$new_proj_phids = array_values($proj_phids);
	$rem_proj_phids = array_diff($current_proj_phids,
	$new_proj_phids);

	$editor = id(new PhabricatorEdgeEditor());
	foreach ($rem_proj_phids as $phid) {
	$editor->removeEdge($commit_phid, $edge_type, $phid);
	}
	foreach ($new_proj_phids as $phid) {
	$editor->addEdge($commit_phid, $edge_type, $phid);
	}
	$editor->save();

	id(new PhabricatorSearchIndexer())
	->queueDocumentForIndexing($commit->getPHID());

	return id(new AphrontRedirectResponse())
	->setURI('/r'.$callsign.$commit->getCommitIdentifier());
	}

	$tokenizer_id = celerity_generate_unique_node_id();
	- $form = id(new AphrontFormView())
	+ $form = id(new AphrontFormView())
	->setUser($user)
	->setAction($request->getRequestURI()->getPath())
	->appendChild(
	id(new AphrontFormTokenizerControl())
	->setLabel(pht('Projects'))
	->setName('projects')
	->setValue($proj_t_values)
	->setID($tokenizer_id)
	->setCaption(
	javelin_tag(
	'a',
	array(
	'href' => '/project/create/',
	'mustcapture' => true,
	'sigil' => 'project-create',
	),
	pht('Create New Project')))
	->setDatasource(new PhabricatorProjectDatasource()));

	+ $reason = $data->getCommitDetail('autocloseReason', false);
	+ if ($reason !== false) {
	+ switch ($reason) {
	+ case PhabricatorRepository::BECAUSE_REPOSITORY_IMPORTING:
	+ $desc = pht('No, Repository Importing');
	+ break;
	+ case PhabricatorRepository::BECAUSE_AUTOCLOSE_DISABLED:
	+ $desc = pht('No, Autoclose Disabled');
	+ break;
	+ case PhabricatorRepository::BECAUSE_NOT_ON_AUTOCLOSE_BRANCH:
	+ $desc = pht('No, Not On Autoclose Branch');
	+ break;
	+ case null:
	+ $desc = pht('Yes');
	+ break;
	+ default:
	+ $desc = pht('Unknown');
	+ break;
	+ }
	+
	+ $doc_href = PhabricatorEnv::getDoclink('Diffusion User Guide: Autoclose');
	+ $doc_link = phutil_tag(
	+ 'a',
	+ array(
	+ 'href' => $doc_href,
	+ 'target' => '_blank',
	+ ),
	+ pht('Learn More'));
	+
	+ $form->appendChild(
	+ id(new AphrontFormMarkupControl())
	+ ->setLabel(pht('Autoclose?'))
	+ ->setValue(array($desc, " \xC2\xB7 ", $doc_link)));
	+ }
	+
	+
	Javelin::initBehavior('project-create', array(
	'tokenizerID' => $tokenizer_id,
	));

	$submit = id(new AphrontFormSubmitControl())
	->setValue(pht('Save'))
	->addCancelButton('/r'.$callsign.$commit->getCommitIdentifier());
	$form->appendChild($submit);

	+ $crumbs = $this->buildCrumbs(array(
	+ 'commit' => true,
	+ ));
	+ $crumbs->addTextCrumb(pht('Edit'));
	+
	$form_box = id(new PHUIObjectBoxView())
	->setHeaderText($page_title)
	->setForm($form);

	return $this->buildApplicationPage(
	array(
	+ $crumbs,
	$form_box,
	),
	array(
	'title' => $page_title,
	));
	}

	}
	diff --git a/src/applications/diffusion/view/DiffusionBranchTableView.php b/src/applications/diffusion/view/DiffusionBranchTableView.php
	index 7cbdb0d089..c214d4b2dc 100644
	--- a/src/applications/diffusion/view/DiffusionBranchTableView.php
	+++ b/src/applications/diffusion/view/DiffusionBranchTableView.php
	@@ -1,91 +1,136 @@
	<?php

	final class DiffusionBranchTableView extends DiffusionView {

	private $branches;
	private $commits = array();

	public function setBranches(array $branches) {
	assert_instances_of($branches, 'DiffusionRepositoryRef');
	$this->branches = $branches;
	return $this;
	}

	public function setCommits(array $commits) {
	assert_instances_of($commits, 'PhabricatorRepositoryCommit');
	$this->commits = mpull($commits, null, 'getCommitIdentifier');
	return $this;
	}

	public function render() {
	$drequest = $this->getDiffusionRequest();
	$current_branch = $drequest->getBranch();
	+ $repository = $drequest->getRepository();
	+
	+ Javelin::initBehavior('phabricator-tooltips');
	+
	+ $doc_href = PhabricatorEnv::getDoclink('Diffusion User Guide: Autoclose');

	$rows = array();
	$rowc = array();
	foreach ($this->branches as $branch) {
	$commit = idx($this->commits, $branch->getCommitIdentifier());
	if ($commit) {
	$details = $commit->getSummary();
	$datetime = phabricator_datetime($commit->getEpoch(), $this->user);
	} else {
	$datetime = null;
	$details = null;
	}

	+ switch ($repository->shouldSkipAutocloseBranch($branch->getShortName())) {
	+ case PhabricatorRepository::BECAUSE_REPOSITORY_IMPORTING:
	+ $icon = 'fa-times bluegrey';
	+ $tip = pht('Repository Importing');
	+ break;
	+ case PhabricatorRepository::BECAUSE_AUTOCLOSE_DISABLED:
	+ $icon = 'fa-times bluegrey';
	+ $tip = pht('Repository Autoclose Disabled');
	+ break;
	+ case PhabricatorRepository::BECAUSE_BRANCH_UNTRACKED:
	+ $icon = 'fa-times bluegrey';
	+ $tip = pht('Branch Untracked');
	+ break;
	+ case PhabricatorRepository::BECAUSE_BRANCH_NOT_AUTOCLOSE:
	+ $icon = 'fa-times bluegrey';
	+ $tip = pht('Branch Autoclose Disabled');
	+ break;
	+ case null:
	+ $icon = 'fa-check bluegrey';
	+ $tip = pht('Autoclose Enabled');
	+ break;
	+ default:
	+ $icon = 'fa-question';
	+ $tip = pht('Status Unknown');
	+ break;
	+ }
	+
	+ $status_icon = id(new PHUIIconView())
	+ ->setIconFont($icon)
	+ ->addSigil('has-tooltip')
	+ ->setHref($doc_href)
	+ ->setMetadata(
	+ array(
	+ 'tip' => $tip,
	+ 'size' => 200,
	+ ));
	+
	$rows[] = array(
	phutil_tag(
	'a',
	array(
	'href' => $drequest->generateURI(
	array(
	'action' => 'history',
	'branch' => $branch->getShortName(),
	))
	),
	pht('History')),
	phutil_tag(
	'a',
	array(
	'href' => $drequest->generateURI(
	array(
	'action' => 'browse',
	'branch' => $branch->getShortName(),
	)),
	),
	$branch->getShortName()),
	self::linkCommit(
	$drequest->getRepository(),
	$branch->getCommitIdentifier()),
	+ $status_icon,
	$datetime,
	AphrontTableView::renderSingleDisplayLine($details),
	);
	if ($branch->getShortName() == $current_branch) {
	$rowc[] = 'highlighted';
	} else {
	$rowc[] = null;
	}
	}

	$view = new AphrontTableView($rows);
	$view->setHeaders(
	array(
	pht('History'),
	pht('Branch'),
	pht('Head'),
	+ pht(''),
	pht('Modified'),
	pht('Details'),
	));
	$view->setColumnClasses(
	array(
	'',
	'pri',
	'',
	'',
	+ '',
	'wide',
	));
	$view->setRowClasses($rowc);
	return $view->render();
	}

	}
	diff --git a/src/applications/herald/adapter/HeraldCommitAdapter.php b/src/applications/herald/adapter/HeraldCommitAdapter.php
	index 4daa3895f8..90b3c91552 100644
	--- a/src/applications/herald/adapter/HeraldCommitAdapter.php
	+++ b/src/applications/herald/adapter/HeraldCommitAdapter.php
	@@ -1,559 +1,557 @@
	<?php

	final class HeraldCommitAdapter extends HeraldAdapter {

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

	protected $diff;
	protected $revision;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	$object = new HeraldCommitAdapter();

	$commit->attachRepository($repository);

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

	return $object;
	}

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

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

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

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

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

	return $this;
	}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	$byte_limit = self::getEnormousByteLimit();

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

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

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

	$diff = DifferentialDiff::newFromRawChanges($changes);
	return $diff;
	}

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

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

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

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

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

	return $result;
	}

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

	switch ($revision->getStatus()) {
	case ArcanistDifferentialRevisionStatus::ACCEPTED:
	case ArcanistDifferentialRevisionStatus::CLOSED:
	return $revision->getPHID();
	}

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

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

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

	return parent::getHeraldField($field);
	}

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

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

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

	}
	diff --git a/src/applications/repository/storage/PhabricatorRepository.php b/src/applications/repository/storage/PhabricatorRepository.php
	index cc4fe75a37..41e387313f 100644
	--- a/src/applications/repository/storage/PhabricatorRepository.php
	+++ b/src/applications/repository/storage/PhabricatorRepository.php
	@@ -1,1461 +1,1534 @@
	<?php

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

	/**
	* 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 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';
	+
	protected $name;
	protected $callsign;
	protected $uuid;
	protected $viewPolicy;
	protected $editPolicy;
	protected $pushPolicy;

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

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

	return id(new PhabricatorRepository())
	->setViewPolicy($view_policy)
	->setEditPolicy($edit_policy)
	->setPushPolicy($push_policy);
	}

	public function getConfiguration() {
	return array(
	self::CONFIG_AUX_PHID => true,
	self::CONFIG_SERIALIZATION => array(
	'details' => self::SERIALIZATION_JSON,
	),
	) + 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(),
	);
	}

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

	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('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('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('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('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('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

	$lines = preg_split('/(?<=\n)/', $stdout);
	$regex = '/ignoring untrusted configuration option .*\n$/';

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

	return implode('', $lines);
	}

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

	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('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) {
	$filter = $this->getDetail($filter_key, array());
	if ($filter && empty($filter[$branch])) {
	return false;
	}
	}

	// By default, all branches pass.
	return true;
	}

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

	- public function shouldAutocloseBranch($branch) {
	- if ($this->isImporting()) {
	- return false;
	+ 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;
	}

	- if ($this->getDetail('disable-autoclose', false)) {
	- return false;
	+ return 'r'.$this->getCallsign().$short_identifier;
	+ }
	+
	+ public function isImporting() {
	+ return (bool)$this->getDetail('importing', false);
	+ }
	+
	+
	+/* -( 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 false;
	+ return self::BECAUSE_BRANCH_UNTRACKED;
	+ }
	+
	+ if (!$this->isBranchInFilter($branch, 'close-commits-filter')) {
	+ return self::BECAUSE_BRANCH_NOT_AUTOCLOSE;
	}

	- return $this->isBranchInFilter($branch, 'close-commits-filter');
	+ return null;
	}

	- public function shouldAutocloseCommit(
	- PhabricatorRepositoryCommit $commit,
	- PhabricatorRepositoryCommitData $data) {

	- if ($this->getDetail('disable-autoclose', false)) {
	- return false;
	+ /**
	+ * 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:
	- return true;
	+ case PhabricatorRepositoryType::REPOSITORY_TYPE_MERCURIAL:
	+ return null;
	case PhabricatorRepositoryType::REPOSITORY_TYPE_GIT:
	break;
	- case PhabricatorRepositoryType::REPOSITORY_TYPE_MERCURIAL:
	- return true;
	default:
	throw new Exception('Unrecognized version control system.');
	}

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

	- // TODO: Remove this eventually, it's no longer written to by the import
	- // pipeline (however, old tasks may still be queued which don't reflect
	- // the new data format).
	- $branches = $data->getCommitDetail('seenOnBranches', array());
	- foreach ($branches as $branch) {
	- if ($this->shouldAutocloseBranch($branch)) {
	- return true;
	- }
	- }
	-
	- return false;
	+ return null;
	}

	- 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;
	+ /**
	+ * 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;
	}

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

	- public function isImporting() {
	- return (bool)$this->getDetail('importing', false);
	+ 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("Remote URI '{$raw_uri}' could not be parsed!");
	}


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

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

	$projects = id(new PhabricatorRepositoryArcanistProject())
	->loadAllWhere('repositoryID = %d', $this->getID());
	foreach ($projects as $project) {
	// note each project deletes its PhabricatorRepositorySymbols
	$project->delete();
	}

	$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 ".
	"'proto://domain/path', not 'proto://domain:/path'. ".
	"The ':/path' syntax is only valid in SCP-style URIs."));
	}
	}

	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 ".
	"'ssh://', 'http://', 'https://', 'git://', 'svn://', ".
	"'svn+ssh://', or be in the form '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;
	}


	/* -( 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();
	$this->saveTransaction();
	}

	}
	diff --git a/src/applications/repository/worker/commitmessageparser/PhabricatorRepositoryCommitMessageParserWorker.php b/src/applications/repository/worker/commitmessageparser/PhabricatorRepositoryCommitMessageParserWorker.php
	index 637c5ac179..cfe340e2b7 100644
	--- a/src/applications/repository/worker/commitmessageparser/PhabricatorRepositoryCommitMessageParserWorker.php
	+++ b/src/applications/repository/worker/commitmessageparser/PhabricatorRepositoryCommitMessageParserWorker.php
	@@ -1,509 +1,517 @@
	<?php

	abstract class PhabricatorRepositoryCommitMessageParserWorker
	extends PhabricatorRepositoryCommitParserWorker {

	final protected function updateCommitData(DiffusionCommitRef $ref) {
	$commit = $this->commit;
	$author = $ref->getAuthor();
	$message = $ref->getMessage();
	$committer = $ref->getCommitter();
	$hashes = $ref->getHashes();

	$data = id(new PhabricatorRepositoryCommitData())->loadOneWhere(
	'commitID = %d',
	$commit->getID());
	if (!$data) {
	$data = new PhabricatorRepositoryCommitData();
	}
	$data->setCommitID($commit->getID());
	$data->setAuthorName((string)$author);
	$data->setCommitDetail(
	'authorPHID',
	$this->resolveUserPHID($commit, $author));

	$data->setCommitMessage($message);

	if (strlen($committer)) {
	$data->setCommitDetail('committer', $committer);
	$data->setCommitDetail(
	'committerPHID',
	$this->resolveUserPHID($commit, $committer));
	}

	$repository = $this->repository;

	$author_phid = $data->getCommitDetail('authorPHID');
	$committer_phid = $data->getCommitDetail('committerPHID');

	$user = new PhabricatorUser();
	if ($author_phid) {
	$user = $user->loadOneWhere(
	'phid = %s',
	$author_phid);
	}

	$differential_app = 'PhabricatorDifferentialApplication';
	$revision_id = null;
	if (PhabricatorApplication::isClassInstalled($differential_app)) {
	$field_values = id(new DiffusionLowLevelCommitFieldsQuery())
	->setRepository($repository)
	->withCommitRef($ref)
	->execute();
	$revision_id = idx($field_values, 'revisionID');

	if (!empty($field_values['reviewedByPHIDs'])) {
	$data->setCommitDetail(
	'reviewerPHID',
	reset($field_values['reviewedByPHIDs']));
	}

	$data->setCommitDetail('differential.revisionID', $revision_id);
	}

	if ($author_phid != $commit->getAuthorPHID()) {
	$commit->setAuthorPHID($author_phid);
	}

	$commit->setSummary($data->getSummary());
	$commit->save();

	+ // Figure out if we're going to try to "autoclose" related objects (e.g.,
	+ // close linked tasks and related revisions) and, if not, record why we
	+ // aren't. Autoclose can be disabled for various reasons at the repository
	+ // or commit levels.
	+
	+ $autoclose_reason = $repository->shouldSkipAutocloseCommit($commit);
	+ $data->setCommitDetail('autocloseReason', $autoclose_reason);
	+ $should_autoclose = $repository->shouldAutocloseCommit($commit);
	+
	+
	// When updating related objects, we'll act under an omnipotent user to
	// ensure we can see them, but take actions as either the committer or
	// author (if we recognize their accounts) or the Diffusion application
	// (if we do not).

	$actor = PhabricatorUser::getOmnipotentUser();
	$acting_as_phid = nonempty(
	$committer_phid,
	$author_phid,
	id(new PhabricatorDiffusionApplication())->getPHID());

	$conn_w = id(new DifferentialRevision())->establishConnection('w');

	// NOTE: The `differential_commit` table has a unique ID on `commitPHID`,
	// preventing more than one revision from being associated with a commit.
	// Generally this is good and desirable, but with the advent of hash
	// tracking we may end up in a situation where we match several different
	// revisions. We just kind of ignore this and pick one, we might want to
	// revisit this and do something differently. (If we match several revisions
	// someone probably did something very silly, though.)

	$revision = null;
	- $should_autoclose = $repository->shouldAutocloseCommit($commit, $data);
	-
	if ($revision_id) {
	$revision_query = id(new DifferentialRevisionQuery())
	->withIDs(array($revision_id))
	->setViewer($actor)
	->needReviewerStatus(true)
	->needActiveDiffs(true);

	$revision = $revision_query->executeOne();

	if ($revision) {
	$commit_drev = PhabricatorEdgeConfig::TYPE_COMMIT_HAS_DREV;
	id(new PhabricatorEdgeEditor())
	->addEdge($commit->getPHID(), $commit_drev, $revision->getPHID())
	->save();

	queryfx(
	$conn_w,
	'INSERT IGNORE INTO %T (revisionID, commitPHID) VALUES (%d, %s)',
	DifferentialRevision::TABLE_COMMIT,
	$revision->getID(),
	$commit->getPHID());

	$status_closed = ArcanistDifferentialRevisionStatus::CLOSED;
	$should_close = ($revision->getStatus() != $status_closed) &&
	$should_autoclose;

	if ($should_close) {
	$commit_name = $repository->formatCommitName(
	$commit->getCommitIdentifier());

	$committer_name = $this->loadUserName(
	$committer_phid,
	$data->getCommitDetail('committer'),
	$actor);

	$author_name = $this->loadUserName(
	$author_phid,
	$data->getAuthorName(),
	$actor);

	if ($committer_name && ($committer_name != $author_name)) {
	$revision_update_comment = pht(
	'Closed by commit %s (authored by %s, committed by %s).',
	$commit_name,
	$author_name,
	$committer_name);
	} else {
	$revision_update_comment = pht(
	'Closed by commit %s (authored by %s).',
	$commit_name,
	$author_name);
	}

	$diff = $this->generateFinalDiff($revision, $acting_as_phid);

	$vs_diff = $this->loadChangedByCommit($revision, $diff);
	$changed_uri = null;
	if ($vs_diff) {
	$data->setCommitDetail('vsDiff', $vs_diff->getID());

	$changed_uri = PhabricatorEnv::getProductionURI(
	'/D'.$revision->getID().
	'?vs='.$vs_diff->getID().
	'&id='.$diff->getID().
	'#toc');
	}

	$xactions = array();

	$xactions[] = id(new DifferentialTransaction())
	->setTransactionType(DifferentialTransaction::TYPE_ACTION)
	->setNewValue(DifferentialAction::ACTION_CLOSE);

	$xactions[] = id(new DifferentialTransaction())
	->setTransactionType(DifferentialTransaction::TYPE_UPDATE)
	->setIgnoreOnNoEffect(true)
	->setNewValue($diff->getPHID());

	$xactions[] = id(new DifferentialTransaction())
	->setTransactionType(PhabricatorTransactions::TYPE_COMMENT)
	->setIgnoreOnNoEffect(true)
	->attachComment(
	id(new DifferentialTransactionComment())
	->setContent($revision_update_comment));

	$content_source = PhabricatorContentSource::newForSource(
	PhabricatorContentSource::SOURCE_DAEMON,
	array());

	$editor = id(new DifferentialTransactionEditor())
	->setActor($actor)
	->setActingAsPHID($acting_as_phid)
	->setContinueOnMissingFields(true)
	->setContentSource($content_source)
	->setChangedPriorToCommitURI($changed_uri)
	->setIsCloseByCommit(true);

	try {
	$editor->applyTransactions($revision, $xactions);
	} catch (PhabricatorApplicationTransactionNoEffectException $ex) {
	// NOTE: We've marked transactions other than the CLOSE transaction
	// as ignored when they don't have an effect, so this means that we
	// lost a race to close the revision. That's perfectly fine, we can
	// just continue normally.
	}
	}
	}
	}

	if ($should_autoclose) {
	$this->closeTasks(
	$actor,
	$acting_as_phid,
	$repository,
	$commit,
	$message);
	}

	$data->save();

	$commit->writeImportStatusFlag(
	PhabricatorRepositoryCommit::IMPORTED_MESSAGE);
	}

	private function loadUserName($user_phid, $default, PhabricatorUser $actor) {
	if (!$user_phid) {
	return $default;
	}
	$handle = id(new PhabricatorHandleQuery())
	->setViewer($actor)
	->withPHIDs(array($user_phid))
	->executeOne();

	return '@'.$handle->getName();
	}

	private function generateFinalDiff(
	DifferentialRevision $revision,
	$actor_phid) {

	$viewer = PhabricatorUser::getOmnipotentUser();

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

	$raw_diff = DiffusionQuery::callConduitWithDiffusionRequest(
	$viewer,
	$drequest,
	'diffusion.rawdiffquery',
	array(
	'commit' => $this->commit->getCommitIdentifier(),
	));

	// TODO: Support adds, deletes and moves under SVN.
	if (strlen($raw_diff)) {
	$changes = id(new ArcanistDiffParser())->parseDiff($raw_diff);
	} else {
	// This is an empty diff, maybe made with `git commit --allow-empty`.
	// NOTE: These diffs have the same tree hash as their ancestors, so
	// they may attach to revisions in an unexpected way. Just let this
	// happen for now, although it might make sense to special case it
	// eventually.
	$changes = array();
	}

	$diff = DifferentialDiff::newFromRawChanges($changes)
	->setRepositoryPHID($this->repository->getPHID())
	->setAuthorPHID($actor_phid)
	->setCreationMethod('commit')
	->setSourceControlSystem($this->repository->getVersionControlSystem())
	->setLintStatus(DifferentialLintStatus::LINT_SKIP)
	->setUnitStatus(DifferentialUnitStatus::UNIT_SKIP)
	->setDateCreated($this->commit->getEpoch())
	->setDescription(
	'Commit r'.
	$this->repository->getCallsign().
	$this->commit->getCommitIdentifier());

	// TODO: This is not correct in SVN where one repository can have multiple
	// Arcanist projects.
	$arcanist_project = id(new PhabricatorRepositoryArcanistProject())
	->loadOneWhere('repositoryID = %d LIMIT 1', $this->repository->getID());
	if ($arcanist_project) {
	$diff->setArcanistProjectPHID($arcanist_project->getPHID());
	}

	$parents = DiffusionQuery::callConduitWithDiffusionRequest(
	$viewer,
	$drequest,
	'diffusion.commitparentsquery',
	array(
	'commit' => $this->commit->getCommitIdentifier(),
	));
	if ($parents) {
	$diff->setSourceControlBaseRevision(head($parents));
	}

	// TODO: Attach binary files.

	return $diff->save();
	}

	private function loadChangedByCommit(
	DifferentialRevision $revision,
	DifferentialDiff $diff) {

	$repository = $this->repository;

	$vs_diff = id(new DifferentialDiffQuery())
	->setViewer(PhabricatorUser::getOmnipotentUser())
	->withRevisionIDs(array($revision->getID()))
	->needChangesets(true)
	->setLimit(1)
	->executeOne();
	if (!$vs_diff) {
	return null;
	}

	if ($vs_diff->getCreationMethod() == 'commit') {
	return null;
	}

	$vs_changesets = array();
	foreach ($vs_diff->getChangesets() as $changeset) {
	$path = $changeset->getAbsoluteRepositoryPath($repository, $vs_diff);
	$path = ltrim($path, '/');
	$vs_changesets[$path] = $changeset;
	}

	$changesets = array();
	foreach ($diff->getChangesets() as $changeset) {
	$path = $changeset->getAbsoluteRepositoryPath($repository, $diff);
	$path = ltrim($path, '/');
	$changesets[$path] = $changeset;
	}

	if (array_fill_keys(array_keys($changesets), true) !=
	array_fill_keys(array_keys($vs_changesets), true)) {
	return $vs_diff;
	}

	$file_phids = array();
	foreach ($vs_changesets as $changeset) {
	$metadata = $changeset->getMetadata();
	$file_phid = idx($metadata, 'new:binary-phid');
	if ($file_phid) {
	$file_phids[$file_phid] = $file_phid;
	}
	}

	$files = array();
	if ($file_phids) {
	$files = id(new PhabricatorFileQuery())
	->setViewer(PhabricatorUser::getOmnipotentUser())
	->withPHIDs($file_phids)
	->execute();
	$files = mpull($files, null, 'getPHID');
	}

	foreach ($changesets as $path => $changeset) {
	$vs_changeset = $vs_changesets[$path];

	$file_phid = idx($vs_changeset->getMetadata(), 'new:binary-phid');
	if ($file_phid) {
	if (!isset($files[$file_phid])) {
	return $vs_diff;
	}
	$drequest = DiffusionRequest::newFromDictionary(array(
	'user' => PhabricatorUser::getOmnipotentUser(),
	'initFromConduit' => false,
	'repository' => $this->repository,
	'commit' => $this->commit->getCommitIdentifier(),
	'path' => $path,
	));
	$corpus = DiffusionFileContentQuery::newFromDiffusionRequest($drequest)
	->setViewer(PhabricatorUser::getOmnipotentUser())
	->loadFileContent()
	->getCorpus();
	if ($files[$file_phid]->loadFileData() != $corpus) {
	return $vs_diff;
	}
	} else {
	$context = implode("\n", $changeset->makeChangesWithContext());
	$vs_context = implode("\n", $vs_changeset->makeChangesWithContext());

	// We couldn't just compare $context and $vs_context because following
	// diffs will be considered different:
	//
	// -(empty line)
	// -echo 'test';
	// (empty line)
	//
	// (empty line)
	// -echo "test";
	// -(empty line)

	$hunk = id(new DifferentialHunkModern())->setChanges($context);
	$vs_hunk = id(new DifferentialHunkModern())->setChanges($vs_context);
	if ($hunk->makeOldFile() != $vs_hunk->makeOldFile() \|\|
	$hunk->makeNewFile() != $vs_hunk->makeNewFile()) {
	return $vs_diff;
	}
	}
	}

	return null;
	}

	private function resolveUserPHID(
	PhabricatorRepositoryCommit $commit,
	$user_name) {

	return id(new DiffusionResolveUserQuery())
	->withCommit($commit)
	->withName($user_name)
	->execute();
	}

	private function closeTasks(
	PhabricatorUser $actor,
	$acting_as,
	PhabricatorRepository $repository,
	PhabricatorRepositoryCommit $commit,
	$message) {

	$maniphest = 'PhabricatorManiphestApplication';
	if (!PhabricatorApplication::isClassInstalled($maniphest)) {
	return;
	}

	$prefixes = ManiphestTaskStatus::getStatusPrefixMap();
	$suffixes = ManiphestTaskStatus::getStatusSuffixMap();

	$matches = id(new ManiphestCustomFieldStatusParser())
	->parseCorpus($message);

	$task_statuses = array();
	foreach ($matches as $match) {
	$prefix = phutil_utf8_strtolower($match['prefix']);
	$suffix = phutil_utf8_strtolower($match['suffix']);

	$status = idx($suffixes, $suffix);
	if (!$status) {
	$status = idx($prefixes, $prefix);
	}

	foreach ($match['monograms'] as $task_monogram) {
	$task_id = (int)trim($task_monogram, 'tT');
	$task_statuses[$task_id] = $status;
	}
	}

	if (!$task_statuses) {
	return;
	}

	$tasks = id(new ManiphestTaskQuery())
	->setViewer($actor)
	->withIDs(array_keys($task_statuses))
	->execute();

	foreach ($tasks as $task_id => $task) {
	$xactions = array();

	$edge_type = ManiphestTaskHasCommitEdgeType::EDGECONST;
	$xactions[] = id(new ManiphestTransaction())
	->setTransactionType(PhabricatorTransactions::TYPE_EDGE)
	->setMetadataValue('edge:type', $edge_type)
	->setNewValue(
	array(
	'+' => array(
	$commit->getPHID() => $commit->getPHID(),
	),
	));

	$status = $task_statuses[$task_id];
	if ($status) {
	if ($task->getStatus() != $status) {
	$xactions[] = id(new ManiphestTransaction())
	->setTransactionType(ManiphestTransaction::TYPE_STATUS)
	->setNewValue($status);

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

	$status_message = pht(
	'Closed by commit %s.',
	$commit_name);

	$xactions[] = id(new ManiphestTransaction())
	->setTransactionType(PhabricatorTransactions::TYPE_COMMENT)
	->attachComment(
	id(new ManiphestTransactionComment())
	->setContent($status_message));
	}
	}

	$content_source = PhabricatorContentSource::newForSource(
	PhabricatorContentSource::SOURCE_DAEMON,
	array());

	$editor = id(new ManiphestTransactionEditor())
	->setActor($actor)
	->setActingAsPHID($acting_as)
	->setContinueOnNoEffect(true)
	->setContinueOnMissingFields(true)
	->setContentSource($content_source);

	$editor->applyTransactions($task, $xactions);
	}
	}

	}
	diff --git a/src/docs/user/userguide/diffusion_autoclose.diviner b/src/docs/user/userguide/diffusion_autoclose.diviner
	new file mode 100644
	index 0000000000..adbc753aad
	--- /dev/null
	+++ b/src/docs/user/userguide/diffusion_autoclose.diviner
	@@ -0,0 +1,60 @@
	+@title Diffusion User Guide: Autoclose
	+@group userguide
	+
	+Explains when Diffusion will close tasks and revisions upon discovery of related
	+commits.
	+
	+Overview
	+========
	+
	+Diffusion can close tasks and revisions when related commits appear in a
	+repository. For example, if you make a commit with `Fixes T123` in the commit
	+message, Diffusion will close the task `T123`.
	+
	+This document explains how autoclose works, how to configure it, and how to
	+troubleshoot it.
	+
	+Troubleshooting Autoclose
	+=========================
	+
	+You can check if a branch is currently configured to autoclose on the main
	+repository view, or in the branches list view. Hover over the {icon check} or
	+{icon times} icon and you should see one of these messages:
	+
	+ - {icon check} Autoclose Enabled Autoclose is active for this branch.
	+ - {icon times} Repository Importing This repository is still importing.
	+ Autoclose does not activate until a repository finishes importing for the
	+ first time. This prevents situations where you import a repository and
	+ accidentally close hundreds of related objects during import. Autoclose
	+ will activate for new commits after the initial import completes.
	+ - {icon times} Repository Autoclose Disabled Autoclose is disabled for
	+ this entire repository. You can enable it in Edit Repository.
	+ - {icon times} Branch Untracked This branch is not tracked. Because it
	+ is not tracked, commits on it won't be seen and won't be discovered.
	+ - {icon times} Branch Autoclose Disabled Autoclose is not enabled for
	+ this branch. You can adjust which branches autoclose in Edit Repository.
	+ This option is only available in Git.
	+
	+If a branch is in good shape, you can check a specific commit by viewing it
	+in the web UI and clicking Edit Commit. There should be an Autoclose?
	+field visible in the form, with possible values listed below.
	+
	+Note that this field records the state of the world at the time the commit was
	+processed, and does not necessarily reflect the current state of the world.
	+For example, if a commit did not trigger autoclose because it was processed
	+during initial import, the field will still show No, Repository Importing
	+even after import completes. This means that the commit did not trigger
	+autoclose because the repository was importing at the time it was processed,
	+not necessarily that the repository is still importing.
	+
	+ - Yes At the time the commit was imported, autoclose triggered and
	+ Phabricator attempted to close related objects.
	+ - No, Repository Importing At the time the commit was processed, the
	+ repository was still importing. Autoclose does not activate until a
	+ repository fully imports for the first time.
	+ - No, Autoclose Disabled At the time the commit was processed, the
	+ repository had autoclose disabled.
	+ - No, Not On Autoclose Branch At the time the commit was processed,
	+ no containing branch was configured to autoclose.
	+ - //Field Not Present// This commit was processed before we implemented
	+ this diagnostic feature, and no information is available.

File Metadata

Mime Type: text/x-diff
Expires: Sun, Jan 19, 16:32 (2 w, 6 d ago)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1126511
Default Alt Text: (93 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions