No OneTemporary
Actions

Size

79 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/scripts/arcanist.php b/scripts/arcanist.php
	index f73fdc29..785f4f8a 100755
	--- a/scripts/arcanist.php
	+++ b/scripts/arcanist.php
	@@ -1,411 +1,421 @@
	#!/usr/bin/env php
	<?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.
	*/

	sanity_check_environment();

	require_once dirname(__FILE__).'/__init_script__.php';

	phutil_require_module('phutil', 'conduit/client');
	phutil_require_module('phutil', 'console');
	phutil_require_module('phutil', 'future/exec');
	phutil_require_module('phutil', 'filesystem');
	phutil_require_module('phutil', 'symbols');

	phutil_require_module('arcanist', 'exception/usage');
	phutil_require_module('arcanist', 'configuration');
	phutil_require_module('arcanist', 'workingcopyidentity');
	phutil_require_module('arcanist', 'repository/api/base');

	ini_set('memory_limit', -1);

	$original_argv = $argv;
	$args = new PhutilArgumentParser($argv);
	$args->parseStandardArguments();

	$argv = $args->getUnconsumedArgumentVector();
	$config_trace_mode = $args->getArg('trace');

	$force_conduit = null;
	$args = $argv;
	$load = array();
	$matches = null;
	foreach ($args as $key => $arg) {
	if ($arg == '--') {
	break;
	} else if (preg_match('/^--load-phutil-library=(.*)$/', $arg, $matches)) {
	unset($args[$key]);
	$load[] = $matches[1];
	} else if (preg_match('/^--conduit-uri=(.*)$/', $arg, $matches)) {
	unset($args[$key]);
	$force_conduit = $matches[1];
	}
	}

	$args = array_values($args);
	$working_directory = getcwd();

	try {

	if (!$args) {
	throw new ArcanistUsageException("No command provided. Try 'arc help'.");
	}

	$working_copy = ArcanistWorkingCopyIdentity::newFromPath($working_directory);
	if ($load) {
	$libs = $load;
	} else {
	$libs = $working_copy->getConfig('phutil_libraries');
	}
	if ($libs) {
	foreach ($libs as $name => $location) {

	// Try to resolve the library location. We look in several places, in
	// order:
	//
	// 1. Inside the working copy. This is for phutil libraries within the
	// project. For instance "library/src" will resolve to
	// "./library/src" if it exists.
	// 2. In the same directory as the working copy. This allows you to
	// check out a library alongside a working copy and reference it.
	// If we haven't resolved yet, "library/src" will try to resolve to
	// "../library/src" if it exists.
	// 3. Using normal libphutil resolution rules. Generally, this means
	// that it checks for libraries next to libphutil, then libraries
	// in the PHP include_path.

	$resolved = false;

	// Check inside the working copy.
	$resolved_location = Filesystem::resolvePath(
	$location,
	$working_copy->getProjectRoot());
	if (Filesystem::pathExists($resolved_location)) {
	$location = $resolved_location;
	$resolved = true;
	}

	// If we didn't find anything, check alongside the working copy.
	if (!$resolved) {
	$resolved_location = Filesystem::resolvePath(
	$location,
	dirname($working_copy->getProjectRoot()));
	if (Filesystem::pathExists($resolved_location)) {
	$location = $resolved_location;
	$resolved = true;
	}
	}

	if ($config_trace_mode) {
	echo "Loading phutil library '{$name}' from '{$location}'...\n";
	}

	try {
	phutil_load_library($location);
	} catch (PhutilBootloaderException $ex) {
	$error_msg = sprintf(
	'Failed to load library "%s" at location "%s". Please check the '.
	'"phutil_libraries" setting in your .arcconfig file. Refer to '.
	'<http://www.phabricator.com/docs/phabricator/article/'.
	'Arcanist_User_Guide_Configuring_a_New_Project.html> '.
	'for more information.',
	$name,
	$location);
	throw new ArcanistUsageException($error_msg);
	} catch (PhutilLibraryConflictException $ex) {
	if ($ex->getLibrary() != 'arcanist') {
	throw $ex;
	}

	$arc_dir = dirname(dirname(__FILE__));
	$error_msg =
	"You are trying to run one copy of Arcanist on another copy of ".
	"Arcanist. This operation is not supported. To execute Arcanist ".
	"operations against this working copy, run './bin/arc' (from the ".
	"current working copy) not some other copy of 'arc' (you ran one ".
	"from '{$arc_dir}').";

	throw new ArcanistUsageException($error_msg);
	}
	}
	}

	$user_config = ArcanistBaseWorkflow::readUserConfigurationFile();
	+ $global_config = ArcanistBaseWorkflow::readGlobalArcConfig();

	$config = $working_copy->getConfig('arcanist_configuration');
	if ($config) {
	PhutilSymbolLoader::loadClass($config);
	$config = new $config();
	} else {
	$config = new ArcanistConfiguration();
	}

	$command = strtolower($args[0]);
	$args = array_slice($args, 1);
	$workflow = $config->buildWorkflow($command);
	if (!$workflow) {

	// If the user has an alias, like 'arc alias dhelp diff help', look it up
	// and substitute it. We do this only after trying to resolve the workflow
	// normally to prevent you from doing silly things like aliasing 'alias'
	// to something else.

	list($new_command, $args) = ArcanistAliasWorkflow::resolveAliases(
	$command,
	$config,
	$args,
	$working_copy);

	if ($new_command) {
	$workflow = $config->buildWorkflow($new_command);
	}

	if (!$workflow) {
	throw new ArcanistUsageException(
	"Unknown command '{$command}'. Try 'arc help'.");
	} else {
	if ($config_trace_mode) {
	$aliases = ArcanistAliasWorkflow::getAliases($working_copy);
	$target = implode(' ', idx($aliases, $command, array()));
	echo "[alias: 'arc {$command}' -> 'arc {$target}']\n";
	}
	$command = $new_command;
	}
	}
	$workflow->setArcanistConfiguration($config);
	$workflow->setCommand($command);
	$workflow->setWorkingDirectory($working_directory);
	$workflow->parseArguments($args);

	$need_working_copy = $workflow->requiresWorkingCopy();
	$need_conduit = $workflow->requiresConduit();
	$need_auth = $workflow->requiresAuthentication();
	$need_repository_api = $workflow->requiresRepositoryAPI();

	$need_conduit = $need_conduit \|\|
	$need_auth;
	$need_working_copy = $need_working_copy \|\|
	- $need_conduit \|\|
	$need_repository_api;

	if ($need_working_copy) {
	if (!$working_copy->getProjectRoot()) {
	throw new ArcanistUsageException(
	- "There is no '.arcconfig' file in this directory or any parent ".
	- "directory. Create a '.arcconfig' file to configure this project ".
	- "for use with Arcanist.");
	+ "This command must be run in a Git, Mercurial or Subversion working ".
	+ "copy.");
	}
	$workflow->setWorkingCopy($working_copy);
	}

	-
	if ($force_conduit) {
	$conduit_uri = $force_conduit;
	} else {
	- $conduit_uri = $working_copy->getConduitURI();
	+ if ($working_copy->getConduitURI()) {
	+ $conduit_uri = $working_copy->getConduitURI();
	+ } else {
	+ $conduit_uri = idx($global_config, 'default');
	+ }
	}
	if ($conduit_uri) {
	// Set the URI path to '/api/'. TODO: Originally, I contemplated letting
	// you deploy Phabricator somewhere other than the domain root, but ended
	// up never pursuing that. We should get rid of all "/api/" silliness
	// in things users are expected to configure. This is already happening
	// to some degree, e.g. "arc install-certificate" does it for you.
	$conduit_uri = new PhutilURI($conduit_uri);
	$conduit_uri->setPath('/api/');
	$conduit_uri = (string)$conduit_uri;
	}
	$workflow->setConduitURI($conduit_uri);

	if ($need_conduit) {
	if (!$conduit_uri) {
	- throw new ArcanistUsageException(
	- "No Conduit URI is specified in the .arcconfig file for this project. ".
	- "Specify the Conduit URI for the host Differential is running on.");
	+
	+ $message = phutil_console_format(
	+ "This command requires arc to connect to a Phabricator install, but ".
	+ "no Phabricator installation is configured. To configure a ".
	+ "Phabricator URI:\n\n".
	+ " - set a default location with `arc set-config default <uri>`; or\n".
	+ " - specify '--conduit-uri=uri' explicitly; or\n".
	+ " - run 'arc' in a working copy with an '.arcconfig'.\n");
	+
	+ $message = phutil_console_wrap($message);
	+ throw new ArcanistUsageException($message);
	}
	$workflow->establishConduit();
	}

	$hosts_config = idx($user_config, 'hosts', array());
	$host_config = idx($hosts_config, $conduit_uri, array());
	$user_name = idx($host_config, 'user');
	$certificate = idx($host_config, 'cert');

	$description = implode(' ', $original_argv);
	$credentials = array(
	'user' => $user_name,
	'certificate' => $certificate,
	'description' => $description,
	);
	$workflow->setConduitCredentials($credentials);

	if ($need_auth) {
	if (!$user_name \|\| !$certificate) {
	throw new ArcanistUsageException(
	phutil_console_format(
	"YOU NEED TO __INSTALL A CERTIFICATE__ TO LOGIN TO PHABRICATOR\n\n".
	"You are trying to connect to '{$conduit_uri}' but do not have ".
	"a certificate installed for this host. Run:\n\n".
	" $ arc install-certificate\n\n".
	"...to install one."));
	}
	$workflow->authenticateConduit();
	}

	if ($need_repository_api) {
	$repository_api = ArcanistRepositoryAPI::newAPIFromWorkingCopyIdentity(
	$working_copy);
	$workflow->setRepositoryAPI($repository_api);
	}

	$listeners = $working_copy->getConfig('events.listeners');
	if ($listeners) {
	foreach ($listeners as $listener) {
	id(new $listener())->register();
	}
	}

	$config->willRunWorkflow($command, $workflow);
	$workflow->willRunWorkflow();
	$err = $workflow->run();
	$config->didRunWorkflow($command, $workflow, $err);
	exit($err);

	} catch (ArcanistUsageException $ex) {
	echo phutil_console_format(
	"Usage Exception: %s\n",
	$ex->getMessage());
	if ($config_trace_mode) {
	echo "\n";
	throw $ex;
	}

	exit(1);
	} catch (Exception $ex) {
	if ($config_trace_mode) {
	throw $ex;
	}

	echo phutil_console_format(
	"\nException:\n%s\n%s\n",
	$ex->getMessage(),
	"(Run with --trace for a full exception trace.)");

	exit(1);
	}


	/**
	* Perform some sanity checks against the possible diversity of PHP builds in
	* the wild, like very old versions and builds that were compiled with flags
	* that exclude core functionality.
	*/
	function sanity_check_environment() {
	$min_version = '5.2.3';
	$cur_version = phpversion();
	if (version_compare($cur_version, $min_version, '<')) {
	die_with_bad_php(
	"You are running PHP version '{$cur_version}', which is older than ".
	"the minimum version, '{$min_version}'. Update to at least ".
	"'{$min_version}'.");
	}

	// NOTE: We don't have phutil_is_windows() yet here.

	if (DIRECTORY_SEPARATOR != '/') {
	$need_functions = array(
	'curl_init' => array('builtin-dll', 'php_curl.dll'),
	);
	} else {
	$need_functions = array(
	'curl_init' => array(
	'text',
	"You need to install the cURL PHP extension, maybe with ".
	"'apt-get install php5-curl' or 'yum install php53-curl' or ".
	"something similar."),
	'json_decode' => array('flag', '--without-json'),
	);
	}

	$problems = array();

	$config = null;
	$show_config = false;
	foreach ($need_functions as $fname => $resolution) {
	if (function_exists($fname)) {
	continue;
	}

	static $info;
	if ($info === null) {
	ob_start();
	phpinfo(INFO_GENERAL);
	$info = ob_get_clean();
	$matches = null;
	if (preg_match('/^Configure Command =>\s(.?)$/m', $info, $matches)) {
	$config = $matches[1];
	}
	}

	$generic = true;
	list($what, $which) = $resolution;

	if ($what == 'flag' && strpos($config, $which) !== false) {
	$show_config = true;
	$generic = false;
	$problems[] =
	"This build of PHP was compiled with the configure flag '{$which}', ".
	"which means it does not have the function '{$fname}()'. This ".
	"function is required for arc to run. Rebuild PHP without this flag. ".
	"You may also be able to build or install the relevant extension ".
	"separately.";
	}

	if ($what == 'builtin-dll') {
	$generic = false;
	$problems[] =
	"Your install of PHP does not have the '{$which}' extension enabled. ".
	"Edit your php.ini file and uncomment the line which reads ".
	"'extension={$which}'.";
	}

	if ($what == 'text') {
	$generic = false;
	$problems[] = $which;
	}

	if ($generic) {
	$problems[] =
	"This build of PHP is missing the required function '{$fname}()'. ".
	"Rebuild PHP or install the extension which provides '{$fname}()'.";
	}
	}

	if ($problems) {
	if ($show_config) {
	$problems[] = "PHP was built with this configure command:\n\n{$config}";
	}
	die_with_bad_php(implode("\n\n", $problems));
	}
	}

	function die_with_bad_php($message) {
	echo "\nPHP CONFIGURATION ERRORS\n\n";
	echo $message;
	echo "\n\n";
	exit(1);
	}
	diff --git a/src/repository/api/subversion/ArcanistSubversionAPI.php b/src/repository/api/subversion/ArcanistSubversionAPI.php
	index 84986d14..ca987ba8 100644
	--- a/src/repository/api/subversion/ArcanistSubversionAPI.php
	+++ b/src/repository/api/subversion/ArcanistSubversionAPI.php
	@@ -1,559 +1,563 @@
	<?php

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

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

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

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

	private $svnBaseRevisionNumber;

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

	protected function buildLocalFuture(array $argv) {

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

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


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

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

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

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

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

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

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

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

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

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

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

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

	$files[$path] = $mask;
	}

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

	$this->svnStatus = $files;
	}

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

	return $status;
	}

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

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

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

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

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

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

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

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

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

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

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

	public function getSVNInfo($path) {

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

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

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

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

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

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

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

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

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


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

	$status = $status[$path];

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

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

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

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

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

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

	return $stdout;
	}

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

	EODIFF;
	}

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

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

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

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

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

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

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

	if (!file_exists($full_path)) {
	return null;
	}

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

	EODIFF;
	}

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

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

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

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

	return $blame;
	}

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

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

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

	public function getLocalCommitInformation() {
	return null;
	}

	public function supportsRelativeLocalCommits() {
	return false;
	}

	public function hasLocalCommit($commit) {
	return false;
	}

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

	public function supportsLocalBranchMerge() {
	return false;
	}

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

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

	// We don't have much to go on in SVN, look for revisions that came from
	// this directory and belong to the same project.

	$project = $this->getWorkingCopyIdentity()->getProjectID();
	+ if (!$project) {
	+ return array();
	+ }
	+
	$results = $conduit->callMethodSynchronous(
	'differential.query',
	$query + array(
	'arcanistProjects' => array($project),
	));

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

	return $results;
	}

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

	}
	diff --git a/src/workflow/base/ArcanistBaseWorkflow.php b/src/workflow/base/ArcanistBaseWorkflow.php
	index fe5ca40b..cfb5e204 100644
	--- a/src/workflow/base/ArcanistBaseWorkflow.php
	+++ b/src/workflow/base/ArcanistBaseWorkflow.php
	@@ -1,1114 +1,1123 @@
	<?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.
	*
	* = Scratch Files =
	*
	* Arcanist workflows can read and write 'scratch files', which are temporary
	* files stored in the project that persist across commands. They can be useful
	* if you want to save some state, or keep a copy of a long message the user
	* entered in something goes wrong..
	*
	*
	* @task conduit Conduit
	* @task scratch Scratch Files
	* @group workflow
	* @stable
	*/
	abstract class ArcanistBaseWorkflow {

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

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

	private $repositoryEncoding;

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

	/**
	* Returns the URI the conduit connection within the workflow uses.
	*
	* @return string
	* @task conduit
	*/
	final public function getConduitURI() {
	return $this->conduitURI;
	}

	/**
	* 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->isConduitAuthenticated()) {
	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->isConduitAuthenticated()) {
	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' => 4,
	'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;
	}

	/**
	* @return bool True if conduit is authenticated, false otherwise.
	* @task conduit
	*/
	final protected function isConduitAuthenticated() {
	return (bool) $this->conduitAuthenticated;
	}


	/**
	* 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 getCommandSynopses() {
	return get_class($this).": Undocumented";
	}

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

	// Exempt ".arc/" scratch files from this warning so that things work
	// a little more smoothly if no one has gotten around to adding .arc to
	// the ignore list.
	foreach ($untracked as $key => $path) {
	if (preg_match('@\.arc/@', $path)) {
	unset($untracked[$key]);
	}
	}

	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 ArcanistUncommittedChangesException(
	"You have uncommitted changes in this working copy. Commit (or ".
	"revert) them before proceeding.\n\n".
	$working_copy_desc.
	" Uncommitted changes in working copy\n".
	" ".implode("\n ", $uncommitted)."\n");
	}
	}


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

	if (!file_exists($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() {
	if (phutil_is_windows()) {
	return getenv('APPDATA').'/.arcrc';
	} else {
	return getenv('HOME').'/.arcrc';
	}
	}

	public static function readUserConfigurationFile() {
	$user_config = array();
	$user_config_path = self::getUserConfigurationFileLocation();
	if (Filesystem::pathExists($user_config_path)) {

	if (!phutil_is_windows()) {
	$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;
	}


	public static function writeUserConfigurationFile($config) {
	$json_encoder = new PhutilJSON();
	$json = $json_encoder->encodeFormatted($config);

	$path = self::getUserConfigurationFileLocation();
	Filesystem::writeFile($path, $json);

	if (!phutil_is_windows()) {
	execx('chmod 600 %s', $path);
	}
	}

	- protected function readGlobalArcConfig() {
	+ public static function readGlobalArcConfig() {
	return idx(self::readUserConfigurationFile(), 'config', array());
	}

	- protected function writeGlobalArcConfig(array $options) {
	+ public static function writeGlobalArcConfig(array $options) {
	$config = self::readUserConfigurationFile();
	$config['config'] = $options;
	self::writeUserConfigurationFile($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.
	* @param mask Mask of ArcanistRepositoryAPI flags to exclude.
	* Defaults to ArcanistRepositoryAPI::FLAG_UNTRACKED.
	* @return list List of paths the workflow should act on.
	*/
	protected function selectPathsForWorkflow(
	array $paths,
	$rev,
	$omit_mask = null) {

	if ($omit_mask === null) {
	$omit_mask = ArcanistRepositoryAPI::FLAG_UNTRACKED;
	}

	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 & $omit_mask) {
	unset($paths[$path]);
	}
	}
	$paths = array_keys($paths);
	}

	return array_values($paths);
	}

	protected function renderRevisionList(array $revisions) {
	$list = array();
	foreach ($revisions as $revision) {
	$list[] = ' - D'.$revision['id'].': '.$revision['title']."\n";
	}
	return implode('', $list);
	}


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


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


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


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


	/**
	* Get a human-readable description of the scratch file location.
	*
	* @param string Scratch file name.
	* @return mixed String, or false on failure.
	* @task scratch
	*/
	protected function getReadableScratchFilePath($path) {
	if (!$this->repositoryAPI) {
	return false;
	}
	return $this->getRepositoryAPI()->getReadableScratchFilePath($path);
	}


	/**
	* Get the path to a scratch file, if possible.
	*
	* @param string Scratch file name.
	* @return mixed File path, or false on failure.
	* @task scratch
	*/
	protected function getScratchFilePath($path) {
	if (!$this->repositoryAPI) {
	return false;
	}
	return $this->getRepositoryAPI()->getScratchFilePath($path);
	}

	protected function getRepositoryEncoding() {
	if ($this->repositoryEncoding) {
	return $this->repositoryEncoding;
	}

	+ $default = 'UTF-8';
	+
	+ $project_id = $this->getWorkingCopy()->getProjectID();
	+ if (!$project_id) {
	+ return $default;
	+ }
	+
	$project_info = $this->getConduit()->callMethodSynchronous(
	'arcanist.projectinfo',
	array(
	- 'name' => $this->getWorkingCopy()->getProjectID(),
	+ 'name' => $project_id,
	));
	- $this->repositoryEncoding = nonempty($project_info['encoding'], 'UTF-8');
	+
	+ $this->repositoryEncoding = nonempty($project_info['encoding'], $default);
	+
	return $this->repositoryEncoding;
	}

	}
	diff --git a/src/workflow/close-revision/ArcanistCloseRevisionWorkflow.php b/src/workflow/close-revision/ArcanistCloseRevisionWorkflow.php
	index cb24081d..390dea10 100644
	--- a/src/workflow/close-revision/ArcanistCloseRevisionWorkflow.php
	+++ b/src/workflow/close-revision/ArcanistCloseRevisionWorkflow.php
	@@ -1,174 +1,177 @@
	<?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.
	*/

	/**
	* Explicitly closes Differential revisions.
	*
	* @group workflow
	*/
	final class ArcanistCloseRevisionWorkflow extends ArcanistBaseWorkflow {

	public function getCommandSynopses() {
	return phutil_console_format(<<<EOTEXT
	close-revision [__options__] __revision__
	EOTEXT
	);
	}

	public function getCommandHelp() {
	return phutil_console_format(<<<EOTEXT
	Supports: git, hg, svn
	Close a revision which has been committed (svn) or pushed (git, hg).
	You should not normally need to do this: arc commit (svn), arc amend
	(git), arc land (git), or repository tracking on the master remote
	repository should do it for you. However, if these mechanisms have
	failed for some reason you can use this command to manually change a
	revision status from "Accepted" to "Closed".
	EOTEXT
	);
	}

	public function getArguments() {
	return array(
	'finalize' => array(
	'help' =>
	"Close only if the repository is untracked and the revision is ".
	"accepted. Continue even if the close can't happen. This is a soft ".
	"version of 'close-revision' used by other workflows.",
	),
	'quiet' => array(
	'help' => 'Do not print a success message.',
	),
	'*' => 'revision',
	);
	}

	public function requiresConduit() {
	return true;
	}

	public function requiresAuthentication() {
	return true;
	}

	public function requiresRepositoryAPI() {
	// NOTE: Technically we only use this to generate the right message at
	// the end, and you can even get the wrong message (e.g., if you run
	// "arc close-revision D123" from a git repository, but D123 is an SVN
	// revision). We could be smarter about this, but it's just display fluff.
	return true;
	}

	public function run() {
	$is_finalize = $this->getArgument('finalize');

	$conduit = $this->getConduit();

	$revision_list = $this->getArgument('revision', array());
	if (!$revision_list) {
	throw new ArcanistUsageException(
	"close-revision requires a revision number.");
	}
	if (count($revision_list) != 1) {
	throw new ArcanistUsageException(
	"close-revision requires exactly one revision.");
	}
	$revision_id = reset($revision_list);
	$revision_id = $this->normalizeRevisionID($revision_id);

	$revision = null;
	try {
	$revision = $conduit->callMethodSynchronous(
	'differential.getrevision',
	array(
	'revision_id' => $revision_id,
	)
	);
	} catch (Exception $ex) {
	if (!$is_finalize) {
	throw new ArcanistUsageException(
	"Revision D{$revision_id} does not exist."
	);
	}
	}

	$status_accepted = ArcanistDifferentialRevisionStatus::ACCEPTED;
	$status_closed = ArcanistDifferentialRevisionStatus::CLOSED;

	if (!$is_finalize && $revision['status'] != $status_accepted) {
	throw new ArcanistUsageException(
	"Revision D{$revision_id} can not be closed. You can only close ".
	"revisions which have been 'accepted'.");
	}

	if ($revision) {
	if (!$is_finalize && $revision['authorPHID'] != $this->getUserPHID()) {
	$prompt = "You are not the author of revision D{$revision_id}, ".
	'are you sure you want to close it?';
	if (!phutil_console_confirm($prompt)) {
	throw new ArcanistUserAbortException();
	}
	}

	$actually_close = true;
	if ($is_finalize) {
	- $project_info = $conduit->callMethodSynchronous(
	- 'arcanist.projectinfo',
	- array(
	- 'name' => $this->getWorkingCopy()->getProjectID(),
	- ));
	- if ($project_info['tracked'] \|\|
	- $revision['status'] != $status_accepted) {
	- $actually_close = false;
	+ $project_id = $this->getWorkingCopy()->getProjectID();
	+ if ($project_id) {
	+ $project_info = $conduit->callMethodSynchronous(
	+ 'arcanist.projectinfo',
	+ array(
	+ 'name' => $project_id,
	+ ));
	+ if ($project_info['tracked'] \|\|
	+ $revision['status'] != $status_accepted) {
	+ $actually_close = false;
	+ }
	}
	}
	if ($actually_close) {
	$revision_name = $revision['title'];

	echo "Closing revision D{$revision_id} '{$revision_name}'...\n";

	$conduit->callMethodSynchronous(
	'differential.close',
	array(
	'revisionID' => $revision_id,
	));
	}
	}

	$status = $revision['status'];
	if ($status == $status_accepted \|\| $status == $status_closed) {
	// If this has already been attached to commits, don't show the
	// "you can push this commit" message since we know it's been pushed
	// already.
	$is_finalized = empty($revision['commits']);
	} else {
	$is_finalized = false;
	}

	if (!$this->getArgument('quiet')) {
	if ($is_finalized) {
	$message = $this->getRepositoryAPI()->getFinalizedRevisionMessage();
	echo phutil_console_wrap($message)."\n";
	} else {
	echo "Done.\n";
	}
	}

	return 0;
	}
	}
	diff --git a/src/workflow/get-config/ArcanistGetConfigWorkflow.php b/src/workflow/get-config/ArcanistGetConfigWorkflow.php
	index 2dac758e..497fc409 100644
	--- a/src/workflow/get-config/ArcanistGetConfigWorkflow.php
	+++ b/src/workflow/get-config/ArcanistGetConfigWorkflow.php
	@@ -1,66 +1,66 @@
	<?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.
	*/

	/**
	* Read configuration settings.
	*
	* @group workflow
	*/
	final class ArcanistGetConfigWorkflow extends ArcanistBaseWorkflow {

	public function getCommandSynopses() {
	return phutil_console_format(<<<EOTEXT
	get-config [__name__ ...]
	EOTEXT
	);
	}

	public function getCommandHelp() {
	return phutil_console_format(<<<EOTEXT
	Supports: cli
	Reads an arc configuration option. With no arugment, reads all
	options.
	EOTEXT
	);
	}

	public function getArguments() {
	return array(
	'*' => 'argv',
	);
	}

	public function run() {
	$argv = $this->getArgument('argv');

	- $config = $this->readGlobalArcConfig();
	+ $config = self::readGlobalArcConfig();
	if ($argv) {
	$keys = $argv;
	} else {
	$keys = array_keys($config);
	sort($keys);
	}

	foreach ($keys as $key) {
	echo "{$key} = ".idx($config, $key)."\n";
	}

	return 0;
	}

	}
	diff --git a/src/workflow/set-config/ArcanistSetConfigWorkflow.php b/src/workflow/set-config/ArcanistSetConfigWorkflow.php
	index d6bee4bd..4effedde 100644
	--- a/src/workflow/set-config/ArcanistSetConfigWorkflow.php
	+++ b/src/workflow/set-config/ArcanistSetConfigWorkflow.php
	@@ -1,89 +1,89 @@
	<?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.
	*/

	/**
	* Write configuration settings.
	*
	* @group workflow
	*/
	final class ArcanistSetConfigWorkflow extends ArcanistBaseWorkflow {

	public function getCommandSynopses() {
	return phutil_console_format(<<<EOTEXT
	set-config __name__ __value__
	EOTEXT
	);
	}

	public function getCommandHelp() {
	return phutil_console_format(<<<EOTEXT
	Supports: cli
	Sets an arc configuration option.

	Values are written to '~/.arcrc' on Linux and Mac OS X, and an
	undisclosed location on Windows.
	EOTEXT
	);
	}

	public function getArguments() {
	return array(
	'*' => 'argv',
	);
	}

	public function run() {
	$argv = $this->getArgument('argv');
	if (count($argv) != 2) {
	throw new ArcanistUsageException("Specify a key and a value.");
	}

	- $config = $this->readGlobalArcConfig();
	+ $config = self::readGlobalArcConfig();

	$key = $argv[0];
	$val = $argv[1];

	$old = null;
	if (array_key_exists($key, $config)) {
	$old = $config[$key];
	}

	if (!strlen($val)) {
	unset($config[$key]);
	- $this->writeGlobalArcConfig($config);
	+ self::writeGlobalArcConfig($config);

	if ($old === null) {
	echo "Deleted key '{$key}'.\n";
	} else {
	echo "Deleted key '{$key}' (was '{$old}').\n";
	}
	} else {
	$config[$key] = $val;
	- $this->writeGlobalArcConfig($config);
	+ self::writeGlobalArcConfig($config);

	if ($old === null) {
	echo "Set key '{$key}' = '{$val}'.\n";
	} else {
	echo "Set key '{$key}' = '{$val}' (was '{$old}').\n";
	}
	}

	return 0;
	}

	}
	diff --git a/src/workingcopyidentity/ArcanistWorkingCopyIdentity.php b/src/workingcopyidentity/ArcanistWorkingCopyIdentity.php
	index 0468074d..c2400404 100644
	--- a/src/workingcopyidentity/ArcanistWorkingCopyIdentity.php
	+++ b/src/workingcopyidentity/ArcanistWorkingCopyIdentity.php
	@@ -1,101 +1,118 @@
	<?php

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

	/**
	* Interfaces with basic information about the working copy.
	*
	* @group workingcopy
	*/
	final class ArcanistWorkingCopyIdentity {

	protected $projectConfig;
	protected $projectRoot;

	public static function newFromPath($path) {
	$project_id = null;
	$project_root = null;
	$config = array();
	foreach (Filesystem::walkToRoot($path) as $dir) {
	$config_file = $dir.'/.arcconfig';
	if (!Filesystem::pathExists($config_file)) {
	continue;
	}
	$proj_raw = Filesystem::readFile($config_file);
	$config = self::parseRawConfigFile($proj_raw, $config_file);
	$project_root = $dir;
	break;
	}
	+
	+ if (!$project_root) {
	+ foreach (Filesystem::walkToRoot($path) as $dir) {
	+ $try = array(
	+ $dir.'/.svn',
	+ $dir.'/.hg',
	+ $dir.'/.git',
	+ );
	+ foreach ($try as $trydir) {
	+ if (Filesystem::pathExists($trydir)) {
	+ $project_root = $dir;
	+ break 2;
	+ }
	+ }
	+ }
	+ }
	+
	return new ArcanistWorkingCopyIdentity($project_root, $config);
	}

	public static function newFromRootAndConfigFile(
	$root,
	$config_raw,
	$from_where) {

	$config = self::parseRawConfigFile($config_raw, $from_where);
	return new ArcanistWorkingCopyIdentity($root, $config);
	}

	private static function parseRawConfigFile($raw_config, $from_where) {
	$proj = json_decode($raw_config, true);
	if (!is_array($proj)) {
	throw new Exception(
	"Unable to parse '.arcconfig' file '{$from_where}'. The file contents ".
	"should be valid JSON.\n\n".
	"FILE CONTENTS\n".
	substr($raw_config, 0, 2048));
	}
	$required_keys = array(
	'project_id',
	);
	foreach ($required_keys as $key) {
	if (!array_key_exists($key, $proj)) {
	throw new Exception(
	"Required key '{$key}' is missing from '.arcconfig' file ".
	"'{$from_where}'.");
	}
	}
	return $proj;
	}

	protected function __construct($root, array $config) {
	$this->projectRoot = $root;
	$this->projectConfig = $config;
	}

	public function getProjectID() {
	return $this->getConfig('project_id');
	}

	public function getProjectRoot() {
	return $this->projectRoot;
	}

	public function getConduitURI() {
	return $this->getConfig('conduit_uri');
	}

	public function getConfig($key) {
	if (!empty($this->projectConfig[$key])) {
	return $this->projectConfig[$key];
	}
	return null;
	}

	}

File Metadata

Mime Type: text/x-diff
Expires: Jan 19 2025, 20:46 (6 w, 1 d ago)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1128579
Default Alt Text: (79 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions