No OneTemporary
Actions

Size

80 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/src/parser/bundle/ArcanistBundle.php b/src/parser/bundle/ArcanistBundle.php
	index 1599e4eb..5acc8603 100644
	--- a/src/parser/bundle/ArcanistBundle.php
	+++ b/src/parser/bundle/ArcanistBundle.php
	@@ -1,639 +1,653 @@
	<?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.
	*/

	/**
	* Converts changesets between different formats.
	*
	* @group diff
	*/
	class ArcanistBundle {

	private $changes;
	private $conduit;
	private $blobs = array();
	private $diskPath;
	private $projectID;
	private $baseRevision;
	+ private $revisionID;

	public function setConduit(ConduitClient $conduit) {
	$this->conduit = $conduit;
	}

	public function setProjectID($project_id) {
	$this->projectID = $project_id;
	}

	public function getProjectID() {
	return $this->projectID;
	}

	public function setBaseRevision($base_revision) {
	$this->baseRevision = $base_revision;
	}

	public function getBaseRevision() {
	return $this->baseRevision;
	}

	+ public function setRevisionID($revision_id) {
	+ $this->revisionID = $revision_id;
	+ return $this;
	+ }
	+
	+ public function getRevisionID() {
	+ return $this->revisionID;
	+ }
	+
	public static function newFromChanges(array $changes) {
	$obj = new ArcanistBundle();
	$obj->changes = $changes;
	return $obj;
	}

	public static function newFromArcBundle($path) {
	$path = Filesystem::resolvePath($path);

	$future = new ExecFuture(
	csprintf(
	'tar tfO %s',
	$path));
	list($stdout, $file_list) = $future->resolvex();
	$file_list = explode("\n", trim($file_list));

	if (in_array('meta.json', $file_list)) {
	$future = new ExecFuture(
	csprintf(
	'tar xfO %s meta.json',
	$path));
	$meta_info = $future->resolveJSON();
	- $version = idx($meta_info, 'version', 0);
	- $project_name = idx($meta_info, 'projectName');
	+ $version = idx($meta_info, 'version', 0);
	+ $project_name = idx($meta_info, 'projectName');
	$base_revision = idx($meta_info, 'baseRevision');
	+ $revision_id = idx($meta_info, 'revisionID');
	// this arc bundle was probably made before we started storing meta info
	} else {
	- $version = 0;
	- $project_name = null;
	+ $version = 0;
	+ $project_name = null;
	$base_revision = null;
	+ $revision_id = null;
	}

	$future = new ExecFuture(
	csprintf(
	'tar xfO %s changes.json',
	$path));
	$changes = $future->resolveJSON();

	foreach ($changes as $change_key => $change) {
	foreach ($change['hunks'] as $key => $hunk) {
	list($hunk_data) = execx('tar xfO %s hunks/%s', $path, $hunk['corpus']);
	$changes[$change_key]['hunks'][$key]['corpus'] = $hunk_data;
	}
	}

	foreach ($changes as $change_key => $change) {
	$changes[$change_key] = ArcanistDiffChange::newFromDictionary($change);
	}

	$obj = new ArcanistBundle();
	$obj->changes = $changes;
	$obj->diskPath = $path;
	$obj->setProjectID($project_name);
	$obj->setBaseRevision($base_revision);
	+ $obj->setRevisionID($revision_id);

	return $obj;
	}

	public static function newFromDiff($data) {
	$obj = new ArcanistBundle();

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

	return $obj;
	}

	private function __construct() {

	}

	public function writeToDisk($path) {
	$changes = $this->getChanges();

	$change_list = array();
	foreach ($changes as $change) {
	$change_list[] = $change->toDictionary();
	}

	$hunks = array();
	foreach ($change_list as $change_key => $change) {
	foreach ($change['hunks'] as $key => $hunk) {
	$hunks[] = $hunk['corpus'];
	$change_list[$change_key]['hunks'][$key]['corpus'] = count($hunks) - 1;
	}
	}

	$blobs = array();
	foreach ($change_list as $change) {
	if (!empty($change['metadata']['old:binary-phid'])) {
	$blobs[$change['metadata']['old:binary-phid']] = null;
	}
	if (!empty($change['metadata']['new:binary-phid'])) {
	$blobs[$change['metadata']['new:binary-phid']] = null;
	}
	}
	foreach ($blobs as $phid => $null) {
	$blobs[$phid] = $this->getBlob($phid);
	}

	$meta_info = array(
	- 'version' => 2,
	+ 'version' => 3,
	'projectName' => $this->getProjectID(),
	'baseRevision' => $this->getBaseRevision(),
	+ 'revisionID' => $this->getRevisionID(),
	);

	$dir = Filesystem::createTemporaryDirectory();
	Filesystem::createDirectory($dir.'/hunks');
	Filesystem::createDirectory($dir.'/blobs');
	Filesystem::writeFile($dir.'/changes.json', json_encode($change_list));
	Filesystem::writeFile($dir.'/meta.json', json_encode($meta_info));
	foreach ($hunks as $key => $hunk) {
	Filesystem::writeFile($dir.'/hunks/'.$key, $hunk);
	}
	foreach ($blobs as $key => $blob) {
	Filesystem::writeFile($dir.'/blobs/'.$key, $blob);
	}
	execx(
	'(cd %s; tar -czf %s *)',
	$dir,
	Filesystem::resolvePath($path));
	Filesystem::remove($dir);
	}

	public function toUnifiedDiff() {

	$result = array();
	$changes = $this->getChanges();
	foreach ($changes as $change) {

	$old_path = $this->getOldPath($change);
	$cur_path = $this->getCurrentPath($change);

	$index_path = $cur_path;
	if ($index_path === null) {
	$index_path = $old_path;
	}

	$result[] = 'Index: '.$index_path;
	$result[] = str_repeat('=', 67);

	if ($old_path === null) {
	$old_path = '/dev/null';
	}

	if ($cur_path === null) {
	$cur_path = '/dev/null';
	}

	// When the diff is used by `patch`, `patch` ignores what is listed as the
	// current path and just makes changes to the file at the old path (unless
	// the current path is '/dev/null'.
	// If the old path and the current path aren't the same (and neither is
	// /dev/null), this indicates the file was moved or copied. By listing
	// both paths as the new file, `patch` will apply the diff to the new
	// file.
	if ($cur_path !== '/dev/null' && $old_path !== '/dev/null') {
	$old_path = $cur_path;
	}

	$result[] = '--- '.$old_path;
	$result[] = '+++ '.$cur_path;

	$result[] = $this->buildHunkChanges($change->getHunks());
	}

	return implode("\n", $result)."\n";
	}

	public function toGitPatch() {
	$result = array();
	$changes = $this->getChanges();

	foreach (array_keys($changes) as $multicopy_key) {
	$multicopy_change = $changes[$multicopy_key];

	$type = $multicopy_change->getType();
	if ($type != ArcanistDiffChangeType::TYPE_MULTICOPY) {
	continue;
	}

	// Decompose MULTICOPY into one MOVE_HERE and several COPY_HERE because
	// we need more information than we have in order to build a delete patch
	// and represent it as a bunch of COPY_HERE plus a delete. For details,
	// see T419.

	// Basically, MULTICOPY means there are 2 or more corresponding COPY_HERE
	// changes, so find one of them arbitrariy and turn it into a MOVE_HERE.

	// TODO: We might be able to do this more cleanly after T230 is resolved.

	$decompose_okay = false;
	foreach ($changes as $change_key => $change) {
	if ($change->getType() != ArcanistDiffChangeType::TYPE_COPY_HERE) {
	continue;
	}
	if ($change->getOldPath() != $multicopy_change->getCurrentPath()) {
	continue;
	}
	$decompose_okay = true;
	$change = clone $change;
	$change->setType(ArcanistDiffChangeType::TYPE_MOVE_HERE);
	$changes[$change_key] = $change;

	// The multicopy is now fully represented by MOVE_HERE plus one or more
	// COPY_HERE, so throw it away.
	unset($changes[$multicopy_key]);
	break;
	}

	if (!$decompose_okay) {
	throw new Exception(
	"Failed to decompose multicopy changeset in order to generate diff.");
	}
	}

	foreach ($changes as $change) {
	$type = $change->getType();
	$file_type = $change->getFileType();

	if ($file_type == ArcanistDiffChangeType::FILE_DIRECTORY) {
	// TODO: We should raise a FYI about this, so the user is aware
	// that we omitted it, if the directory is empty or has permissions
	// which git can't represent.

	// Git doesn't support empty directories, so we simply ignore them. If
	// the directory is nonempty, 'git apply' will create it when processing
	// the changesets for files inside it.
	continue;
	}

	if ($type == ArcanistDiffChangeType::TYPE_MOVE_AWAY) {
	// Git will apply this in the corresponding MOVE_HERE.
	continue;
	}

	$old_mode = idx($change->getOldProperties(), 'unix:filemode', '100644');
	$new_mode = idx($change->getNewProperties(), 'unix:filemode', '100644');

	$is_binary = ($file_type == ArcanistDiffChangeType::FILE_BINARY \|\|
	$file_type == ArcanistDiffChangeType::FILE_IMAGE);

	if ($is_binary) {
	$change_body = $this->buildBinaryChange($change);
	} else {
	$change_body = $this->buildHunkChanges($change->getHunks());
	}
	if ($type == ArcanistDiffChangeType::TYPE_COPY_AWAY) {
	// TODO: This is only relevant when patching old Differential diffs
	// which were created prior to arc pruning TYPE_COPY_AWAY for files
	// with no modifications.
	if (!strlen($change_body) && ($old_mode == $new_mode)) {
	continue;
	}
	}

	$old_path = $this->getOldPath($change);
	$cur_path = $this->getCurrentPath($change);

	if ($old_path === null) {
	$old_index = 'a/'.$cur_path;
	$old_target = '/dev/null';
	} else {
	$old_index = 'a/'.$old_path;
	$old_target = 'a/'.$old_path;
	}

	if ($cur_path === null) {
	$cur_index = 'b/'.$old_path;
	$cur_target = '/dev/null';
	} else {
	$cur_index = 'b/'.$cur_path;
	$cur_target = 'b/'.$cur_path;
	}

	$result[] = "diff --git {$old_index} {$cur_index}";

	if ($type == ArcanistDiffChangeType::TYPE_ADD) {
	$result[] = "new file mode {$new_mode}";
	}

	if ($type == ArcanistDiffChangeType::TYPE_COPY_HERE \|\|
	$type == ArcanistDiffChangeType::TYPE_MOVE_HERE \|\|
	$type == ArcanistDiffChangeType::TYPE_COPY_AWAY) {
	if ($old_mode !== $new_mode) {
	$result[] = "old mode {$old_mode}";
	$result[] = "new mode {$new_mode}";
	}
	}

	if ($type == ArcanistDiffChangeType::TYPE_COPY_HERE) {
	$result[] = "copy from {$old_path}";
	$result[] = "copy to {$cur_path}";
	} else if ($type == ArcanistDiffChangeType::TYPE_MOVE_HERE) {
	$result[] = "rename from {$old_path}";
	$result[] = "rename to {$cur_path}";
	} else if ($type == ArcanistDiffChangeType::TYPE_DELETE \|\|
	$type == ArcanistDiffChangeType::TYPE_MULTICOPY) {
	$old_mode = idx($change->getOldProperties(), 'unix:filemode');
	if ($old_mode) {
	$result[] = "deleted file mode {$old_mode}";
	}
	}

	if (!$is_binary) {
	$result[] = "--- {$old_target}";
	$result[] = "+++ {$cur_target}";
	}
	$result[] = $change_body;
	}
	return implode("\n", $result)."\n";
	}

	public function getChanges() {
	return $this->changes;
	}

	private function breakHunkIntoSmallHunks(ArcanistDiffHunk $hunk) {
	$context = 3;

	$results = array();
	$lines = explode("\n", $hunk->getCorpus());
	$n = count($lines);

	$old_offset = $hunk->getOldOffset();
	$new_offset = $hunk->getNewOffset();

	$ii = 0;
	$jj = 0;
	while ($ii < $n) {
	for ($jj = $ii; $jj < $n && $lines[$jj][0] == ' '; ++$jj) {
	// Skip lines until we find the first line with changes.
	}
	if ($jj >= $n) {
	break;
	}

	$hunk_start = max($jj - $context, 0);


	// NOTE: There are two tricky considerations here.
	// We can not generate a patch with overlapping hunks, or 'git apply'
	// rejects it after 1.7.3.4.
	// We can not generate a patch with too much trailing context, or
	// 'patch' rejects it.
	// So we need to ensure that we generate disjoint hunks, but don't
	// generate any hunks with too much context.

	$old_lines = 0;
	$new_lines = 0;
	$last_change = $jj;
	$break_here = null;
	for (; $jj < $n; ++$jj) {
	if ($lines[$jj][0] == ' ') {

	if ($jj - $last_change > $context) {
	if ($break_here === null) {
	// We haven't seen a change in $context lines, so this is a
	// potential place to break the hunk. However, we need to keep
	// looking in case there is another change fewer than $context
	// lines away, in which case we have to merge the hunks.
	$break_here = $jj;
	}
	}

	if ($jj - $last_change > (($context + 1) * 2)) {
	// We definitely aren't going to merge this with the next hunk, so
	// break out of the loop. We'll end the hunk at $break_here.
	break;
	}
	} else {
	$break_here = null;
	$last_change = $jj;
	if ($lines[$jj][0] == '-') {
	++$old_lines;
	} else {
	++$new_lines;
	}
	}
	}

	if ($break_here !== null) {
	$jj = $break_here;
	}

	$hunk_length = min($jj, $n) - $hunk_start;

	$hunk = new ArcanistDiffHunk();
	$hunk->setOldOffset($old_offset + $hunk_start - $ii);
	$hunk->setNewOffset($new_offset + $hunk_start - $ii);
	$hunk->setOldLength($hunk_length - $new_lines);
	$hunk->setNewLength($hunk_length - $old_lines);

	$corpus = array_slice($lines, $hunk_start, $hunk_length);
	$corpus = implode("\n", $corpus);
	$hunk->setCorpus($corpus);

	$results[] = $hunk;

	$old_offset += ($jj - $ii) - $new_lines;
	$new_offset += ($jj - $ii) - $old_lines;
	$ii = $jj;
	}

	return $results;
	}

	private function getOldPath(ArcanistDiffChange $change) {
	$old_path = $change->getOldPath();
	$type = $change->getType();

	if (!strlen($old_path) \|\|
	$type == ArcanistDiffChangeType::TYPE_ADD) {
	$old_path = null;
	}

	return $old_path;
	}

	private function getCurrentPath(ArcanistDiffChange $change) {
	$cur_path = $change->getCurrentPath();
	$type = $change->getType();

	if (!strlen($cur_path) \|\|
	$type == ArcanistDiffChangeType::TYPE_DELETE \|\|
	$type == ArcanistDiffChangeType::TYPE_MULTICOPY) {
	$cur_path = null;
	}

	return $cur_path;
	}

	private function buildHunkChanges(array $hunks) {
	$result = array();
	foreach ($hunks as $hunk) {
	$small_hunks = $this->breakHunkIntoSmallHunks($hunk);
	foreach ($small_hunks as $small_hunk) {
	$o_off = $small_hunk->getOldOffset();
	$o_len = $small_hunk->getOldLength();
	$n_off = $small_hunk->getNewOffset();
	$n_len = $small_hunk->getNewLength();
	$corpus = $small_hunk->getCorpus();

	$result[] = "@@ -{$o_off},{$o_len} +{$n_off},{$n_len} @@";
	$result[] = $corpus;
	}
	}
	return implode("\n", $result);
	}

	private function getBlob($phid) {
	if ($this->diskPath) {
	list($blob_data) = execx('tar xfO %s blobs/%s', $this->diskPath, $phid);
	return $blob_data;
	}

	if ($this->conduit) {
	echo "Downloading binary data...\n";
	$data_base64 = $this->conduit->callMethodSynchronous(
	'file.download',
	array(
	'phid' => $phid,
	));
	return base64_decode($data_base64);
	}

	throw new Exception("Nowhere to load blob '{$phid} from!");
	}

	private function buildBinaryChange(ArcanistDiffChange $change) {
	$old_phid = $change->getMetadata('old:binary-phid', null);
	$new_phid = $change->getMetadata('new:binary-phid', null);

	$type = $change->getType();
	if ($type == ArcanistDiffChangeType::TYPE_ADD) {
	$old_null = true;
	} else {
	$old_null = false;
	}

	if ($type == ArcanistDiffChangeType::TYPE_DELETE) {
	$new_null = true;
	} else {
	$new_null = false;
	}

	if ($old_null) {
	$old_data = '';
	$old_length = 0;
	$old_sha1 = str_repeat('0', 40);
	} else {
	$old_data = $this->getBlob($old_phid);
	$old_length = strlen($old_data);
	$old_sha1 = sha1("blob {$old_length}\0{$old_data}");
	}

	if ($new_null) {
	$new_data = '';
	$new_length = 0;
	$new_sha1 = str_repeat('0', 40);
	} else {
	$new_data = $this->getBlob($new_phid);
	$new_length = strlen($new_data);
	$new_sha1 = sha1("blob {$new_length}\0{$new_data}");
	}

	$content = array();
	$content[] = "index {$old_sha1}..{$new_sha1}";
	$content[] = "GIT binary patch";

	$content[] = "literal {$new_length}";
	$content[] = $this->emitBinaryDiffBody($new_data);

	$content[] = "literal {$old_length}";
	$content[] = $this->emitBinaryDiffBody($old_data);

	return implode("\n", $content);
	}

	private function emitBinaryDiffBody($data) {
	// See emit_binary_diff_body() in diff.c for git's implementation.

	$buf = '';

	$deflated = gzcompress($data);
	$lines = str_split($deflated, 52);
	foreach ($lines as $line) {
	$len = strlen($line);
	// The first character encodes the line length.
	if ($len <= 26) {
	$buf .= chr($len + ord('A') - 1);
	} else {
	$buf .= chr($len - 26 + ord('a') - 1);
	}
	$buf .= $this->encodeBase85($line);
	$buf .= "\n";
	}

	$buf .= "\n";

	return $buf;
	}

	private function encodeBase85($data) {
	// This is implemented awkwardly in order to closely mirror git's
	// implementation in base85.c

	static $map = array(
	'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
	'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J',
	'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T',
	'U', 'V', 'W', 'X', 'Y', 'Z',
	'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j',
	'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't',
	'u', 'v', 'w', 'x', 'y', 'z',
	'!', '#', '$', '%', '&', '(', ')', '*', '+', '-',
	';', '<', '=', '>', '?', '@', '^', '_', '`', '{',
	'\|', '}', '~',
	);

	$buf = '';

	$pos = 0;
	$bytes = strlen($data);
	while ($bytes) {
	$accum = '0';
	for ($count = 24; $count >= 0; $count -= 8) {
	$val = ord($data[$pos++]);
	$val = bcmul($val, (string)(1 << $count));
	$accum = bcadd($accum, $val);
	if (--$bytes == 0) {
	break;
	}
	}
	$slice = '';
	for ($count = 4; $count >= 0; $count--) {
	$val = bcmod($accum, 85);
	$accum = bcdiv($accum, 85);
	$slice .= $map[$val];
	}
	$buf .= strrev($slice);
	}

	return $buf;
	}

	}
	diff --git a/src/workflow/base/ArcanistBaseWorkflow.php b/src/workflow/base/ArcanistBaseWorkflow.php
	index 1400263a..2960505d 100644
	--- a/src/workflow/base/ArcanistBaseWorkflow.php
	+++ b/src/workflow/base/ArcanistBaseWorkflow.php
	@@ -1,985 +1,986 @@
	<?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.
	*/

	/**
	* Implements a runnable command, like "arc diff" or "arc help".
	*
	* = Managing Conduit =
	*
	* Workflows have the builtin ability to open a Conduit connection to a
	* Phabricator installation, so methods can be invoked over the API. Workflows
	* may either not need this (e.g., "help"), or may need a Conduit but not
	* authentication (e.g., calling only public APIs), or may need a Conduit and
	* authentication (e.g., "arc diff").
	*
	* To specify that you need an //unauthenticated// conduit, override
	* @{method:requiresConduit} to return ##true##. To specify that you need an
	* //authenticated// conduit, override @{method:requiresAuthentication} to
	* return ##true##. You can also manually invoke @{method:establishConduit}
	* and/or @{method:authenticateConduit} later in a workflow to upgrade it.
	* Once a conduit is open, you can access the client by calling
	* @{method:getConduit}, which allows you to invoke methods. You can get
	* verified information about the user identity by calling @{method:getUserPHID}
	* or @{method:getUserName} after authentication occurs.
	*
	* @task conduit Conduit
	* @group workflow
	*/
	class ArcanistBaseWorkflow {

	private $conduit;
	private $conduitURI;
	private $conduitCredentials;
	private $conduitAuthenticated;

	private $userPHID;
	private $userName;
	private $repositoryAPI;
	private $workingCopy;
	private $arguments;
	private $command;

	private $arcanistConfiguration;
	private $parentWorkflow;
	private $workingDirectory;

	private $changeCache = array();

	public function __construct() {

	}


	/* -( Conduit )------------------------------------------------------------ */


	/**
	* Set the URI which the workflow will open a conduit connection to when
	* @{method:establishConduit} is called. Arcanist makes an effort to set
	* this by default for all workflows (by reading ##.arcconfig## and/or the
	* value of ##--conduit-uri##) even if they don't need Conduit, so a workflow
	* can generally upgrade into a conduit workflow later by just calling
	* @{method:establishConduit}.
	*
	* You generally should not need to call this method unless you are
	* specifically overriding the default URI. It is normally sufficient to
	* just invoke @{method:establishConduit}.
	*
	* NOTE: You can not call this after a conduit has been established.
	*
	* @param string The URI to open a conduit to when @{method:establishConduit}
	* is called.
	* @return this
	* @task conduit
	*/
	final public function setConduitURI($conduit_uri) {
	if ($this->conduit) {
	throw new Exception(
	"You can not change the Conduit URI after a conduit is already open.");
	}
	$this->conduitURI = $conduit_uri;
	return $this;
	}


	/**
	* Open a conduit channel to the server which was previously configured by
	* calling @{method:setConduitURI}. Arcanist will do this automatically if
	* the workflow returns ##true## from @{method:requiresConduit}, or you can
	* later upgrade a workflow and build a conduit by invoking it manually.
	*
	* You must establish a conduit before you can make conduit calls.
	*
	* NOTE: You must call @{method:setConduitURI} before you can call this
	* method.
	*
	* @return this
	* @task conduit
	*/
	final public function establishConduit() {
	if ($this->conduit) {
	return $this;
	}

	if (!$this->conduitURI) {
	throw new Exception(
	"You must specify a Conduit URI with setConduitURI() before you can ".
	"establish a conduit.");
	}

	$this->conduit = new ConduitClient($this->conduitURI);

	return $this;
	}


	/**
	* Set credentials which will be used to authenticate against Conduit. These
	* credentials can then be used to establish an authenticated connection to
	* conduit by calling @{method:authenticateConduit}. Arcanist sets some
	* defaults for all workflows regardless of whether or not they return true
	* from @{method:requireAuthentication}, based on the ##~/.arcrc## and
	* ##.arcconf## files if they are present. Thus, you can generally upgrade a
	* workflow which does not require authentication into an authenticated
	* workflow by later invoking @{method:requireAuthentication}. You should not
	* normally need to call this method unless you are specifically overriding
	* the defaults.
	*
	* NOTE: You can not call this method after calling
	* @{method:authenticateConduit}.
	*
	* @param dict A credential dictionary, see @{method:authenticateConduit}.
	* @return this
	* @task conduit
	*/
	final public function setConduitCredentials(array $credentials) {
	if ($this->conduitAuthenticated) {
	throw new Exception(
	"You may not set new credentials after authenticating conduit.");
	}

	$this->conduitCredentials = $credentials;
	return $this;
	}


	/**
	* Open and authenticate a conduit connection to a Phabricator server using
	* provided credentials. Normally, Arcanist does this for you automatically
	* when you return true from @{method:requiresAuthentication}, but you can
	* also upgrade an existing workflow to one with an authenticated conduit
	* by invoking this method manually.
	*
	* You must authenticate the conduit before you can make authenticated conduit
	* calls (almost all calls require authentication).
	*
	* This method uses credentials provided via @{method:setConduitCredentials}
	* to authenticate to the server:
	*
	* - ##user## (required) The username to authenticate with.
	* - ##certificate## (required) The Conduit certificate to use.
	* - ##description## (optional) Description of the invoking command.
	*
	* Successful authentication allows you to call @{method:getUserPHID} and
	* @{method:getUserName}, as well as use the client you access with
	* @{method:getConduit} to make authenticated calls.
	*
	* NOTE: You must call @{method:setConduitURI} and
	* @{method:setConduitCredentials} before you invoke this method.
	*
	* @return this
	* @task conduit
	*/
	final public function authenticateConduit() {
	if ($this->conduitAuthenticated) {
	return $this;
	}

	$this->establishConduit();

	$credentials = $this->conduitCredentials;
	if (!$credentials) {
	throw new Exception(
	"Set conduit credentials with setConduitCredentials() before ".
	"authenticating conduit!");
	}

	if (empty($credentials['user']) \|\| empty($credentials['certificate'])) {
	throw new Exception(
	"Credentials must include a 'user' and a 'certificate'.");
	}

	$description = idx($credentials, 'description', '');
	$user = $credentials['user'];
	$certificate = $credentials['certificate'];

	try {
	$connection = $this->getConduit()->callMethodSynchronous(
	'conduit.connect',
	array(
	'client' => 'arc',
	'clientVersion' => 3,
	'clientDescription' => php_uname('n').':'.$description,
	'user' => $user,
	'certificate' => $certificate,
	'host' => $this->conduitURI,
	));
	} catch (ConduitClientException $ex) {
	if ($ex->getErrorCode() == 'ERR-NO-CERTIFICATE' \|\|
	$ex->getErrorCode() == 'ERR-INVALID-USER') {
	$conduit_uri = $this->conduitURI;
	$message =
	"\n".
	phutil_console_format(
	"YOU NEED TO __INSTALL A CERTIFICATE__ TO LOGIN TO PHABRICATOR").
	"\n\n".
	phutil_console_format(
	" To do this, run: arc install-certificate").
	"\n\n".
	"The server '{$conduit_uri}' rejected your request:".
	"\n".
	$ex->getMessage();
	throw new ArcanistUsageException($message);
	} else {
	throw $ex;
	}
	}

	$this->userName = $user;
	$this->userPHID = $connection['userPHID'];

	$this->conduitAuthenticated = true;

	return $this;
	}


	/**
	* Override this to return true if your workflow requires a conduit channel.
	* Arc will build the channel for you before your workflow executes. This
	* implies that you only need an unauthenticated channel; if you need
	* authentication, override @{method:requiresAuthentication}.
	*
	* @return bool True if arc should build a conduit channel before running
	* the workflow.
	* @task conduit
	*/
	public function requiresConduit() {
	return false;
	}


	/**
	* Override this to return true if your workflow requires an authenticated
	* conduit channel. This implies that it requires a conduit. Arc will build
	* and authenticate the channel for you before the workflow executes.
	*
	* @return bool True if arc should build an authenticated conduit channel
	* before running the workflow.
	* @task conduit
	*/
	public function requiresAuthentication() {
	return false;
	}


	/**
	* Returns the PHID for the user once they've authenticated via Conduit.
	*
	* @return phid Authenticated user PHID.
	* @task conduit
	*/
	final public function getUserPHID() {
	if (!$this->userPHID) {
	$workflow = get_class($this);
	throw new Exception(
	"This workflow ('{$workflow}') requires authentication, override ".
	"requiresAuthentication() to return true.");
	}
	return $this->userPHID;
	}

	/**
	* Deprecated. See @{method:getUserPHID}.
	*
	* @deprecated
	*/
	final public function getUserGUID() {
	phutil_deprecated(
	'ArcanistBaseWorkflow::getUserGUID',
	'This method has been renamed to getUserPHID().');
	return $this->getUserPHID();
	}

	/**
	* Return the username for the user once they've authenticated via Conduit.
	*
	* @return string Authenticated username.
	* @task conduit
	*/
	final public function getUserName() {
	return $this->userName;
	}


	/**
	* Get the established @{class@libphutil:ConduitClient} in order to make
	* Conduit method calls. Before the client is available it must be connected,
	* either implicitly by making @{method:requireConduit} or
	* @{method:requireAuthentication} return true, or explicitly by calling
	* @{method:establishConduit} or @{method:authenticateConduit}.
	*
	* @return @{class@libphutil:ConduitClient} Live conduit client.
	* @task conduit
	*/
	final public function getConduit() {
	if (!$this->conduit) {
	$workflow = get_class($this);
	throw new Exception(
	"This workflow ('{$workflow}') requires a Conduit, override ".
	"requiresConduit() to return true.");
	}
	return $this->conduit;
	}


	public function setArcanistConfiguration($arcanist_configuration) {
	$this->arcanistConfiguration = $arcanist_configuration;
	return $this;
	}

	public function getArcanistConfiguration() {
	return $this->arcanistConfiguration;
	}

	public function getCommandHelp() {
	return get_class($this).": Undocumented";
	}

	public function requiresWorkingCopy() {
	return false;
	}


	public function requiresRepositoryAPI() {
	return false;
	}

	public function setCommand($command) {
	$this->command = $command;
	return $this;
	}

	public function getCommand() {
	return $this->command;
	}

	public function getArguments() {
	return array();
	}

	public function setWorkingDirectory($working_directory) {
	$this->workingDirectory = $working_directory;
	return $this;
	}

	public function getWorkingDirectory() {
	return $this->workingDirectory;
	}

	private function setParentWorkflow($parent_workflow) {
	$this->parentWorkflow = $parent_workflow;
	return $this;
	}

	protected function getParentWorkflow() {
	return $this->parentWorkflow;
	}

	public function buildChildWorkflow($command, array $argv) {
	$arc_config = $this->getArcanistConfiguration();
	$workflow = $arc_config->buildWorkflow($command);
	$workflow->setParentWorkflow($this);
	$workflow->setCommand($command);

	if ($this->repositoryAPI) {
	$workflow->setRepositoryAPI($this->repositoryAPI);
	}

	if ($this->userPHID) {
	$workflow->userPHID = $this->getUserPHID();
	$workflow->userName = $this->getUserName();
	}

	if ($this->conduit) {
	$workflow->conduit = $this->conduit;
	}

	if ($this->workingCopy) {
	$workflow->setWorkingCopy($this->workingCopy);
	}

	$workflow->setArcanistConfiguration($arc_config);

	$workflow->parseArguments(array_values($argv));

	return $workflow;
	}

	public function getArgument($key, $default = null) {
	$args = $this->arguments;
	if (!array_key_exists($key, $args)) {
	return $default;
	}
	return $args[$key];
	}

	final public function getCompleteArgumentSpecification() {
	$spec = $this->getArguments();
	$arc_config = $this->getArcanistConfiguration();
	$command = $this->getCommand();
	$spec += $arc_config->getCustomArgumentsForCommand($command);
	return $spec;
	}

	public function parseArguments(array $args) {

	$spec = $this->getCompleteArgumentSpecification();

	$dict = array();

	$more_key = null;
	if (!empty($spec['*'])) {
	$more_key = $spec['*'];
	unset($spec['*']);
	$dict[$more_key] = array();
	}

	$short_to_long_map = array();
	foreach ($spec as $long => $options) {
	if (!empty($options['short'])) {
	$short_to_long_map[$options['short']] = $long;
	}
	}

	$more = array();
	for ($ii = 0; $ii < count($args); $ii++) {
	$arg = $args[$ii];
	$arg_name = null;
	$arg_key = null;
	if ($arg == '--') {
	$more = array_merge(
	$more,
	array_slice($args, $ii + 1));
	break;
	} else if (!strncmp($arg, '--', 2)) {
	$arg_key = substr($arg, 2);
	if (!array_key_exists($arg_key, $spec)) {
	throw new ArcanistUsageException(
	"Unknown argument '{$arg_key}'. Try 'arc help'.");
	}
	} else if (!strncmp($arg, '-', 1)) {
	$arg_key = substr($arg, 1);
	if (empty($short_to_long_map[$arg_key])) {
	throw new ArcanistUsageException(
	"Unknown argument '{$arg_key}'. Try 'arc help'.");
	}
	$arg_key = $short_to_long_map[$arg_key];
	} else {
	$more[] = $arg;
	continue;
	}

	$options = $spec[$arg_key];
	if (empty($options['param'])) {
	$dict[$arg_key] = true;
	} else {
	if ($ii == count($args) - 1) {
	throw new ArcanistUsageException(
	"Option '{$arg}' requires a parameter.");
	}
	$dict[$arg_key] = $args[$ii + 1];
	$ii++;
	}
	}

	if ($more) {
	if ($more_key) {
	$dict[$more_key] = $more;
	} else {
	$example = reset($more);
	throw new ArcanistUsageException(
	"Unrecognized argument '{$example}'. Try 'arc help'.");
	}
	}

	foreach ($dict as $key => $value) {
	if (empty($spec[$key]['conflicts'])) {
	continue;
	}
	foreach ($spec[$key]['conflicts'] as $conflict => $more) {
	if (isset($dict[$conflict])) {
	if ($more) {
	$more = ': '.$more;
	} else {
	$more = '.';
	}
	// TODO: We'll always display these as long-form, when the user might
	// have typed them as short form.
	throw new ArcanistUsageException(
	"Arguments '--{$key}' and '--{$conflict}' are mutually exclusive".
	$more);
	}
	}
	}

	$this->arguments = $dict;

	$this->didParseArguments();

	return $this;
	}

	protected function didParseArguments() {
	// Override this to customize workflow argument behavior.
	}

	public function getWorkingCopy() {
	if (!$this->workingCopy) {
	$workflow = get_class($this);
	throw new Exception(
	"This workflow ('{$workflow}') requires a working copy, override ".
	"requiresWorkingCopy() to return true.");
	}
	return $this->workingCopy;
	}

	public function setWorkingCopy(
	ArcanistWorkingCopyIdentity $working_copy) {
	$this->workingCopy = $working_copy;
	return $this;
	}

	public function setRepositoryAPI($api) {
	$this->repositoryAPI = $api;
	return $this;
	}

	public function getRepositoryAPI() {
	if (!$this->repositoryAPI) {
	$workflow = get_class($this);
	throw new Exception(
	"This workflow ('{$workflow}') requires a Repository API, override ".
	"requiresRepositoryAPI() to return true.");
	}
	return $this->repositoryAPI;
	}

	protected function shouldRequireCleanUntrackedFiles() {
	return empty($this->arguments['allow-untracked']);
	}

	public function requireCleanWorkingCopy() {
	$api = $this->getRepositoryAPI();

	$working_copy_desc = phutil_console_format(
	" Working copy: __%s__\n\n",
	$api->getPath());

	$untracked = $api->getUntrackedChanges();
	if ($this->shouldRequireCleanUntrackedFiles()) {
	if (!empty($untracked)) {
	echo "You have untracked files in this working copy.\n\n".
	$working_copy_desc.
	" Untracked files in working copy:\n".
	" ".implode("\n ", $untracked)."\n\n";

	if ($api instanceof ArcanistGitAPI) {
	echo phutil_console_wrap(
	"Since you don't have '.gitignore' rules for these files and have ".
	"not listed them in '.git/info/exclude', you may have forgotten ".
	"to 'git add' them to your commit.");
	} else if ($api instanceof ArcanistSubversionAPI) {
	echo phutil_console_wrap(
	"Since you don't have 'svn:ignore' rules for these files, you may ".
	"have forgotten to 'svn add' them.");
	} else if ($api instanceof ArcanistMercurialAPI) {
	echo phutil_console_wrap(
	"Since you don't have '.hgignore' rules for these files, you ".
	"may have forgotten to 'hg add' them to your commit.");
	}

	$prompt = "Do you want to continue without adding these files?";
	if (!phutil_console_confirm($prompt, $default_no = false)) {
	throw new ArcanistUserAbortException();
	}
	}
	}

	$incomplete = $api->getIncompleteChanges();
	if ($incomplete) {
	throw new ArcanistUsageException(
	"You have incompletely checked out directories in this working copy. ".
	"Fix them before proceeding.\n\n".
	$working_copy_desc.
	" Incomplete directories in working copy:\n".
	" ".implode("\n ", $incomplete)."\n\n".
	"You can fix these paths by running 'svn update' on them.");
	}

	$conflicts = $api->getMergeConflicts();
	if ($conflicts) {
	throw new ArcanistUsageException(
	"You have merge conflicts in this working copy. Resolve merge ".
	"conflicts before proceeding.\n\n".
	$working_copy_desc.
	" Conflicts in working copy:\n".
	" ".implode("\n ", $conflicts)."\n");
	}

	$unstaged = $api->getUnstagedChanges();
	if ($unstaged) {
	throw new ArcanistUsageException(
	"You have unstaged changes in this working copy. Stage and commit (or ".
	"revert) them before proceeding.\n\n".
	$working_copy_desc.
	" Unstaged changes in working copy:\n".
	" ".implode("\n ", $unstaged)."\n");
	}

	$uncommitted = $api->getUncommittedChanges();
	if ($uncommitted) {
	throw new ArcanistUsageException(
	"You have uncommitted changes in this branch. Commit (or revert) them ".
	"before proceeding.\n\n".
	$working_copy_desc.
	" Uncommitted changes in working copy\n".
	" ".implode("\n ", $uncommitted)."\n");
	}
	}

	protected function chooseRevision(
	array $revision_data,
	$revision_id,
	$prompt = null) {

	$revisions = array();
	foreach ($revision_data as $data) {
	$ref = ArcanistDifferentialRevisionRef::newFromDictionary($data);
	$revisions[$ref->getID()] = $ref;
	}

	if ($revision_id) {
	$revision_id = $this->normalizeRevisionID($revision_id);
	if (empty($revisions[$revision_id])) {
	throw new ArcanistChooseInvalidRevisionException();
	}
	return $revisions[$revision_id];
	}

	if (!count($revisions)) {
	throw new ArcanistChooseNoRevisionsException();
	}

	$repository_api = $this->getRepositoryAPI();

	$candidates = array();
	$cur_path = $repository_api->getPath();
	foreach ($revisions as $revision) {
	$source_path = $revision->getSourcePath();
	if ($source_path == $cur_path) {
	$candidates[] = $revision;
	}
	}

	if (count($candidates) == 1) {
	$candidate = reset($candidates);
	$revision_id = $candidate->getID();
	}

	if ($revision_id) {
	return $revisions[$revision_id];
	}

	$revision_indexes = array_keys($revisions);

	echo "\n";
	$ii = 1;
	foreach ($revisions as $revision) {
	echo ' ['.$ii++.'] D'.$revision->getID().' '.$revision->getName()."\n";
	}

	while (true) {
	$id = phutil_console_prompt($prompt);
	$id = trim(strtoupper($id), 'D');
	if (isset($revisions[$id])) {
	return $revisions[$id];
	}
	if (isset($revision_indexes[$id - 1])) {
	return $revisions[$revision_indexes[$id - 1]];
	}
	}
	}

	protected function loadDiffBundleFromConduit(
	ConduitClient $conduit,
	$diff_id) {

	return $this->loadBundleFromConduit(
	$conduit,
	array(
	'diff_id' => $diff_id,
	));
	}

	protected function loadRevisionBundleFromConduit(
	ConduitClient $conduit,
	$revision_id) {

	return $this->loadBundleFromConduit(
	$conduit,
	array(
	'revision_id' => $revision_id,
	));
	}

	private function loadBundleFromConduit(
	ConduitClient $conduit,
	$params) {

	$future = $conduit->callMethod('differential.getdiff', $params);
	$diff = $future->resolve();

	$changes = array();
	foreach ($diff['changes'] as $changedict) {
	$changes[] = ArcanistDiffChange::newFromDictionary($changedict);
	}
	$bundle = ArcanistBundle::newFromChanges($changes);
	$bundle->setConduit($conduit);
	$bundle->setProjectID($diff['projectName']);
	$bundle->setBaseRevision($diff['sourceControlBaseRevision']);
	+ $bundle->setRevisionID($diff['revisionID']);
	return $bundle;
	}

	/**
	* Return a list of lines changed by the current diff, or ##null## if the
	* change list is meaningless (for example, because the path is a directory
	* or binary file).
	*
	* @param string Path within the repository.
	* @param string Change selection mode (see ArcanistDiffHunk).
	* @return list\|null List of changed line numbers, or null to indicate that
	* the path is not a line-oriented text file.
	*/
	protected function getChangedLines($path, $mode) {
	$repository_api = $this->getRepositoryAPI();
	$full_path = $repository_api->getPath($path);
	if (is_dir($full_path)) {
	return null;
	}

	$change = $this->getChange($path);

	if ($change->getFileType() !== ArcanistDiffChangeType::FILE_TEXT) {
	return null;
	}

	$lines = $change->getChangedLines($mode);
	return array_keys($lines);
	}

	private function getChange($path) {
	$repository_api = $this->getRepositoryAPI();

	if ($repository_api instanceof ArcanistSubversionAPI) {
	// NOTE: In SVN, we don't currently support a "get all local changes"
	// operation, so special case it.
	if (empty($this->changeCache[$path])) {
	$diff = $repository_api->getRawDiffText($path);
	$parser = new ArcanistDiffParser();
	$changes = $parser->parseDiff($diff);
	if (count($changes) != 1) {
	throw new Exception("Expected exactly one change.");
	}
	$this->changeCache[$path] = reset($changes);
	}
	} else if ($repository_api->supportsRelativeLocalCommits()) {
	if (empty($this->changeCache)) {
	$changes = $repository_api->getAllLocalChanges();
	foreach ($changes as $change) {
	$this->changeCache[$change->getCurrentPath()] = $change;
	}
	}
	} else {
	throw new Exception("Missing VCS support.");
	}

	if (empty($this->changeCache[$path])) {
	if ($repository_api instanceof ArcanistGitAPI) {
	// This can legitimately occur under git if you make a change, "git
	// commit" it, and then revert the change in the working copy and run
	// "arc lint".
	$change = new ArcanistDiffChange();
	$change->setCurrentPath($path);
	return $change;
	} else {
	throw new Exception(
	"Trying to get change for unchanged path '{$path}'!");
	}
	}

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

	final public function willRunWorkflow() {
	$spec = $this->getCompleteArgumentSpecification();
	foreach ($this->arguments as $arg => $value) {
	if (empty($spec[$arg])) {
	continue;
	}
	$options = $spec[$arg];
	if (!empty($options['supports'])) {
	$system_name = $this->getRepositoryAPI()->getSourceControlSystemName();
	if (!in_array($system_name, $options['supports'])) {
	$extended_info = null;
	if (!empty($options['nosupport'][$system_name])) {
	$extended_info = ' '.$options['nosupport'][$system_name];
	}
	throw new ArcanistUsageException(
	"Option '--{$arg}' is not supported under {$system_name}.".
	$extended_info);
	}
	}
	}
	}

	protected function normalizeRevisionID($revision_id) {
	return ltrim(strtoupper($revision_id), 'D');
	}

	protected function shouldShellComplete() {
	return true;
	}

	protected function getShellCompletions(array $argv) {
	return array();
	}

	protected function getSupportedRevisionControlSystems() {
	return array('any');
	}

	protected function getPassthruArgumentsAsMap($command) {
	$map = array();
	foreach ($this->getCompleteArgumentSpecification() as $key => $spec) {
	if (!empty($spec['passthru'][$command])) {
	if (isset($this->arguments[$key])) {
	$map[$key] = $this->arguments[$key];
	}
	}
	}
	return $map;
	}

	protected function getPassthruArgumentsAsArgv($command) {
	$spec = $this->getCompleteArgumentSpecification();
	$map = $this->getPassthruArgumentsAsMap($command);
	$argv = array();
	foreach ($map as $key => $value) {
	$argv[] = '--'.$key;
	if (!empty($spec[$key]['param'])) {
	$argv[] = $value;
	}
	}
	return $argv;
	}

	public static function getUserConfigurationFileLocation() {
	return getenv('HOME').'/.arcrc';
	}

	public static function readUserConfigurationFile() {
	$user_config = array();
	$user_config_path = self::getUserConfigurationFileLocation();
	if (Filesystem::pathExists($user_config_path)) {
	$mode = fileperms($user_config_path);
	if (!$mode) {
	throw new Exception("Unable to get perms of '{$user_config_path}'!");
	}
	if ($mode & 0177) {
	// Mode should allow only owner access.
	$prompt = "File permissions on your ~/.arcrc are too open. ".
	"Fix them by chmod'ing to 600?";
	if (!phutil_console_confirm($prompt, $default_no = false)) {
	throw new ArcanistUsageException("Set ~/.arcrc to file mode 600.");
	}
	execx('chmod 600 %s', $user_config_path);
	}

	$user_config_data = Filesystem::readFile($user_config_path);
	$user_config = json_decode($user_config_data, true);
	if (!is_array($user_config)) {
	throw new ArcanistUsageException(
	"Your '~/.arcrc' file is not a valid JSON file.");
	}
	}
	return $user_config;
	}

	/**
	* Write a message to stderr so that '--json' flags or stdout which is meant
	* to be piped somewhere aren't disrupted.
	*
	* @param string Message to write to stderr.
	* @return void
	*/
	protected function writeStatusMessage($msg) {
	file_put_contents('php://stderr', $msg);
	}

	protected function isHistoryImmutable() {
	$working_copy = $this->getWorkingCopy();
	return ($working_copy->getConfig('immutable_history') === true);
	}

	/**
	* Workflows like 'lint' and 'unit' operate on a list of working copy paths.
	* The user can either specify the paths explicitly ("a.js b.php"), or by
	* specfifying a revision ("--rev a3f10f1f") to select all paths modified
	* since that revision, or by omitting both and letting arc choose the
	* default relative revision.
	*
	* This method takes the user's selections and returns the paths that the
	* workflow should act upon.
	*
	* @param list List of explicitly provided paths.
	* @param string\|null Revision name, if provided.
	* @return list List of paths the workflow should act on.
	*/
	protected function selectPathsForWorkflow(array $paths, $rev) {
	if ($paths) {
	$working_copy = $this->getWorkingCopy();
	foreach ($paths as $key => $path) {
	$full_path = Filesystem::resolvePath($path);
	if (!Filesystem::pathExists($full_path)) {
	throw new ArcanistUsageException("Path '{$path}' does not exist!");
	}
	$relative_path = Filesystem::readablePath(
	$full_path,
	$working_copy->getProjectRoot());
	$paths[$key] = $relative_path;
	}
	} else {
	$repository_api = $this->getRepositoryAPI();
	if ($rev) {
	$repository_api->parseRelativeLocalCommit(array($rev));
	}

	$paths = $repository_api->getWorkingCopyStatus();
	foreach ($paths as $path => $flags) {
	if ($flags & ArcanistRepositoryAPI::FLAG_UNTRACKED) {
	unset($paths[$path]);
	}
	}
	$paths = array_keys($paths);
	}

	return array_values($paths);
	}

	}
	diff --git a/src/workflow/export/ArcanistExportWorkflow.php b/src/workflow/export/ArcanistExportWorkflow.php
	index ff9b5daf..9b1ce4e8 100644
	--- a/src/workflow/export/ArcanistExportWorkflow.php
	+++ b/src/workflow/export/ArcanistExportWorkflow.php
	@@ -1,224 +1,225 @@
	<?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.
	*/

	/**
	* Exports changes from Differential or the working copy to a file.
	*
	* @group workflow
	*/
	final class ArcanistExportWorkflow extends ArcanistBaseWorkflow {

	const SOURCE_LOCAL = 'local';
	const SOURCE_DIFF = 'diff';
	const SOURCE_REVISION = 'revision';

	const FORMAT_GIT = 'git';
	const FORMAT_UNIFIED = 'unified';
	const FORMAT_BUNDLE = 'arcbundle';

	private $source;
	private $sourceID;
	private $format;

	public function getCommandHelp() {
	return phutil_console_format(<<<EOTEXT
	export [__paths__] __format__ (svn)
	export [__commit_range__] __format__ (git)
	export __--revision__ __revision_id__ __format__
	export __--diff__ __diff_id__ __format__
	Supports: git, svn
	Export the local changeset (or a Differential changeset) to a file,
	in some __format__: git diff (__--git__), unified diff
	(__--unified__), or arc bundle (__--arcbundle__ __path__) format.
	EOTEXT
	);
	}

	public function getArguments() {
	return array(
	'git' => array(
	'help' =>
	"Export change as a git patch. This format is more complete than ".
	"unified, but less complete than arc bundles. These patches can be ".
	"applied with 'git apply' or 'arc patch'.",
	),
	'unified' => array(
	'help' =>
	"Export change as a unified patch. This format is less complete ".
	"than git patches or arc bundles. These patches can be applied with ".
	"'patch' or 'arc patch'.",
	),
	'arcbundle' => array(
	'param' => 'file',
	'help' =>
	"Export change as an arc bundle. This format can represent all ".
	"changes. These bundles can be applied with 'arc patch'.",
	),
	'revision' => array(
	'param' => 'revision_id',
	'help' =>
	"Instead of exporting changes from the working copy, export them ".
	"from a Differential revision."
	),
	'diff' => array(
	'param' => 'diff_id',
	'help' =>
	"Instead of exporting changes from the working copy, export them ".
	"from a Differential diff."
	),
	'*' => 'paths',
	);
	}


	protected function didParseArguments() {
	$source = self::SOURCE_LOCAL;
	$requested = 0;
	if ($this->getArgument('revision')) {
	$source = self::SOURCE_REVISION;
	$requested++;
	}
	if ($this->getArgument('diff')) {
	$source = self::SOURCE_DIFF;
	$requested++;
	}

	if ($requested > 1) {
	throw new ArcanistUsageException(
	"Options '--revision' and '--diff' are not compatible. Choose exactly ".
	"one change source.");
	}

	$this->source = $source;
	$this->sourceID = $this->getArgument($source);

	$format = null;
	$requested = 0;
	if ($this->getArgument('git')) {
	$format = self::FORMAT_GIT;
	$requested++;
	}
	if ($this->getArgument('unified')) {
	$format = self::FORMAT_UNIFIED;
	$requested++;
	}
	if ($this->getArgument('arcbundle')) {
	$format = self::FORMAT_BUNDLE;
	$requested++;
	}

	if ($requested === 0) {
	throw new ArcanistUsageException(
	"Specify one of '--git', '--unified' or '--arcbundle <path>' to ".
	"choose an export format.");
	} else if ($requested > 1) {
	throw new ArcanistUsageException(
	"Options '--git', '--unified' and '--arcbundle' are not compatible. ".
	"Choose exactly one export format.");
	}

	$this->format = $format;
	}

	public function requiresConduit() {
	return $this->getSource() != self::SOURCE_LOCAL;
	}

	public function requiresAuthentication() {
	return $this->requiresConduit();
	}

	public function requiresRepositoryAPI() {
	return $this->getSource() == self::SOURCE_LOCAL;
	}

	public function requiresWorkingCopy() {
	return $this->getSource() == self::SOURCE_LOCAL;
	}

	private function getSource() {
	return $this->source;
	}

	private function getSourceID() {
	return $this->sourceID;
	}

	private function getFormat() {
	return $this->format;
	}

	public function run() {

	$source = $this->getSource();

	switch ($source) {
	case self::SOURCE_LOCAL:
	$repository_api = $this->getRepositoryAPI();
	$parser = new ArcanistDiffParser();

	if ($repository_api instanceof ArcanistGitAPI) {
	$repository_api->parseRelativeLocalCommit(
	$this->getArgument('paths'));
	$diff = $repository_api->getFullGitDiff();
	$changes = $parser->parseDiff($diff);
	} else {
	// TODO: paths support
	$paths = $repository_api->getWorkingCopyStatus();
	$changes = $parser->parseSubversionDiff(
	$repository_api,
	$paths);
	}

	$bundle = ArcanistBundle::newFromChanges($changes);
	$bundle->setProjectID($this->getWorkingCopy()->getProjectID());
	$bundle->setBaseRevision(
	$repository_api->getSourceControlBaseRevision());
	+ // note we can't get a revision ID for SOURCE_LOCAL
	break;
	case self::SOURCE_REVISION:
	$bundle = $this->loadRevisionBundleFromConduit(
	$this->getConduit(),
	$this->getSourceID());
	break;
	case self::SOURCE_DIFF:
	$bundle = $this->loadDiffBundleFromConduit(
	$this->getConduit(),
	$this->getSourceID());
	break;
	}

	$format = $this->getFormat();

	switch ($format) {
	case self::FORMAT_GIT:
	echo $bundle->toGitPatch();
	break;
	case self::FORMAT_UNIFIED:
	echo $bundle->toUnifiedDiff();
	break;
	case self::FORMAT_BUNDLE:
	$path = $this->getArgument('arcbundle');
	echo "Writing bundle to '{$path}'...\n";
	$bundle->writeToDisk($path);
	echo "done.\n";
	break;
	}

	return 0;
	}
	}
	diff --git a/src/workflow/patch/ArcanistPatchWorkflow.php b/src/workflow/patch/ArcanistPatchWorkflow.php
	index 76cd249e..9cae0b2b 100644
	--- a/src/workflow/patch/ArcanistPatchWorkflow.php
	+++ b/src/workflow/patch/ArcanistPatchWorkflow.php
	@@ -1,572 +1,650 @@
	<?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.
	*/

	/**
	* Applies changes from Differential or a file to the working copy.
	*
	* @group workflow
	*/
	final class ArcanistPatchWorkflow extends ArcanistBaseWorkflow {

	const SOURCE_BUNDLE = 'bundle';
	const SOURCE_PATCH = 'patch';
	const SOURCE_REVISION = 'revision';
	const SOURCE_DIFF = 'diff';

	private $source;
	private $sourceParam;

	public function getCommandHelp() {
	return phutil_console_format(<<<EOTEXT
	patch __D12345__
	patch __--revision__ __revision_id__
	patch __--diff__ __diff_id__
	patch __--patch__ __file__
	patch __--arcbundle__ __bundlefile__
	- Supports: git, svn
	+ Supports: git, svn, hg
	Apply the changes in a Differential revision, patchfile, or arc
	bundle to the working copy.
	EOTEXT
	);
	}

	public function getArguments() {
	return array(
	'revision' => array(
	'param' => 'revision_id',
	'paramtype' => 'complete',
	'help' =>
	"Apply changes from a Differential revision, using the most recent ".
	"diff that has been attached to it. You can run 'arc patch D12345' ".
	"as a shorthand for this.",
	),
	'diff' => array(
	'param' => 'diff_id',
	'help' =>
	"Apply changes from a Differential diff. Normally you want to use ".
	"--revision to get the most recent changes, but you can ".
	"specifically apply an out-of-date diff or a diff which was never ".
	"attached to a revision by using this flag.",
	),
	'arcbundle' => array(
	'param' => 'bundlefile',
	'paramtype' => 'file',
	'help' =>
	"Apply changes from an arc bundle generated with 'arc export'.",
	),
	'patch' => array(
	'param' => 'patchfile',
	'paramtype' => 'file',
	'help' =>
	"Apply changes from a git patchfile or unified patchfile.",
	),
	+ 'nocommit' => array(
	+ 'supports' => array(
	+ 'git'
	+ ),
	+ 'help' =>
	+ "Normally under git if the patch is successful the changes are ".
	+ "committed to the working copy. This flag prevents the commit.",
	+ ),
	'force' => array(
	'help' =>
	"Do not run any sanity checks.",
	),
	'*' => 'name',
	);
	}

	protected function didParseArguments() {
	$source = null;
	$requested = 0;
	if ($this->getArgument('revision')) {
	$source = self::SOURCE_REVISION;
	$requested++;
	}
	if ($this->getArgument('diff')) {
	$source = self::SOURCE_DIFF;
	$requested++;
	}
	if ($this->getArgument('arcbundle')) {
	$source = self::SOURCE_BUNDLE;
	$requested++;
	}
	if ($this->getArgument('patch')) {
	$source = self::SOURCE_PATCH;
	$requested++;
	}

	$use_revision_id = null;
	if ($this->getArgument('name')) {
	$namev = $this->getArgument('name');
	if (count($namev) > 1) {
	throw new ArcanistUsageException("Specify at most one revision name.");
	}
	$source = self::SOURCE_REVISION;
	$requested++;

	$use_revision_id = $this->normalizeRevisionID(head($namev));
	}

	if ($requested === 0) {
	throw new ArcanistUsageException(
	"Specify one of 'D12345', '--revision <revision_id>' (to select the ".
	"current changes attached to a Differential revision), ".
	"'--diff <diff_id>' (to select a specific, out-of-date diff or a ".
	"diff which is not attached to a revision), '--arcbundle <file>' ".
	"or '--patch <file>' to choose a patch source.");
	} else if ($requested > 1) {
	throw new ArcanistUsageException(
	"Options 'D12345', '--revision', '--diff', '--arcbundle' and ".
	"'--patch' are not compatible. Choose exactly one patch source.");
	}

	$this->source = $source;
	$this->sourceParam = nonempty(
	$use_revision_id,
	$this->getArgument($source));
	}

	public function requiresConduit() {
	return ($this->getSource() != self::SOURCE_PATCH);
	}

	public function requiresRepositoryAPI() {
	return true;
	}

	public function requiresWorkingCopy() {
	return true;
	}

	private function getSource() {
	return $this->source;
	}

	private function getSourceParam() {
	return $this->sourceParam;
	}

	+ private function shouldCommit() {
	+ $no_commit = $this->getArgument('nocommit', false);
	+ if ($no_commit) {
	+ return false;
	+ }
	+
	+ return true;
	+ }
	+
	public function run() {

	$source = $this->getSource();
	$param = $this->getSourceParam();
	try {
	switch ($source) {
	case self::SOURCE_PATCH:
	if ($param == '-') {
	$patch = @file_get_contents('php://stdin');
	if (!strlen($patch)) {
	throw new ArcanistUsageException(
	"Failed to read patch from stdin!");
	}
	} else {
	$patch = Filesystem::readFile($param);
	}
	$bundle = ArcanistBundle::newFromDiff($patch);
	break;
	case self::SOURCE_BUNDLE:
	$path = $this->getArgument('arcbundle');
	$bundle = ArcanistBundle::newFromArcBundle($path);
	break;
	case self::SOURCE_REVISION:
	$bundle = $this->loadRevisionBundleFromConduit(
	$this->getConduit(),
	$param);
	break;
	case self::SOURCE_DIFF:
	$bundle = $this->loadDiffBundleFromConduit(
	$this->getConduit(),
	$param);
	break;
	}
	} catch (Exception $ex) {
	if ($ex->getErrorCode() == 'ERR-INVALID-SESSION') {
	// Phabricator is not configured to allow anonymous access to
	// Differential.
	$this->authenticateConduit();
	return $this->run();
	} else {
	throw $ex;
	}
	}

	$force = $this->getArgument('force', false);
	if ($force) {
	// force means don't do any sanity checks about the patch
	} else {
	$this->sanityCheckPatch($bundle);
	}

	$repository_api = $this->getRepositoryAPI();
	if ($repository_api instanceof ArcanistSubversionAPI) {
	$patch_err = 0;

	$copies = array();
	$deletes = array();
	$patches = array();
	$propset = array();
	$adds = array();
	$symlinks = array();

	$changes = $bundle->getChanges();
	foreach ($changes as $change) {
	$type = $change->getType();
	$should_patch = true;

	$filetype = $change->getFileType();
	switch ($filetype) {
	case ArcanistDiffChangeType::FILE_SYMLINK:
	$should_patch = false;
	$symlinks[] = $change;
	break;
	}

	switch ($type) {
	case ArcanistDiffChangeType::TYPE_MOVE_AWAY:
	case ArcanistDiffChangeType::TYPE_MULTICOPY:
	case ArcanistDiffChangeType::TYPE_DELETE:
	$path = $change->getCurrentPath();
	$fpath = $repository_api->getPath($path);
	if (!@file_exists($fpath)) {
	$ok = phutil_console_confirm(
	"Patch deletes file '{$path}', but the file does not exist in ".
	"the working copy. Continue anyway?");
	if (!$ok) {
	throw new ArcanistUserAbortException();
	}
	} else {
	$deletes[] = $change->getCurrentPath();
	}
	$should_patch = false;
	break;
	case ArcanistDiffChangeType::TYPE_COPY_HERE:
	case ArcanistDiffChangeType::TYPE_MOVE_HERE:
	$path = $change->getOldPath();
	$fpath = $repository_api->getPath($path);
	if (!@file_exists($fpath)) {
	$cpath = $change->getCurrentPath();
	if ($type == ArcanistDiffChangeType::TYPE_COPY_HERE) {
	$verbs = 'copies';
	} else {
	$verbs = 'moves';
	}
	$ok = phutil_console_confirm(
	"Patch {$verbs} '{$path}' to '{$cpath}', but source path ".
	"does not exist in the working copy. Continue anyway?");
	if (!$ok) {
	throw new ArcanistUserAbortException();
	}
	} else {
	$copies[] = array(
	$change->getOldPath(),
	$change->getCurrentPath());
	}
	break;
	case ArcanistDiffChangeType::TYPE_ADD:
	$adds[] = $change->getCurrentPath();
	break;
	}
	if ($should_patch) {
	if ($change->getHunks()) {
	$cbundle = ArcanistBundle::newFromChanges(array($change));
	$patches[$change->getCurrentPath()] = $cbundle->toUnifiedDiff();
	}
	$prop_old = $change->getOldProperties();
	$prop_new = $change->getNewProperties();
	$props = $prop_old + $prop_new;
	foreach ($props as $key => $ignored) {
	if (idx($prop_old, $key) !== idx($prop_new, $key)) {
	$propset[$change->getCurrentPath()][$key] = idx($prop_new, $key);
	}
	}
	}
	}

	// Before we start doing anything, create all the directories we're going
	// to add files to if they don't already exist.
	foreach ($copies as $copy) {
	list($src, $dst) = $copy;
	$this->createParentDirectoryOf($dst);
	}

	foreach ($patches as $path => $patch) {
	$this->createParentDirectoryOf($path);
	}

	foreach ($adds as $add) {
	$this->createParentDirectoryOf($add);
	}

	foreach ($copies as $copy) {
	list($src, $dst) = $copy;
	passthru(
	csprintf(
	'(cd %s; svn cp %s %s)',
	$repository_api->getPath(),
	$src,
	$dst));
	}

	foreach ($deletes as $delete) {
	passthru(
	csprintf(
	'(cd %s; svn rm %s)',
	$repository_api->getPath(),
	$delete));
	}

	foreach ($symlinks as $symlink) {
	$link_target = $symlink->getSymlinkTarget();
	$link_path = $symlink->getCurrentPath();
	switch ($symlink->getType()) {
	case ArcanistDiffChangeType::TYPE_ADD:
	case ArcanistDiffChangeType::TYPE_MODIFY:
	case ArcanistDiffChangeType::TYPE_MOVE_HERE:
	case ArcanistDiffChangeType::TYPE_COPY_HERE:
	execx(
	'(cd %s && ln -sf %s %s)',
	$repository_api->getPath(),
	$link_target,
	$link_path);
	break;
	}
	}

	foreach ($patches as $path => $patch) {
	$tmp = new TempFile();
	Filesystem::writeFile($tmp, $patch);
	$err = null;
	passthru(
	csprintf(
	'(cd %s; patch -p0 < %s)',
	$repository_api->getPath(),
	$tmp),
	$err);
	if ($err) {
	$patch_err = max($patch_err, $err);
	}
	}

	foreach ($adds as $add) {
	passthru(
	csprintf(
	'(cd %s; svn add %s)',
	$repository_api->getPath(),
	$add));
	}

	foreach ($propset as $path => $changes) {
	foreach ($change as $prop => $value) {
	// TODO: Probably need to handle svn:executable specially here by
	// doing chmod +x or -x.
	if ($value === null) {
	passthru(
	csprintf(
	'(cd %s; svn propdel %s %s)',
	$repository_api->getPath(),
	$prop,
	$path));
	} else {
	passthru(
	csprintf(
	'(cd %s; svn propset %s %s %s)',
	$repository_api->getPath(),
	$prop,
	$value,
	$path));
	}
	}
	}

	if ($patch_err == 0) {
	echo phutil_console_format(
	"<bg:green> OKAY </bg> Successfully applied patch to the ".
	"working copy.\n");
	} else {
	echo phutil_console_format(
	"\n\n<bg:yellow> WARNING </bg> Some hunks could not be applied ".
	"cleanly by the unix 'patch' utility. Your working copy may be ".
	"different from the revision's base, or you may be in the wrong ".
	"subdirectory. You can export the raw patch file using ".
	"'arc export --unified', and then try to apply it by fiddling with ".
	"options to 'patch' (particularly, -p), or manually. The output ".
	"above, from 'patch', may be helpful in figuring out what went ".
	"wrong.\n");
	}

	return $patch_err;
	} else if ($repository_api instanceof ArcanistGitAPI) {
	+ // if we're going to commit, we should make sure the working copy
	+ // is clean
	+ if ($this->shouldCommit()) {
	+ $this->requireCleanWorkingCopy();
	+ }
	+
	$future = new ExecFuture(
	'(cd %s; git apply --index --reject)',
	$repository_api->getPath());
	$future->write($bundle->toGitPatch());
	$future->resolvex();

	+ if ($this->shouldCommit()) {
	+ $commit_message = $this->getCommitMessage($bundle);
	+ $future = new ExecFuture(
	+ '(cd %s; git commit -a -F -)',
	+ $repository_api->getPath());
	+ $future->write($commit_message);
	+ $future->resolvex();
	+ $verb = 'committed';
	+ } else {
	+ $verb = 'applied';
	+ }
	echo phutil_console_format(
	- "<bg:green> OKAY </bg> Successfully applied patch.\n");
	+ "<bg:green> OKAY </bg> Successfully {$verb} patch.\n");
	} else if ($repository_api instanceof ArcanistMercurialAPI) {
	$future = new ExecFuture(
	'(cd %s; hg import --no-commit -)',
	$repository_api->getPath());
	$future->write($bundle->toGitPatch());
	$future->resolvex();

	echo phutil_console_format(
	"<bg:green> OKAY </bg> Successfully applied patch.\n");
	} else {
	throw new Exception('Unknown version control system.');
	}

	return 0;
	}

	+ private function getCommitMessage(ArcanistBundle $bundle) {
	+ $revision_id = $bundle->getRevisionID();
	+ $commit_message = null;
	+ $prompt_message = null;
	+
	+ // if we have a revision id the commit message is in differential
	+ if ($revision_id) {
	+ $conduit = $this->getConduit();
	+ $commit_message = $conduit->callMethodSynchronous(
	+ 'differential.getcommitmessage',
	+ array(
	+ 'revision_id' => $revision_id,
	+ ));
	+ $prompt_message = " Note arcanist failed to load the commit message ".
	+ "from differential for revision D{$revision_id}.";
	+ }
	+
	+ // no revision id or failed to fetch commit message so get it from the
	+ // user on the command line
	+ if (!$commit_message) {
	+ $template =
	+ "\n\n".
	+ "# Enter a commit message for this patch. If you just want to apply ".
	+ "the patch to the working copy without committing, re-run arc patch ".
	+ "with the --nocommit flag.".
	+ $prompt_message.
	+ "\n";
	+
	+ $commit_message = id(new PhutilInteractiveEditor($template))
	+ ->setName('arcanist-patch-commit-message')
	+ ->editInteractively();
	+
	+ $commit_message = preg_replace('/^\s#.$/m',
	+ '',
	+ $commit_message);
	+ $commit_message = rtrim($commit_message);
	+ if (!strlen($commit_message)) {
	+ throw new ArcanistUserAbortException();
	+ }
	+ }
	+
	+ return $commit_message;
	+ }
	+
	public function getShellCompletions(array $argv) {
	// TODO: Pull open diffs from 'arc list'?
	return array('ARGUMENT');
	}

	/**
	* Do the best we can to prevent PEBKAC and id10t issues.
	*/
	private function sanityCheckPatch(ArcanistBundle $bundle) {

	// Check to see if the bundle's project id matches the working copy
	// project id
	$bundle_project_id = $bundle->getProjectID();
	$working_copy_project_id = $this->getWorkingCopy()->getProjectID();
	if (empty($bundle_project_id)) {
	// this means $source is SOURCE_PATCH \|\| SOURCE_BUNDLE w/ $version = 0
	// they don't come with a project id so just do nothing
	} else if ($bundle_project_id != $working_copy_project_id) {
	$ok = phutil_console_confirm(
	"This diff is for the '{$bundle_project_id}' project but the working ".
	"copy belongs to the '{$working_copy_project_id}' project. ".
	"Still try to apply it?",
	$default_no = false
	);
	if (!$ok) {
	throw new ArcanistUserAbortException();
	}
	}

	// Check to see if the bundle's base revision matches the working copy
	// base revision
	$bundle_base_rev = $bundle->getBaseRevision();
	if (empty($bundle_base_rev)) {
	// this means $source is SOURCE_PATCH \|\| SOURCE_BUNDLE w/ $version < 2
	// they don't have a base rev so just do nothing
	} else {
	$repository_api = $this->getRepositoryAPI();
	$source_base_rev = $repository_api->getWorkingCopyRevision();

	if ($source_base_rev != $bundle_base_rev) {
	// we have a problem...! lots of work because we need to ask
	// differential for revision information for these base revisions
	// to improve our error message.
	$bundle_base_rev_str = null;
	$source_base_rev_str = null;

	// SVN doesn't store these hashes, so we're basically done already
	// and will have a relatively "lame" error message
	if ($repository_api instanceof ArcanistSubversionAPI) {
	$hash_type = null;
	} else if ($repository_api instanceof ArcanistGitAPI) {
	$hash_type = ArcanistDifferentialRevisionHash::HASH_GIT_COMMIT;
	} else if ($repository_api instanceof ArcanistMercurialAPI) {
	$hash_type = ArcanistDifferentialRevisionHash::HASH_MERCURIAL_COMMIT;
	} else {
	$hash_type = null;
	}

	if ($hash_type) {
	// 2 round trips because even though we could send off one query
	// we wouldn't be able to tell which revisions were for which hash
	$hash = array($hash_type, $bundle_base_rev);
	$bundle_revision = $this->loadRevisionFromHash($hash);
	$hash = array($hash_type, $source_base_rev);
	$source_revision = $this->loadRevisionFromHash($hash);

	if ($bundle_revision) {
	$bundle_base_rev_str = $bundle_base_rev .
	' \ D' . $bundle_revision['id'];
	}
	if ($source_revision) {
	$source_base_rev_str = $source_base_rev .
	' \ D' . $source_revision['id'];
	}
	}
	$bundle_base_rev_str = nonempty($bundle_base_rev_str,
	$bundle_base_rev);
	$source_base_rev_str = nonempty($source_base_rev_str,
	$source_base_rev);

	$ok = phutil_console_confirm(
	"This diff is against commit {$bundle_base_rev_str}, but the ".
	"working copy is at {$source_base_rev_str}. ".
	"Still try to apply it?",
	$default_no = false
	);
	if (!$ok) {
	throw new ArcanistUserAbortException();
	}
	}
	}

	// TODO -- more sanity checks here
	}

	/**
	* Create parent directories one at a time, since we need to "svn add" each
	* one. (Technically we could "svn add" just the topmost new directory.)
	*/
	private function createParentDirectoryOf($path) {
	$repository_api = $this->getRepositoryAPI();
	$dir = dirname($path);
	if (Filesystem::pathExists($dir)) {
	return;
	} else {
	// Make sure the parent directory exists before we make this one.
	$this->createParentDirectoryOf($dir);
	execx(
	'(cd %s && mkdir %s)',
	$repository_api->getPath(),
	$dir);
	passthru(
	csprintf(
	'(cd %s && svn add %s)',
	$repository_api->getPath(),
	$dir));
	}
	}

	private function loadRevisionFromHash($hash) {
	$conduit = $this->getConduit();

	$revisions = $conduit->callMethodSynchronous(
	'differential.query',
	array(
	'commitHashes' => array($hash),
	)
	);


	// grab the latest committed revision only
	$found_revision = null;
	$revisions = isort($revisions, 'dateModified');
	foreach ($revisions as $revision) {
	if ($revision['status'] ==
	ArcanistDifferentialRevisionStatus::COMMITTED) {
	$found_revision = $revision;
	}
	}
	return $found_revision;
	}
	}
	diff --git a/src/workflow/patch/__init__.php b/src/workflow/patch/__init__.php
	index 35015c6f..7e2852ad 100644
	--- a/src/workflow/patch/__init__.php
	+++ b/src/workflow/patch/__init__.php
	@@ -1,25 +1,26 @@
	<?php
	/**
	* This file is automatically generated. Lint this module to rebuild it.
	* @generated
	*/



	phutil_require_module('arcanist', 'differential/constants/revisionhash');
	phutil_require_module('arcanist', 'differential/constants/revisionstatus');
	phutil_require_module('arcanist', 'exception/usage');
	phutil_require_module('arcanist', 'exception/usage/userabort');
	phutil_require_module('arcanist', 'parser/bundle');
	phutil_require_module('arcanist', 'parser/diff/changetype');
	phutil_require_module('arcanist', 'workflow/base');

	phutil_require_module('phutil', 'console');
	+phutil_require_module('phutil', 'console/editor');
	phutil_require_module('phutil', 'filesystem');
	phutil_require_module('phutil', 'filesystem/tempfile');
	phutil_require_module('phutil', 'future/exec');
	phutil_require_module('phutil', 'utils');
	phutil_require_module('phutil', 'xsprintf/csprintf');


	phutil_require_source('ArcanistPatchWorkflow.php');

File Metadata

Mime Type: text/x-diff
Expires: Fri, Nov 22, 17:19 (16 h, 15 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 547718
Default Alt Text: (80 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions