No OneTemporary
Actions

Size

54 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/src/parser/ArcanistBundle.php b/src/parser/ArcanistBundle.php
	index 18222579..4812b0ab 100644
	--- a/src/parser/ArcanistBundle.php
	+++ b/src/parser/ArcanistBundle.php
	@@ -1,758 +1,767 @@
	<?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
	*/
	final class ArcanistBundle {

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

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

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

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

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

	public function setEncoding($encoding) {
	$this->encoding = $encoding;
	return $this;
	}

	public function getEncoding() {
	return $this->encoding;
	}

	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');
	$base_revision = idx($meta_info, 'baseRevision');
	$revision_id = idx($meta_info, 'revisionID');
	$encoding = idx($meta_info, 'encoding');
	// this arc bundle was probably made before we started storing meta info
	} else {
	$version = 0;
	$project_name = null;
	$base_revision = null;
	$revision_id = null;
	$encoding = 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);
	$obj->setEncoding($encoding);

	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' => 3,
	'projectName' => $this->getProjectID(),
	'baseRevision' => $this->getBaseRevision(),
	'revisionID' => $this->getRevisionID(),
	'encoding' => $this->getEncoding(),
	);

	$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) {

	+ $hunk_changes = $this->buildHunkChanges($change->getHunks());
	+ if (!$hunk_changes) {
	+ continue;
	+ }
	+
	$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());
	+ $result[] = $hunk_changes;
	+ }
	+
	+ if (!$result) {
	+ return '';
	}

	$diff = implode("\n", $result)."\n";
	return $this->convertNonUTF8Diff($diff);
	}

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

	$old_file_phids = array();
	foreach ($changes as $change) {
	$type = $change->getType();
	if ($type == ArcanistDiffChangeType::TYPE_MOVE_AWAY) {
	$file_type = $change->getFileType();
	$is_binary = ($file_type == ArcanistDiffChangeType::FILE_BINARY \|\|
	$file_type == ArcanistDiffChangeType::FILE_IMAGE);
	if ($is_binary) {
	foreach ($change->getAwayPaths() as $path) {
	$old_file_phids[$path] = $change->getMetadata('old:binary-phid');
	}
	}
	}
	}

	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) {
	$old_phid = idx($old_file_phids, $this->getCurrentPath($change));
	$change_body = $this->buildBinaryChange($change, $old_phid);
	} 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;
	}

	$diff = implode("\n", $result)."\n";
	return $this->convertNonUTF8Diff($diff);
	}

	private function convertNonUTF8Diff($diff) {
	if ($this->encoding) {
	$diff = phutil_utf8_convert($diff, $this->encoding, 'UTF-8');
	}
	return $diff;
	}

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

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

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

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

	$ii = 0;
	$jj = 0;
	while ($ii < $n) {
	// Skip lines until we find the next line with changes. Note: this skips
	// both ' ' (no changes) and '\' (no newline at end of file) lines. If we
	// don't skip the latter, we may incorrectly generate a terminal hunk
	// that has no actual change information when a file doesn't have a
	// terminal newline and not changed near the end of the file. 'patch' will
	// fail to apply the diff if we generate a hunk that does not actually
	// contain changes.
	for ($jj = $ii; $jj < $n; ++$jj) {
	$char = $lines[$jj][0];
	if ($char == '-' \|\| $char == '+') {
	break;
	}
	}
	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;
	$hunk_adjust = 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] == '\\') {
	// When we have a "\ No newline at end of file" line, it does not
	// contribute to either hunk length.
	++$hunk_adjust;
	} else if ($lines[$jj][0] == '-') {
	++$old_lines;
	} else if ($lines[$jj][0] == '+') {
	++$new_lines;
	}
	}
	}

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

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

	$hunk = new ArcanistDiffHunk();
	$hunk->setOldOffset($old_offset + $hunk_start - $ii);
	$hunk->setNewOffset($new_offset + $hunk_start - $ii);
	$hunk->setOldLength($count_length - $new_lines);
	$hunk->setNewLength($count_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) {
	assert_instances_of($hunks, 'ArcanistDiffHunk');
	$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();

	// NOTE: If the length is 1 it can be omitted. Since git does this,
	// we also do it so that "arc export --git" diffs are as similar to
	// real git diffs as possible, which helps debug issues.

	if ($o_len == 1) {
	$o_head = "{$o_off}";
	} else {
	$o_head = "{$o_off},{$o_len}";
	}

	if ($n_len == 1) {
	$n_head = "{$n_off}";
	} else {
	$n_head = "{$n_off},{$n_len}";
	}

	$result[] = "@@ -{$o_head} +{$n_head} @@";
	$result[] = $corpus;
	}
	}
	return implode("\n", $result);
	}

	public function setLoadFileDataCallback($callback) {
	$this->loadFileDataCallback = $callback;
	return $this;
	}

	private function getBlob($phid) {
	if ($this->loadFileDataCallback) {
	return call_user_func($this->loadFileDataCallback, $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) {
	$old_phid = idx($change->getAllMetadata(), 'old:binary-phid', $old_phid);
	$new_phid = $change->getMetadata('new:binary-phid');

	if (!$old_phid) {
	$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_phid) {
	$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) {
	if (!function_exists('gzcompress')) {
	throw new Exception(
	"This patch has binary data. The PHP zlib extension is required to ".
	"apply patches with binary data to git. Install the PHP zlib ".
	"extension to continue.");
	}

	// 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 .= self::encodeBase85($line);
	$buf .= "\n";
	}

	$buf .= "\n";

	return $buf;
	}

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

	// It is also implemeted awkwardly to work correctly on 32-bit machines.
	// Broadly, this algorithm converts the binary input to printable output
	// by transforming each 4 binary bytes of input to 5 printable bytes of
	// output, one piece at a time.
	//
	// To do this, we convert the 4 bytes into a 32-bit integer, then use
	// modulus and division by 85 to pick out printable bytes (85^5 is slightly
	// larger than 2^32). In C, this algorithm is fairly easy to implement
	// because the accumulator can be made unsigned.
	//
	// In PHP, there are no unsigned integers, so values larger than 2^31 break
	// on 32-bit systems under modulus:
	//
	// $ php -r 'print (1 << 31) % 13;' # On a 32-bit machine.
	// -11
	//
	// However, PHP's float type is an IEEE 754 64-bit double precision float,
	// so we can safely store integers up to around 2^53 without loss of
	// precision. To work around the lack of an unsigned type, we just use a
	// double and perform the modulus with fmod().
	//
	// (Since PHP overflows integer operations into floats, we don't need much
	// additional casting.)

	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 = $val * (1 << $count);
	$accum = $accum + $val;
	if (--$bytes == 0) {
	break;
	}
	}
	$slice = '';
	for ($count = 4; $count >= 0; $count--) {
	$val = (int)fmod($accum, 85.0);
	$accum = floor($accum / 85.0);
	$slice .= $map[$val];
	}
	$buf .= strrev($slice);
	}

	return $buf;
	}

	}
	diff --git a/src/workflow/ArcanistPatchWorkflow.php b/src/workflow/ArcanistPatchWorkflow.php
	index 22a9fa25..7caab84b 100644
	--- a/src/workflow/ArcanistPatchWorkflow.php
	+++ b/src/workflow/ArcanistPatchWorkflow.php
	@@ -1,946 +1,953 @@
	<?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 getCommandSynopses() {
	return phutil_console_format(<<<EOTEXT
	patch __D12345__
	patch __--revision__ __revision_id__
	patch __--diff__ __diff_id__
	patch __--patch__ __file__
	patch __--arcbundle__ __bundlefile__
	EOTEXT
	);
	}

	public function getCommandHelp() {
	return phutil_console_format(<<<EOTEXT
	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.",
	),
	'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.",
	),
	'encoding' => array(
	'param' => 'encoding',
	'help' =>
	"Attempt to convert non UTF-8 patch into specified encoding.",
	),
	'update' => array(
	'supports' => array(
	'git', 'svn', 'hg'
	),
	'help' =>
	"Update the local working copy before applying the patch.",
	'conflicts' => array(
	'nobranch' => true,
	'bookmark' => true,
	),
	),
	'nocommit' => array(
	'supports' => array(
	'git', 'hg'
	),
	'help' =>
	"Normally under git/hg, if the patch is successful, the changes ".
	"are committed to the working copy. This flag prevents the commit.",
	),
	'nobranch' => array(
	'supports' => array(
	'git'
	),
	'help' =>
	"Normally under git, a new branch is created and then the patch ".
	"is applied and committed in the new branch. This flag skips the ".
	"branch creation step and applies and commits the patch to the ".
	"current branch.",
	'conflicts' => array(
	'update' => true,
	),
	),
	'bookmark' => array(
	'supports' => array(
	'hg'
	),
	'help' =>
	"Normally under hg, a new bookmark is not created and the patch ".
	"is applied and committed in the current bookmark. With this flag, ".
	"a new bookmark is created and the patch is applied and committed ".
	"in the new bookmark.",
	'conflicts' => array(
	'update' => true,
	),
	),
	'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;
	}

	private function shouldBranch() {
	// git only for now
	$repository_api = $this->getRepositoryAPI();
	if (!($repository_api instanceof ArcanistGitAPI)) {
	return false;
	}

	$no_branch = $this->getArgument('nobranch', false);
	if ($no_branch) {
	return false;
	}

	return true;
	}

	private function shouldBookmark() {
	// specific to hg
	$repository_api = $this->getRepositoryAPI();
	if (!($repository_api instanceof ArcanistMercurialAPI)) {
	return false;
	}

	$bookmark = $this->getArgument('bookmark', false);
	if ($bookmark) {
	return true;
	}

	return false;
	}


	private function getBranchName(ArcanistBundle $bundle) {
	$branch_name = null;
	$repository_api = $this->getRepositoryAPI();
	$revision_id = $bundle->getRevisionID();
	$base_name = "arcpatch";
	if ($revision_id) {
	$base_name .= "-D{$revision_id}";
	}

	$suffixes = array(null, '-1', '-2', '-3');
	foreach ($suffixes as $suffix) {
	$proposed_name = $base_name.$suffix;

	list($err) = $repository_api->execManualLocal(
	'rev-parse --verify %s',
	$proposed_name);

	// no error means git rev-parse found a branch
	if (!$err) {
	echo phutil_console_format(
	"Branch name {$proposed_name} already exists; trying a new name.\n"
	);
	continue;
	} else {
	$branch_name = $proposed_name;
	break;
	}
	}

	if (!$branch_name) {
	throw new Exception(
	"Arc was unable to automagically make a name for this patch. ".
	"Please clean up your working copy and try again."
	);
	}

	return $branch_name;
	}

	private function getBookmarkName(ArcanistBundle $bundle) {
	$bookmark_name = null;
	$repository_api = $this->getRepositoryAPI();
	$revision_id = $bundle->getRevisionID();
	$base_name = "arcpatch";
	if ($revision_id) {
	$base_name .= "-D{$revision_id}";
	}

	$suffixes = array(null, '-1', '-2', '-3');
	foreach ($suffixes as $suffix) {
	$proposed_name = $base_name.$suffix;

	list($err) = $repository_api->execManualLocal(
	'log -r %s',
	$proposed_name);

	// no error means hg log found a bookmark
	if (!$err) {
	echo phutil_console_format(
	"Bookmark name {$proposed_name} already exists; trying a new name.\n"
	);
	continue;
	} else {
	$bookmark_name = $proposed_name;
	break;
	}
	}

	if (!$bookmark_name) {
	throw new Exception(
	"Arc was unable to automagically make a name for this patch. ".
	"Please clean up your working copy and try again."
	);
	}

	return $bookmark_name;
	}

	private function createBranch(ArcanistBundle $bundle) {
	$branch_name = $this->getBranchName($bundle);
	$repository_api = $this->getRepositoryAPI();
	$base_revision = $bundle->getBaseRevision();

	// verify the base revision is valid
	// in a working copy that uses the git-svn bridge, the base revision might
	// be a svn uri instead of a git ref

	// NOTE: Use 'cat-file', not 'rev-parse --verify', because 'rev-parse'
	// always "verifies" any properly-formatted commit even if it does not
	// exist.
	list($err) = $repository_api->execManualLocal(
	'cat-file -t %s',
	$base_revision);

	if ($base_revision && !$err) {
	$repository_api->execxLocal(
	'checkout -b %s %s',
	$branch_name,
	$base_revision);
	} else {
	$repository_api->execxLocal(
	'checkout -b %s',
	$branch_name);
	}

	echo phutil_console_format(
	"Created and checked out branch %s.\n",
	$branch_name);
	}

	private function createBookmark(ArcanistBundle $bundle) {
	$bookmark_name = $this->getBookmarkName($bundle);
	$repository_api = $this->getRepositoryAPI();

	$repository_api->execxLocal(
	'bookmark %s',
	$bookmark_name);

	echo phutil_console_format(
	"Created and applied bookmark %s.\n",
	$bookmark_name);
	}

	private function shouldUpdateWorkingCopy() {
	return $this->getArgument('update', false);
	}

	private function updateWorkingCopy() {
	echo "Updating working copy...\n";
	$this->getRepositoryAPI()->updateWorkingCopy();
	echo "Done.\n";
	}

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

	$try_encoding = nonempty($this->getArgument('encoding'), null);
	if (!$try_encoding) {
	if ($this->requiresConduit()) {
	try {
	$try_encoding = $this->getRepositoryEncoding();
	} catch (ConduitClientException $e) {
	$try_encoding = null;
	}
	}
	}

	if ($try_encoding) {
	$bundle->setEncoding($try_encoding);
	}

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

	// we should update the working copy before we do ANYTHING else
	if ($this->shouldUpdateWorkingCopy()) {
	$this->updateWorkingCopy();
	}

	if ($this->shouldBranch()) {
	$this->createBranch($bundle);
	}

	if ($this->shouldBookmark()) {
	$this->createBookmark($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();
	- }
	+ $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);
	}

	// TODO: The SVN patch workflow likely does not work on windows because
	// of the (cd ...) stuff.

	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_CHANGE:
	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 ($patch) {
	+ $tmp = new TempFile();
	+ Filesystem::writeFile($tmp, $patch);
	+ passthru(
	+ csprintf(
	+ '(cd %s; patch -p0 < %s)',
	+ $repository_api->getPath(),
	+ $tmp),
	+ $err);
	+ } else {
	+ passthru(
	+ csprintf(
	+ '(cd %s; touch %s)',
	+ $repository_api->getPath(),
	+ $path),
	+ $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 ($changes 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) {
	$future = $repository_api->execFutureLocal(
	'apply --index --reject');
	$future->write($bundle->toGitPatch());

	try {
	$future->resolvex();
	} catch (CommandException $ex) {
	echo phutil_console_format(
	"\n<bg:red> Patch Failed! </bg>\n");
	$stderr = $ex->getStdErr();
	if (preg_match('/already exists in working directory/', $stderr)) {
	echo phutil_console_wrap(
	phutil_console_format(
	"\n<bg:yellow> WARNING </bg> This patch may have failed ".
	"because it attempts to change the case of a filename (for ".
	"instance, from 'example.c' to 'Example.c'). Git cannot apply ".
	"patches like this on case-insensitive filesystems. You must ".
	"apply this patch manually.\n"));
	}
	throw $ex;
	}

	if ($this->shouldCommit()) {
	$commit_message = $this->getCommitMessage($bundle);
	$future = $repository_api->execFutureLocal(
	'commit -a -F -');
	$future->write($commit_message);
	$future->resolvex();
	$verb = 'committed';
	} else {
	$verb = 'applied';
	}
	echo phutil_console_format(
	"<bg:green> OKAY </bg> Successfully {$verb} patch.\n");
	} else if ($repository_api instanceof ArcanistMercurialAPI) {

	$future = $repository_api->execFutureLocal(
	'import --no-commit -');
	$future->write($bundle->toGitPatch());

	try {
	$future->resolvex();
	} catch (CommandException $ex) {
	echo phutil_console_format(
	"\n<bg:red> Patch Failed! </bg>\n");
	$stderr = $ex->getStdErr();
	if (preg_match('/case-folding collision/', $stderr)) {
	echo phutil_console_wrap(
	phutil_console_format(
	"\n<bg:yellow> WARNING </bg> This patch may have failed ".
	"because it attempts to change the case of a filename (for ".
	"instance, from 'example.c' to 'Example.c'). Mercurial cannot ".
	"apply patches like this on case-insensitive filesystems. You ".
	"must apply this patch manually.\n"));
	}
	throw $ex;
	}

	if ($this->shouldCommit()) {
	$commit_message = $this->getCommitMessage($bundle);
	$future = $repository_api->execFutureLocal(
	'commit -A -l -');
	$future->write($commit_message);
	$future->resolvex();
	$verb = 'committed';
	} else {
	$verb = 'applied';
	}
	echo phutil_console_format(
	"<bg:green> OKAY </bg> Successfully {$verb} 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

	// TODO: See T848 for the authenticated stuff.
	if ($revision_id && $this->isConduitAuthenticated()) {

	$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 = $this->newInteractiveEditor($template)
	->setName('arcanist-patch-commit-message')
	->editInteractively();

	$commit_message = ArcanistCommentRemover::removeComments($commit_message);
	if (!strlen(trim($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 sanityCheck(ArcanistBundle $bundle) {

	// Require clean working copy
	$this->requireCleanWorkingCopy();

	// 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) {
	if ($working_copy_project_id) {
	$issue =
	"This patch is for the '{$bundle_project_id}' project, but the ".
	"working copy belongs to the '{$working_copy_project_id}' project.";
	} else {
	$issue =
	"This patch is for the '{$bundle_project_id}' project, but the ".
	"working copy does not have an '.arcconfig' file to identify which ".
	"project it belongs to.";
	}
	$ok = phutil_console_confirm(
	"{$issue} Still try to apply the patch?",
	$default_no = false
	);
	if (!$ok) {
	throw new ArcanistUserAbortException();
	}
	}

	// Check to see if the bundle's base revision matches the working copy
	// base revision
	$repository_api = $this->getRepositoryAPI();
	if ($repository_api->supportsRelativeLocalCommits()) {
	$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
	$commit_exists = true;
	} else {
	$commit_exists =
	$repository_api->hasLocalCommit($bundle_base_rev);
	}
	if (!$commit_exists) {
	// 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 = $repository_api->getWorkingCopyRevision();
	$source_base_rev_str = null;

	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 ".
	"commit is nowhere in the working copy. Try to apply it against ".
	"the current working copy state? ({$source_base_rev_str})",
	$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) {
	// TODO -- de-hack this as permissions become more clear with things
	// like T848 (add scope to OAuth)
	if (!$this->isConduitAuthenticated()) {
	return null;
	}

	$conduit = $this->getConduit();

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


	// grab the latest closed revision only
	$found_revision = null;
	$revisions = isort($revisions, 'dateModified');
	foreach ($revisions as $revision) {
	if ($revision['status'] == ArcanistDifferentialRevisionStatus::CLOSED) {
	$found_revision = $revision;
	}
	}
	return $found_revision;
	}
	}

File Metadata

Mime Type: text/x-diff
Expires: Sat, Nov 8, 06:33 (1 d, 13 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1034174
Default Alt Text: (54 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions