No OneTemporary
Actions

Size

89 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/src/applications/diffusion/controller/DiffusionRepositoryCreateController.php b/src/applications/diffusion/controller/DiffusionRepositoryCreateController.php
	index 0486b248fe..417119704f 100644
	--- a/src/applications/diffusion/controller/DiffusionRepositoryCreateController.php
	+++ b/src/applications/diffusion/controller/DiffusionRepositoryCreateController.php
	@@ -1,918 +1,920 @@
	<?php

	final class DiffusionRepositoryCreateController
	extends DiffusionRepositoryEditController {

	private $edit;
	private $repository;

	public function willProcessRequest(array $data) {
	parent::willProcessRequest($data);
	$this->edit = $data['edit'];
	}

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

	// NOTE: We can end up here via either "Create Repository", or via
	// "Import Repository", or via "Edit Remote", or via "Edit Policies". In
	// the latter two cases, we show only a few of the pages.

	$repository = null;
	switch ($this->edit) {
	case 'remote':
	case 'policy':
	$repository = $this->getDiffusionRequest()->getRepository();

	// Make sure we have CAN_EDIT.
	PhabricatorPolicyFilter::requireCapability(
	$viewer,
	$repository,
	PhabricatorPolicyCapability::CAN_EDIT);

	$this->setRepository($repository);

	$cancel_uri = $this->getRepositoryControllerURI($repository, 'edit/');
	break;
	case 'import':
	case 'create':
	$this->requireApplicationCapability(
	DiffusionCapabilityCreateRepositories::CAPABILITY);

	$cancel_uri = $this->getApplicationURI('new/');
	break;
	default:
	throw new Exception("Invalid edit operation!");
	}

	$form = id(new PHUIPagedFormView())
	->setUser($viewer)
	->setCancelURI($cancel_uri);

	switch ($this->edit) {
	case 'remote':
	$title = pht('Edit Remote');
	$form
	->addPage('remote-uri', $this->buildRemoteURIPage())
	->addPage('auth', $this->buildAuthPage());
	break;
	case 'policy':
	$title = pht('Edit Policies');
	$form
	->addPage('policy', $this->buildPolicyPage());
	break;
	case 'create':
	$title = pht('Create Repository');
	$form
	->addPage('vcs', $this->buildVCSPage())
	->addPage('name', $this->buildNamePage())
	->addPage('policy', $this->buildPolicyPage())
	->addPage('done', $this->buildDonePage());
	break;
	case 'import':
	$title = pht('Import Repository');
	$form
	->addPage('vcs', $this->buildVCSPage())
	->addPage('name', $this->buildNamePage())
	->addPage('remote-uri', $this->buildRemoteURIPage())
	->addPage('auth', $this->buildAuthPage())
	->addPage('policy', $this->buildPolicyPage())
	->addPage('done', $this->buildDonePage());
	break;
	}

	if ($request->isFormPost()) {
	$form->readFromRequest($request);
	if ($form->isComplete()) {

	$is_create = ($this->edit === 'import' \|\| $this->edit === 'create');
	$is_auth = ($this->edit == 'import' \|\| $this->edit == 'remote');
	$is_policy = ($this->edit != 'remote');
	$is_init = ($this->edit == 'create');

	if ($is_create) {
	$repository = PhabricatorRepository::initializeNewRepository(
	$viewer);
	}

	$template = id(new PhabricatorRepositoryTransaction());

	$type_name = PhabricatorRepositoryTransaction::TYPE_NAME;
	$type_vcs = PhabricatorRepositoryTransaction::TYPE_VCS;
	$type_activate = PhabricatorRepositoryTransaction::TYPE_ACTIVATE;
	$type_local_path = PhabricatorRepositoryTransaction::TYPE_LOCAL_PATH;
	$type_remote_uri = PhabricatorRepositoryTransaction::TYPE_REMOTE_URI;
	$type_hosting = PhabricatorRepositoryTransaction::TYPE_HOSTING;
	$type_credential = PhabricatorRepositoryTransaction::TYPE_CREDENTIAL;
	$type_view = PhabricatorTransactions::TYPE_VIEW_POLICY;
	$type_edit = PhabricatorTransactions::TYPE_EDIT_POLICY;
	$type_push = PhabricatorRepositoryTransaction::TYPE_PUSH_POLICY;

	$xactions = array();

	// If we're creating a new repository, set all this core stuff.
	if ($is_create) {
	$callsign = $form->getPage('name')
	->getControl('callsign')->getValue();

	// We must set this to a unique value to save the repository
	// initially, and it's immutable, so we don't bother using
	// transactions to apply this change.
	$repository->setCallsign($callsign);

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

	$xactions[] = id(clone $template)
	->setTransactionType($type_name)
	->setNewValue(
	$form->getPage('name')->getControl('name')->getValue());

	$xactions[] = id(clone $template)
	->setTransactionType($type_vcs)
	->setNewValue(
	$form->getPage('vcs')->getControl('vcs')->getValue());

	$activate = $form->getPage('done')
	->getControl('activate')->getValue();
	$xactions[] = id(clone $template)
	->setTransactionType($type_activate)
	->setNewValue(
	($activate == 'start'));

	$default_local_path = PhabricatorEnv::getEnvConfig(
	'repository.default-local-path');

	$default_local_path = rtrim($default_local_path, '/');
	$default_local_path = $default_local_path.'/'.$callsign.'/';

	$xactions[] = id(clone $template)
	->setTransactionType($type_local_path)
	->setNewValue($default_local_path);
	}

	if ($is_init) {
	$xactions[] = id(clone $template)
	->setTransactionType($type_hosting)
	->setNewValue(true);
	}

	if ($is_auth) {
	$xactions[] = id(clone $template)
	->setTransactionType($type_remote_uri)
	->setNewValue(
	$form->getPage('remote-uri')->getControl('remoteURI')
	->getValue());

	$xactions[] = id(clone $template)
	->setTransactionType($type_credential)
	->setNewValue(
	$form->getPage('auth')->getControl('credential')->getValue());
	}

	if ($is_policy) {
	$xactions[] = id(clone $template)
	->setTransactionType($type_view)
	->setNewValue(
	$form->getPage('policy')->getControl('viewPolicy')->getValue());

	$xactions[] = id(clone $template)
	->setTransactionType($type_edit)
	->setNewValue(
	$form->getPage('policy')->getControl('editPolicy')->getValue());

	if ($is_init \|\| $repository->isHosted()) {
	$xactions[] = id(clone $template)
	->setTransactionType($type_push)
	->setNewValue(
	$form->getPage('policy')->getControl('pushPolicy')->getValue());
	}
	}

	id(new PhabricatorRepositoryEditor())
	->setContinueOnNoEffect(true)
	->setContentSourceFromRequest($request)
	->setActor($viewer)
	->applyTransactions($repository, $xactions);

	$repo_uri = $this->getRepositoryControllerURI($repository, 'edit/');
	return id(new AphrontRedirectResponse())->setURI($repo_uri);
	}
	} else {
	$dict = array();
	if ($repository) {
	$dict = array(
	'remoteURI' => $repository->getRemoteURI(),
	'credential' => $repository->getCredentialPHID(),
	'viewPolicy' => $repository->getViewPolicy(),
	'editPolicy' => $repository->getEditPolicy(),
	'pushPolicy' => $repository->getPushPolicy(),
	);
	}
	$form->readFromObject($dict);
	}

	$crumbs = $this->buildApplicationCrumbs();
	$crumbs->addTextCrumb($title);

	return $this->buildApplicationPage(
	array(
	$crumbs,
	$form,
	),
	array(
	'title' => $title,
	'device' => true,
	));
	}


	/* -( Page: VCS Type )----------------------------------------------------- */


	private function buildVCSPage() {

	$is_import = ($this->edit == 'import');

	if ($is_import) {
	$git_str = pht(
	'Import a Git repository (for example, a repository hosted '.
	'on GitHub).');
	$hg_str = pht(
	'Import a Mercurial repository (for example, a repository '.
	'hosted on Bitbucket).');
	$svn_str = pht('Import a Subversion repository.');
	} else {
	$git_str = pht('Create a new, empty Git repository.');
	$hg_str = pht('Create a new, empty Mercurial repository.');
	$svn_str = pht('Create a new, empty Subversion repository.');
	}

	$control = id(new AphrontFormRadioButtonControl())
	->setName('vcs')
	->setLabel(pht('Type'))
	->addButton(
	PhabricatorRepositoryType::REPOSITORY_TYPE_GIT,
	pht('Git'),
	$git_str)
	->addButton(
	PhabricatorRepositoryType::REPOSITORY_TYPE_MERCURIAL,
	pht('Mercurial'),
	$hg_str)
	->addButton(
	PhabricatorRepositoryType::REPOSITORY_TYPE_SVN,
	pht('Subversion'),
	$svn_str);

	if ($is_import) {
	$control->addButton(
	PhabricatorRepositoryType::REPOSITORY_TYPE_PERFORCE,
	pht('Perforce'),
	pht(
	'Perforce is not directly supported, but you can import '.
	'a Perforce repository as a Git repository using %s.',
	phutil_tag(
	'a',
	array(
	'href' =>
	'http://www.perforce.com/product/components/git-fusion',
	'target' => '_blank',
	),
	pht('Perforce Git Fusion'))),
	'disabled',
	$disabled = true);
	}

	return id(new PHUIFormPageView())
	->setPageName(pht('Repository Type'))
	->setUser($this->getRequest()->getUser())
	->setValidateFormPageCallback(array($this, 'validateVCSPage'))
	->addControl($control);
	}

	public function validateVCSPage(PHUIFormPageView $page) {
	$valid = array(
	PhabricatorRepositoryType::REPOSITORY_TYPE_GIT => true,
	PhabricatorRepositoryType::REPOSITORY_TYPE_MERCURIAL => true,
	PhabricatorRepositoryType::REPOSITORY_TYPE_SVN => true,
	);

	$c_vcs = $page->getControl('vcs');
	$v_vcs = $c_vcs->getValue();
	if (!$v_vcs) {
	$c_vcs->setError(pht('Required'));
	$page->addPageError(
	pht('You must select a version control system.'));
	} else if (empty($valid[$v_vcs])) {
	$c_vcs->setError(pht('Invalid'));
	$page->addPageError(
	pht('You must select a valid version control system.'));
	}

	return $c_vcs->isValid();
	}


	/* -( Page: Name and Callsign )-------------------------------------------- */


	private function buildNamePage() {
	return id(new PHUIFormPageView())
	->setUser($this->getRequest()->getUser())
	->setPageName(pht('Repository Name and Location'))
	->setValidateFormPageCallback(array($this, 'validateNamePage'))
	->addRemarkupInstructions(
	pht(
	'Choose a human-readable name for this repository, like '.
	'"CompanyName Mobile App" or "CompanyName Backend Server". You '.
	'can change this later.'))
	->addControl(
	id(new AphrontFormTextControl())
	->setName('name')
	->setLabel(pht('Name'))
	->setCaption(pht('Human-readable repository name.')))
	->addRemarkupInstructions(
	pht(
	'Choose a "Callsign" for the repository. This is a short, '.
	'unique string which identifies commits elsewhere in Phabricator. '.
	'For example, you might use `M` for your mobile app repository '.
	'and `B` for your backend repository.'.
	"\n\n".
	'Callsigns must be UPPERCASE, and can not be edited after the '.
	'repository is created. Generally, you should choose short '.
	'callsigns.'))
	->addControl(
	id(new AphrontFormTextControl())
	->setName('callsign')
	->setLabel(pht('Callsign'))
	->setCaption(pht('Short UPPERCASE identifier.')));
	}

	public function validateNamePage(PHUIFormPageView $page) {
	$c_name = $page->getControl('name');
	$v_name = $c_name->getValue();
	if (!strlen($v_name)) {
	$c_name->setError(pht('Required'));
	$page->addPageError(
	pht('You must choose a name for this repository.'));
	}

	$c_call = $page->getControl('callsign');
	$v_call = $c_call->getValue();
	if (!strlen($v_call)) {
	$c_call->setError(pht('Required'));
	$page->addPageError(
	pht('You must choose a callsign for this repository.'));
	} else if (!preg_match('/^[A-Z]+$/', $v_call)) {
	$c_call->setError(pht('Invalid'));
	$page->addPageError(
	pht('The callsign must contain only UPPERCASE letters.'));
	} else {
	$exists = false;
	try {
	$repo = id(new PhabricatorRepositoryQuery())
	->setViewer($this->getRequest()->getUser())
	->withCallsigns(array($v_call))
	->executeOne();
	$exists = (bool)$repo;
	} catch (PhabricatorPolicyException $ex) {
	$exists = true;
	}
	if ($exists) {
	$c_call->setError(pht('Not Unique'));
	$page->addPageError(
	pht(
	'Another repository already uses that callsign. You must choose '.
	'a unique callsign.'));
	}
	}

	return $c_name->isValid() &&
	$c_call->isValid();
	}


	/* -( Page: Remote URI )--------------------------------------------------- */


	private function buildRemoteURIPage() {
	return id(new PHUIFormPageView())
	->setUser($this->getRequest()->getUser())
	->setPageName(pht('Repository Remote URI'))
	->setValidateFormPageCallback(array($this, 'validateRemoteURIPage'))
	->setAdjustFormPageCallback(array($this, 'adjustRemoteURIPage'))
	->addControl(
	id(new AphrontFormTextControl())
	->setName('remoteURI'));
	}

	public function adjustRemoteURIPage(PHUIFormPageView $page) {
	$form = $page->getForm();

	$is_git = false;
	$is_svn = false;
	$is_mercurial = false;

	if ($this->getRepository()) {
	$vcs = $this->getRepository()->getVersionControlSystem();
	} else {
	$vcs = $form->getPage('vcs')->getControl('vcs')->getValue();
	}

	switch ($vcs) {
	case PhabricatorRepositoryType::REPOSITORY_TYPE_GIT:
	$is_git = true;
	break;
	case PhabricatorRepositoryType::REPOSITORY_TYPE_SVN:
	$is_svn = true;
	break;
	case PhabricatorRepositoryType::REPOSITORY_TYPE_MERCURIAL:
	$is_mercurial = true;
	break;
	default:
	throw new Exception("Unsupported VCS!");
	}

	$has_local = ($is_git \|\| $is_mercurial);
	if ($is_git) {
	$uri_label = pht('Remote URI');
	$instructions = pht(
	'Enter the URI to clone this Git repository from. It should usually '.
	'look like one of these examples:'.
	"\n\n".
	"\| Example Git Remote URIs \|\n".
	"\| ----------------------- \|\n".
	"\| `git@github.com:example/example.git` \|\n".
	"\| `ssh://user@host.com/git/example.git` \|\n".
	"\| `file:///local/path/to/repo` \|\n".
	"\| `https://example.com/repository.git` \|\n");
	} else if ($is_mercurial) {
	$uri_label = pht('Remote URI');
	$instructions = pht(
	'Enter the URI to clone this Mercurial repository from. It should '.
	'usually look like one of these examples:'.
	"\n\n".
	"\| Example Mercurial Remote URIs \|\n".
	"\| ----------------------- \|\n".
	"\| `ssh://hg@bitbucket.org/example/repository` \|\n".
	"\| `file:///local/path/to/repo` \|\n");
	} else if ($is_svn) {
	$uri_label = pht('Repository Root');
	$instructions = pht(
	'Enter the Repository Root for this Subversion repository. '.
	'You can figure this out by running `svn info` in a working copy '.
	'and looking at the value in the `Repository Root` field. It '.
	'should be a URI and will usually look like these:'.
	"\n\n".
	"\| Example Subversion Repository Root URIs \|\n".
	"\| ------------------------------ \|\n".
	"\| `http://svn.example.org/svnroot/` \|\n".
	"\| `svn+ssh://svn.example.com/svnroot/` \|\n".
	"\| `svn://svn.example.net/svnroot/` \|\n".
	"\| `file:///local/path/to/svnroot/` \|\n".
	"\n\n".
	- "Make sure you specify the root of the repository, not a ".
	- "subdirectory.");
	+ "You MUST specify the root of the repository, not a ".
	+ "subdirectory. (If you want to import only part of a Subversion ".
	+ "repository, use the //Import Only// option at the end of this ".
	+ "workflow.)");
	} else {
	throw new Exception("Unsupported VCS!");
	}

	$page->addRemarkupInstructions($instructions, 'remoteURI');
	$page->getControl('remoteURI')->setLabel($uri_label);
	}

	public function validateRemoteURIPage(PHUIFormPageView $page) {
	$c_remote = $page->getControl('remoteURI');
	$v_remote = $c_remote->getValue();

	if (!strlen($v_remote)) {
	$c_remote->setError(pht('Required'));
	$page->addPageError(
	pht("You must specify a URI."));
	} else {
	$proto = $this->getRemoteURIProtocol($v_remote);

	if ($proto === 'file') {
	if (!preg_match('@^file:///@', $v_remote)) {
	$c_remote->setError(pht('Invalid'));
	$page->addPageError(
	pht(
	"URIs using the 'file://' protocol should have three slashes ".
	"(e.g., 'file:///absolute/path/to/file'). You only have two. ".
	"Add another one."));
	}
	}

	// 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 ($proto == 'ssh') {
	if (preg_match('(^[^:@]+://[^/:]+:[^\d])', $v_remote)) {
	$c_remote->setError(pht('Invalid'));
	$page->addPageError(
	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 ($proto) {
	case 'ssh':
	case 'http':
	case 'https':
	case 'file':
	case 'git':
	case 'svn':
	case 'svn+ssh':
	break;
	default:
	$c_remote->setError(pht('Invalid'));
	$page->addPageError(
	pht(
	"The URI protocol is unrecognized. It should begin ".
	"'ssh://', 'http://', 'https://', 'file://', 'git://', ".
	"'svn://', 'svn+ssh://', or be in the form ".
	"'git@domain.com:path'."));
	break;
	}
	}

	return $c_remote->isValid();
	}


	/* -( Page: Authentication )----------------------------------------------- */


	public function buildAuthPage() {
	return id(new PHUIFormPageView())
	->setPageName(pht('Authentication'))
	->setUser($this->getRequest()->getUser())
	->setAdjustFormPageCallback(array($this, 'adjustAuthPage'))
	->addControl(
	id(new PassphraseCredentialControl())
	->setName('credential'));
	}


	public function adjustAuthPage($page) {
	$form = $page->getForm();

	if ($this->getRepository()) {
	$vcs = $this->getRepository()->getVersionControlSystem();
	} else {
	$vcs = $form->getPage('vcs')->getControl('vcs')->getValue();
	}

	$remote_uri = $form->getPage('remote-uri')
	->getControl('remoteURI')
	->getValue();
	$proto = $this->getRemoteURIProtocol($remote_uri);
	$remote_user = $this->getRemoteURIUser($remote_uri);

	$c_credential = $page->getControl('credential');
	$c_credential->setDefaultUsername($remote_user);

	if ($this->isSSHProtocol($proto)) {
	$c_credential->setLabel(pht('SSH Key'));
	$c_credential->setCredentialType(
	PassphraseCredentialTypeSSHPrivateKeyText::CREDENTIAL_TYPE);
	$provides_type = PassphraseCredentialTypeSSHPrivateKey::PROVIDES_TYPE;

	$page->addRemarkupInstructions(
	pht(
	'Choose or add the SSH credentials to use to connect to the the '.
	'repository hosted at:'.
	"\n\n".
	" lang=text\n".
	" %s",
	$remote_uri),
	'credential');
	} else if ($this->isUsernamePasswordProtocol($proto)) {
	$c_credential->setLabel(pht('Password'));
	$c_credential->setAllowNull(true);
	$c_credential->setCredentialType(
	PassphraseCredentialTypePassword::CREDENTIAL_TYPE);
	$provides_type = PassphraseCredentialTypePassword::PROVIDES_TYPE;

	$page->addRemarkupInstructions(
	pht(
	'Choose the a username and pasword used to connect to the '.
	'repository hosted at:'.
	"\n\n".
	" lang=text\n".
	" %s".
	"\n\n".
	"If this repository does not require a username or password, ".
	"you can continue to the next step.",
	$remote_uri),
	'credential');
	} else if ($proto == 'file') {
	$c_credential->setHidden(true);
	$provides_type = null;

	$page->addRemarkupInstructions(
	pht(
	'You do not need to configure any credentials for repositories '.
	'accessed over the `file://` protocol. Continue to the next step.'),
	'credential');
	} else {
	throw new Exception("Unknown URI protocol!");
	}

	if ($provides_type) {
	$viewer = $this->getRequest()->getUser();

	$options = id(new PassphraseCredentialQuery())
	->setViewer($viewer)
	->withIsDestroyed(false)
	->withProvidesTypes(array($provides_type))
	->execute();

	$c_credential->setOptions($options);
	}

	}

	public function validateAuthPage(PHUIFormPageView $page) {
	$form = $page->getForm();
	$remote_uri = $form->getPage('remote')->getControl('remoteURI')->getValue();
	$proto = $this->getRemoteURIProtocol($remote_uri);

	$c_credential = $page->getControl('credential');
	$v_credential = $c_credential->getValue();

	// NOTE: We're using the omnipotent user here because the viewer might be
	// editing a repository they're allowed to edit which uses a credential they
	// are not allowed to see. This is fine, as long as they don't change it.
	$credential = id(new PassphraseCredentialQuery())
	->setViewer(PhabricatorUser::getOmnipotentUser())
	->withPHIDs(array($v_credential))
	->executeOne();

	if ($this->isSSHProtocol($proto)) {
	if (!$credential) {
	$c_credential->setError(pht('Required'));
	$page->addPageError(
	pht('You must choose an SSH credential to connect over SSH.'));
	}

	$ssh_type = PassphraseCredentialTypeSSHPrivateKey::PROVIDES_TYPE;
	if ($credential->getProvidesType() !== $ssh_type) {
	$c_credential->setError(pht('Invalid'));
	$page->addPageError(
	pht(
	'You must choose an SSH credential, not some other type '.
	'of credential.'));
	}

	} else if ($this->isUsernamePasswordProtocol($proto)) {
	if ($credential) {
	$password_type = PassphraseCredentialTypePassword::PROVIDES_TYPE;
	if ($credential->getProvidesType() !== $password_type) {
	$c_credential->setError(pht('Invalid'));
	$page->addPageError(
	pht(
	'You must choose a username/password credential, not some other '.
	'type of credential.'));
	}
	}

	return $c_credential->isValid();
	} else {
	return true;
	}
	}


	/* -( Page: Policy )------------------------------------------------------- */


	private function buildPolicyPage() {
	$viewer = $this->getRequest()->getUser();
	if ($this->getRepository()) {
	$repository = $this->getRepository();
	} else {
	$repository = PhabricatorRepository::initializeNewRepository($viewer);
	}

	$policies = id(new PhabricatorPolicyQuery())
	->setViewer($viewer)
	->setObject($repository)
	->execute();

	$view_policy = id(new AphrontFormPolicyControl())
	->setUser($viewer)
	->setCapability(PhabricatorPolicyCapability::CAN_VIEW)
	->setPolicyObject($repository)
	->setPolicies($policies)
	->setName('viewPolicy');

	$edit_policy = id(new AphrontFormPolicyControl())
	->setUser($viewer)
	->setCapability(PhabricatorPolicyCapability::CAN_EDIT)
	->setPolicyObject($repository)
	->setPolicies($policies)
	->setName('editPolicy');

	$push_policy = id(new AphrontFormPolicyControl())
	->setUser($viewer)
	->setCapability(DiffusionCapabilityPush::CAPABILITY)
	->setPolicyObject($repository)
	->setPolicies($policies)
	->setName('pushPolicy');

	return id(new PHUIFormPageView())
	->setPageName(pht('Policies'))
	->setValidateFormPageCallback(array($this, 'validatePolicyPage'))
	->setAdjustFormPageCallback(array($this, 'adjustPolicyPage'))
	->setUser($viewer)
	->addRemarkupInstructions(
	pht(
	"Select access policies for this repository."))
	->addControl($view_policy)
	->addControl($edit_policy)
	->addControl($push_policy);
	}

	public function adjustPolicyPage(PHUIFormPageView $page) {
	if ($this->getRepository()) {
	$repository = $this->getRepository();
	$show_push = $repository->isHosted();
	} else {
	$show_push = ($this->edit == 'create');
	}

	if (!$show_push) {
	$c_push = $page->getControl('pushPolicy');
	$c_push->setHidden(true);
	}
	}

	public function validatePolicyPage(PHUIFormPageView $page) {
	$form = $page->getForm();
	$viewer = $this->getRequest()->getUser();

	$c_view = $page->getControl('viewPolicy');
	$c_edit = $page->getControl('editPolicy');
	$c_push = $page->getControl('pushPolicy');
	$v_view = $c_view->getValue();
	$v_edit = $c_edit->getValue();
	$v_push = $c_push->getValue();

	if ($this->getRepository()) {
	$repository = $this->getRepository();
	} else {
	$repository = PhabricatorRepository::initializeNewRepository($viewer);
	}

	$proxy = clone $repository;
	$proxy->setViewPolicy($v_view);
	$proxy->setEditPolicy($v_edit);

	$can_view = PhabricatorPolicyFilter::hasCapability(
	$viewer,
	$proxy,
	PhabricatorPolicyCapability::CAN_VIEW);

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

	if (!$can_view) {
	$c_view->setError(pht('Invalid'));
	$page->addPageError(
	pht(
	'You can not use the selected policy, because you would be unable '.
	'to see the repository.'));
	}

	if (!$can_edit) {
	$c_edit->setError(pht('Invalid'));
	$page->addPageError(
	pht(
	'You can not use the selected edit policy, because you would be '.
	'unable to edit the repository.'));
	}

	return $c_view->isValid() &&
	$c_edit->isValid();
	}

	/* -( Page: Done )--------------------------------------------------------- */


	private function buildDonePage() {

	$is_create = ($this->edit == 'create');
	if ($is_create) {
	$now_label = pht('Create Repository Now');
	$now_caption = pht(
	'Create the repository right away. This will create the repository '.
	'using default settings.');

	$wait_label = pht('Configure More Options First');
	$wait_caption = pht(
	'Configure more options before creating the repository. '.
	'This will let you fine-tune settings. You can create the repository '.
	'whenever you are ready.');
	} else {
	$now_label = pht('Start Import Now');
	$now_caption = pht(
	'Start importing the repository right away. This will import '.
	'the entire repository using default settings.');

	$wait_label = pht('Configure More Options First');
	$wait_caption = pht(
	'Configure more options before beginning the repository '.
	'import. This will let you fine-tune settings. You can '.
	'start the import whenever you are ready.');
	}

	return id(new PHUIFormPageView())
	->setPageName(pht('Repository Ready!'))
	->setValidateFormPageCallback(array($this, 'validateDonePage'))
	->setUser($this->getRequest()->getUser())
	->addControl(
	id(new AphrontFormRadioButtonControl())
	->setName('activate')
	->setLabel(pht('Start Now'))
	->addButton(
	'start',
	$now_label,
	$now_caption)
	->addButton(
	'wait',
	$wait_label,
	$wait_caption));
	}

	public function validateDonePage(PHUIFormPageView $page) {
	$c_activate = $page->getControl('activate');
	$v_activate = $c_activate->getValue();

	if ($v_activate != 'start' && $v_activate != 'wait') {
	$c_activate->setError(pht('Required'));
	$page->addPageError(
	pht('Make a choice about repository activation.'));
	}

	return $c_activate->isValid();
	}


	/* -( Internal )----------------------------------------------------------- */


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

	private function getRemoteURIUser($raw_uri) {
	$uri = new PhutilURI($raw_uri);
	if ($uri->getUser()) {
	return $uri->getUser();
	}

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

	return null;
	}

	private function isSSHProtocol($proto) {
	return ($proto == 'git' \|\| $proto == 'ssh' \|\| $proto == 'svn+ssh');
	}

	private function isUsernamePasswordProtocol($proto) {
	return ($proto == 'http' \|\| $proto == 'https' \|\| $proto == 'svn');
	}

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

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


	}
	diff --git a/src/applications/repository/data/PhabricatorRepositoryURINormalizer.php b/src/applications/repository/data/PhabricatorRepositoryURINormalizer.php
	index aa7c8d6520..75714f4f83 100644
	--- a/src/applications/repository/data/PhabricatorRepositoryURINormalizer.php
	+++ b/src/applications/repository/data/PhabricatorRepositoryURINormalizer.php
	@@ -1,98 +1,110 @@
	<?php

	/**
	* Normalize repository URIs. For example, these URIs are generally equivalent
	* and all point at the same repository:
	*
	* ssh://user@host/repo
	* ssh://user@host/repo/
	* ssh://user@host:22/repo
	* user@host:/repo
	* ssh://user@host/repo.git
	*
	* This class can be used to normalize URIs like this, in order to detect
	* alternate spellings of the same repository URI. In particular, the
	* @{method:getNormalizedPath} method will return:
	*
	* repo
	*
	* ...for all of these URIs. Generally, usage looks like this:
	*
	* $norm_a = new PhabricatorRepositoryURINormalizer($type, $uri_a);
	* $norm_b = new PhabricatorRepositoryURINormalizer($type, $uri_b);
	*
	* if ($norm_a->getNormalizedPath() == $norm_b->getNormalizedPath()) {
	* // URIs appear to point at the same repository.
	* } else {
	* // URIs are very unlikely to be the same repository.
	* }
	*
	* Because a repository can be hosted at arbitrarly many arbitrary URIs, there
	* is no way to completely prevent false negatives by only examining URIs
	* (that is, repositories with totally different URIs could really be the same).
	* However, normalization is relatively agressive and false negatives should
	* be rare: if normalization says two URIs are different repositories, they
	* probably are.
	*
	* @task normal Normalizing URIs
	*/
	final class PhabricatorRepositoryURINormalizer extends Phobject {

	const TYPE_GIT = 'git';
	+ const TYPE_SVN = 'svn';
	+
	private $type;
	private $uri;

	public function __construct($type, $uri) {
	switch ($type) {
	case self::TYPE_GIT:
	+ case self::TYPE_SVN:
	break;
	default:
	throw new Exception(pht('Unknown URI type "%s"!'));
	}

	$this->type = $type;
	$this->uri = $uri;
	}


	/* -( Normalizing URIs )--------------------------------------------------- */


	/**
	* @task normal
	*/
	public function getPath() {
	switch ($this->type) {
	case self::TYPE_GIT:
	$uri = new PhutilURI($this->uri);
	if ($uri->getProtocol()) {
	return $uri->getPath();
	}

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

	+ return $this->uri;
	+ case self::TYPE_SVN:
	+ $uri = new PhutilURI($this->uri);
	+ if ($uri->getProtocol()) {
	+ return $uri->getPath();
	+ }
	+
	return $this->uri;
	}
	}


	/**
	* @task normal
	*/
	public function getNormalizedPath() {
	$path = $this->getPath();
	$path = trim($path, '/');

	switch ($this->type) {
	case self::TYPE_GIT:
	$path = preg_replace('/\.git$/', '', $path);
	break;
	+ case self::TYPE_SVN:
	+ break;
	}

	return $path;
	}

	}
	diff --git a/src/applications/repository/data/__tests__/PhabricatorRepositoryURINormalizerTestCase.php b/src/applications/repository/data/__tests__/PhabricatorRepositoryURINormalizerTestCase.php
	index 32429ce244..d69d98bb54 100644
	--- a/src/applications/repository/data/__tests__/PhabricatorRepositoryURINormalizerTestCase.php
	+++ b/src/applications/repository/data/__tests__/PhabricatorRepositoryURINormalizerTestCase.php
	@@ -1,31 +1,49 @@
	<?php

	final class PhabricatorRepositoryURINormalizerTestCase
	extends PhabricatorTestCase {

	public function testGitURINormalizer() {
	$cases = array(
	'ssh://user@domain.com/path.git' => 'path',
	'https://user@domain.com/path.git' => 'path',
	'git@domain.com:path.git' => 'path',
	'ssh://user@gitserv002.com/path.git' => 'path',
	'ssh://htaft@domain.com/path.git' => 'path',
	'ssh://user@domain.com/bananas.git' => 'bananas',
	'git@domain.com:bananas.git' => 'bananas',
	'user@domain.com:path/repo' => 'path/repo',
	'user@domain.com:path/repo/' => 'path/repo',
	'file:///path/to/local/repo.git' => 'path/to/local/repo',
	'/path/to/local/repo.git' => 'path/to/local/repo',
	);

	$type_git = PhabricatorRepositoryURINormalizer::TYPE_GIT;

	foreach ($cases as $input => $expect) {
	$normal = new PhabricatorRepositoryURINormalizer($type_git, $input);
	$this->assertEqual(
	$expect,
	$normal->getNormalizedPath(),
	- pht('Normalized path for "%s".', $input));
	+ pht('Normalized Git path for "%s".', $input));
	}
	}
	+
	+ public function testSVNURINormalizer() {
	+ $cases = array(
	+ 'file:///path/to/repo' => 'path/to/repo',
	+ 'file:///path/to/repo/' => 'path/to/repo',
	+ );
	+
	+ $type_svn = PhabricatorRepositoryURINormalizer::TYPE_SVN;
	+
	+ foreach ($cases as $input => $expect) {
	+ $normal = new PhabricatorRepositoryURINormalizer($type_svn, $input);
	+ $this->assertEqual(
	+ $expect,
	+ $normal->getNormalizedPath(),
	+ pht('Normalized SVN path for "%s".', $input));
	+ }
	+ }
	+
	}
	diff --git a/src/applications/repository/engine/PhabricatorRepositoryDiscoveryEngine.php b/src/applications/repository/engine/PhabricatorRepositoryDiscoveryEngine.php
	index b6f5fe4ba3..3744f09d11 100644
	--- a/src/applications/repository/engine/PhabricatorRepositoryDiscoveryEngine.php
	+++ b/src/applications/repository/engine/PhabricatorRepositoryDiscoveryEngine.php
	@@ -1,550 +1,591 @@
	<?php

	/**
	* @task discover Discovering Repositories
	* @task svn Discovering Subversion Repositories
	* @task git Discovering Git Repositories
	* @task hg Discovering Mercurial Repositories
	* @task internal Internals
	*/
	final class PhabricatorRepositoryDiscoveryEngine
	extends PhabricatorRepositoryEngine {

	private $repairMode;
	private $commitCache = array();
	const MAX_COMMIT_CACHE_SIZE = 2048;


	/* -( Discovering Repositories )------------------------------------------- */


	public function setRepairMode($repair_mode) {
	$this->repairMode = $repair_mode;
	return $this;
	}


	public function getRepairMode() {
	return $this->repairMode;
	}


	/**
	* @task discovery
	*/
	public function discoverCommits() {
	$repository = $this->getRepository();

	$vcs = $repository->getVersionControlSystem();
	switch ($vcs) {
	case PhabricatorRepositoryType::REPOSITORY_TYPE_SVN:
	$refs = $this->discoverSubversionCommits();
	break;
	case PhabricatorRepositoryType::REPOSITORY_TYPE_MERCURIAL:
	$refs = $this->discoverMercurialCommits();
	break;
	case PhabricatorRepositoryType::REPOSITORY_TYPE_GIT:
	$refs = $this->discoverGitCommits();
	break;
	default:
	throw new Exception("Unknown VCS '{$vcs}'!");
	}

	// Record discovered commits and mark them in the cache.
	foreach ($refs as $ref) {
	$this->recordCommit(
	$repository,
	$ref->getIdentifier(),
	$ref->getEpoch(),
	$ref->getCanCloseImmediately());

	$this->commitCache[$ref->getIdentifier()] = true;
	}

	return $refs;
	}


	/* -( Discovering Git Repositories )--------------------------------------- */


	/**
	* @task git
	*/
	private function discoverGitCommits() {
	$repository = $this->getRepository();

	if (!$repository->isHosted()) {
	$this->verifyGitOrigin($repository);
	}

	$branches = id(new DiffusionLowLevelGitRefQuery())
	->setRepository($repository)
	->withIsOriginBranch(true)
	->execute();

	if (!$branches) {
	// This repository has no branches at all, so we don't need to do
	// anything. Generally, this means the repository is empty.
	return array();
	}

	$branches = $this->sortBranches($branches);
	$branches = mpull($branches, 'getCommitIdentifier', 'getShortName');

	$this->log(
	pht(
	'Discovering commits in repository %s.',
	$repository->getCallsign()));

	$refs = array();
	foreach ($branches as $name => $commit) {
	$this->log(pht('Examining branch "%s", at "%s".', $name, $commit));

	if (!$repository->shouldTrackBranch($name)) {
	$this->log(pht("Skipping, branch is untracked."));
	continue;
	}

	if ($this->isKnownCommit($commit)) {
	$this->log(pht("Skipping, HEAD is known."));
	continue;
	}

	$this->log(pht("Looking for new commits."));

	$refs[] = $this->discoverStreamAncestry(
	new PhabricatorGitGraphStream($repository, $commit),
	$commit,
	$repository->shouldAutocloseBranch($name));
	}

	return array_mergev($refs);
	}


	/**
	* Verify that the "origin" remote exists, and points at the correct URI.
	*
	* This catches or corrects some types of misconfiguration, and also repairs
	* an issue where Git 1.7.1 does not create an "origin" for `--bare` clones.
	* See T4041.
	*
	* @param PhabricatorRepository Repository to verify.
	* @return void
	*/
	private function verifyGitOrigin(PhabricatorRepository $repository) {
	list($remotes) = $repository->execxLocalCommand(
	'remote show -n origin');

	$matches = null;
	if (!preg_match('/^\sFetch URL:\s(.?)\s$/m', $remotes, $matches)) {
	throw new Exception(
	"Expected 'Fetch URL' in 'git remote show -n origin'.");
	}

	$remote_uri = $matches[1];
	$expect_remote = $repository->getRemoteURI();

	if ($remote_uri == "origin") {
	// If a remote does not exist, git pretends it does and prints out a
	// made up remote where the URI is the same as the remote name. This is
	// definitely not correct.

	// Possibly, we should use `git remote --verbose` instead, which does not
	// suffer from this problem (but is a little more complicated to parse).
	$valid = false;
	$exists = false;
	} else {
	$normal_type_git = PhabricatorRepositoryURINormalizer::TYPE_GIT;

	$remote_normal = id(new PhabricatorRepositoryURINormalizer(
	$normal_type_git,
	$remote_uri))->getNormalizedPath();

	$expect_normal = id(new PhabricatorRepositoryURINormalizer(
	$normal_type_git,
	$expect_remote))->getNormalizedPath();

	$valid = ($remote_normal == $expect_normal);
	$exists = true;
	}

	if (!$valid) {
	if (!$exists) {
	// If there's no "origin" remote, just create it regardless of how
	// strongly we own the working copy. There is almost no conceivable
	// scenario in which this could do damage.
	$this->log(
	pht(
	'Remote "origin" does not exist. Creating "origin", with '.
	'URI "%s".',
	$expect_remote));
	$repository->execxLocalCommand(
	'remote add origin %P',
	$repository->getRemoteURIEnvelope());

	// NOTE: This doesn't fetch the origin (it just creates it), so we won't
	// know about origin branches until the next "pull" happens. That's fine
	// for our purposes, but might impact things in the future.
	} else {
	if ($repository->canDestroyWorkingCopy()) {
	// Bad remote, but we can try to repair it.
	$this->log(
	pht(
	'Remote "origin" exists, but is pointed at the wrong URI, "%s". '.
	'Resetting origin URI to "%s.',
	$remote_uri,
	$expect_remote));
	$repository->execxLocalCommand(
	'remote set-url origin %P',
	$repository->getRemoteURIEnvelope());
	} else {
	// Bad remote and we aren't comfortable repairing it.
	$message = pht(
	'Working copy at "%s" has a mismatched origin URI, "%s". '.
	'The expected origin URI is "%s". Fix your configuration, or '.
	'set the remote URI correctly. To avoid breaking anything, '.
	'Phabricator will not automatically fix this.',
	$repository->getLocalPath(),
	$remote_uri,
	$expect_remote);
	throw new Exception($message);
	}
	}
	}
	}


	/* -( Discovering Subversion Repositories )-------------------------------- */


	/**
	* @task svn
	*/
	private function discoverSubversionCommits() {
	$repository = $this->getRepository();

	+ if (!$repository->isHosted()) {
	+ $this->verifySubversionRoot($repository);
	+ }
	+
	$upper_bound = null;
	$limit = 1;
	$refs = array();
	do {
	// Find all the unknown commits on this path. Note that we permit
	// importing an SVN subdirectory rather than the entire repository, so
	// commits may be nonsequential.

	if ($upper_bound === null) {
	$at_rev = 'HEAD';
	} else {
	$at_rev = ($upper_bound - 1);
	}

	try {
	list($xml, $stderr) = $repository->execxRemoteCommand(
	'log --xml --quiet --limit %d %s',
	$limit,
	$repository->getSubversionBaseURI($at_rev));
	} catch (CommandException $ex) {
	$stderr = $ex->getStdErr();
	if (preg_match('/(path\|File) not found/', $stderr)) {
	// We've gone all the way back through history and this path was not
	// affected by earlier commits.
	break;
	}
	throw $ex;
	}

	$xml = phutil_utf8ize($xml);
	$log = new SimpleXMLElement($xml);
	foreach ($log->logentry as $entry) {
	$identifier = (int)$entry['revision'];
	$epoch = (int)strtotime((string)$entry->date[0]);
	$refs[$identifier] = id(new PhabricatorRepositoryCommitRef())
	->setIdentifier($identifier)
	->setEpoch($epoch)
	->setCanCloseImmediately(true);

	if ($upper_bound === null) {
	$upper_bound = $identifier;
	} else {
	$upper_bound = min($upper_bound, $identifier);
	}
	}

	// Discover 2, 4, 8, ... 256 logs at a time. This allows us to initially
	// import large repositories fairly quickly, while pulling only as much
	// data as we need in the common case (when we've already imported the
	// repository and are just grabbing one commit at a time).
	$limit = min($limit * 2, 256);

	} while ($upper_bound > 1 && !$this->isKnownCommit($upper_bound));

	krsort($refs);
	while ($refs && $this->isKnownCommit(last($refs)->getIdentifier())) {
	array_pop($refs);
	}
	$refs = array_reverse($refs);

	return $refs;
	}


	+ private function verifySubversionRoot(PhabricatorRepository $repository) {
	+ list($xml) = $repository->execxRemoteCommand(
	+ 'info --xml %s',
	+ $repository->getSubversionPathURI());
	+
	+ $xml = phutil_utf8ize($xml);
	+ $xml = new SimpleXMLElement($xml);
	+
	+ $remote_root = (string)($xml->entry[0]->repository[0]->root[0]);
	+ $expect_root = $repository->getSubversionPathURI();
	+
	+ $normal_type_svn = PhabricatorRepositoryURINormalizer::TYPE_SVN;
	+
	+ $remote_normal = id(new PhabricatorRepositoryURINormalizer(
	+ $normal_type_svn,
	+ $remote_root))->getNormalizedPath();
	+
	+ $expect_normal = id(new PhabricatorRepositoryURINormalizer(
	+ $normal_type_svn,
	+ $expect_root))->getNormalizedPath();
	+
	+ if ($remote_normal != $expect_normal) {
	+ throw new Exception(
	+ pht(
	+ 'Repository "%s" does not have a correctly configured remote URI. '.
	+ 'The remote URI for a Subversion repository MUST point at the '.
	+ 'repository root. The root for this repository is "%s", but the '.
	+ 'configured URI is "%s". To resolve this error, set the remote URI '.
	+ 'to point at the repository root. If you want to import only part '.
	+ 'of a Subversion repository, use the "Import Only" option.',
	+ $repository->getCallsign(),
	+ $remote_root,
	+ $expect_root));
	+ }
	+ }
	+
	+
	/* -( Discovering Mercurial Repositories )--------------------------------- */


	/**
	* @task hg
	*/
	private function discoverMercurialCommits() {
	$repository = $this->getRepository();

	$branches = id(new DiffusionLowLevelMercurialBranchesQuery())
	->setRepository($repository)
	->execute();

	$refs = array();
	foreach ($branches as $branch) {
	// NOTE: Mercurial branches may have multiple heads, so the names may
	// not be unique.
	$name = $branch->getShortName();
	$commit = $branch->getCommitIdentifier();

	$this->log(pht('Examining branch "%s" head "%s".', $name, $commit));
	if (!$repository->shouldTrackBranch($name)) {
	$this->log(pht("Skipping, branch is untracked."));
	continue;
	}

	if ($this->isKnownCommit($commit)) {
	$this->log(pht("Skipping, this head is a known commit."));
	continue;
	}

	$this->log(pht("Looking for new commits."));

	$refs[] = $this->discoverStreamAncestry(
	new PhabricatorMercurialGraphStream($repository, $commit),
	$commit,
	$close_immediately = true);
	}

	return array_mergev($refs);
	}


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


	private function discoverStreamAncestry(
	PhabricatorRepositoryGraphStream $stream,
	$commit,
	$close_immediately) {

	$discover = array($commit);
	$graph = array();
	$seen = array();

	// Find all the reachable, undiscovered commits. Build a graph of the
	// edges.
	while ($discover) {
	$target = array_pop($discover);

	if (empty($graph[$target])) {
	$graph[$target] = array();
	}

	$parents = $stream->getParents($target);
	foreach ($parents as $parent) {
	if ($this->isKnownCommit($parent)) {
	continue;
	}

	$graph[$target][$parent] = true;

	if (empty($seen[$parent])) {
	$seen[$parent] = true;
	$discover[] = $parent;
	}
	}
	}

	// Now, sort them topographically.
	$commits = $this->reduceGraph($graph);

	$refs = array();
	foreach ($commits as $commit) {
	$refs[] = id(new PhabricatorRepositoryCommitRef())
	->setIdentifier($commit)
	->setEpoch($stream->getCommitDate($commit))
	->setCanCloseImmediately($close_immediately);
	}

	return $refs;
	}


	private function reduceGraph(array $edges) {
	foreach ($edges as $commit => $parents) {
	$edges[$commit] = array_keys($parents);
	}

	$graph = new PhutilDirectedScalarGraph();
	$graph->addNodes($edges);

	$commits = $graph->getTopographicallySortedNodes();

	// NOTE: We want the most ancestral nodes first, so we need to reverse the
	// list we get out of AbstractDirectedGraph.
	$commits = array_reverse($commits);

	return $commits;
	}


	private function isKnownCommit($identifier) {
	if (isset($this->commitCache[$identifier])) {
	return true;
	}

	if ($this->repairMode) {
	// In repair mode, rediscover the entire repository, ignoring the
	// database state. We can hit the local cache above, but if we miss it
	// stop the script from going to the database cache.
	return false;
	}

	$commit = id(new PhabricatorRepositoryCommit())->loadOneWhere(
	'repositoryID = %d AND commitIdentifier = %s',
	$this->getRepository()->getID(),
	$identifier);

	if (!$commit) {
	return false;
	}

	$this->commitCache[$identifier] = true;
	while (count($this->commitCache) > self::MAX_COMMIT_CACHE_SIZE) {
	array_shift($this->commitCache);
	}

	return true;
	}


	/**
	* Sort branches so we process closeable branches first. This makes the
	* whole import process a little cheaper, since we can close these commits
	* the first time through rather than catching them in the refs step.
	*
	* @task internal
	*
	* @param list<DiffusionRepositoryRef> List of branch heads.
	* @return list<DiffusionRepositoryRef> Sorted list of branch heads.
	*/
	private function sortBranches(array $branches) {
	$repository = $this->getRepository();

	$head_branches = array();
	$tail_branches = array();
	foreach ($branches as $branch) {
	$name = $branch->getShortName();

	if ($repository->shouldAutocloseBranch($name)) {
	$head_branches[] = $branch;
	} else {
	$tail_branches[] = $branch;
	}
	}

	return array_merge($head_branches, $tail_branches);
	}


	private function recordCommit(
	PhabricatorRepository $repository,
	$commit_identifier,
	$epoch,
	$close_immediately) {

	$commit = new PhabricatorRepositoryCommit();
	$commit->setRepositoryID($repository->getID());
	$commit->setCommitIdentifier($commit_identifier);
	$commit->setEpoch($epoch);
	if ($close_immediately) {
	$commit->setImportStatus(PhabricatorRepositoryCommit::IMPORTED_CLOSEABLE);
	}

	$data = new PhabricatorRepositoryCommitData();

	try {
	$commit->openTransaction();
	$commit->save();
	$data->setCommitID($commit->getID());
	$data->save();
	$commit->saveTransaction();

	$this->insertTask($repository, $commit);

	queryfx(
	$repository->establishConnection('w'),
	'INSERT INTO %T (repositoryID, size, lastCommitID, epoch)
	VALUES (%d, 1, %d, %d)
	ON DUPLICATE KEY UPDATE
	size = size + 1,
	lastCommitID =
	IF(VALUES(epoch) > epoch, VALUES(lastCommitID), lastCommitID),
	epoch = IF(VALUES(epoch) > epoch, VALUES(epoch), epoch)',
	PhabricatorRepository::TABLE_SUMMARY,
	$repository->getID(),
	$commit->getID(),
	$epoch);

	if ($this->repairMode) {
	// Normally, the query should throw a duplicate key exception. If we
	// reach this in repair mode, we've actually performed a repair.
	$this->log(pht('Repaired commit "%s".', $commit_identifier));
	}

	PhutilEventEngine::dispatchEvent(
	new PhabricatorEvent(
	PhabricatorEventType::TYPE_DIFFUSION_DIDDISCOVERCOMMIT,
	array(
	'repository' => $repository,
	'commit' => $commit,
	)));

	} catch (AphrontQueryDuplicateKeyException $ex) {
	$commit->killTransaction();
	// Ignore. This can happen because we discover the same new commit
	// more than once when looking at history, or because of races or
	// data inconsistency or cosmic radiation; in any case, we're still
	// in a good state if we ignore the failure.
	}
	}

	private function insertTask(
	PhabricatorRepository $repository,
	PhabricatorRepositoryCommit $commit,
	$data = array()) {

	$vcs = $repository->getVersionControlSystem();
	switch ($vcs) {
	case PhabricatorRepositoryType::REPOSITORY_TYPE_GIT:
	$class = 'PhabricatorRepositoryGitCommitMessageParserWorker';
	break;
	case PhabricatorRepositoryType::REPOSITORY_TYPE_SVN:
	$class = 'PhabricatorRepositorySvnCommitMessageParserWorker';
	break;
	case PhabricatorRepositoryType::REPOSITORY_TYPE_MERCURIAL:
	$class = 'PhabricatorRepositoryMercurialCommitMessageParserWorker';
	break;
	default:
	throw new Exception("Unknown repository type '{$vcs}'!");
	}

	$data['commitID'] = $commit->getID();

	PhabricatorWorker::scheduleTask($class, $data);
	}

	}
	diff --git a/src/applications/repository/engine/__tests__/PhabricatorWorkingCopyTestCase.php b/src/applications/repository/engine/__tests__/PhabricatorWorkingCopyTestCase.php
	index ab1ea5ebca..40412e45d0 100644
	--- a/src/applications/repository/engine/__tests__/PhabricatorWorkingCopyTestCase.php
	+++ b/src/applications/repository/engine/__tests__/PhabricatorWorkingCopyTestCase.php
	@@ -1,93 +1,101 @@
	<?php

	abstract class PhabricatorWorkingCopyTestCase extends PhabricatorTestCase {

	private $dirs = array();

	protected function getPhabricatorTestCaseConfiguration() {
	return array(
	self::PHABRICATOR_TESTCONFIG_BUILD_STORAGE_FIXTURES => true,
	);
	}

	protected function buildBareRepository($callsign) {
	+ $existing_repository = id(new PhabricatorRepositoryQuery())
	+ ->withCallsigns(array($callsign))
	+ ->setViewer(PhabricatorUser::getOmnipotentUser())
	+ ->executeOne();
	+ if ($existing_repository) {
	+ $existing_repository->delete();
	+ }
	+
	$data_dir = dirname(__FILE__).'/data/';

	$types = array(
	'svn' => PhabricatorRepositoryType::REPOSITORY_TYPE_SVN,
	'hg' => PhabricatorRepositoryType::REPOSITORY_TYPE_MERCURIAL,
	'git' => PhabricatorRepositoryType::REPOSITORY_TYPE_GIT,
	);

	$hits = array();
	foreach ($types as $type => $const) {
	$path = $data_dir.$callsign.'.'.$type.'.tgz';
	if (Filesystem::pathExists($path)) {
	$hits[$const] = $path;
	}
	}

	if (!$hits) {
	throw new Exception(
	"No test data for callsign '{$callsign}'. Expected an archive ".
	"like '{$callsign}.git.tgz' in '{$data_dir}'.");
	}

	if (count($hits) > 1) {
	throw new Exception(
	"Expected exactly one archive matching callsign '{$callsign}', ".
	"found too many: ".implode(', ', $hits));
	}

	$path = head($hits);
	$vcs_type = head_key($hits);

	$dir = PhutilDirectoryFixture::newFromArchive($path);
	$local = new TempFile('.ignore');

	$user = $this->generateNewTestUser();
	$repo = PhabricatorRepository::initializeNewRepository($user)
	->setCallsign($callsign)
	->setName(pht('Test Repo "%s"', $callsign))
	->setVersionControlSystem($vcs_type)
	->setDetail('local-path', dirname($local).'/'.$callsign)
	->setDetail('remote-uri', 'file://'.$dir->getPath().'/');

	$this->didConstructRepository($repo);

	$repo->save();
	$repo->makeEphemeral();

	// Keep the disk resources around until we exit.
	$this->dirs[] = $dir;
	$this->dirs[] = $local;

	return $repo;
	}

	protected function didConstructRepository(PhabricatorRepository $repository) {
	return;
	}

	protected function buildPulledRepository($callsign) {
	$repository = $this->buildBareRepository($callsign);

	id(new PhabricatorRepositoryPullEngine())
	->setRepository($repository)
	->pullRepository();

	return $repository;
	}

	protected function buildDiscoveredRepository($callsign) {
	$repository = $this->buildPulledRepository($callsign);

	id(new PhabricatorRepositoryDiscoveryEngine())
	->setRepository($repository)
	- ->discoverCommits($repository);
	+ ->discoverCommits();

	return $repository;
	}


	}
	diff --git a/src/applications/repository/worker/__tests__/PhabricatorChangeParserTestCase.php b/src/applications/repository/worker/__tests__/PhabricatorChangeParserTestCase.php
	index 54bbdd74c8..1f02ae8e7a 100644
	--- a/src/applications/repository/worker/__tests__/PhabricatorChangeParserTestCase.php
	+++ b/src/applications/repository/worker/__tests__/PhabricatorChangeParserTestCase.php
	@@ -1,1138 +1,1186 @@
	<?php

	final class PhabricatorChangeParserTestCase
	extends PhabricatorWorkingCopyTestCase {

	public function testGitParser() {
	$repository = $this->buildDiscoveredRepository('CHA');
	$viewer = PhabricatorUser::getOmnipotentUser();

	$commits = id(new DiffusionCommitQuery())
	->setViewer($viewer)
	->withRepositoryIDs(array($repository->getID()))
	->execute();

	$this->expectChanges(
	$repository,
	$commits,
	array(
	// 8ebb73c add +x
	'8ebb73c3f127625ad090472f4f3bfc72804def54' => array(
	array(
	'/',
	null,
	null,
	DifferentialChangeType::TYPE_CHILD,
	DifferentialChangeType::FILE_DIRECTORY,
	0,
	1389892449,
	),
	array(
	'/file_moved',
	null,
	null,
	DifferentialChangeType::TYPE_CHANGE,
	DifferentialChangeType::FILE_NORMAL,
	1,
	1389892449,
	),
	),

	// ee9c790 add symlink
	'ee9c7909e012da7d75e8e1293c7803a6e73ac26a' => array(
	array(
	'/',
	null,
	null,
	DifferentialChangeType::TYPE_CHILD,
	DifferentialChangeType::FILE_DIRECTORY,
	0,
	1389892436,
	),
	array(
	'/file_link',
	null,
	null,
	DifferentialChangeType::TYPE_ADD,
	DifferentialChangeType::FILE_SYMLINK,
	1,
	1389892436,
	),
	),

	// 7260ca4 add directory file
	'7260ca4b6cec35e755bb5365c4ccdd3f1977772e' => array(
	array(
	'/',
	null,
	null,
	DifferentialChangeType::TYPE_CHILD,
	DifferentialChangeType::FILE_DIRECTORY,
	0,
	1389892408,
	),
	array(
	'/dir',
	null,
	null,
	DifferentialChangeType::TYPE_ADD,
	DifferentialChangeType::FILE_DIRECTORY,
	1,
	1389892408,
	),
	array(
	'/dir/subfile',
	null,
	null,
	DifferentialChangeType::TYPE_ADD,
	DifferentialChangeType::FILE_NORMAL,
	1,
	1389892408,
	),
	),

	// 1fe783c move a file
	'1fe783cf207c1e5f3e01650d2d9cb80b8a707f0e' => array(
	array(
	'/',
	null,
	null,
	DifferentialChangeType::TYPE_CHILD,
	DifferentialChangeType::FILE_DIRECTORY,
	0,
	1389892388,
	),
	array(
	'/file',
	null,
	null,
	DifferentialChangeType::TYPE_MOVE_AWAY,
	DifferentialChangeType::FILE_NORMAL,
	1,
	1389892388,
	),
	array(
	'/file_moved',
	'/file',
	'1fe783cf207c1e5f3e01650d2d9cb80b8a707f0e',
	DifferentialChangeType::TYPE_MOVE_HERE,
	DifferentialChangeType::FILE_NORMAL,
	1,
	1389892388,
	),
	),

	// 376af8c copy a file
	'376af8cd8f5b96ec55b7d9a86ccc85b8df8fb833' => array(
	array(
	'/',
	null,
	null,
	DifferentialChangeType::TYPE_CHILD,
	DifferentialChangeType::FILE_DIRECTORY,
	0,
	1389892377,
	),
	array(
	'/file',
	null,
	null,
	DifferentialChangeType::TYPE_COPY_AWAY,
	DifferentialChangeType::FILE_NORMAL,
	0,
	1389892377,
	),
	array(
	'/file_copy',
	'/file',
	'376af8cd8f5b96ec55b7d9a86ccc85b8df8fb833',
	DifferentialChangeType::TYPE_COPY_HERE,
	DifferentialChangeType::FILE_NORMAL,
	1,
	1389892377,
	),
	),

	// ece6ea6 changed a file
	'ece6ea6c6836e8b11a103e21707b8f30e6840c94' => array(
	array(
	'/',
	null,
	null,
	DifferentialChangeType::TYPE_CHILD,
	DifferentialChangeType::FILE_DIRECTORY,
	0,
	1389892352,
	),
	array(
	'/file',
	null,
	null,
	DifferentialChangeType::TYPE_CHANGE,
	DifferentialChangeType::FILE_NORMAL,
	1,
	1389892352,
	),
	),

	// 513103f added a file
	'513103f65b8413dd2f1a1b5c1d4852a4a598540f' => array(
	array(
	'/',
	null,
	null,
	DifferentialChangeType::TYPE_CHILD,
	DifferentialChangeType::FILE_DIRECTORY,
	// This is the initial commit and technically created this
	// directory; arguably the parser should figure this out and
	// mark this as a direct change.
	0,
	1389892330,
	),
	array(
	'/file',
	null,
	null,
	DifferentialChangeType::TYPE_ADD,
	DifferentialChangeType::FILE_NORMAL,
	1,
	1389892330,
	),
	),
	));
	}

	public function testMercurialParser() {
	$repository = $this->buildDiscoveredRepository('CHB');
	$viewer = PhabricatorUser::getOmnipotentUser();

	$commits = id(new DiffusionCommitQuery())
	->setViewer($viewer)
	->withRepositoryIDs(array($repository->getID()))
	->execute();

	$this->expectChanges(
	$repository,
	$commits,
	array(
	'970357a2dc4264060e65d68e42240bb4e5984085' => array(
	array(
	'/',
	null,
	null,
	DifferentialChangeType::TYPE_CHILD,
	DifferentialChangeType::FILE_DIRECTORY,
	0,
	1390249395,
	),
	array(
	'/file_moved',
	null,
	null,
	DifferentialChangeType::TYPE_CHANGE,
	DifferentialChangeType::FILE_NORMAL,
	1,
	1390249395,
	),
	),

	'fbb49af9788e5dbffbc05a060b680df1fd457be3' => array(
	array(
	'/',
	null,
	null,
	DifferentialChangeType::TYPE_CHILD,
	DifferentialChangeType::FILE_DIRECTORY,
	0,
	1390249380,
	),
	array(
	'/file_link',
	null,
	null,
	DifferentialChangeType::TYPE_ADD,
	// TODO: This is not correct, and should be FILE_SYMLINK. See
	// note in the parser about this. This is a known bug.
	DifferentialChangeType::FILE_NORMAL,
	1,
	1390249380,
	),
	),

	'0e8d3465944c7ed7a7c139da7edc652cf80dba69' => array(
	array(
	'/',
	null,
	null,
	DifferentialChangeType::TYPE_CHILD,
	DifferentialChangeType::FILE_DIRECTORY,
	0,
	1390249342,
	),
	array(
	'/dir',
	null,
	null,
	DifferentialChangeType::TYPE_ADD,
	DifferentialChangeType::FILE_DIRECTORY,
	1,
	1390249342,
	),
	array(
	'/dir/subfile',
	null,
	null,
	DifferentialChangeType::TYPE_ADD,
	DifferentialChangeType::FILE_NORMAL,
	1,
	1390249342,
	),
	),

	'22c75131ff15c8a44d7a729c4542b7f4c8ed27f4' => array(
	array(
	'/',
	null,
	null,
	DifferentialChangeType::TYPE_CHILD,
	DifferentialChangeType::FILE_DIRECTORY,
	0,
	1390249320,
	),
	array(
	'/file',
	null,
	null,
	DifferentialChangeType::TYPE_MOVE_AWAY,
	DifferentialChangeType::FILE_NORMAL,
	1,
	1390249320,
	),
	array(
	'/file_moved',
	'/file',
	'22c75131ff15c8a44d7a729c4542b7f4c8ed27f4',
	DifferentialChangeType::TYPE_MOVE_HERE,
	DifferentialChangeType::FILE_NORMAL,
	1,
	1390249320,
	),
	),

	'd9d252df30cb7251ad3ea121eff30c7d2e36dd67' => array(
	array(
	'/',
	null,
	null,
	DifferentialChangeType::TYPE_CHILD,
	DifferentialChangeType::FILE_DIRECTORY,
	0,
	1390249308,
	),
	array(
	'/file',
	null,
	null,
	DifferentialChangeType::TYPE_COPY_AWAY,
	DifferentialChangeType::FILE_NORMAL,
	0,
	1390249308,
	),
	array(
	'/file_copy',
	'/file',
	'd9d252df30cb7251ad3ea121eff30c7d2e36dd67',
	DifferentialChangeType::TYPE_COPY_HERE,
	DifferentialChangeType::FILE_NORMAL,
	1,
	1390249308,
	),
	),

	'1fc0445d5e3d0f33e9dcbb68bbe419a847460d25' => array(
	array(
	'/',
	null,
	null,
	DifferentialChangeType::TYPE_CHILD,
	DifferentialChangeType::FILE_DIRECTORY,
	0,
	1390249294,
	),
	array(
	'/file',
	null,
	null,
	DifferentialChangeType::TYPE_CHANGE,
	DifferentialChangeType::FILE_NORMAL,
	1,
	1390249294,
	),
	),

	'61518e196efb7f80700333cc0d00634c2578871a' => array(
	array(
	'/',
	null,
	null,
	DifferentialChangeType::TYPE_ADD,
	DifferentialChangeType::FILE_DIRECTORY,
	1,
	1390249286,
	),
	array(
	'/file',
	null,
	null,
	DifferentialChangeType::TYPE_ADD,
	DifferentialChangeType::FILE_NORMAL,
	1,
	1390249286,
	),
	),
	));
	}

	public function testSubversionParser() {
	$repository = $this->buildDiscoveredRepository('CHC');
	$viewer = PhabricatorUser::getOmnipotentUser();

	$commits = id(new DiffusionCommitQuery())
	->setViewer($viewer)
	->withRepositoryIDs(array($repository->getID()))
	->execute();

	$this->expectChanges(
	$repository,
	$commits,
	array(
	'15' => array(
	array(
	'/',
	null,
	null,
	DifferentialChangeType::TYPE_CHILD,
	DifferentialChangeType::FILE_DIRECTORY,
	0,
	15,
	),
	array(
	'/file_copy',
	null,
	null,
	DifferentialChangeType::TYPE_MULTICOPY,
	DifferentialChangeType::FILE_NORMAL,
	1,
	15,
	),
	array(
	'/file_copy_x',
	'/file_copy',
	'12',
	DifferentialChangeType::TYPE_MOVE_HERE,
	DifferentialChangeType::FILE_NORMAL,
	1,
	15,
	),
	array(
	'/file_copy_y',
	'/file_copy',
	'12',
	DifferentialChangeType::TYPE_MOVE_HERE,
	DifferentialChangeType::FILE_NORMAL,
	1,
	15,
	),
	array(
	'/file_copy_z',
	'/file_copy',
	'12',
	DifferentialChangeType::TYPE_MOVE_HERE,
	DifferentialChangeType::FILE_NORMAL,
	1,
	15,
	),
	),

	// Add a file from a different revision
	'14' => array(
	array(
	'/',
	null,
	null,
	DifferentialChangeType::TYPE_CHILD,
	DifferentialChangeType::FILE_DIRECTORY,
	0,
	14,
	),
	array(
	'/file',
	null,
	null,
	DifferentialChangeType::TYPE_COPY_AWAY,
	DifferentialChangeType::FILE_NORMAL,
	0,
	14,
	),
	array(
	'/file_1',
	'/file',
	'1',
	DifferentialChangeType::TYPE_COPY_HERE,
	DifferentialChangeType::FILE_NORMAL,
	1,
	14,
	),
	),

	// Property change on "/"
	'13' => array(
	array(
	'/',
	null,
	null,
	DifferentialChangeType::TYPE_CHANGE,
	DifferentialChangeType::FILE_DIRECTORY,
	1,
	13,
	),
	),

	// Copy a directory, removing and adding files to the copy
	'12' => array(
	array(
	'/',
	null,
	null,
	DifferentialChangeType::TYPE_CHILD,
	DifferentialChangeType::FILE_DIRECTORY,
	0,
	12,
	),
	array(
	'/dir',
	null,
	null,
	// TODO: This might reasonbly be considered a bug in the parser; it
	// should probably be COPY_AWAY.
	DifferentialChangeType::TYPE_CHILD,
	DifferentialChangeType::FILE_DIRECTORY,
	0,
	12,
	),
	array(
	'/dir/a',
	null,
	null,
	DifferentialChangeType::TYPE_COPY_AWAY,
	DifferentialChangeType::FILE_NORMAL,
	0,
	12,
	),
	array(
	'/dir/b',
	null,
	null,
	DifferentialChangeType::TYPE_COPY_AWAY,
	DifferentialChangeType::FILE_NORMAL,
	0,
	12,
	),
	array(
	'/dir/subdir',
	null,
	null,
	DifferentialChangeType::TYPE_COPY_AWAY,
	DifferentialChangeType::FILE_DIRECTORY,
	0,
	12,
	),
	array(
	'/dir/subdir/a',
	null,
	null,
	DifferentialChangeType::TYPE_COPY_AWAY,
	DifferentialChangeType::FILE_NORMAL,
	0,
	12,
	),
	array(
	'/dir/subdir/b',
	null,
	null,
	DifferentialChangeType::TYPE_COPY_AWAY,
	DifferentialChangeType::FILE_NORMAL,
	0,
	12,
	),
	array(
	'/dir_copy',
	'/dir',
	'11',
	DifferentialChangeType::TYPE_COPY_HERE,
	DifferentialChangeType::FILE_DIRECTORY,
	1,
	12,
	),
	array(
	'/dir_copy/a',
	'/dir/a',
	'11',
	DifferentialChangeType::TYPE_COPY_HERE,
	DifferentialChangeType::FILE_NORMAL,
	1,
	12,
	),
	array(
	'/dir_copy/b',
	'/dir/b',
	'11',
	DifferentialChangeType::TYPE_COPY_HERE,
	DifferentialChangeType::FILE_NORMAL,
	1,
	12,
	),
	array(
	'/dir_copy/subdir',
	'/dir/subdir',
	'11',
	DifferentialChangeType::TYPE_COPY_HERE,
	DifferentialChangeType::FILE_DIRECTORY,
	1,
	12,
	),
	array(
	'/dir_copy/subdir/a',
	'/dir/subdir/a',
	'11',
	DifferentialChangeType::TYPE_COPY_HERE,
	DifferentialChangeType::FILE_NORMAL,
	1,
	12,
	),
	array(
	'/dir_copy/subdir/b',
	'/dir/subdir/b',
	'11',
	DifferentialChangeType::TYPE_DELETE,
	DifferentialChangeType::FILE_NORMAL,
	1,
	12,
	),
	array(
	'/dir_copy/subdir/c',
	null,
	null,
	DifferentialChangeType::TYPE_ADD,
	DifferentialChangeType::FILE_NORMAL,
	1,
	12,
	),
	),

	// Add a directory with a subdirectory and files, sets up next commit
	'11' => array(
	array(
	'/',
	null,
	null,
	DifferentialChangeType::TYPE_CHILD,
	DifferentialChangeType::FILE_DIRECTORY,
	0,
	11,
	),
	array(
	'/dir',
	null,
	null,
	DifferentialChangeType::TYPE_ADD,
	DifferentialChangeType::FILE_DIRECTORY,
	1,
	11,
	),
	array(
	'/dir/a',
	null,
	null,
	DifferentialChangeType::TYPE_ADD,
	DifferentialChangeType::FILE_NORMAL,
	1,
	11,
	),
	array(
	'/dir/b',
	null,
	null,
	DifferentialChangeType::TYPE_ADD,
	DifferentialChangeType::FILE_NORMAL,
	1,
	11,
	),
	array(
	'/dir/subdir',
	null,
	null,
	DifferentialChangeType::TYPE_ADD,
	DifferentialChangeType::FILE_DIRECTORY,
	1,
	11,
	),
	array(
	'/dir/subdir/a',
	null,
	null,
	DifferentialChangeType::TYPE_ADD,
	DifferentialChangeType::FILE_NORMAL,
	1,
	11,
	),
	array(
	'/dir/subdir/b',
	null,
	null,
	DifferentialChangeType::TYPE_ADD,
	DifferentialChangeType::FILE_NORMAL,
	1,
	11,
	),
	),

	// Remove directory
	'10' => array(
	array(
	'/',
	null,
	null,
	DifferentialChangeType::TYPE_CHILD,
	DifferentialChangeType::FILE_DIRECTORY,
	0,
	10,
	),
	array(
	'/dir',
	null,
	null,
	DifferentialChangeType::TYPE_DELETE,
	DifferentialChangeType::FILE_DIRECTORY,
	1,
	10,
	),
	array(
	'/dir/subfile',
	null,
	null,
	DifferentialChangeType::TYPE_DELETE,
	DifferentialChangeType::FILE_NORMAL,
	1,
	10,
	),
	),

	// Replace directory with file
	'9' => array(
	array(
	'/',
	null,
	null,
	DifferentialChangeType::TYPE_CHILD,
	DifferentialChangeType::FILE_DIRECTORY,
	0,
	9,
	),
	array(
	'/file_moved',
	null,
	null,
	DifferentialChangeType::TYPE_CHANGE,
	DifferentialChangeType::FILE_DIRECTORY,
	1,
	9,
	),
	),

	// Replace file with file
	'8' => array(
	array(
	'/',
	null,
	null,
	DifferentialChangeType::TYPE_CHILD,
	DifferentialChangeType::FILE_DIRECTORY,
	0,
	8,
	),
	array(
	'/file_moved',
	null,
	null,
	DifferentialChangeType::TYPE_CHANGE,
	DifferentialChangeType::FILE_NORMAL,
	1,
	8,
	),
	),

	'7' => array(
	array(
	'/',
	null,
	null,
	DifferentialChangeType::TYPE_CHILD,
	DifferentialChangeType::FILE_DIRECTORY,
	0,
	7,
	),
	array(
	'/file_moved',
	null,
	null,
	DifferentialChangeType::TYPE_CHANGE,
	DifferentialChangeType::FILE_NORMAL,
	1,
	7,
	),
	),

	'6' => array(
	array(
	'/',
	null,
	null,
	DifferentialChangeType::TYPE_CHILD,
	DifferentialChangeType::FILE_DIRECTORY,
	0,
	6,
	),
	array(
	'/file_link',
	null,
	null,
	DifferentialChangeType::TYPE_ADD,
	// TODO: This is not correct, and should be FILE_SYMLINK.
	DifferentialChangeType::FILE_NORMAL,
	1,
	6,
	),
	),

	'5' => array(
	array(
	'/',
	null,
	null,
	DifferentialChangeType::TYPE_CHILD,
	DifferentialChangeType::FILE_DIRECTORY,
	0,
	5,
	),
	array(
	'/dir',
	null,
	null,
	DifferentialChangeType::TYPE_ADD,
	DifferentialChangeType::FILE_DIRECTORY,
	1,
	5,
	),
	array(
	'/dir/subfile',
	null,
	null,
	DifferentialChangeType::TYPE_ADD,
	DifferentialChangeType::FILE_NORMAL,
	1,
	5,
	),
	),

	'4' => array(
	array(
	'/',
	null,
	null,
	DifferentialChangeType::TYPE_CHILD,
	DifferentialChangeType::FILE_DIRECTORY,
	0,
	4,
	),
	array(
	'/file',
	null,
	null,
	DifferentialChangeType::TYPE_MOVE_AWAY,
	DifferentialChangeType::FILE_NORMAL,
	1,
	4,
	),
	array(
	'/file_moved',
	'/file',
	'2',
	DifferentialChangeType::TYPE_MOVE_HERE,
	DifferentialChangeType::FILE_NORMAL,
	1,
	4,
	),
	),

	'3' => array(
	array(
	'/',
	null,
	null,
	DifferentialChangeType::TYPE_CHILD,
	DifferentialChangeType::FILE_DIRECTORY,
	0,
	3,
	),
	array(
	'/file',
	null,
	null,
	DifferentialChangeType::TYPE_COPY_AWAY,
	DifferentialChangeType::FILE_NORMAL,
	0,
	3,
	),
	array(
	'/file_copy',
	'/file',
	'2',
	DifferentialChangeType::TYPE_COPY_HERE,
	DifferentialChangeType::FILE_NORMAL,
	1,
	3,
	),
	),

	'2' => array(
	array(
	'/',
	null,
	null,
	DifferentialChangeType::TYPE_CHILD,
	DifferentialChangeType::FILE_DIRECTORY,
	0,
	2,
	),
	array(
	'/file',
	null,
	null,
	DifferentialChangeType::TYPE_CHANGE,
	DifferentialChangeType::FILE_NORMAL,
	1,
	2,
	),
	),

	'1' => array(
	array(
	'/',
	null,
	null,
	// The Git and Svn parsers don't recognize the first commit as
	// creating "/", while the Mercurial parser does. All the parsers
	// should probably behave like the Mercurial parser.
	DifferentialChangeType::TYPE_CHILD,
	DifferentialChangeType::FILE_DIRECTORY,
	0,
	1,
	),
	array(
	'/file',
	null,
	null,
	DifferentialChangeType::TYPE_ADD,
	DifferentialChangeType::FILE_NORMAL,
	1,
	1,
	),
	),
	));
	}

	public function testSubversionPartialParser() {
	$repository = $this->buildBareRepository('CHD');
	$repository->setDetail('svn-subpath', 'trunk/');

	id(new PhabricatorRepositoryPullEngine())
	->setRepository($repository)
	->pullRepository();

	id(new PhabricatorRepositoryDiscoveryEngine())
	->setRepository($repository)
	- ->discoverCommits($repository);
	+ ->discoverCommits();

	$viewer = PhabricatorUser::getOmnipotentUser();

	$commits = id(new DiffusionCommitQuery())
	->setViewer($viewer)
	->withRepositoryIDs(array($repository->getID()))
	->execute();

	$this->expectChanges(
	$repository,
	$commits,
	array(
	// Copy of a file outside of the subpath from an earlier revision
	// into the subpath.
	4 => array(
	array(
	'/',
	null,
	null,
	DifferentialChangeType::TYPE_CHILD,
	DifferentialChangeType::FILE_DIRECTORY,
	0,
	4,
	),
	array(
	'/goat',
	null,
	null,
	DifferentialChangeType::TYPE_COPY_AWAY,
	DifferentialChangeType::FILE_NORMAL,
	0,
	4,
	),
	array(
	'/trunk',
	null,
	null,
	DifferentialChangeType::TYPE_CHILD,
	DifferentialChangeType::FILE_DIRECTORY,
	0,
	4,
	),
	array(
	'/trunk/goat',
	'/goat',
	'1',
	DifferentialChangeType::TYPE_COPY_HERE,
	DifferentialChangeType::FILE_NORMAL,
	1,
	4,
	),
	),
	3 => array(
	array(
	'/',
	null,
	null,
	DifferentialChangeType::TYPE_CHILD,
	DifferentialChangeType::FILE_DIRECTORY,
	0,
	3,
	),
	array(
	'/trunk',
	null,
	null,
	DifferentialChangeType::TYPE_ADD,
	DifferentialChangeType::FILE_DIRECTORY,
	1,
	3,
	),
	array(
	'/trunk/apple',
	null,
	null,
	DifferentialChangeType::TYPE_ADD,
	DifferentialChangeType::FILE_NORMAL,
	1,
	3,
	),
	array(
	'/trunk/banana',
	null,
	null,
	DifferentialChangeType::TYPE_ADD,
	DifferentialChangeType::FILE_NORMAL,
	1,
	3,
	),
	),
	));
	}

	+ public function testSubversionValidRootParser() {
	+ // First, automatically configure the root correctly.
	+ $repository = $this->buildBareRepository('CHD');
	+ id(new PhabricatorRepositoryPullEngine())
	+ ->setRepository($repository)
	+ ->pullRepository();
	+
	+ $caught = null;
	+ try {
	+ id(new PhabricatorRepositoryDiscoveryEngine())
	+ ->setRepository($repository)
	+ ->discoverCommits();
	+ } catch (Exception $ex) {
	+ $caught = $ex;
	+ }
	+
	+ $this->assertEqual(
	+ false,
	+ ($caught instanceof Exception),
	+ pht('Natural SVN root should work properly.'));
	+
	+
	+ // This time, artificially break the root. We expect this to fail.
	+ $repository = $this->buildBareRepository('CHD');
	+ $repository->setDetail(
	+ 'remote-uri',
	+ $repository->getDetail('remote-uri').'trunk/');
	+
	+ id(new PhabricatorRepositoryPullEngine())
	+ ->setRepository($repository)
	+ ->pullRepository();
	+
	+ $caught = null;
	+ try {
	+ id(new PhabricatorRepositoryDiscoveryEngine())
	+ ->setRepository($repository)
	+ ->discoverCommits();
	+ } catch (Exception $ex) {
	+ $caught = $ex;
	+ }
	+
	+ $this->assertEqual(
	+ true,
	+ ($caught instanceof Exception),
	+ pht('Artificial SVN root should fail.'));
	+ }
	+
	+
	private function expectChanges(
	PhabricatorRepository $repository,
	array $commits,
	array $expect) {

	switch ($repository->getVersionControlSystem()) {
	case PhabricatorRepositoryType::REPOSITORY_TYPE_GIT:
	$parser = 'PhabricatorRepositoryGitCommitChangeParserWorker';
	break;
	case PhabricatorRepositoryType::REPOSITORY_TYPE_MERCURIAL:
	$parser = 'PhabricatorRepositoryMercurialCommitChangeParserWorker';
	break;
	case PhabricatorRepositoryType::REPOSITORY_TYPE_SVN:
	$parser = 'PhabricatorRepositorySvnCommitChangeParserWorker';
	break;
	default:
	throw new Exception(pht('No support yet.'));
	}

	foreach ($commits as $commit) {
	$commit_identifier = $commit->getCommitIdentifier();
	$expect_changes = idx($expect, $commit_identifier);

	if ($expect_changes === null) {
	$this->assertEqual(
	$commit_identifier,
	null,
	pht(
	'No test entry for commit "%s" in repository "%s"!',
	$commit_identifier,
	$repository->getCallsign()));
	}

	$parser_object = newv($parser, array(array()));
	$changes = $parser_object->parseChangesForUnitTest($repository, $commit);

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

	$target_commits = array_filter(mpull($changes, 'getTargetCommitID'));
	if ($target_commits) {
	$commits = id(new DiffusionCommitQuery())
	->setViewer(PhabricatorUser::getOmnipotentUser())
	->withIDs($target_commits)
	->execute();
	$target_commits = mpull($commits, 'getCommitIdentifier', 'getID');
	}

	$dicts = array();
	foreach ($changes as $key => $change) {
	$target_path = idx($path_map, $change->getTargetPathID());
	$target_commit = idx($target_commits, $change->getTargetCommitID());

	$dicts[$key] = array(
	$path_map[(int)$change->getPathID()],
	$target_path,
	$target_commit ? (string)$target_commit : null,
	(int)$change->getChangeType(),
	(int)$change->getFileType(),
	(int)$change->getIsDirect(),
	(int)$change->getCommitSequence(),
	);
	}

	$dicts = ipull($dicts, null, 0);
	$expect_changes = ipull($expect_changes, null, 0);
	ksort($dicts);
	ksort($expect_changes);

	$this->assertEqual(
	$expect_changes,
	$dicts,
	pht('Commit %s', $commit_identifier));
	}
	}


	}

File Metadata

Mime Type: text/x-diff
Expires: Mon, Dec 1, 3:18 AM (1 d, 1 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 430175
Default Alt Text: (89 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions