No OneTemporary
Actions

Size

67 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/src/__phutil_library_map__.php b/src/__phutil_library_map__.php
	index 72890ccd..68f1dc54 100644
	--- a/src/__phutil_library_map__.php
	+++ b/src/__phutil_library_map__.php
	@@ -1,181 +1,183 @@
	<?php

	/**
	* This file is automatically generated. Use 'phutil_mapper.php' to rebuild it.
	* @generated
	*/

	phutil_register_library_map(array(
	'class' =>
	array(
	'ArcanistAmendWorkflow' => 'workflow/amend',
	'ArcanistApacheLicenseLinter' => 'lint/linter/apachelicense',
	'ArcanistApacheLicenseLinterTestCase' => 'lint/linter/apachelicense/__tests__',
	'ArcanistBaseUnitTestEngine' => 'unit/engine/base',
	'ArcanistBaseWorkflow' => 'workflow/base',
	'ArcanistBranchWorkflow' => 'workflow/branch',
	'ArcanistBundle' => 'parser/bundle',
	'ArcanistBundleTestCase' => 'parser/bundle/__tests__',
	'ArcanistCallConduitWorkflow' => 'workflow/call-conduit',
	'ArcanistCapabilityNotSupportedException' => 'workflow/exception/notsupported',
	'ArcanistChooseInvalidRevisionException' => 'exception',
	'ArcanistChooseNoRevisionsException' => 'exception',
	'ArcanistCommitWorkflow' => 'workflow/commit',
	'ArcanistConduitLinter' => 'lint/linter/conduit',
	'ArcanistConfiguration' => 'configuration',
	'ArcanistCoverWorkflow' => 'workflow/cover',
	'ArcanistDiffChange' => 'parser/diff/change',
	'ArcanistDiffChangeType' => 'parser/diff/changetype',
	'ArcanistDiffHunk' => 'parser/diff/hunk',
	'ArcanistDiffParser' => 'parser/diff',
	'ArcanistDiffParserTestCase' => 'parser/diff/__tests__',
	'ArcanistDiffUtils' => 'difference',
	'ArcanistDiffUtilsTestCase' => 'difference/__tests__',
	'ArcanistDiffWorkflow' => 'workflow/diff',
	'ArcanistDifferentialCommitMessage' => 'differential/commitmessage',
	'ArcanistDifferentialCommitMessageParserException' => 'differential/commitmessage',
	'ArcanistDifferentialRevisionHash' => 'differential/constants/revisionhash',
	'ArcanistDifferentialRevisionRef' => 'differential/revision',
	'ArcanistDifferentialRevisionStatus' => 'differential/constants/revisionstatus',
	'ArcanistDownloadWorkflow' => 'workflow/download',
	'ArcanistEventType' => 'events/constant/type',
	'ArcanistExportWorkflow' => 'workflow/export',
	'ArcanistFilenameLinter' => 'lint/linter/filename',
	'ArcanistGeneratedLinter' => 'lint/linter/generated',
	'ArcanistGitAPI' => 'repository/api/git',
	'ArcanistGitHookPreReceiveWorkflow' => 'workflow/git-hook-pre-receive',
	'ArcanistHelpWorkflow' => 'workflow/help',
	'ArcanistHookAPI' => 'repository/hookapi/base',
	'ArcanistInstallCertificateWorkflow' => 'workflow/install-certificate',
	'ArcanistJSHintLinter' => 'lint/linter/jshint',
	'ArcanistLiberateLintEngine' => 'lint/engine/liberate',
	'ArcanistLiberateWorkflow' => 'workflow/liberate',
	'ArcanistLicenseLinter' => 'lint/linter/license',
	'ArcanistLintEngine' => 'lint/engine/base',
	'ArcanistLintJSONRenderer' => 'lint/renderer',
	'ArcanistLintMessage' => 'lint/message',
	'ArcanistLintPatcher' => 'lint/patcher',
	'ArcanistLintRenderer' => 'lint/renderer',
	'ArcanistLintResult' => 'lint/result',
	'ArcanistLintSeverity' => 'lint/severity',
	'ArcanistLintSummaryRenderer' => 'lint/renderer',
	'ArcanistLintWorkflow' => 'workflow/lint',
	'ArcanistLinter' => 'lint/linter/base',
	'ArcanistLinterTestCase' => 'lint/linter/base/test',
	'ArcanistListWorkflow' => 'workflow/list',
	'ArcanistMarkCommittedWorkflow' => 'workflow/mark-committed',
	'ArcanistMercurialAPI' => 'repository/api/mercurial',
	'ArcanistMercurialParser' => 'repository/parser/mercurial',
	'ArcanistMercurialParserTestCase' => 'repository/parser/mercurial/__tests__',
	'ArcanistMergeWorkflow' => 'workflow/merge',
	'ArcanistNoEffectException' => 'exception/usage/noeffect',
	'ArcanistNoEngineException' => 'exception/usage/noengine',
	'ArcanistNoLintLinter' => 'lint/linter/nolint',
	'ArcanistNoLintTestCaseMisnamed' => 'lint/linter/nolint/__tests__',
	'ArcanistPEP8Linter' => 'lint/linter/pep8',
	'ArcanistPasteWorkflow' => 'workflow/paste',
	'ArcanistPatchWorkflow' => 'workflow/patch',
	'ArcanistPhutilModuleLinter' => 'lint/linter/phutilmodule',
	'ArcanistPhutilTestCase' => 'unit/engine/phutil/testcase',
	'ArcanistPhutilTestTerminatedException' => 'unit/engine/phutil/testcase/exception',
	'ArcanistPyFlakesLinter' => 'lint/linter/pyflakes',
	'ArcanistPyLintLinter' => 'lint/linter/pylint',
	'ArcanistRepositoryAPI' => 'repository/api/base',
	'ArcanistShellCompleteWorkflow' => 'workflow/shell-complete',
	'ArcanistSpellingDefaultData' => 'lint/linter/spelling',
	'ArcanistSpellingLinter' => 'lint/linter/spelling',
	'ArcanistSpellingLinterTestCase' => 'lint/linter/spelling/__tests__',
	'ArcanistSubversionAPI' => 'repository/api/subversion',
	'ArcanistSubversionHookAPI' => 'repository/hookapi/subversion',
	'ArcanistSvnHookPreCommitWorkflow' => 'workflow/svn-hook-pre-commit',
	'ArcanistTextLinter' => 'lint/linter/text',
	'ArcanistTextLinterTestCase' => 'lint/linter/text/__tests__',
	'ArcanistUnitTestResult' => 'unit/result',
	'ArcanistUnitWorkflow' => 'workflow/unit',
	'ArcanistUploadWorkflow' => 'workflow/upload',
	'ArcanistUsageException' => 'exception/usage',
	'ArcanistUserAbortException' => 'exception/usage/userabort',
	+ 'ArcanistWhichWorkflow' => 'workflow/which',
	'ArcanistWorkingCopyIdentity' => 'workingcopyidentity',
	'ArcanistXHPASTLintNamingHook' => 'lint/linter/xhpast/naminghook',
	'ArcanistXHPASTLinter' => 'lint/linter/xhpast',
	'ArcanistXHPASTLinterTestCase' => 'lint/linter/xhpast/__tests__',
	'BranchInfo' => 'branch',
	'ComprehensiveLintEngine' => 'lint/engine/comprehensive',
	'ExampleLintEngine' => 'lint/engine/example',
	'PhutilLintEngine' => 'lint/engine/phutil',
	'PhutilModuleRequirements' => 'parser/phutilmodule',
	'PhutilUnitTestEngine' => 'unit/engine/phutil',
	'PhutilUnitTestEngineTestCase' => 'unit/engine/phutil/__tests__',
	'UnitTestableArcanistLintEngine' => 'lint/engine/test',
	),
	'function' =>
	array(
	),
	'requires_class' =>
	array(
	'ArcanistAmendWorkflow' => 'ArcanistBaseWorkflow',
	'ArcanistApacheLicenseLinter' => 'ArcanistLicenseLinter',
	'ArcanistApacheLicenseLinterTestCase' => 'ArcanistLinterTestCase',
	'ArcanistBranchWorkflow' => 'ArcanistBaseWorkflow',
	'ArcanistBundleTestCase' => 'ArcanistPhutilTestCase',
	'ArcanistCallConduitWorkflow' => 'ArcanistBaseWorkflow',
	'ArcanistCommitWorkflow' => 'ArcanistBaseWorkflow',
	'ArcanistConduitLinter' => 'ArcanistLinter',
	'ArcanistCoverWorkflow' => 'ArcanistBaseWorkflow',
	'ArcanistDiffParserTestCase' => 'ArcanistPhutilTestCase',
	'ArcanistDiffUtilsTestCase' => 'ArcanistPhutilTestCase',
	'ArcanistDiffWorkflow' => 'ArcanistBaseWorkflow',
	'ArcanistDownloadWorkflow' => 'ArcanistBaseWorkflow',
	'ArcanistEventType' => 'PhutilEventType',
	'ArcanistExportWorkflow' => 'ArcanistBaseWorkflow',
	'ArcanistFilenameLinter' => 'ArcanistLinter',
	'ArcanistGeneratedLinter' => 'ArcanistLinter',
	'ArcanistGitAPI' => 'ArcanistRepositoryAPI',
	'ArcanistGitHookPreReceiveWorkflow' => 'ArcanistBaseWorkflow',
	'ArcanistHelpWorkflow' => 'ArcanistBaseWorkflow',
	'ArcanistInstallCertificateWorkflow' => 'ArcanistBaseWorkflow',
	'ArcanistJSHintLinter' => 'ArcanistLinter',
	'ArcanistLiberateLintEngine' => 'ArcanistLintEngine',
	'ArcanistLiberateWorkflow' => 'ArcanistBaseWorkflow',
	'ArcanistLicenseLinter' => 'ArcanistLinter',
	'ArcanistLintWorkflow' => 'ArcanistBaseWorkflow',
	'ArcanistLinterTestCase' => 'ArcanistPhutilTestCase',
	'ArcanistListWorkflow' => 'ArcanistBaseWorkflow',
	'ArcanistMarkCommittedWorkflow' => 'ArcanistBaseWorkflow',
	'ArcanistMercurialAPI' => 'ArcanistRepositoryAPI',
	'ArcanistMercurialParserTestCase' => 'ArcanistPhutilTestCase',
	'ArcanistMergeWorkflow' => 'ArcanistBaseWorkflow',
	'ArcanistNoEffectException' => 'ArcanistUsageException',
	'ArcanistNoEngineException' => 'ArcanistUsageException',
	'ArcanistNoLintLinter' => 'ArcanistLinter',
	'ArcanistNoLintTestCaseMisnamed' => 'ArcanistLinterTestCase',
	'ArcanistPEP8Linter' => 'ArcanistLinter',
	'ArcanistPasteWorkflow' => 'ArcanistBaseWorkflow',
	'ArcanistPatchWorkflow' => 'ArcanistBaseWorkflow',
	'ArcanistPhutilModuleLinter' => 'ArcanistLinter',
	'ArcanistPyFlakesLinter' => 'ArcanistLinter',
	'ArcanistPyLintLinter' => 'ArcanistLinter',
	'ArcanistShellCompleteWorkflow' => 'ArcanistBaseWorkflow',
	'ArcanistSpellingLinter' => 'ArcanistLinter',
	'ArcanistSpellingLinterTestCase' => 'ArcanistLinterTestCase',
	'ArcanistSubversionAPI' => 'ArcanistRepositoryAPI',
	'ArcanistSubversionHookAPI' => 'ArcanistHookAPI',
	'ArcanistSvnHookPreCommitWorkflow' => 'ArcanistBaseWorkflow',
	'ArcanistTextLinter' => 'ArcanistLinter',
	'ArcanistTextLinterTestCase' => 'ArcanistLinterTestCase',
	'ArcanistUnitWorkflow' => 'ArcanistBaseWorkflow',
	'ArcanistUploadWorkflow' => 'ArcanistBaseWorkflow',
	'ArcanistUserAbortException' => 'ArcanistUsageException',
	+ 'ArcanistWhichWorkflow' => 'ArcanistBaseWorkflow',
	'ArcanistXHPASTLinter' => 'ArcanistLinter',
	'ArcanistXHPASTLinterTestCase' => 'ArcanistLinterTestCase',
	'ComprehensiveLintEngine' => 'ArcanistLintEngine',
	'ExampleLintEngine' => 'ArcanistLintEngine',
	'PhutilLintEngine' => 'ArcanistLintEngine',
	'PhutilUnitTestEngine' => 'ArcanistBaseUnitTestEngine',
	'PhutilUnitTestEngineTestCase' => 'ArcanistPhutilTestCase',
	'UnitTestableArcanistLintEngine' => 'ArcanistLintEngine',
	),
	'requires_interface' =>
	array(
	),
	));
	diff --git a/src/repository/api/base/ArcanistRepositoryAPI.php b/src/repository/api/base/ArcanistRepositoryAPI.php
	index 469e2a0e..8d80e0a9 100644
	--- a/src/repository/api/base/ArcanistRepositoryAPI.php
	+++ b/src/repository/api/base/ArcanistRepositoryAPI.php
	@@ -1,180 +1,183 @@
	<?php

	/*
	* Copyright 2012 Facebook, Inc.
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	/**
	* Interfaces with the VCS in the working copy.
	*
	* @group workingcopy
	*/
	abstract class ArcanistRepositoryAPI {

	const FLAG_MODIFIED = 1;
	const FLAG_ADDED = 2;
	const FLAG_DELETED = 4;
	const FLAG_UNTRACKED = 8;
	const FLAG_CONFLICT = 16;
	const FLAG_MISSING = 32;
	const FLAG_UNSTAGED = 64;
	const FLAG_UNCOMMITTED = 128;
	const FLAG_EXTERNALS = 256;

	// Occurs in SVN when you replace a file with a directory without telling
	// SVN about it.
	const FLAG_OBSTRUCTED = 512;

	// Occurs in SVN when an update was interrupted or failed, e.g. you ^C'd it.
	const FLAG_INCOMPLETE = 1024;

	protected $path;
	protected $diffLinesOfContext = 0x7FFF;

	abstract public function getSourceControlSystemName();

	public function getDiffLinesOfContext() {
	return $this->diffLinesOfContext;
	}

	public function setDiffLinesOfContext($lines) {
	$this->diffLinesOfContext = $lines;
	return $this;
	}

	public static function newAPIFromWorkingCopyIdentity(
	ArcanistWorkingCopyIdentity $working_copy) {

	$root = $working_copy->getProjectRoot();

	if (!$root) {
	throw new ArcanistUsageException(
	"There is no readable '.arcconfig' file in the working directory or ".
	"any parent directory. Create an '.arcconfig' file to configure arc.");
	}

	if (Filesystem::pathExists($root.'/.svn')) {
	return newv('ArcanistSubversionAPI', array($root));
	}

	if (Filesystem::pathExists($root.'/.hg')) {
	return newv('ArcanistMercurialAPI', array($root));
	}

	$git_root = self::discoverGitBaseDirectory($root);
	if ($git_root) {
	if (!Filesystem::pathsAreEquivalent($root, $git_root)) {
	throw new ArcanistUsageException(
	"'.arcconfig' file is located at '{$root}', but working copy root ".
	"is '{$git_root}'. Move '.arcconfig' file to the working copy root.");
	}

	return newv('ArcanistGitAPI', array($root));
	}

	throw new ArcanistUsageException(
	"The current working directory is not part of a working copy for a ".
	"supported version control system (svn, git or mercurial).");
	}

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

	public function getPath($to_file = null) {
	if ($to_file !== null) {
	return $this->path.'/'.ltrim($to_file, '/');
	} else {
	return $this->path.'/';
	}
	}

	public function getUntrackedChanges() {
	return $this->getWorkingCopyFilesWithMask(self::FLAG_UNTRACKED);
	}

	public function getUnstagedChanges() {
	return $this->getWorkingCopyFilesWithMask(self::FLAG_UNSTAGED);
	}

	public function getUncommittedChanges() {
	return $this->getWorkingCopyFilesWithMask(self::FLAG_UNCOMMITTED);
	}

	public function getMergeConflicts() {
	return $this->getWorkingCopyFilesWithMask(self::FLAG_CONFLICT);
	}

	public function getIncompleteChanges() {
	return $this->getWorkingCopyFilesWithMask(self::FLAG_INCOMPLETE);
	}

	private function getWorkingCopyFilesWithMask($mask) {
	$match = array();
	foreach ($this->getWorkingCopyStatus() as $file => $flags) {
	if ($flags & $mask) {
	$match[] = $file;
	}
	}
	return $match;
	}

	private static function discoverGitBaseDirectory($root) {
	try {
	list($stdout) = execx(
	'(cd %s; git rev-parse --show-cdup)',
	$root);
	return Filesystem::resolvePath(rtrim($stdout, "\n"), $root);
	} catch (CommandException $ex) {
	if (preg_match('/^fatal: Not a git repository/', $ex->getStdErr())) {
	return null;
	}
	throw $ex;
	}
	}

	abstract public function getBlame($path);
	abstract public function getWorkingCopyStatus();
	abstract public function getRawDiffText($path);
	abstract public function getOriginalFileData($path);
	abstract public function getCurrentFileData($path);
	abstract public function getLocalCommitInformation();
	abstract public function getSourceControlBaseRevision();
	abstract public function supportsRelativeLocalCommits();
	abstract public function getWorkingCopyRevision();
	+ abstract public function loadWorkingCopyDifferentialRevisions(
	+ ConduitClient $conduit,
	+ array $query);

	public function getCommitMessageForRevision($revision) {
	throw new ArcanistCapabilityNotSupportedException($this);
	}

	public function parseRelativeLocalCommit(array $argv) {
	throw new ArcanistCapabilityNotSupportedException($this);
	}

	public function getAllLocalChanges() {
	throw new ArcanistCapabilityNotSupportedException($this);
	}

	abstract public function supportsLocalBranchMerge();

	public function performLocalBranchMerge($branch, $message) {
	throw new ArcanistCapabilityNotSupportedException($this);
	}

	public function getFinalizedRevisionMessage() {
	throw new ArcanistCapabilityNotSupportedException($this);
	}

	}
	diff --git a/src/repository/api/git/ArcanistGitAPI.php b/src/repository/api/git/ArcanistGitAPI.php
	index 32248f2e..c25f3d66 100644
	--- a/src/repository/api/git/ArcanistGitAPI.php
	+++ b/src/repository/api/git/ArcanistGitAPI.php
	@@ -1,622 +1,680 @@
	<?php

	/*
	* Copyright 2012 Facebook, Inc.
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	/**
	* Interfaces with Git working copies.
	*
	* @group workingcopy
	*/
	class ArcanistGitAPI extends ArcanistRepositoryAPI {

	private $status;
	private $relativeCommit = null;
	private $repositoryHasNoCommits = false;
	const SEARCH_LENGTH_FOR_PARENT_REVISIONS = 16;

	/**
	* For the repository's initial commit, 'git diff HEAD^' and similar do
	* not work. Using this instead does work.
	*/
	const GIT_MAGIC_ROOT_COMMIT = '4b825dc642cb6eb9a060e54bf8d69288fbee4904';

	public static function newHookAPI($root) {
	return new ArcanistGitAPI($root);
	}

	public function getSourceControlSystemName() {
	return 'git';
	}

	public function getHasCommits() {
	return !$this->repositoryHasNoCommits;
	}

	public function setRelativeCommit($relative_commit) {
	$this->relativeCommit = $relative_commit;
	return $this;
	}

	public function getLocalCommitInformation() {
	if ($this->repositoryHasNoCommits) {
	// Zero commits.
	throw new Exception(
	"You can't get local commit information for a repository with no ".
	"commits.");
	} else if ($this->relativeCommit == self::GIT_MAGIC_ROOT_COMMIT) {
	// One commit.
	$against = 'HEAD';
	} else {
	// 2..N commits.
	$against = $this->getRelativeCommit().'..HEAD';
	}

	list($info) = execx(
	'(cd %s && git log %s --format=%s --)',
	$this->getPath(),
	$against,
	'%H%x00%T%x00%P%x00%at%x00%an%x00%s');

	$commits = array();

	$info = trim($info);
	$info = explode("\n", $info);
	foreach ($info as $line) {
	list($commit, $tree, $parents, $time, $author, $title)
	= explode("\0", $line, 6);

	$commits[] = array(
	'commit' => $commit,
	'tree' => $tree,
	'parents' => array_filter(explode(' ', $parents)),
	'time' => $time,
	'author' => $author,
	'summary' => $title,
	);
	}

	return $commits;
	}

	public function getRelativeCommit() {
	if ($this->relativeCommit === null) {
	list($err) = exec_manual(
	'(cd %s; git rev-parse --verify HEAD^)',
	$this->getPath());
	if ($err) {
	list($err) = exec_manual(
	'(cd %s; git rev-parse --verify HEAD)',
	$this->getPath());
	if ($err) {
	$this->repositoryHasNoCommits = true;
	}
	$this->relativeCommit = self::GIT_MAGIC_ROOT_COMMIT;

	} else {
	$this->relativeCommit = 'HEAD^';
	}
	}
	return $this->relativeCommit;
	}

	private function getDiffFullOptions() {
	$options = array(
	self::getDiffBaseOptions(),
	'-M',
	'-C',
	'--no-color',
	'--src-prefix=a/',
	'--dst-prefix=b/',
	'-U'.$this->getDiffLinesOfContext(),
	);
	return implode(' ', $options);
	}

	private function getDiffBaseOptions() {
	$options = array(
	// Disable external diff drivers, like graphical differs, since Arcanist
	// needs to capture the diff text.
	'--no-ext-diff',
	// Disable textconv so we treat binary files as binary, even if they have
	// an alternative textual representation. TODO: Ideally, Differential
	// would ship up the binaries for 'arc patch' but display the textconv
	// output in the visual diff.
	'--no-textconv',
	);
	return implode(' ', $options);
	}

	public function getFullGitDiff() {
	$options = $this->getDiffFullOptions();
	list($stdout) = execx(
	"(cd %s; git diff {$options} %s --)",
	$this->getPath(),
	$this->getRelativeCommit());
	return $stdout;
	}

	public function getRawDiffText($path) {
	$options = $this->getDiffFullOptions();
	list($stdout) = execx(
	"(cd %s; git diff {$options} %s -- %s)",
	$this->getPath(),
	$this->getRelativeCommit(),
	$path);
	return $stdout;
	}

	public function getBranchName() {
	// TODO: consider:
	//
	// $ git rev-parse --abbrev-ref `git symbolic-ref HEAD`
	//
	// But that may fail if you're not on a branch.
	list($stdout) = execx(
	'(cd %s; git branch)',
	$this->getPath());

	$matches = null;
	if (preg_match('/^\* (.+)$/m', $stdout, $matches)) {
	return $matches[1];
	}
	return null;
	}

	public function getSourceControlPath() {
	// TODO: Try to get something useful here.
	return null;
	}

	public function getGitCommitLog() {
	$relative = $this->getRelativeCommit();
	if ($this->repositoryHasNoCommits) {
	// No commits yet.
	return '';
	} else if ($relative == self::GIT_MAGIC_ROOT_COMMIT) {
	// First commit.
	list($stdout) = execx(
	'(cd %s; git log --format=medium HEAD)',
	$this->getPath());
	} else {
	// 2..N commits.
	list($stdout) = execx(
	'(cd %s; git log --first-parent --format=medium %s..HEAD)',
	$this->getPath(),
	$this->getRelativeCommit());
	}
	return $stdout;
	}

	public function getGitHistoryLog() {
	list($stdout) = execx(
	'(cd %s; git log --format=medium -n%d %s)',
	$this->getPath(),
	self::SEARCH_LENGTH_FOR_PARENT_REVISIONS,
	$this->getRelativeCommit());
	return $stdout;
	}

	public function getSourceControlBaseRevision() {
	list($stdout) = execx(
	'(cd %s; git rev-parse %s)',
	$this->getPath(),
	$this->getRelativeCommit());
	return rtrim($stdout, "\n");
	}

	/**
	* Returns the sha1 of the HEAD revision
	* @param boolean $short whether return the abbreviated or full hash.
	*/
	public function getGitHeadRevision($short=false) {
	if ($short) {
	$flags = '--short';
	} else {
	$flags = '';
	}
	list($stdout) = execx(
	'(cd %s; git rev-parse %s HEAD)',
	$this->getPath(),
	$flags);
	return rtrim($stdout, "\n");
	}

	public function getWorkingCopyStatus() {
	if (!isset($this->status)) {

	$options = $this->getDiffBaseOptions();

	// -- parallelize these slow cpu bound git calls.

	// Find committed changes.
	$committed_future = new ExecFuture(
	"(cd %s; git diff {$options} --raw %s --)",
	$this->getPath(),
	$this->getRelativeCommit());

	// Find uncommitted changes.
	$uncommitted_future = new ExecFuture(
	"(cd %s; git diff {$options} --raw %s --)",
	$this->getPath(),
	$this->repositoryHasNoCommits
	? self::GIT_MAGIC_ROOT_COMMIT
	: 'HEAD');

	// Untracked files
	$untracked_future = new ExecFuture(
	'(cd %s; git ls-files --others --exclude-standard)',
	$this->getPath());

	// TODO: This doesn't list unstaged adds. It's not clear how to get that
	// list other than "git status --porcelain" and then parsing it. :/

	// Unstaged changes
	$unstaged_future = new ExecFuture(
	'(cd %s; git ls-files -m)',
	$this->getPath());

	$futures = array(
	$committed_future,
	$uncommitted_future,
	$untracked_future,
	$unstaged_future
	);
	Futures($futures)->resolveAll();


	// -- read back and process the results

	list($stdout, $stderr) = $committed_future->resolvex();
	$files = $this->parseGitStatus($stdout);

	list($stdout, $stderr) = $uncommitted_future->resolvex();
	$uncommitted_files = $this->parseGitStatus($stdout);
	foreach ($uncommitted_files as $path => $mask) {
	$mask \|= self::FLAG_UNCOMMITTED;
	if (!isset($files[$path])) {
	$files[$path] = 0;
	}
	$files[$path] \|= $mask;
	}

	list($stdout, $stderr) = $untracked_future->resolvex();
	$stdout = rtrim($stdout, "\n");
	if (strlen($stdout)) {
	$stdout = explode("\n", $stdout);
	foreach ($stdout as $file) {
	$files[$file] = self::FLAG_UNTRACKED;
	}
	}

	list($stdout, $stderr) = $unstaged_future->resolvex();
	$stdout = rtrim($stdout, "\n");
	if (strlen($stdout)) {
	$stdout = explode("\n", $stdout);
	foreach ($stdout as $file) {
	$files[$file] = isset($files[$file])
	? ($files[$file] \| self::FLAG_UNSTAGED)
	: self::FLAG_UNSTAGED;
	}
	}

	$this->status = $files;
	}

	return $this->status;
	}

	public function amendGitHeadCommit($message) {
	execx(
	'(cd %s; git commit --amend --allow-empty --message %s)',
	$this->getPath(),
	$message);
	}

	public function getPreReceiveHookStatus($old_ref, $new_ref) {
	$options = $this->getDiffBaseOptions();
	list($stdout) = execx(
	"(cd %s && git diff {$options} --raw %s %s --)",
	$this->getPath(),
	$old_ref,
	$new_ref);
	return $this->parseGitStatus($stdout, $full = true);
	}

	private function parseGitStatus($status, $full = false) {
	static $flags = array(
	'A' => self::FLAG_ADDED,
	'M' => self::FLAG_MODIFIED,
	'D' => self::FLAG_DELETED,
	);

	$status = trim($status);
	$lines = array();
	foreach (explode("\n", $status) as $line) {
	if ($line) {
	$lines[] = preg_split("/[ \t]/", $line);
	}
	}

	$files = array();
	foreach ($lines as $line) {
	$mask = 0;
	$flag = $line[4];
	$file = $line[5];
	foreach ($flags as $key => $bits) {
	if ($flag == $key) {
	$mask \|= $bits;
	}
	}
	if ($full) {
	$files[$file] = array(
	'mask' => $mask,
	'ref' => rtrim($line[3], '.'),
	);
	} else {
	$files[$file] = $mask;
	}
	}

	return $files;
	}

	public function getBlame($path) {
	// TODO: 'git blame' supports --porcelain and we should probably use it.
	list($stdout) = execx(
	'(cd %s; git blame --date=iso -w -M %s -- %s)',
	$this->getPath(),
	$this->getRelativeCommit(),
	$path);

	$blame = array();
	foreach (explode("\n", trim($stdout)) as $line) {
	if (!strlen($line)) {
	continue;
	}

	// lines predating a git repo's history are blamed to the oldest revision,
	// with the commit hash prepended by a ^. we shouldn't count these lines
	// as blaming to the oldest diff's unfortunate author
	if ($line[0] == '^') {
	continue;
	}

	$matches = null;
	$ok = preg_match(
	'/^([0-9a-f]+)[^(]+?[(](.*?) +\d\d\d\d-\d\d-\d\d/',
	$line,
	$matches);
	if (!$ok) {
	throw new Exception("Bad blame? `{$line}'");
	}
	$revision = $matches[1];
	$author = $matches[2];

	$blame[] = array($author, $revision);
	}

	return $blame;
	}

	public function getOriginalFileData($path) {
	return $this->getFileDataAtRevision($path, $this->getRelativeCommit());
	}

	public function getCurrentFileData($path) {
	return $this->getFileDataAtRevision($path, 'HEAD');
	}

	private function parseGitTree($stdout) {
	$result = array();

	$stdout = trim($stdout);
	if (!strlen($stdout)) {
	return $result;
	}

	$lines = explode("\n", $stdout);
	foreach ($lines as $line) {
	$matches = array();
	$ok = preg_match(
	'/^(\d{6}) (blob\|tree) ([a-z0-9]{40})[\t](.*)$/',
	$line,
	$matches);
	if (!$ok) {
	throw new Exception("Failed to parse git ls-tree output!");
	}
	$result[$matches[4]] = array(
	'mode' => $matches[1],
	'type' => $matches[2],
	'ref' => $matches[3],
	);
	}
	return $result;
	}

	private function getFileDataAtRevision($path, $revision) {

	// NOTE: We don't want to just "git show {$revision}:{$path}" since if the
	// path was a directory at the given revision we'll get a list of its files
	// and treat it as though it as a file containing a list of other files,
	// which is silly.

	list($stdout) = execx(
	'(cd %s && git ls-tree %s -- %s)',
	$this->getPath(),
	$revision,
	$path);

	$info = $this->parseGitTree($stdout);
	if (empty($info[$path])) {
	// No such path, or the path is a directory and we executed 'ls-tree dir/'
	// and got a list of its contents back.
	return null;
	}

	if ($info[$path]['type'] != 'blob') {
	// Path is or was a directory, not a file.
	return null;
	}

	list($stdout) = execx(
	'(cd %s && git cat-file blob %s)',
	$this->getPath(),
	$info[$path]['ref']);
	return $stdout;
	}

	/**
	* Returns names of all the branches in the current repository.
	*
	* @return array where each element is a triple ('name', 'sha1', 'current')
	*/
	public function getAllBranches() {
	list($branch_info) = execx(
	'cd %s && git branch --no-color', $this->getPath());
	$lines = explode("\n", trim($branch_info));
	$result = array();
	foreach ($lines as $line) {
	$match = array();
	preg_match('/^(\?)\s(.*)$/', $line, $match);
	$name = $match[2];
	if ($name == '(no branch)') {
	// Just ignore this, we could theoretically try to figure out the ref
	// and treat it like a real branch but that's sort of ridiculous.
	continue;
	}
	$result[] = array(
	'current' => !empty($match[1]),
	'name' => $name,
	);
	}
	$all_names = ipull($result, 'name');
	// Calling 'git branch' first and then 'git rev-parse' is way faster than
	// 'git branch -v' for some reason.
	list($sha1s_string) = execx(
	"cd %s && git rev-parse %Ls",
	$this->path,
	$all_names);
	$sha1_map = array_combine($all_names, explode("\n", trim($sha1s_string)));
	foreach ($result as &$branch) {
	$branch['sha1'] = $sha1_map[$branch['name']];
	}
	return $result;
	}

	/**
	* Returns git commit messages for the given revisions,
	* in the specified format (see git show --help for options).
	*
	* @param array $revs a list of commit hashes
	* @param string $format the format to show messages in
	*/
	public function multigetCommitMessages($revs, $format) {
	$delimiter = "%%x00";
	$revs_list = implode(' ', $revs);
	$show_command =
	"git show -s --pretty=\"format:$format$delimiter\" $revs_list";
	list($commits_string) = execx(
	"cd %s && $show_command",
	$this->getPath());
	$commits_list = array_slice(explode("\0", $commits_string), 0, -1);
	$commits_list = array_combine($revs, $commits_list);
	return $commits_list;
	}

	public function getRepositoryOwner() {
	list($owner) = execx(
	'cd %s && git config --get user.name',
	$this->getPath());
	return trim($owner);
	}

	public function getWorkingCopyRevision() {
	list($stdout) = execx(
	'(cd %s; git rev-parse %s)',
	$this->getPath(),
	'HEAD');
	return rtrim($stdout, "\n");
	}

	public function supportsRelativeLocalCommits() {
	return true;
	}

	public function parseRelativeLocalCommit(array $argv) {
	if (count($argv) == 0) {
	return;
	}
	if (count($argv) != 1) {
	throw new ArcanistUsageException("Specify only one commit.");
	}
	$base = reset($argv);
	if ($base == ArcanistGitAPI::GIT_MAGIC_ROOT_COMMIT) {
	$merge_base = $base;
	} else {
	list($err, $merge_base) = exec_manual(
	'(cd %s; git merge-base %s HEAD)',
	$this->getPath(),
	$base);
	if ($err) {
	throw new ArcanistUsageException(
	"Unable to find any git commit named '{$base}' in this repository.");
	}
	}
	$this->setRelativeCommit(trim($merge_base));
	}

	public function getAllLocalChanges() {
	$diff = $this->getFullGitDiff();
	$parser = new ArcanistDiffParser();
	return $parser->parseDiff($diff);
	}

	public function supportsLocalBranchMerge() {
	return true;
	}

	public function performLocalBranchMerge($branch, $message) {
	if (!$branch) {
	throw new ArcanistUsageException(
	"Under git, you must specify the branch you want to merge.");
	}
	$err = phutil_passthru(
	'(cd %s && git merge --no-ff -m %s %s)',
	$this->getPath(),
	$message,
	$branch);

	if ($err) {
	throw new ArcanistUsageException("Merge failed!");
	}
	}

	public function getFinalizedRevisionMessage() {
	return "You may now push this commit upstream, as appropriate (e.g. with ".
	"'git push', or 'git svn dcommit', or by printing and faxing it).";
	}

	public function getCommitMessageForRevision($rev) {
	list($message) = execx(
	'(cd %s && git log -n1 %s)',
	$this->getPath(),
	$rev);
	$parser = new ArcanistDiffParser();
	return head($parser->parseDiff($message));
	}

	+ public function loadWorkingCopyDifferentialRevisions(
	+ ConduitClient $conduit,
	+ array $query) {
	+
	+ $messages = $this->getGitCommitLog();
	+ if (!strlen($messages)) {
	+ return array();
	+ }
	+
	+ $parser = new ArcanistDiffParser();
	+ $messages = $parser->parseDiff($messages);
	+
	+ // First, try to find revisions by explicit revision IDs in commit messages.
	+ $revision_ids = array();
	+ foreach ($messages as $message) {
	+ $object = ArcanistDifferentialCommitMessage::newFromRawCorpus(
	+ $message->getMetadata('message'));
	+ if ($object->getRevisionID()) {
	+ $revision_ids[] = $object->getRevisionID();
	+ }
	+ }
	+
	+ if ($revision_ids) {
	+ $results = $conduit->callMethodSynchronous(
	+ 'differential.query',
	+ $query + array(
	+ 'ids' => $revision_ids,
	+ ));
	+ return $results;
	+ }
	+
	+ // If we didn't succeed, try to find revisions by hash.
	+ $hashes = array();
	+ foreach ($this->getLocalCommitInformation() as $commit) {
	+ $hashes[] = array('gtcm', $commit['commit']);
	+ $hashes[] = array('gttr', $commit['tree']);
	+ }
	+
	+ $results = $conduit->callMethodSynchronous(
	+ 'differential.query',
	+ $query + array(
	+ 'commitHashes' => $hashes,
	+ ));
	+
	+ if ($results) {
	+ return $results;
	+ }
	+
	+ // If we still didn't succeed, try to find revisions by branch name.
	+ $results = $conduit->callMethodSynchronous(
	+ 'differential.query',
	+ $query + array(
	+ 'branches' => array($this->getBranchName()),
	+ ));
	+
	+ return $results;
	+ }
	+
	}
	diff --git a/src/repository/api/git/__init__.php b/src/repository/api/git/__init__.php
	index a7fd205d..3bfab98b 100644
	--- a/src/repository/api/git/__init__.php
	+++ b/src/repository/api/git/__init__.php
	@@ -1,18 +1,19 @@
	<?php
	/**
	* This file is automatically generated. Lint this module to rebuild it.
	* @generated
	*/



	+phutil_require_module('arcanist', 'differential/commitmessage');
	phutil_require_module('arcanist', 'exception/usage');
	phutil_require_module('arcanist', 'parser/diff');
	phutil_require_module('arcanist', 'repository/api/base');

	phutil_require_module('phutil', 'future');
	phutil_require_module('phutil', 'future/exec');
	phutil_require_module('phutil', 'utils');


	phutil_require_source('ArcanistGitAPI.php');
	diff --git a/src/repository/api/mercurial/ArcanistMercurialAPI.php b/src/repository/api/mercurial/ArcanistMercurialAPI.php
	index 4968a56d..9aa736b9 100644
	--- a/src/repository/api/mercurial/ArcanistMercurialAPI.php
	+++ b/src/repository/api/mercurial/ArcanistMercurialAPI.php
	@@ -1,377 +1,407 @@
	<?php

	/*
	* Copyright 2012 Facebook, Inc.
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	/**
	* Interfaces with the Mercurial working copies.
	*
	* @group workingcopy
	*/
	class ArcanistMercurialAPI extends ArcanistRepositoryAPI {

	private $status;
	private $base;
	private $relativeCommit;

	public function getSourceControlSystemName() {
	return 'hg';
	}

	public function getSourceControlBaseRevision() {
	list($stdout) = execx(
	'(cd %s && hg log -l 1 --template %s -r %s)',
	$this->getPath(),
	'{node}\\n',
	$this->getRelativeCommit());
	return rtrim($stdout, "\n");
	}

	public function getSourceControlPath() {
	return '/';
	}

	public function getBranchName() {
	- // TODO: I have nearly no idea how hg local branches work.
	+ // TODO: I have nearly no idea how hg branches work.
	list($stdout) = execx(
	'(cd %s && hg branch)',
	$this->getPath());
	- return $stdout;
	+ return trim($stdout);
	}

	public function setRelativeCommit($commit) {
	list($err) = exec_manual(
	'(cd %s && hg id -ir %s)',
	$this->getPath(),
	$commit);

	if ($err) {
	throw new ArcanistUsageException(
	"Commit '{$commit}' is not a valid Mercurial commit identifier.");
	}

	$this->relativeCommit = $commit;
	return $this;
	}

	public function getRelativeCommit() {
	if (empty($this->relativeCommit)) {
	list($stdout) = execx(
	'(cd %s && hg outgoing --branch `hg branch` --style default)',
	$this->getPath());
	$logs = ArcanistMercurialParser::parseMercurialLog($stdout);
	if (!count($logs)) {
	throw new ArcanistUsageException("You have no outgoing changes!");
	}

	$outgoing_revs = ipull($logs, 'rev');

	// This is essentially an implementation of a theoretical `hg merge-base`
	// command.
	$against = 'tip';
	while (true) {
	// NOTE: The "^" and "~" syntaxes were only added in hg 1.9, which is
	// new as of July 2011, so do this in a compatible way. Also, "hg log"
	// and "hg outgoing" don't necessarily show parents (even if given an
	// explicit template consisting of just the parents token) so we need
	// to separately execute "hg parents".

	list($stdout) = execx(
	'(cd %s && hg parents --style default --rev %s)',
	$this->getPath(),
	$against);
	$parents_logs = ArcanistMercurialParser::parseMercurialLog($stdout);

	list($p1, $p2) = array_merge($parents_logs, array(null, null));

	if ($p1 && !in_array($p1['rev'], $outgoing_revs)) {
	$against = $p1['rev'];
	break;
	} else if ($p2 && !in_array($p2['rev'], $outgoing_revs)) {
	$against = $p2['rev'];
	break;
	} else if ($p1) {
	$against = $p1['rev'];
	} else {
	// This is the case where you have a new repository and the entire
	// thing is outgoing; Mercurial literally accepts "--rev null" as
	// meaning "diff against the empty state".
	$against = 'null';
	break;
	}
	}

	$this->relativeCommit = $against;
	}
	return $this->relativeCommit;
	}

	public function getLocalCommitInformation() {
	list($info) = execx(
	'(cd %s && hg log --style default --rev %s..%s --)',
	$this->getPath(),
	$this->getRelativeCommit(),
	$this->getWorkingCopyRevision());
	$logs = ArcanistMercurialParser::parseMercurialLog($info);

	// Get rid of the first log, it's not actually part of the diff. "hg log"
	// is inclusive, while "hg diff" is exclusive.
	array_shift($logs);

	// Expand short hashes (12 characters) to full hashes (40 characters) by
	// issuing a big "hg log" command. Possibly we should do this with parents
	// too, but nothing uses them directly at the moment.
	if ($logs) {
	$cmd = array();
	foreach (ipull($logs, 'rev') as $rev) {
	$cmd[] = csprintf('--rev %s', $rev);
	}

	list($full) = execx(
	'(cd %s && hg log --template %s %C --)',
	$this->getPath(),
	'{node}\\n',
	implode(' ', $cmd));

	$full = explode("\n", trim($full));
	foreach ($logs as $key => $dict) {
	$logs[$key]['rev'] = array_pop($full);
	}
	}

	return $logs;
	}

	public function getBlame($path) {
	list($stdout) = execx(
	'(cd %s && hg annotate -u -v -c --rev %s -- %s)',
	$this->getPath(),
	$this->getRelativeCommit(),
	$path);

	$blame = array();
	foreach (explode("\n", trim($stdout)) as $line) {
	if (!strlen($line)) {
	continue;
	}

	$matches = null;
	$ok = preg_match('/^\s([^:]+?) [a-f0-9]{12}: (.)$/', $line, $matches);

	if (!$ok) {
	throw new Exception("Unable to parse Mercurial blame line: {$line}");
	}

	$revision = $matches[2];
	$author = trim($matches[1]);
	$blame[] = array($author, $revision);
	}

	return $blame;
	}

	public function getWorkingCopyStatus() {

	if (!isset($this->status)) {
	// A reviewable revision spans multiple local commits in Mercurial, but
	// there is no way to get file change status across multiple commits, so
	// just take the entire diff and parse it to figure out what's changed.

	$diff = $this->getFullMercurialDiff();
	$parser = new ArcanistDiffParser();
	$changes = $parser->parseDiff($diff);

	$status_map = array();

	foreach ($changes as $change) {
	$flags = 0;
	switch ($change->getType()) {
	case ArcanistDiffChangeType::TYPE_ADD:
	case ArcanistDiffChangeType::TYPE_MOVE_HERE:
	case ArcanistDiffChangeType::TYPE_COPY_HERE:
	$flags \|= self::FLAG_ADDED;
	break;
	case ArcanistDiffChangeType::TYPE_CHANGE:
	case ArcanistDiffChangeType::TYPE_COPY_AWAY: // Check for changes?
	$flags \|= self::FLAG_MODIFIED;
	break;
	case ArcanistDiffChangeType::TYPE_DELETE:
	case ArcanistDiffChangeType::TYPE_MOVE_AWAY:
	case ArcanistDiffChangeType::TYPE_MULTICOPY:
	$flags \|= self::FLAG_DELETED;
	break;
	}
	$status_map[$change->getCurrentPath()] = $flags;
	}

	list($stdout) = execx(
	'(cd %s && hg status)',
	$this->getPath());

	$working_status = ArcanistMercurialParser::parseMercurialStatus($stdout);
	foreach ($working_status as $path => $status) {
	if ($status & ArcanistRepositoryAPI::FLAG_UNTRACKED) {
	// If the file is untracked, don't mark it uncommitted.
	continue;
	}
	$status \|= self::FLAG_UNCOMMITTED;
	if (!empty($status_map[$path])) {
	$status_map[$path] \|= $status;
	} else {
	$status_map[$path] = $status;
	}
	}

	$this->status = $status_map;
	}

	return $this->status;
	}

	private function getDiffOptions() {
	$options = array(
	'--git',
	// NOTE: We can't use "--color never" because that flag is provided
	// by the color extension, which may or may not be enabled. Instead,
	// set the color mode configuration so that color is disabled regardless
	// of whether the extension is present or not.
	'--config color.mode=off',
	'-U'.$this->getDiffLinesOfContext(),
	);
	return implode(' ', $options);
	}

	public function getRawDiffText($path) {
	$options = $this->getDiffOptions();

	list($stdout) = execx(
	'(cd %s && hg diff %C --rev %s --rev %s -- %s)',
	$this->getPath(),
	$options,
	$this->getRelativeCommit(),
	$this->getWorkingCopyRevision(),
	$path);

	return $stdout;
	}

	public function getFullMercurialDiff() {
	$options = $this->getDiffOptions();

	list($stdout) = execx(
	'(cd %s && hg diff %C --rev %s --rev %s --)',
	$this->getPath(),
	$options,
	$this->getRelativeCommit(),
	$this->getWorkingCopyRevision());

	return $stdout;
	}

	public function getOriginalFileData($path) {
	return $this->getFileDataAtRevision($path, $this->getRelativeCommit());
	}

	public function getCurrentFileData($path) {
	return $this->getFileDataAtRevision(
	$path,
	$this->getWorkingCopyRevision());
	}

	private function getFileDataAtRevision($path, $revision) {
	list($err, $stdout) = exec_manual(
	'(cd %s && hg cat --rev %s -- %s)',
	$this->getPath(),
	$revision,
	$path);
	if ($err) {
	// Assume this is "no file at revision", i.e. a deleted or added file.
	return null;
	} else {
	return $stdout;
	}
	}

	public function getWorkingCopyRevision() {
	// In Mercurial, "tip" means the tip of the current branch, not what's in
	// the working copy. The tip may be ahead of the working copy. We need to
	// use "hg summary" to figure out what is actually in the working copy.
	// For instance, "hg up 4 && arc diff" should not show commits 5 and above.

	// Without arguments, "hg id" shows the current working directory's commit,
	// and "--debug" expands it to a 40-character hash.
	list($stdout) = execx(
	'(cd %s && hg --debug id --id)',
	$this->getPath());

	// Even with "--id", "hg id" will print a trailing "+" after the hash
	// if the working copy is dirty (has uncommitted changes). We'll explicitly
	// detect this later by calling getWorkingCopyStatus(); ignore it for now.
	$stdout = trim($stdout);
	return rtrim($stdout, '+');
	}

	public function supportsRelativeLocalCommits() {
	return true;
	}

	public function parseRelativeLocalCommit(array $argv) {
	if (count($argv) == 0) {
	return;
	}
	if (count($argv) != 1) {
	throw new ArcanistUsageException("Specify only one commit.");
	}
	// This does the "hg id" call we need to normalize/validate the revision
	// identifier.
	$this->setRelativeCommit(reset($argv));
	}

	public function getAllLocalChanges() {
	$diff = $this->getFullMercurialDiff();
	$parser = new ArcanistDiffParser();
	return $parser->parseDiff($diff);
	}

	public function supportsLocalBranchMerge() {
	return true;
	}

	public function performLocalBranchMerge($branch, $message) {
	if ($branch) {
	$err = phutil_passthru(
	'(cd %s && hg merge --rev %s && hg commit -m %s)',
	$this->getPath(),
	$branch,
	$message);
	} else {
	$err = phutil_passthru(
	'(cd %s && hg merge && hg commit -m %s)',
	$this->getPath(),
	$message);
	}

	if ($err) {
	throw new ArcanistUsageException("Merge failed!");
	}
	}

	public function getFinalizedRevisionMessage() {
	return "You may now push this commit upstream, as appropriate (e.g. with ".
	"'hg push' or by printing and faxing it).";
	}

	+ public function loadWorkingCopyDifferentialRevisions(
	+ ConduitClient $conduit,
	+ array $query) {
	+
	+ // Try to find revisions by hash.
	+ $hashes = array();
	+ foreach ($this->getLocalCommitInformation() as $commit) {
	+ $hashes[] = array('hgcm', $commit['rev']);
	+ }
	+
	+ $results = $conduit->callMethodSynchronous(
	+ 'differential.query',
	+ $query + array(
	+ 'commitHashes' => $hashes,
	+ ));
	+
	+ if ($results) {
	+ return $results;
	+ }
	+
	+ // If we still didn't succeed, try to find revisions by branch name.
	+ $results = $conduit->callMethodSynchronous(
	+ 'differential.query',
	+ $query + array(
	+ 'branches' => array($this->getBranchName()),
	+ ));
	+
	+ return $results;
	+ }
	+
	}
	diff --git a/src/repository/api/subversion/ArcanistSubversionAPI.php b/src/repository/api/subversion/ArcanistSubversionAPI.php
	index 9656d17a..2070734e 100644
	--- a/src/repository/api/subversion/ArcanistSubversionAPI.php
	+++ b/src/repository/api/subversion/ArcanistSubversionAPI.php
	@@ -1,509 +1,529 @@
	<?php

	/*
	* Copyright 2012 Facebook, Inc.
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	/**
	* Interfaces with Subversion working copies.
	*
	* @group workingcopy
	*/
	class ArcanistSubversionAPI extends ArcanistRepositoryAPI {

	protected $svnStatus;
	protected $svnBaseRevisions;
	protected $svnInfo = array();

	protected $svnInfoRaw = array();
	protected $svnDiffRaw = array();

	private $svnBaseRevisionNumber;

	public function getSourceControlSystemName() {
	return 'svn';
	}

	public function hasMergeConflicts() {
	foreach ($this->getSVNStatus() as $path => $mask) {
	if ($mask & self::FLAG_CONFLICT) {
	return true;
	}
	}
	return false;
	}

	public function getWorkingCopyStatus() {
	return $this->getSVNStatus();
	}

	public function getSVNBaseRevisions() {
	if ($this->svnBaseRevisions === null) {
	$this->getSVNStatus();
	}
	return $this->svnBaseRevisions;
	}

	public function getSVNStatus($with_externals = false) {
	if ($this->svnStatus === null) {
	list($status) = execx('(cd %s && svn --xml status)', $this->getPath());
	$xml = new SimpleXMLElement($status);

	if (count($xml->target) != 1) {
	throw new Exception("Expected exactly one XML status target.");
	}

	$externals = array();
	$files = array();

	$target = $xml->target[0];
	$this->svnBaseRevisions = array();
	foreach ($target->entry as $entry) {
	$path = (string)$entry['path'];
	$mask = 0;

	$props = (string)($entry->{'wc-status'}[0]['props']);
	$item = (string)($entry->{'wc-status'}[0]['item']);

	$base = (string)($entry->{'wc-status'}[0]['revision']);
	$this->svnBaseRevisions[$path] = $base;

	switch ($props) {
	case 'none':
	case 'normal':
	break;
	case 'modified':
	$mask \|= self::FLAG_MODIFIED;
	break;
	default:
	throw new Exception("Unrecognized property status '{$props}'.");
	}

	switch ($item) {
	case 'normal':
	break;
	case 'external':
	$mask \|= self::FLAG_EXTERNALS;
	$externals[] = $path;
	break;
	case 'unversioned':
	$mask \|= self::FLAG_UNTRACKED;
	break;
	case 'obstructed':
	$mask \|= self::FLAG_OBSTRUCTED;
	break;
	case 'missing':
	$mask \|= self::FLAG_MISSING;
	break;
	case 'added':
	$mask \|= self::FLAG_ADDED;
	break;
	case 'replaced':
	// This is the result of "svn rm"-ing a file, putting another one
	// in place of it, and then "svn add"-ing the new file. Just treat
	// this as equivalent to "modified".
	$mask \|= self::FLAG_MODIFIED;
	break;
	case 'modified':
	$mask \|= self::FLAG_MODIFIED;
	break;
	case 'deleted':
	$mask \|= self::FLAG_DELETED;
	break;
	case 'conflicted':
	$mask \|= self::FLAG_CONFLICT;
	break;
	case 'incomplete':
	$mask \|= self::FLAG_INCOMPLETE;
	break;
	default:
	throw new Exception("Unrecognized item status '{$item}'.");
	}

	// This is new in or around Subversion 1.6.
	$tree_conflicts = (string)($entry->{'wc-status'}[0]['tree-conflicted']);
	if ($tree_conflicts) {
	$mask \|= self::FLAG_CONFLICT;
	}

	$files[$path] = $mask;
	}

	foreach ($files as $path => $mask) {
	foreach ($externals as $external) {
	if (!strncmp($path, $external, strlen($external))) {
	$files[$path] \|= self::FLAG_EXTERNALS;
	}
	}
	}

	$this->svnStatus = $files;
	}

	$status = $this->svnStatus;
	if (!$with_externals) {
	foreach ($status as $path => $mask) {
	if ($mask & ArcanistRepositoryAPI::FLAG_EXTERNALS) {
	unset($status[$path]);
	}
	}
	}

	return $status;
	}

	public function getSVNProperty($path, $property) {
	list($stdout) = execx(
	'svn propget %s %s@',
	$property,
	$this->getPath($path));
	return trim($stdout);
	}

	public function getSourceControlPath() {
	return idx($this->getSVNInfo('/'), 'URL');
	}

	public function getSourceControlBaseRevision() {
	$info = $this->getSVNInfo('/');
	return $info['URL'].'@'.$this->getSVNBaseRevisionNumber();
	}

	public function getSVNBaseRevisionNumber() {
	if ($this->svnBaseRevisionNumber) {
	return $this->svnBaseRevisionNumber;
	}
	$info = $this->getSVNInfo('/');
	return $info['Revision'];
	}

	public function overrideSVNBaseRevisionNumber($effective_base_revision) {
	$this->svnBaseRevisionNumber = $effective_base_revision;
	return $this;
	}

	public function getBranchName() {
	return 'svn';
	}

	public function buildInfoFuture($path) {
	if ($path == '/') {
	// When the root of a working copy is referenced by a symlink and you
	// execute 'svn info' on that symlink, svn fails. This is a longstanding
	// bug in svn:
	//
	// See http://subversion.tigris.org/issues/show_bug.cgi?id=2305
	//
	// To reproduce, do:
	//
	// $ ln -s working_copy working_link
	// $ svn info working_copy # ok
	// $ svn info working_link # fails
	//
	// Work around this by cd-ing into the directory before executing
	// 'svn info'.
	return new ExecFuture(
	'(cd %s && svn info .)',
	$this->getPath());
	} else {
	// Note: here and elsewhere we need to append "@" to the path because if
	// a file has a literal "@" in it, everything after that will be
	// interpreted as a revision. By appending "@" with no argument, SVN
	// parses it properly.
	return new ExecFuture(
	'svn info %s@',
	$this->getPath($path));
	}
	}

	public function buildDiffFuture($path) {
	// The "--depth empty" flag prevents us from picking up changes in
	// children when we run 'diff' against a directory. Specifically, when a
	// user has added or modified some directory "example/", we want to return
	// ONLY changes to that directory when given it as a path. If we run
	// without "--depth empty", svn will give us changes to the directory
	// itself (such as property changes) and also give us changes to any
	// files within the directory (basically, implicit recursion). We don't
	// want that, so prevent recursive diffing.
	return new ExecFuture(
	'(cd %s; svn diff --depth empty --diff-cmd diff -x -U%d %s)',
	$this->getPath(),
	$this->getDiffLinesOfContext(),
	$path);
	}

	public function primeSVNInfoResult($path, $result) {
	$this->svnInfoRaw[$path] = $result;
	return $this;
	}

	public function primeSVNDiffResult($path, $result) {
	$this->svnDiffRaw[$path] = $result;
	return $this;
	}

	public function getSVNInfo($path) {

	if (empty($this->svnInfo[$path])) {

	if (empty($this->svnInfoRaw[$path])) {
	$this->svnInfoRaw[$path] = $this->buildInfoFuture($path)->resolve();
	}

	list($err, $stdout) = $this->svnInfoRaw[$path];
	if ($err) {
	throw new Exception(
	"Error #{$err} executing svn info against '{$path}'.");
	}

	$patterns = array(
	'/^(URL): (\S+)$/m',
	'/^(Revision): (\d+)$/m',
	'/^(Last Changed Author): (\S+)$/m',
	'/^(Last Changed Rev): (\d+)$/m',
	'/^(Last Changed Date): (.+) $.+$$/m',
	'/^(Copied From URL): (\S+)$/m',
	'/^(Copied From Rev): (\d+)$/m',
	'/^(Repository UUID): (\S+)$/m',
	);

	$result = array();
	foreach ($patterns as $pattern) {
	$matches = null;
	if (preg_match($pattern, $stdout, $matches)) {
	$result[$matches[1]] = $matches[2];
	}
	}

	if (isset($result['Last Changed Date'])) {
	$result['Last Changed Date'] = strtotime($result['Last Changed Date']);
	}

	if (empty($result)) {
	throw new Exception('Unable to parse SVN info.');
	}

	$this->svnInfo[$path] = $result;
	}

	return $this->svnInfo[$path];
	}


	public function getRawDiffText($path) {
	$status = $this->getSVNStatus();
	if (!isset($status[$path])) {
	return null;
	}

	$status = $status[$path];

	// Build meaningful diff text for "svn copy" operations.
	if ($status & ArcanistRepositoryAPI::FLAG_ADDED) {
	$info = $this->getSVNInfo($path);
	if (!empty($info['Copied From URL'])) {
	return $this->buildSyntheticAdditionDiff(
	$path,
	$info['Copied From URL'],
	$info['Copied From Rev']);
	}
	}

	// If we run "diff" on a binary file which doesn't have the "svn:mime-type"
	// of "application/octet-stream", `diff' will explode in a rain of
	// unhelpful hellfire as it tries to build a textual diff of the two
	// files. We just fix this inline since it's pretty unambiguous.
	// TODO: Move this to configuration?
	$matches = null;
	if (preg_match('/\.(gif\|png\|jpe?g\|swf\|pdf\|ico)$/i', $path, $matches)) {
	$mime = $this->getSVNProperty($path, 'svn:mime-type');
	if ($mime != 'application/octet-stream') {
	execx(
	'svn propset svn:mime-type application/octet-stream %s',
	$this->getPath($path));
	}
	}

	if (empty($this->svnDiffRaw[$path])) {
	$this->svnDiffRaw[$path] = $this->buildDiffFuture($path)->resolve();
	}

	list($err, $stdout, $stderr) = $this->svnDiffRaw[$path];

	// Note: GNU Diff returns 2 when SVN hands it binary files to diff and they
	// differ. This is not an error; it is documented behavior. But SVN isn't
	// happy about it. SVN will exit with code 1 and return the string below.
	if ($err != 0 && $stderr !== "svn: 'diff' returned 2\n") {
	throw new Exception(
	"svn diff returned unexpected error code: $err\n".
	"stdout: $stdout\n".
	"stderr: $stderr");
	}

	if ($err == 0 && empty($stdout)) {
	// If there are no changes, 'diff' exits with no output, but that means
	// we can not distinguish between empty and unmodified files. Build a
	// synthetic "diff" without any changes in it.
	return $this->buildSyntheticUnchangedDiff($path);
	}

	return $stdout;
	}

	protected function buildSyntheticAdditionDiff($path, $source, $rev) {
	$type = $this->getSVNProperty($path, 'svn:mime-type');
	if ($type == 'application/octet-stream') {
	return <<<EODIFF
	Index: {$path}
	===================================================================
	Cannot display: file marked as a binary type.
	svn:mime-type = application/octet-stream

	EODIFF;
	}

	if (is_dir($this->getPath($path))) {
	return null;
	}

	$data = Filesystem::readFile($this->getPath($path));
	list($orig) = execx('svn cat %s@%s', $source, $rev);

	$src = new TempFile();
	$dst = new TempFile();
	Filesystem::writeFile($src, $orig);
	Filesystem::writeFile($dst, $data);

	list($err, $diff) = exec_manual(
	'diff -L a/%s -L b/%s -U%d %s %s',
	str_replace($this->getSourceControlPath().'/', '', $source),
	$path,
	$this->getDiffLinesOfContext(),
	$src,
	$dst);

	if ($err == 1) { // 1 means there are differences.
	return <<<EODIFF
	Index: {$path}
	===================================================================
	{$diff}

	EODIFF;
	} else {
	return $this->buildSyntheticUnchangedDiff($path);
	}
	}

	protected function buildSyntheticUnchangedDiff($path) {
	$full_path = $this->getPath($path);
	if (is_dir($full_path)) {
	return null;
	}

	$data = Filesystem::readFile($full_path);
	$lines = explode("\n", $data);
	$len = count($lines);
	foreach ($lines as $key => $line) {
	$lines[$key] = ' '.$line;
	}
	$lines = implode("\n", $lines);
	return <<<EODIFF
	Index: {$path}
	===================================================================
	--- {$path} (synthetic)
	+++ {$path} (synthetic)
	@@ -1,{$len} +1,{$len} @@
	{$lines}

	EODIFF;
	}

	public function getBlame($path) {
	$blame = array();

	list($stdout) = execx(
	'(cd %s && svn blame %s)',
	$this->getPath(),
	$path);

	$stdout = trim($stdout);
	if (!strlen($stdout)) {
	// Empty file.
	return $blame;
	}

	foreach (explode("\n", $stdout) as $line) {
	$m = array();
	if (!preg_match('/^\s*(\d+)\s+(\S+)/', $line, $m)) {
	throw new Exception("Bad blame? `{$line}'");
	}
	$revision = $m[1];
	$author = $m[2];
	$blame[] = array($author, $revision);
	}

	return $blame;
	}

	public function getOriginalFileData($path) {
	// SVN issues warnings for nonexistent paths, directories, etc., but still
	// returns no error code. However, for new paths in the working copy it
	// fails. Assume that failure means the original file does not exist.
	list($err, $stdout) = exec_manual(
	'(cd %s && svn cat %s@)',
	$this->getPath(),
	$path);
	if ($err) {
	return null;
	}
	return $stdout;
	}

	public function getCurrentFileData($path) {
	$full_path = $this->getPath($path);
	if (Filesystem::pathExists($full_path)) {
	return Filesystem::readFile($full_path);
	}
	return null;
	}

	public function getRepositorySVNUUID() {
	$info = $this->getSVNInfo('/');
	return $info['Repository UUID'];
	}

	public function getLocalCommitInformation() {
	return null;
	}

	public function supportsRelativeLocalCommits() {
	return false;
	}

	public function getWorkingCopyRevision() {
	return $this->getSourceControlBaseRevision();
	}

	public function supportsLocalBranchMerge() {
	return false;
	}

	public function getFinalizedRevisionMessage() {
	// In other VCSes we give push instructions here, but it never makes sense
	// in SVN.
	return "Done.";
	}

	+ public function loadWorkingCopyDifferentialRevisions(
	+ ConduitClient $conduit,
	+ array $query) {
	+
	+ // We don't have much to go on in SVN, look for revisions that came from
	+ // this directory.
	+
	+ $results = $conduit->callMethodSynchronous(
	+ 'differential.query',
	+ $query);
	+
	+ foreach ($results as $key => $result) {
	+ if ($result['sourcePath'] != $this->getPath()) {
	+ unset($results[$key]);
	+ }
	+ }
	+
	+ return $results;
	+ }
	+
	}
	diff --git a/src/workflow/which/ArcanistWhichWorkflow.php b/src/workflow/which/ArcanistWhichWorkflow.php
	new file mode 100644
	index 00000000..0c73bb7e
	--- /dev/null
	+++ b/src/workflow/which/ArcanistWhichWorkflow.php
	@@ -0,0 +1,116 @@
	+<?php
	+
	+/*
	+ * Copyright 2012 Facebook, Inc.
	+ *
	+ * Licensed under the Apache License, Version 2.0 (the "License");
	+ * you may not use this file except in compliance with the License.
	+ * You may obtain a copy of the License at
	+ *
	+ * http://www.apache.org/licenses/LICENSE-2.0
	+ *
	+ * Unless required by applicable law or agreed to in writing, software
	+ * distributed under the License is distributed on an "AS IS" BASIS,
	+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	+ * See the License for the specific language governing permissions and
	+ * limitations under the License.
	+ */
	+
	+/**
	+ * Show which revision or revisions are in the working copy.
	+ *
	+ * @group workflow
	+ */
	+class ArcanistWhichWorkflow extends ArcanistBaseWorkflow {
	+
	+ public function getCommandHelp() {
	+ return phutil_console_format(<<<EOTEXT
	+ which (svn)
	+ which [commit] (hg, git)
	+ Supports: svn, git, hg
	+ Shows which revision is in the working copy (or which revisions, if
	+ more than one matches).
	+EOTEXT
	+ );
	+ }
	+
	+ public function requiresConduit() {
	+ return true;
	+ }
	+
	+ public function requiresRepositoryAPI() {
	+ return true;
	+ }
	+
	+ public function requiresAuthentication() {
	+ return true;
	+ }
	+
	+ public function getArguments() {
	+ return array(
	+ 'any-author' => array(
	+ 'help' => "Show revisions by any author, not just you.",
	+ ),
	+ 'any-status' => array(
	+ 'help' => "Show committed and abandoned revisions.",
	+ ),
	+ 'id' => array(
	+ 'help' => "If exactly one revision matches, print it to stdout. ".
	+ "Otherwise, exit with an error. Intended for scripts.",
	+ ),
	+ '*' => 'commit',
	+ );
	+ }
	+
	+ public function run() {
	+
	+ $repository_api = $this->getRepositoryAPI();
	+
	+ $commit = $this->getArgument('commit');
	+ if (count($commit)) {
	+ if (!$repository_api->supportsRelativeLocalCommits()) {
	+ throw new ArcanistUsageException(
	+ "This version control system does not support relative commits.");
	+ } else {
	+ $repository_api->parseRelativeLocalCommit($commit);
	+ }
	+ }
	+
	+ $any_author = $this->getArgument('any-author');
	+ $any_status = $this->getArgument('any-status');
	+
	+ $query = array(
	+ 'authors' => $any_author
	+ ? null
	+ : array($this->getUserPHID()),
	+ 'status' => $any_status
	+ ? 'status-any'
	+ : 'status-open',
	+ );
	+
	+ $revisions = $repository_api->loadWorkingCopyDifferentialRevisions(
	+ $this->getConduit(),
	+ $query);
	+
	+ if (empty($revisions)) {
	+ $this->writeStatusMessage("No matching revisions.\n");
	+ return 1;
	+ }
	+
	+ if ($this->getArgument('id')) {
	+ if (count($revisions) == 1) {
	+ echo idx(head($revisions), 'id');
	+ return 0;
	+ } else {
	+ $this->writeStatusMessage("More than one matching revision.\n");
	+ return 1;
	+ }
	+ }
	+
	+ foreach ($revisions as $revision) {
	+ echo 'D'.$revision['id'].' '.$revision['title']."\n";
	+ }
	+
	+ return 0;
	+ }
	+}
	diff --git a/src/workflow/which/__init__.php b/src/workflow/which/__init__.php
	new file mode 100644
	index 00000000..a92dfa89
	--- /dev/null
	+++ b/src/workflow/which/__init__.php
	@@ -0,0 +1,16 @@
	+<?php
	+/**
	+ * This file is automatically generated. Lint this module to rebuild it.
	+ * @generated
	+ */
	+
	+
	+
	+phutil_require_module('arcanist', 'exception/usage');
	+phutil_require_module('arcanist', 'workflow/base');
	+
	+phutil_require_module('phutil', 'console');
	+phutil_require_module('phutil', 'utils');
	+
	+
	+phutil_require_source('ArcanistWhichWorkflow.php');

File Metadata

Mime Type: text/x-diff
Expires: Mon, Dec 23, 08:12 (20 h, 42 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 556869
Default Alt Text: (67 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions