No OneTemporary
Actions

Size

72 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/.gitignore b/.gitignore
	index 8e146282..6707f606 100644
	--- a/.gitignore
	+++ b/.gitignore
	@@ -1,6 +1,5 @@
	.DS_Store
	._*
	/src/.phutil_module_cache
	/docs/
	/.divinercache/
	-/.arc/
	diff --git a/src/repository/api/ArcanistGitAPI.php b/src/repository/api/ArcanistGitAPI.php
	index 21a5ffc7..aaab2392 100644
	--- a/src/repository/api/ArcanistGitAPI.php
	+++ b/src/repository/api/ArcanistGitAPI.php
	@@ -1,857 +1,861 @@
	<?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
	*/
	final class ArcanistGitAPI extends ArcanistRepositoryAPI {

	private $status;
	private $relativeCommit = null;
	private $relativeExplanation = '???';
	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);
	}

	protected function buildLocalFuture(array $argv) {

	$argv[0] = 'git '.$argv[0];

	$future = newv('ExecFuture', $argv);
	$future->setCWD($this->getPath());
	return $future;
	}


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

	+ public function getMetadataPath() {
	+ return $this->getPath('.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. We include commits reachable from HEAD which are
	// not reachable from the relative commit; this is consistent with
	// user expectations even though it is not actually the diff range.
	// Particularly:
	//
	// \|
	// D <----- master branch
	// \|
	// C Y <- feature branch
	// \| /\|
	// B X
	// \| /
	// A
	// \|
	//
	// If "A, B, C, D" are master, and the user is at Y, when they run
	// "arc diff B" they want (and get) a diff of B vs Y, but they think about
	// this as being the commits X and Y. If we log "B..Y", we only show
	// Y. With "Y --not B", we show X and Y.

	$against = csprintf('%s --not %s', 'HEAD', $this->getRelativeCommit());
	}

	// NOTE: Windows escaping of "%" symbols apparently is inherently broken;
	// when passed throuhgh escapeshellarg() they are replaced with spaces.

	// TODO: Learn how cmd.exe works and find some clever workaround?

	// NOTE: If we use "%x00", output is truncated in Windows.

	list($info) = $this->execxLocal(
	phutil_is_windows()
	? 'log %C --format=%C --'
	: 'log %C --format=%s --',
	$against,
	// NOTE: "%B" is somewhat new, use "%s%n%n%b" instead.
	'%H%x01%T%x01%P%x01%at%x01%an%x01%s%x01%s%n%n%b%x02');

	$commits = array();

	$info = trim($info, " \n\2");
	if (!strlen($info)) {
	return array();
	}

	$info = explode("\2", $info);
	foreach ($info as $line) {
	list($commit, $tree, $parents, $time, $author, $title, $message)
	= explode("\1", trim($line), 7);
	$message = rtrim($message);

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

	return $commits;
	}

	public function getRelativeCommit() {
	if ($this->relativeCommit === null) {

	// Detect zero-commit or one-commit repositories. There is only one
	// relative-commit value that makes any sense in these repositories: the
	// empty tree.
	list($err) = $this->execManualLocal('rev-parse --verify HEAD^');
	if ($err) {
	list($err) = $this->execManualLocal('rev-parse --verify HEAD');
	if ($err) {
	$this->repositoryHasNoCommits = true;
	}

	$this->relativeCommit = self::GIT_MAGIC_ROOT_COMMIT;

	if ($this->repositoryHasNoCommits) {
	$this->relativeExplanation = "the repository has no commits.";
	} else {
	$this->relativeExplanation = "the repository has only one commit.";
	}

	return $this->relativeCommit;
	}

	$do_write = false;
	$default_relative = null;
	$working_copy = $this->getWorkingCopyIdentity();
	if ($working_copy) {
	$default_relative = $working_copy->getConfig(
	'git.default-relative-commit');
	$this->relativeExplanation =
	"it is the merge-base of '{$default_relative}' and HEAD, as ".
	"specified in 'git.default-relative-commit' in '.arcconfig'. This ".
	"setting overrides other settings.";
	}

	if (!$default_relative) {
	list($err, $upstream) = $this->execManualLocal(
	"rev-parse --abbrev-ref --symbolic-full-name '@{upstream}'");

	if (!$err) {
	$default_relative = trim($upstream);
	$this->relativeExplanation =
	"it is the merge-base of '{$default_relative}' (the Git upstream ".
	"of the current branch) HEAD.";
	}
	}

	if (!$default_relative) {
	$default_relative = $this->readScratchFile('default-relative-commit');
	$default_relative = trim($default_relative);
	if ($default_relative) {
	$this->relativeExplanation =
	"it is the merge-base of '{$default_relative}' and HEAD, as ".
	- "specified in '.arc/default-relative-commit'.";
	+ "specified in '.git/arc/default-relative-commit'.";
	}
	}

	if (!$default_relative) {

	// TODO: Remove the history lesson soon.

	echo phutil_console_format(
	"<bg:green> Select a Default Commit Range </bg>\n\n");
	echo phutil_console_wrap(
	"You're running a command which operates on a range of revisions ".
	"(usually, from some revision to HEAD) but have not specified the ".
	"revision that should determine the start of the range.\n\n".
	"Previously, arc assumed you meant 'HEAD^' when you did not specify ".
	"a start revision, but this behavior does not make much sense in ".
	"most workflows outside of Facebook's historic git-svn workflow.\n\n".
	"arc no longer assumes 'HEAD^'. You must specify a relative commit ".
	"explicitly when you invoke a command (e.g., `arc diff HEAD^`, not ".
	"just `arc diff`) or select a default for this working copy.\n\n".
	"In most cases, the best default is 'origin/master'. You can also ".
	"select 'HEAD^' to preserve the old behavior, or some other remote ".
	"or branch. But you almost certainly want to select ".
	"'origin/master'.\n\n".
	"(Technically: the merge-base of the selected revision and HEAD is ".
	"used to determine the start of the commit range.)");

	$prompt = "What default do you want to use? [origin/master]";
	$default = phutil_console_prompt($prompt);

	if (!strlen(trim($default))) {
	$default = 'origin/master';
	}

	$default_relative = $default;
	$do_write = true;
	}

	list($object_type) = $this->execxLocal(
	'cat-file -t %s',
	$default_relative);

	if (trim($object_type) !== 'commit') {
	throw new Exception(
	"Relative commit '{$default_relative}' is not the name of a commit!");
	}

	if ($do_write) {
	// Don't perform this write until we've verified that the object is a
	// valid commit name.
	$this->writeScratchFile('default-relative-commit', $default_relative);
	$this->relativeExplanation =
	"it is the merge-base of '{$default_relative}' and HEAD, as you ".
	"just specified.";
	}

	list($merge_base) = $this->execxLocal(
	'merge-base %s HEAD',
	$default_relative);

	$this->relativeCommit = trim($merge_base);
	}

	return $this->relativeCommit;
	}

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

	if ($detect_moves_and_renames) {
	$options[] = '-M';
	$options[] = '-C';
	}

	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) = $this->execxLocal(
	"diff {$options} %s --",
	$this->getRelativeCommit());
	return $stdout;
	}

	/**
	* @param string Path to generate a diff for.
	* @param bool If true, detect moves and renames. Otherwise, ignore
	* moves/renames; this is useful because it prompts git to
	* generate real diff text.
	*/
	public function getRawDiffText($path, $detect_moves_and_renames = true) {
	$options = $this->getDiffFullOptions($detect_moves_and_renames);
	list($stdout) = $this->execxLocal(
	"diff {$options} %s -- %s",
	$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) = $this->execxLocal('branch');

	$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) = $this->execxLocal(
	'log --format=medium HEAD');
	} else {
	// 2..N commits.
	list($stdout) = $this->execxLocal(
	'log --first-parent --format=medium %s..HEAD',
	$this->getRelativeCommit());
	}
	return $stdout;
	}

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

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

	public function getCanonicalRevisionName($string) {
	list($stdout) = $this->execxLocal('show -s --format=%C %s',
	'%H', $string);
	return rtrim($stdout);
	}

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

	$options = $this->getDiffBaseOptions();

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

	// Find committed changes.
	$committed_future = $this->buildLocalFuture(
	array(
	"diff {$options} --raw %s --",
	$this->getRelativeCommit(),
	));

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

	// Untracked files
	$untracked_future = $this->buildLocalFuture(
	array(
	'ls-files --others --exclude-standard',
	));

	// 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 = $this->buildLocalFuture(
	array(
	'ls-files -m',
	));

	$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 amendCommit($message) {
	$tmp_file = new TempFile();
	Filesystem::writeFile($tmp_file, $message);
	$this->execxLocal(
	'commit --amend --allow-empty -F %s',
	$tmp_file);
	}

	public function getPreReceiveHookStatus($old_ref, $new_ref) {
	$options = $this->getDiffBaseOptions();
	list($stdout) = $this->execxLocal(
	"diff {$options} --raw %s %s --",
	$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) = $this->execxLocal(
	'blame --date=iso -w -M %s -- %s',
	$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) = $this->execxLocal(
	'ls-tree %s -- %s',
	$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) = $this->execxLocal(
	'cat-file blob %s',
	$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) = $this->execxLocal('branch --no-color');
	$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) = $this->execxLocal('rev-parse %Ls', $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) {

	list($commits_string) = $this->execxLocal(
	"show -s --pretty='format:'%s%s %Ls",
	$format,
	'%x00',
	$revs);

	$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) = $this->execxLocal('config --get user.name');
	return trim($owner);
	}

	public function getWorkingCopyRevision() {
	list($stdout) = $this->execxLocal('rev-parse HEAD');
	return rtrim($stdout, "\n");
	}

	public function isHistoryDefaultImmutable() {
	return false;
	}

	public function supportsAmend() {
	return true;
	}

	public function supportsRelativeLocalCommits() {
	return true;
	}

	public function hasLocalCommit($commit) {
	try {
	$this->getCanonicalRevisionName($commit);
	} catch (CommandException $exception) {
	return false;
	}
	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;
	$this->relativeExplanation =
	"you explicitly specified the empty tree.";
	} else {
	list($err, $merge_base) = $this->execManualLocal(
	'merge-base %s HEAD',
	$base);
	if ($err) {
	throw new ArcanistUsageException(
	"Unable to find any git commit named '{$base}' in this repository.");
	}
	$this->relativeExplanation =
	"it is the merge-base of '{$base}' and HEAD, as you explicitly ".
	"specified.";
	}
	$this->setRelativeCommit(trim($merge_base));
	}

	public function getAllLocalChanges() {
	$diff = $this->getFullGitDiff();
	if (!strlen(trim($diff))) {
	return array();
	}
	$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) = $this->execxLocal(
	'log -n1 %s',
	$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.
	$reason_map = array();
	$revision_ids = array();
	foreach ($messages as $message) {
	$object = ArcanistDifferentialCommitMessage::newFromRawCorpus(
	$message->getMetadata('message'));
	if ($object->getRevisionID()) {
	$revision_ids[] = $object->getRevisionID();
	$reason_map[$object->getRevisionID()] = $message->getCommitHash();
	}
	}

	if ($revision_ids) {
	$results = $conduit->callMethodSynchronous(
	'differential.query',
	$query + array(
	'ids' => $revision_ids,
	));

	foreach ($results as $key => $result) {
	$hash = substr($reason_map[$result['id']], 0, 16);
	$results[$key]['why'] =
	"Commit message for '{$hash}' has explicit 'Differential Revision'.";
	}

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

	foreach ($results as $key => $result) {
	$results[$key]['why'] =
	"A git commit or tree hash in the commit range is already attached ".
	"to the Differential revision.";
	}

	return $results;
	}

	public function updateWorkingCopy() {
	$this->execxLocal('pull');
	}

	public function getRelativeExplanation() {
	return $this->relativeExplanation;
	}

	public function getCommitSummary($commit) {
	if ($commit == self::GIT_MAGIC_ROOT_COMMIT) {
	return '(The Empty Tree)';
	}

	list($summary) = $this->execxLocal(
	'log -n 1 --format=%C %s',
	'%s',
	$commit);

	return trim($summary);
	}

	}
	diff --git a/src/repository/api/ArcanistMercurialAPI.php b/src/repository/api/ArcanistMercurialAPI.php
	index fa5c74c6..03d9fa19 100644
	--- a/src/repository/api/ArcanistMercurialAPI.php
	+++ b/src/repository/api/ArcanistMercurialAPI.php
	@@ -1,612 +1,616 @@
	<?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
	*/
	final class ArcanistMercurialAPI extends ArcanistRepositoryAPI {

	private $status;
	private $base;
	private $relativeCommit;
	private $relativeExplanation;
	private $workingCopyRevision;
	private $localCommitInfo;
	private $includeDirectoryStateInDiffs;

	protected function buildLocalFuture(array $argv) {

	// Mercurial has a "defaults" feature which basically breaks automation by
	// allowing the user to add random flags to any command. This feature is
	// "deprecated" and "a bad idea" that you should "forget ... existed"
	// according to project lead Matt Mackall:
	//
	// http://markmail.org/message/hl3d6eprubmkkqh5
	//
	// There is an HGPLAIN environmental variable which enables "plain mode"
	// and hopefully disables this stuff.

	if (phutil_is_windows()) {
	$argv[0] = 'set HGPLAIN=1 & hg '.$argv[0];
	} else {
	$argv[0] = 'HGPLAIN=1 hg '.$argv[0];
	}

	$future = newv('ExecFuture', $argv);
	$future->setCWD($this->getPath());
	return $future;
	}

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

	+ public function getMetadataPath() {
	+ return $this->getPath('.hg');
	+ }
	+
	public function getSourceControlBaseRevision() {
	return $this->getCanonicalRevisionName($this->getRelativeCommit());
	}

	public function getCanonicalRevisionName($string) {
	list($stdout) = $this->execxLocal(
	'log -l 1 --template %s -r %s --',
	'{node}',
	$string);
	return $stdout;
	}

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

	public function getBranchName() {
	// TODO: I have nearly no idea how hg branches work.
	list($stdout) = $this->execxLocal('branch');
	return trim($stdout);
	}

	public function setRelativeCommit($commit) {
	try {
	$commit = $this->getCanonicalRevisionName($commit);
	} catch (Exception $ex) {
	throw new ArcanistUsageException(
	"Commit '{$commit}' is not a valid Mercurial commit identifier.");
	}

	$this->relativeCommit = $commit;
	$this->dropCaches();

	return $this;
	}

	public function getRelativeCommit() {
	if (empty($this->relativeCommit)) {
	list($err, $stdout) = $this->execManualLocal(
	'outgoing --branch `hg branch` --style default');

	if (!$err) {
	$logs = ArcanistMercurialParser::parseMercurialLog($stdout);
	} else {
	// Mercurial (in some versions?) raises an error when there's nothing
	// outgoing.
	$logs = array();
	}

	if (!$logs) {

	$this->relativeExplanation =
	"you have no outgoing commits, so arc assumes you intend to submit ".
	"uncommitted changes in the working copy.";
	// In Mercurial, we support operations against uncommitted changes.
	$this->setRelativeCommit($this->getWorkingCopyRevision());
	return $this->relativeCommit;
	}

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

	// This is essentially an implementation of a theoretical `hg merge-base`
	// command.
	$against = $this->getWorkingCopyRevision();
	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) = $this->execxLocal(
	'parents --style default --rev %s',
	$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;
	}
	}

	if ($against == 'null') {
	$this->relativeExplanation =
	"this is a new repository (all changes are outgoing).";
	} else {
	$this->relativeExplanation =
	"it is the first commit reachable from the working copy state ".
	"which is not outgoing.";
	}

	$this->setRelativeCommit($against);
	}
	return $this->relativeCommit;
	}

	public function getLocalCommitInformation() {
	if ($this->localCommitInfo === null) {
	list($info) = $this->execxLocal(
	"log --template '%C' --prune %s --rev %s --branch %s --",
	"{node}\1{rev}\1{author}\1{date\|rfc822date}\1".
	"{branch}\1{tag}\1{parents}\1{desc}\2",
	$this->getRelativeCommit(),
	"ancestors({$this->getWorkingCopyRevision()})",
	$this->getBranchName());
	$logs = array_filter(explode("\2", $info));

	$last_node = null;

	$futures = array();

	$commits = array();
	foreach ($logs as $log) {
	list($node, $rev, $author, $date, $branch, $tag, $parents, $desc) =
	explode("\1", $log);

	// NOTE: If a commit has only one parent, {parents} returns empty.
	// If it has two parents, {parents} returns revs and short hashes, not
	// full hashes. Try to avoid making calls to "hg parents" because it's
	// relatively expensive.
	$commit_parents = null;
	if (!$parents) {
	if ($last_node) {
	$commit_parents = array($last_node);
	}
	}

	if (!$commit_parents) {
	// We didn't get a cheap hit on previous commit, so do the full-cost
	// "hg parents" call. We can run these in parallel, at least.
	$futures[$node] = $this->execFutureLocal(
	"parents --template='{node}\\n' --rev %s",
	$node);
	}

	$commits[$node] = array(
	'author' => $author,
	'time' => strtotime($date),
	'branch' => $branch,
	'tag' => $tag,
	'commit' => $node,
	'rev' => $node, // TODO: Remove eventually.
	'local' => $rev,
	'parents' => $commit_parents,
	'summary' => head(explode("\n", $desc)),
	'message' => $desc,
	);

	$last_node = $node;
	}

	foreach (Futures($futures)->limit(4) as $node => $future) {
	list($parents) = $future->resolvex();
	$parents = array_filter(explode("\n", $parents));
	$commits[$node]['parents'] = $parents;
	}

	// Put commits in newest-first order, to be consistent with Git and the
	// expected order of "hg log" and "git log" under normal circumstances.
	// The order of ancestors() is oldest-first.
	$commits = array_reverse($commits);

	$this->localCommitInfo = $commits;
	}

	return $this->localCommitInfo;
	}

	public function getBlame($path) {
	list($stdout) = $this->execxLocal(
	'annotate -u -v -c --rev %s -- %s',
	$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();

	if (!$diff) {
	$this->status = array();
	return $this->status;
	}

	$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) = $this->execxLocal('status');

	$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',
	'-U'.$this->getDiffLinesOfContext(),
	);
	return implode(' ', $options);
	}

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

	list($stdout) = $this->execxLocal(
	'diff %C --rev %s --rev %s -- %s',
	$options,
	$this->getRelativeCommit(),
	$this->getDiffToRevision(),
	$path);

	return $stdout;
	}

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

	list($stdout) = $this->execxLocal(
	'diff %C --rev %s --rev %s --',
	$options,
	$this->getRelativeCommit(),
	$this->getDiffToRevision());

	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) = $this->execManualLocal(
	'cat --rev %s -- %s',
	$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() {
	if ($this->workingCopyRevision === null) {
	// 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) = $this->execxLocal('--debug id --id');

	// 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);
	$this->workingCopyRevision = rtrim($stdout, '+');
	}
	return $this->workingCopyRevision;
	}

	public function isHistoryDefaultImmutable() {
	return true;
	}

	public function supportsAmend() {
	list ($err, $stdout) = $this->execManualLocal('help commit');
	if ($err) {
	return false;
	} else {
	return (strstr($stdout, "amend") !== false);
	}
	}

	public function supportsRelativeLocalCommits() {
	return true;
	}

	public function hasLocalCommit($commit) {
	try {
	$this->getCanonicalRevisionName($commit);
	return true;
	} catch (Exception $ex) {
	return false;
	}
	}

	public function parseRelativeLocalCommit(array $argv) {
	if (count($argv) == 0) {
	return;
	}
	if (count($argv) != 1) {
	throw new ArcanistUsageException("Specify only one commit.");
	}

	$this->relativeExplanation = "you explicitly specified it.";

	// This does the "hg id" call we need to normalize/validate the revision
	// identifier.
	$this->setRelativeCommit(reset($argv));
	}

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

	public function supportsLocalBranchMerge() {
	return true;
	}

	public function performLocalBranchMerge($branch, $message) {
	if ($branch) {
	$err = phutil_passthru(
	'(cd %s && HGPLAIN=1 hg merge --rev %s && hg commit -m %s)',
	$this->getPath(),
	$branch,
	$message);
	} else {
	$err = phutil_passthru(
	'(cd %s && HGPLAIN=1 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 getCommitMessageLog() {
	list($stdout) = $this->execxLocal(
	"log --template '{node}\\1{desc}\\0' --prune %s --rev %s --",
	$this->getRelativeCommit(),
	"ancestors({$this->getWorkingCopyRevision()})");

	$map = array();

	$logs = explode("\0", trim($stdout));
	foreach (array_filter($logs) as $log) {
	list($node, $desc) = explode("\1", $log);
	$map[$node] = $desc;
	}

	return array_reverse($map);
	}

	public function loadWorkingCopyDifferentialRevisions(
	ConduitClient $conduit,
	array $query) {

	$messages = $this->getCommitMessageLog();
	$parser = new ArcanistDiffParser();

	// First, try to find revisions by explicit revision IDs in commit messages.
	$reason_map = array();
	$revision_ids = array();
	foreach ($messages as $node_id => $message) {
	$object = ArcanistDifferentialCommitMessage::newFromRawCorpus($message);

	if ($object->getRevisionID()) {
	$revision_ids[] = $object->getRevisionID();
	$reason_map[$object->getRevisionID()] = $node_id;
	}
	}

	if ($revision_ids) {
	$results = $conduit->callMethodSynchronous(
	'differential.query',
	$query + array(
	'ids' => $revision_ids,
	));

	foreach ($results as $key => $result) {
	$hash = substr($reason_map[$result['id']], 0, 16);
	$results[$key]['why'] =
	"Commit message for '{$hash}' has explicit 'Differential Revision'.";
	}

	return $results;
	}

	// Try to find revisions by hash.
	$hashes = array();
	foreach ($this->getLocalCommitInformation() as $commit) {
	$hashes[] = array('hgcm', $commit['commit']);
	}

	$results = $conduit->callMethodSynchronous(
	'differential.query',
	$query + array(
	'commitHashes' => $hashes,
	));

	foreach ($results as $key => $hash) {
	$results[$key]['why'] =
	"A mercurial commit hash in the commit range is already attached ".
	"to the Differential revision.";
	}

	return $results;
	}

	public function updateWorkingCopy() {
	$this->execxLocal('up');
	}

	public function amendCommit($message) {
	$tmp_file = new TempFile();
	Filesystem::writeFile($tmp_file, $message);
	$this->execxLocal(
	'commit --amend -l %s',
	$tmp_file);
	}

	public function setIncludeDirectoryStateInDiffs($include) {
	$this->includeDirectoryStateInDiffs = $include;
	return $this;
	}

	private function getDiffToRevision() {
	$this->dropCaches();

	if ($this->includeDirectoryStateInDiffs) {
	// This is a magic Mercurial revision name which means "current
	// directory state"; see lookup() in localrepo.py.
	return '.';
	} else {
	return $this->getWorkingCopyRevision();
	}
	}

	private function dropCaches() {
	$this->status = null;
	$this->localCommitInfo = null;
	}

	public function getRelativeExplanation() {
	return $this->relativeExplanation;
	}

	public function getCommitSummary($commit) {
	if ($commit == 'null') {
	return '(The Empty Void)';
	}

	list($summary) = $this->execxLocal(
	'log --template {desc} --limit 1 --rev %s',
	$commit);

	$summary = head(explode("\n", $summary));

	return trim($summary);
	}

	}
	diff --git a/src/repository/api/ArcanistRepositoryAPI.php b/src/repository/api/ArcanistRepositoryAPI.php
	index 9440c89e..a049c9ad 100644
	--- a/src/repository/api/ArcanistRepositoryAPI.php
	+++ b/src/repository/api/ArcanistRepositoryAPI.php
	@@ -1,359 +1,385 @@
	<?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;
	private $workingCopyIdentity;

	abstract public function getSourceControlSystemName();

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

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

	public function getWorkingCopyIdentity() {
	return $this->workingCopyIdentity;
	}

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

	// check if we're in an svn working copy
	list($err) = exec_manual('svn info');
	if (!$err) {
	$api = new ArcanistSubversionAPI($root);
	$api->workingCopyIdentity = $working_copy;
	return $api;
	}

	if (Filesystem::pathExists($root.'/.hg')) {
	$api = new ArcanistMercurialAPI($root);
	$api->workingCopyIdentity = $working_copy;
	return $api;
	}

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

	$api = new ArcanistGitAPI($root);
	$api->workingCopyIdentity = $working_copy;
	return $api;
	}

	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.DIRECTORY_SEPARATOR.
	ltrim($to_file, DIRECTORY_SEPARATOR);
	} else {
	return $this->path.DIRECTORY_SEPARATOR;
	}
	}

	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 {

	// NOTE: This awkward construction is to make sure things work on Windows.
	$future = new ExecFuture('git rev-parse --show-cdup');
	$future->setCWD($root);
	list($stdout) = $future->resolvex();

	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 getCanonicalRevisionName($string);
	abstract public function isHistoryDefaultImmutable();
	abstract public function supportsAmend();
	abstract public function supportsRelativeLocalCommits();
	abstract public function getWorkingCopyRevision();
	abstract public function updateWorkingCopy();
	+ abstract public function getMetadataPath();
	abstract public function loadWorkingCopyDifferentialRevisions(
	ConduitClient $conduit,
	array $query);

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

	public function getAllBranches() {
	// TODO: Implement for Mercurial/SVN and make abstract.
	return array();
	}

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

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

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

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

	public function getCommitSummary($commit) {
	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);
	}

	public function execxLocal($pattern /, ... /) {
	$args = func_get_args();
	return $this->buildLocalFuture($args)->resolvex();
	}

	public function execManualLocal($pattern /, ... /) {
	$args = func_get_args();
	return $this->buildLocalFuture($args)->resolve();
	}

	public function execFutureLocal($pattern /, ... /) {
	$args = func_get_args();
	return $this->buildLocalFuture($args);
	}

	abstract protected function buildLocalFuture(array $argv);


	/* -( Scratch Files )------------------------------------------------------ */


	/**
	* Try to read a scratch file, if it exists and is readable.
	*
	* @param string Scratch file name.
	* @return mixed String for file contents, or false for failure.
	* @task scratch
	*/
	public function readScratchFile($path) {
	$full_path = $this->getScratchFilePath($path);
	if (!$full_path) {
	return false;
	}

	if (!Filesystem::pathExists($full_path)) {
	return false;
	}

	try {
	$result = Filesystem::readFile($full_path);
	} catch (FilesystemException $ex) {
	return false;
	}

	return $result;
	}


	/**
	* Try to write a scratch file, if there's somewhere to put it and we can
	* write there.
	*
	* @param string Scratch file name to write.
	* @param string Data to write.
	* @return bool True on success, false on failure.
	* @task scratch
	*/
	public function writeScratchFile($path, $data) {
	$dir = $this->getScratchFilePath('');
	if (!$dir) {
	return false;
	}

	if (!Filesystem::pathExists($dir)) {
	try {
	Filesystem::createDirectory($dir);
	} catch (Exception $ex) {
	return false;
	}
	}

	try {
	Filesystem::writeFile($this->getScratchFilePath($path), $data);
	} catch (FilesystemException $ex) {
	return false;
	}

	return true;
	}


	/**
	* Try to remove a scratch file.
	*
	* @param string Scratch file name to remove.
	* @return bool True if the file was removed successfully.
	* @task scratch
	*/
	public function removeScratchFile($path) {
	$full_path = $this->getScratchFilePath($path);
	if (!$full_path) {
	return false;
	}

	try {
	Filesystem::remove($full_path);
	} catch (FilesystemException $ex) {
	return false;
	}

	return true;
	}


	/**
	* Get a human-readable description of the scratch file location.
	*
	* @param string Scratch file name.
	* @return mixed String, or false on failure.
	* @task scratch
	*/
	public function getReadableScratchFilePath($path) {
	$full_path = $this->getScratchFilePath($path);
	if ($full_path) {
	return Filesystem::readablePath(
	$full_path,
	$this->getPath());
	} else {
	return false;
	}
	}


	/**
	* Get the path to a scratch file, if possible.
	*
	* @param string Scratch file name.
	* @return mixed File path, or false on failure.
	* @task scratch
	*/
	public function getScratchFilePath($path) {
	- return $this->getPath('.arc/'.$path);
	+ $new_scratch_path = Filesystem::resolvePath(
	+ 'arc',
	+ $this->getMetadataPath());
	+
	+ static $checked = false;
	+ if (!$checked) {
	+ $checked = true;
	+ $old_scratch_path = $this->getPath('.arc');
	+ // we only want to do the migration once
	+ // unfortunately, people have checked in .arc directories which
	+ // means that the old one may get recreated after we delete it
	+ if (Filesystem::pathExists($old_scratch_path) &&
	+ !Filesystem::pathExists($new_scratch_path)) {
	+ Filesystem::createDirectory($new_scratch_path);
	+ $existing_files = Filesystem::listDirectory($old_scratch_path, true);
	+ foreach ($existing_files as $file) {
	+ $new_path = Filesystem::resolvePath($file, $new_scratch_path);
	+ $old_path = Filesystem::resolvePath($file, $old_scratch_path);
	+ Filesystem::writeFile(
	+ $new_path,
	+ Filesystem::readFile($old_path));
	+ }
	+ Filesystem::remove($old_scratch_path);
	+ }
	+ }
	+ return Filesystem::resolvePath($path, $new_scratch_path);
	}

	}
	diff --git a/src/repository/api/ArcanistSubversionAPI.php b/src/repository/api/ArcanistSubversionAPI.php
	index ee27665a..0c165a62 100644
	--- a/src/repository/api/ArcanistSubversionAPI.php
	+++ b/src/repository/api/ArcanistSubversionAPI.php
	@@ -1,576 +1,580 @@
	<?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
	*/
	final 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 getMetadataPath() {
	+ return $this->getPath('.svn');
	+ }
	+
	protected function buildLocalFuture(array $argv) {

	$argv[0] = 'svn '.$argv[0];

	$future = newv('ExecFuture', $argv);
	$future->setCWD($this->getPath());
	return $future;
	}


	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 getCanonicalRevisionName($string) {
	throw new ArcanistCapabilityNotSupportedException($this);
	}

	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',
	'/^(Node Kind): (\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;
	}

	if (!file_exists($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 isHistoryDefaultImmutable() {
	return true;
	}

	public function supportsAmend() {
	return false;
	}

	public function supportsRelativeLocalCommits() {
	return false;
	}

	public function hasLocalCommit($commit) {
	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 and belong to the same project.

	$project = $this->getWorkingCopyIdentity()->getProjectID();
	if (!$project) {
	return array();
	}

	$results = $conduit->callMethodSynchronous(
	'differential.query',
	$query + array(
	'arcanistProjects' => array($project),
	));

	foreach ($results as $key => $result) {
	if ($result['sourcePath'] != $this->getPath()) {
	unset($results[$key]);
	}
	}

	foreach ($results as $key => $result) {
	$results[$key]['why'] =
	"Matching arcanist project name and working copy directory path.";
	}

	return $results;
	}

	public function updateWorkingCopy() {
	$this->execxLocal('up');
	}

	}

File Metadata

Mime Type: text/x-diff
Expires: Sat, Nov 23, 08:24 (1 d, 17 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 547939
Default Alt Text: (72 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions