No OneTemporary
Actions

Size

98 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/scripts/arcanist.php b/scripts/arcanist.php
	index 8784b903..e2b6a724 100755
	--- a/scripts/arcanist.php
	+++ b/scripts/arcanist.php
	@@ -1,531 +1,531 @@
	#!/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';

	ini_set('memory_limit', -1);

	$original_argv = $argv;
	$args = new PhutilArgumentParser($argv);
	$args->parseStandardArguments();
	$args->parsePartial(
	array(
	array(
	'name' => 'load-phutil-library',
	'param' => 'path',
	'help' => 'Load a libphutil library.',
	'repeat' => true,
	),
	array(
	'name' => 'conduit-uri',
	'param' => 'uri',
	'help' => 'Connect to Phabricator install specified by __uri__.',
	),
	array(
	'name' => 'conduit-version',
	'param' => 'version',
	'help' => '(Developers) Mock client version in protocol handshake.',
	),
	array(
	'name' => 'conduit-timeout',
	'param' => 'timeout',
	'help' => 'Set Conduit timeout (in seconds).',
	),
	));

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

	$force_conduit = $args->getArg('conduit-uri');
	$force_conduit_version = $args->getArg('conduit-version');
	$conduit_timeout = $args->getArg('conduit-timeout');
	$load = $args->getArg('load-phutil-library');

	$argv = $args->getUnconsumedArgumentVector();
	$args = array_values($argv);

	$working_directory = getcwd();
	$console = PhutilConsole::getConsole();

	try {

	if ($config_trace_mode) {
	$phutil_location = phutil_get_library_root('phutil');
	$arcanist_location = phutil_get_library_root('arcanist');
	$console->writeErr("libphutil loaded from '{$phutil_location}'.\n");
	$console->writeErr("arcanist loaded from '{$arcanist_location}'.\n");
	}

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

	$global_config = ArcanistBaseWorkflow::readGlobalArcConfig();
	$system_config = ArcanistBaseWorkflow::readSystemArcConfig();
	$working_copy = ArcanistWorkingCopyIdentity::newFromPath($working_directory);

	// Load additional libraries, which can provide new classes like configuration
	// overrides, linters and lint engines, unit test engines, etc.

	// If the user specified "--load-phutil-library" one or more times from
	// the command line, we load those libraries instead of whatever else
	// is configured. This is basically a debugging feature to let you force
	// specific libraries to load regardless of the state of the world.
	if ($load) {
	// Load the flag libraries. These must load, since the user specified them
	// explicitly.
	arcanist_load_libraries(
	$load,
	$must_load = true,
	$lib_source = 'a "--load-phutil-library" flag',
	$working_copy,
	$config_trace_mode);
	} else {
	// Load libraries in system 'load' config. In contrast to global config, we
	// fail hard here because this file is edited manually, so if 'arc' breaks
	// that doesn't make it any more difficult to correct.
	arcanist_load_libraries(
	idx($system_config, 'load', array()),
	$must_load = true,
	$lib_source = 'the "load" setting in system config',
	$working_copy,
	$config_trace_mode);

	// Load libraries in global 'load' config, as per "arc set-config load". We
	// need to fail softly if these break because errors would prevent the user
	// from running "arc set-config" to correct them.
	arcanist_load_libraries(
	idx($global_config, 'load', array()),
	$must_load = false,
	$lib_source = 'the "load" setting in global config',
	$working_copy,
	$config_trace_mode);

	// Load libraries in ".arcconfig". Libraries here must load.
	arcanist_load_libraries(
	- $working_copy->getConfig('phutil_libraries'),
	+ $working_copy->getConfig('load'),
	$must_load = true,
	- $lib_source = 'the "phutil_libraries" setting in ".arcconfig"',
	+ $lib_source = 'the "load" setting in ".arcconfig"',
	$working_copy,
	$config_trace_mode);
	}

	$user_config = ArcanistBaseWorkflow::readUserConfigurationFile();

	$config = $working_copy->getConfig('arcanist_configuration');
	if ($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.

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

	$full_alias = idx($aliases, $command, array());
	$full_alias = implode(' ', $full_alias);

	// Run shell command aliases.

	if (ArcanistAliasWorkflow::isShellCommandAlias($new_command)) {
	$shell_cmd = substr($full_alias, 1);

	if ($config_trace_mode) {
	echo "[alias: 'arc {$command}' -> \$ {$full_alias}]\n";
	}

	if ($args) {
	$err = phutil_passthru('%C %Ls', $shell_cmd, $args);
	} else {
	$err = phutil_passthru('%C', $shell_cmd);
	}
	exit($err);
	}

	// Run arc command aliases.

	if ($new_command) {
	$workflow = $config->buildWorkflow($new_command);
	if ($workflow) {
	if ($config_trace_mode) {
	echo "[alias: 'arc {$command}' -> 'arc {$full_alias}']\n";
	}
	$command = $new_command;
	}
	}

	if (!$workflow) {
	throw new ArcanistUsageException(
	"Unknown command '{$command}'. Try 'arc help'.");
	}
	}

	$workflow->setArcanistConfiguration($config);
	$workflow->setCommand($command);
	$workflow->setWorkingDirectory($working_directory);
	$workflow->parseArguments($args);

	if ($force_conduit_version) {
	$workflow->forceConduitVersion($force_conduit_version);
	}
	if ($conduit_timeout) {
	$workflow->setConduitTimeout($conduit_timeout);
	}

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

	$want_repository_api = $workflow->desiresRepositoryAPI();
	$want_working_copy = $workflow->desiresWorkingCopy() \|\|
	$want_repository_api;

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

	if ($need_working_copy \|\| $want_working_copy) {
	if ($need_working_copy && !$working_copy->getProjectRoot()) {
	throw new ArcanistUsageException(
	"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 {
	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) {

	$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 \|\| ($want_repository_api && $working_copy)) {
	$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((int)$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(
	"Exception\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);
	}


	function arcanist_load_libraries(
	$load,
	$must_load,
	$lib_source,
	ArcanistWorkingCopyIdentity $working_copy,
	$config_trace_mode) {

	if (!$load) {
	return;
	}

	if (!is_array($load)) {
	$error = "Libraries specified by {$lib_source} are invalid; expected ".
	"a list. Check your configuration.";
	$console = PhutilConsole::getConsole();
	$console->writeErr("WARNING: %s\n", $error);
	return;
	}

	foreach ($load as $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.
	//
	// Note that absolute paths will just resolve absolutely through rule (1).

	$resolved = false;

	// Check inside the working copy. This also checks absolute paths, since
	// they'll resolve absolute and just ignore the project root.
	$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 from '{$location}'...\n";
	}

	$error = null;
	try {
	phutil_load_library($location);
	} catch (PhutilBootloaderException $ex) {
	$error = "Failed to load phutil library at location '{$location}'. ".
	"This library is specified by {$lib_source}. Check that the ".
	"setting is correct and the library is located in the right ".
	"place.";
	if ($must_load) {
	throw new ArcanistUsageException($error);
	} else {
	file_put_contents(
	'php://stderr',
	phutil_console_wrap('WARNING: '.$error."\n\n"));
	}
	} catch (PhutilLibraryConflictException $ex) {
	if ($ex->getLibrary() != 'arcanist') {
	throw $ex;
	}
	$arc_dir = dirname(dirname(__FILE__));
	$error =
	"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);
	}
	}
	}
	diff --git a/src/__phutil_library_map__.php b/src/__phutil_library_map__.php
	index 732a67ab..98139c72 100644
	--- a/src/__phutil_library_map__.php
	+++ b/src/__phutil_library_map__.php
	@@ -1,239 +1,240 @@
	<?php

	/**
	* This file is automatically generated. Use 'arc liberate' to rebuild it.
	* @generated
	* @phutil-library-version 2
	*/

	phutil_register_library_map(array(
	'__library_version__' => 2,
	'class' =>
	array(
	'ArcanistAliasWorkflow' => 'workflow/ArcanistAliasWorkflow.php',
	'ArcanistAmendWorkflow' => 'workflow/ArcanistAmendWorkflow.php',
	'ArcanistAnoidWorkflow' => 'workflow/ArcanistAnoidWorkflow.php',
	'ArcanistApacheLicenseLinter' => 'lint/linter/ArcanistApacheLicenseLinter.php',
	'ArcanistApacheLicenseLinterTestCase' => 'lint/linter/__tests__/ArcanistApacheLicenseLinterTestCase.php',
	'ArcanistBaseCommitParser' => 'parser/ArcanistBaseCommitParser.php',
	'ArcanistBaseCommitParserTestCase' => 'parser/__tests__/ArcanistBaseCommitParserTestCase.php',
	'ArcanistBaseUnitTestEngine' => 'unit/engine/ArcanistBaseUnitTestEngine.php',
	'ArcanistBaseWorkflow' => 'workflow/ArcanistBaseWorkflow.php',
	'ArcanistBranchWorkflow' => 'workflow/ArcanistBranchWorkflow.php',
	'ArcanistBundle' => 'parser/ArcanistBundle.php',
	'ArcanistBundleTestCase' => 'parser/__tests__/ArcanistBundleTestCase.php',
	'ArcanistCallConduitWorkflow' => 'workflow/ArcanistCallConduitWorkflow.php',
	'ArcanistCapabilityNotSupportedException' => 'workflow/exception/ArcanistCapabilityNotSupportedException.php',
	'ArcanistChooseInvalidRevisionException' => 'exception/ArcanistChooseInvalidRevisionException.php',
	'ArcanistChooseNoRevisionsException' => 'exception/ArcanistChooseNoRevisionsException.php',
	'ArcanistCloseRevisionWorkflow' => 'workflow/ArcanistCloseRevisionWorkflow.php',
	'ArcanistCloseWorkflow' => 'workflow/ArcanistCloseWorkflow.php',
	'ArcanistCommentRemover' => 'parser/ArcanistCommentRemover.php',
	'ArcanistCommentRemoverTestCase' => 'parser/__tests__/ArcanistCommentRemoverTestCase.php',
	'ArcanistCommitWorkflow' => 'workflow/ArcanistCommitWorkflow.php',
	'ArcanistConduitLinter' => 'lint/linter/ArcanistConduitLinter.php',
	'ArcanistConfiguration' => 'configuration/ArcanistConfiguration.php',
	'ArcanistCoverWorkflow' => 'workflow/ArcanistCoverWorkflow.php',
	'ArcanistDiffChange' => 'parser/diff/ArcanistDiffChange.php',
	'ArcanistDiffChangeType' => 'parser/diff/ArcanistDiffChangeType.php',
	'ArcanistDiffHunk' => 'parser/diff/ArcanistDiffHunk.php',
	'ArcanistDiffParser' => 'parser/ArcanistDiffParser.php',
	'ArcanistDiffParserTestCase' => 'parser/__tests__/ArcanistDiffParserTestCase.php',
	'ArcanistDiffUtils' => 'difference/ArcanistDiffUtils.php',
	'ArcanistDiffUtilsTestCase' => 'difference/__tests__/ArcanistDiffUtilsTestCase.php',
	'ArcanistDiffWorkflow' => 'workflow/ArcanistDiffWorkflow.php',
	'ArcanistDifferentialCommitMessage' => 'differential/ArcanistDifferentialCommitMessage.php',
	'ArcanistDifferentialCommitMessageParserException' => 'differential/ArcanistDifferentialCommitMessageParserException.php',
	'ArcanistDifferentialRevisionHash' => 'differential/constants/ArcanistDifferentialRevisionHash.php',
	'ArcanistDifferentialRevisionStatus' => 'differential/constants/ArcanistDifferentialRevisionStatus.php',
	'ArcanistDownloadWorkflow' => 'workflow/ArcanistDownloadWorkflow.php',
	'ArcanistEventType' => 'events/constant/ArcanistEventType.php',
	'ArcanistExportWorkflow' => 'workflow/ArcanistExportWorkflow.php',
	'ArcanistFilenameLinter' => 'lint/linter/ArcanistFilenameLinter.php',
	'ArcanistGeneratedLinter' => 'lint/linter/ArcanistGeneratedLinter.php',
	'ArcanistGetConfigWorkflow' => 'workflow/ArcanistGetConfigWorkflow.php',
	'ArcanistGitAPI' => 'repository/api/ArcanistGitAPI.php',
	'ArcanistGitHookPreReceiveWorkflow' => 'workflow/ArcanistGitHookPreReceiveWorkflow.php',
	'ArcanistHelpWorkflow' => 'workflow/ArcanistHelpWorkflow.php',
	'ArcanistHgClientChannel' => 'hgdaemon/ArcanistHgClientChannel.php',
	'ArcanistHgProxyClient' => 'hgdaemon/ArcanistHgProxyClient.php',
	'ArcanistHgProxyServer' => 'hgdaemon/ArcanistHgProxyServer.php',
	'ArcanistHgServerChannel' => 'hgdaemon/ArcanistHgServerChannel.php',
	'ArcanistHookAPI' => 'repository/hookapi/ArcanistHookAPI.php',
	'ArcanistInlinesWorkflow' => 'workflow/ArcanistInlinesWorkflow.php',
	'ArcanistInstallCertificateWorkflow' => 'workflow/ArcanistInstallCertificateWorkflow.php',
	'ArcanistJSHintLinter' => 'lint/linter/ArcanistJSHintLinter.php',
	'ArcanistLandWorkflow' => 'workflow/ArcanistLandWorkflow.php',
	'ArcanistLiberateWorkflow' => 'workflow/ArcanistLiberateWorkflow.php',
	'ArcanistLicenseLinter' => 'lint/linter/ArcanistLicenseLinter.php',
	'ArcanistLintConsoleRenderer' => 'lint/renderer/ArcanistLintConsoleRenderer.php',
	'ArcanistLintEngine' => 'lint/engine/ArcanistLintEngine.php',
	'ArcanistLintJSONRenderer' => 'lint/renderer/ArcanistLintJSONRenderer.php',
	'ArcanistLintLikeCompilerRenderer' => 'lint/renderer/ArcanistLintLikeCompilerRenderer.php',
	'ArcanistLintMessage' => 'lint/ArcanistLintMessage.php',
	'ArcanistLintPatcher' => 'lint/ArcanistLintPatcher.php',
	'ArcanistLintRenderer' => 'lint/renderer/ArcanistLintRenderer.php',
	'ArcanistLintResult' => 'lint/ArcanistLintResult.php',
	'ArcanistLintSeverity' => 'lint/ArcanistLintSeverity.php',
	'ArcanistLintSummaryRenderer' => 'lint/renderer/ArcanistLintSummaryRenderer.php',
	'ArcanistLintWorkflow' => 'workflow/ArcanistLintWorkflow.php',
	'ArcanistLinter' => 'lint/linter/ArcanistLinter.php',
	'ArcanistLinterTestCase' => 'lint/linter/__tests__/ArcanistLinterTestCase.php',
	'ArcanistListWorkflow' => 'workflow/ArcanistListWorkflow.php',
	'ArcanistMarkCommittedWorkflow' => 'workflow/ArcanistMarkCommittedWorkflow.php',
	'ArcanistMercurialAPI' => 'repository/api/ArcanistMercurialAPI.php',
	'ArcanistMercurialParser' => 'repository/parser/ArcanistMercurialParser.php',
	'ArcanistMercurialParserTestCase' => 'repository/parser/__tests__/ArcanistMercurialParserTestCase.php',
	'ArcanistNoEffectException' => 'exception/usage/ArcanistNoEffectException.php',
	'ArcanistNoEngineException' => 'exception/usage/ArcanistNoEngineException.php',
	'ArcanistNoLintLinter' => 'lint/linter/ArcanistNoLintLinter.php',
	'ArcanistNoLintTestCaseMisnamed' => 'lint/linter/__tests__/ArcanistNoLintTestCase.php',
	'ArcanistPEP8Linter' => 'lint/linter/ArcanistPEP8Linter.php',
	'ArcanistPasteWorkflow' => 'workflow/ArcanistPasteWorkflow.php',
	'ArcanistPatchWorkflow' => 'workflow/ArcanistPatchWorkflow.php',
	'ArcanistPhpcsLinter' => 'lint/linter/ArcanistPhpcsLinter.php',
	'ArcanistPhutilLibraryLinter' => 'lint/linter/ArcanistPhutilLibraryLinter.php',
	'ArcanistPhutilTestCase' => 'unit/engine/phutil/ArcanistPhutilTestCase.php',
	'ArcanistPhutilTestCaseTestCase' => 'unit/engine/phutil/testcase/ArcanistPhutilTestCaseTestCase.php',
	'ArcanistPhutilTestSkippedException' => 'unit/engine/phutil/testcase/ArcanistPhutilTestSkippedException.php',
	'ArcanistPhutilTestTerminatedException' => 'unit/engine/phutil/testcase/ArcanistPhutilTestTerminatedException.php',
	'ArcanistPyFlakesLinter' => 'lint/linter/ArcanistPyFlakesLinter.php',
	'ArcanistPyLintLinter' => 'lint/linter/ArcanistPyLintLinter.php',
	'ArcanistRepositoryAPI' => 'repository/api/ArcanistRepositoryAPI.php',
	'ArcanistScriptAndRegexLinter' => 'lint/linter/ArcanistScriptAndRegexLinter.php',
	'ArcanistSetConfigWorkflow' => 'workflow/ArcanistSetConfigWorkflow.php',
	+ 'ArcanistSettings' => 'configuration/ArcanistSettings.php',
	'ArcanistShellCompleteWorkflow' => 'workflow/ArcanistShellCompleteWorkflow.php',
	'ArcanistSingleLintEngine' => 'lint/engine/ArcanistSingleLintEngine.php',
	'ArcanistSpellingDefaultData' => 'lint/linter/ArcanistSpellingDefaultData.php',
	'ArcanistSpellingLinter' => 'lint/linter/ArcanistSpellingLinter.php',
	'ArcanistSpellingLinterTestCase' => 'lint/linter/__tests__/ArcanistSpellingLinterTestCase.php',
	'ArcanistSubversionAPI' => 'repository/api/ArcanistSubversionAPI.php',
	'ArcanistSubversionHookAPI' => 'repository/hookapi/ArcanistSubversionHookAPI.php',
	'ArcanistSvnHookPreCommitWorkflow' => 'workflow/ArcanistSvnHookPreCommitWorkflow.php',
	'ArcanistTasksWorkflow' => 'workflow/ArcanistTasksWorkflow.php',
	'ArcanistTextLinter' => 'lint/linter/ArcanistTextLinter.php',
	'ArcanistTextLinterTestCase' => 'lint/linter/__tests__/ArcanistTextLinterTestCase.php',
	'ArcanistTodoWorkflow' => 'workflow/ArcanistTodoWorkflow.php',
	'ArcanistUncommittedChangesException' => 'exception/usage/ArcanistUncommittedChangesException.php',
	'ArcanistUnitTestResult' => 'unit/ArcanistUnitTestResult.php',
	'ArcanistUnitWorkflow' => 'workflow/ArcanistUnitWorkflow.php',
	'ArcanistUpgradeWorkflow' => 'workflow/ArcanistUpgradeWorkflow.php',
	'ArcanistUploadWorkflow' => 'workflow/ArcanistUploadWorkflow.php',
	'ArcanistUsageException' => 'exception/ArcanistUsageException.php',
	'ArcanistUserAbortException' => 'exception/usage/ArcanistUserAbortException.php',
	'ArcanistWhichWorkflow' => 'workflow/ArcanistWhichWorkflow.php',
	'ArcanistWorkingCopyIdentity' => 'workingcopyidentity/ArcanistWorkingCopyIdentity.php',
	'ArcanistXHPASTLintNamingHook' => 'lint/linter/xhpast/ArcanistXHPASTLintNamingHook.php',
	'ArcanistXHPASTLintNamingHookTestCase' => 'lint/linter/xhpast/__tests__/ArcanistXHPASTLintNamingHookTestCase.php',
	'ArcanistXHPASTLinter' => 'lint/linter/ArcanistXHPASTLinter.php',
	'ArcanistXHPASTLinterTestCase' => 'lint/linter/__tests__/ArcanistXHPASTLinterTestCase.php',
	'ComprehensiveLintEngine' => 'lint/engine/ComprehensiveLintEngine.php',
	'ExampleLintEngine' => 'lint/engine/ExampleLintEngine.php',
	'NoseTestEngine' => 'unit/engine/NoseTestEngine.php',
	'PhpunitTestEngine' => 'unit/engine/PhpunitTestEngine.php',
	'PhutilLintEngine' => 'lint/engine/PhutilLintEngine.php',
	'PhutilUnitTestEngine' => 'unit/engine/PhutilUnitTestEngine.php',
	'PhutilUnitTestEngineTestCase' => 'unit/engine/__tests__/PhutilUnitTestEngineTestCase.php',
	'UnitTestableArcanistLintEngine' => 'lint/engine/UnitTestableArcanistLintEngine.php',
	),
	'function' =>
	array(
	),
	'xmap' =>
	array(
	'ArcanistAliasWorkflow' => 'ArcanistBaseWorkflow',
	'ArcanistAmendWorkflow' => 'ArcanistBaseWorkflow',
	'ArcanistAnoidWorkflow' => 'ArcanistBaseWorkflow',
	'ArcanistApacheLicenseLinter' => 'ArcanistLicenseLinter',
	'ArcanistApacheLicenseLinterTestCase' => 'ArcanistLinterTestCase',
	'ArcanistBaseCommitParserTestCase' => 'ArcanistPhutilTestCase',
	'ArcanistBranchWorkflow' => 'ArcanistBaseWorkflow',
	'ArcanistBundleTestCase' => 'ArcanistPhutilTestCase',
	'ArcanistCallConduitWorkflow' => 'ArcanistBaseWorkflow',
	'ArcanistCapabilityNotSupportedException' => 'Exception',
	'ArcanistChooseInvalidRevisionException' => 'Exception',
	'ArcanistChooseNoRevisionsException' => 'Exception',
	'ArcanistCloseRevisionWorkflow' => 'ArcanistBaseWorkflow',
	'ArcanistCloseWorkflow' => 'ArcanistBaseWorkflow',
	'ArcanistCommentRemoverTestCase' => 'ArcanistPhutilTestCase',
	'ArcanistCommitWorkflow' => 'ArcanistBaseWorkflow',
	'ArcanistConduitLinter' => 'ArcanistLinter',
	'ArcanistCoverWorkflow' => 'ArcanistBaseWorkflow',
	'ArcanistDiffParserTestCase' => 'ArcanistPhutilTestCase',
	'ArcanistDiffUtilsTestCase' => 'ArcanistPhutilTestCase',
	'ArcanistDiffWorkflow' => 'ArcanistBaseWorkflow',
	'ArcanistDifferentialCommitMessageParserException' => 'Exception',
	'ArcanistDownloadWorkflow' => 'ArcanistBaseWorkflow',
	'ArcanistEventType' => 'PhutilEventType',
	'ArcanistExportWorkflow' => 'ArcanistBaseWorkflow',
	'ArcanistFilenameLinter' => 'ArcanistLinter',
	'ArcanistGeneratedLinter' => 'ArcanistLinter',
	'ArcanistGetConfigWorkflow' => 'ArcanistBaseWorkflow',
	'ArcanistGitAPI' => 'ArcanistRepositoryAPI',
	'ArcanistGitHookPreReceiveWorkflow' => 'ArcanistBaseWorkflow',
	'ArcanistHelpWorkflow' => 'ArcanistBaseWorkflow',
	'ArcanistHgClientChannel' => 'PhutilProtocolChannel',
	'ArcanistHgServerChannel' => 'PhutilProtocolChannel',
	'ArcanistInlinesWorkflow' => 'ArcanistBaseWorkflow',
	'ArcanistInstallCertificateWorkflow' => 'ArcanistBaseWorkflow',
	'ArcanistJSHintLinter' => 'ArcanistLinter',
	'ArcanistLandWorkflow' => 'ArcanistBaseWorkflow',
	'ArcanistLiberateWorkflow' => 'ArcanistBaseWorkflow',
	'ArcanistLicenseLinter' => 'ArcanistLinter',
	'ArcanistLintConsoleRenderer' => 'ArcanistLintRenderer',
	'ArcanistLintJSONRenderer' => 'ArcanistLintRenderer',
	'ArcanistLintLikeCompilerRenderer' => 'ArcanistLintRenderer',
	'ArcanistLintSummaryRenderer' => 'ArcanistLintRenderer',
	'ArcanistLintWorkflow' => 'ArcanistBaseWorkflow',
	'ArcanistLinterTestCase' => 'ArcanistPhutilTestCase',
	'ArcanistListWorkflow' => 'ArcanistBaseWorkflow',
	'ArcanistMarkCommittedWorkflow' => 'ArcanistBaseWorkflow',
	'ArcanistMercurialAPI' => 'ArcanistRepositoryAPI',
	'ArcanistMercurialParserTestCase' => 'ArcanistPhutilTestCase',
	'ArcanistNoEffectException' => 'ArcanistUsageException',
	'ArcanistNoEngineException' => 'ArcanistUsageException',
	'ArcanistNoLintLinter' => 'ArcanistLinter',
	'ArcanistNoLintTestCaseMisnamed' => 'ArcanistLinterTestCase',
	'ArcanistPEP8Linter' => 'ArcanistLinter',
	'ArcanistPasteWorkflow' => 'ArcanistBaseWorkflow',
	'ArcanistPatchWorkflow' => 'ArcanistBaseWorkflow',
	'ArcanistPhpcsLinter' => 'ArcanistLinter',
	'ArcanistPhutilLibraryLinter' => 'ArcanistLinter',
	'ArcanistPhutilTestCaseTestCase' => 'ArcanistPhutilTestCase',
	'ArcanistPhutilTestSkippedException' => 'Exception',
	'ArcanistPhutilTestTerminatedException' => 'Exception',
	'ArcanistPyFlakesLinter' => 'ArcanistLinter',
	'ArcanistPyLintLinter' => 'ArcanistLinter',
	'ArcanistScriptAndRegexLinter' => 'ArcanistLinter',
	'ArcanistSetConfigWorkflow' => 'ArcanistBaseWorkflow',
	'ArcanistShellCompleteWorkflow' => 'ArcanistBaseWorkflow',
	'ArcanistSingleLintEngine' => 'ArcanistLintEngine',
	'ArcanistSpellingLinter' => 'ArcanistLinter',
	'ArcanistSpellingLinterTestCase' => 'ArcanistLinterTestCase',
	'ArcanistSubversionAPI' => 'ArcanistRepositoryAPI',
	'ArcanistSubversionHookAPI' => 'ArcanistHookAPI',
	'ArcanistSvnHookPreCommitWorkflow' => 'ArcanistBaseWorkflow',
	'ArcanistTasksWorkflow' => 'ArcanistBaseWorkflow',
	'ArcanistTextLinter' => 'ArcanistLinter',
	'ArcanistTextLinterTestCase' => 'ArcanistLinterTestCase',
	'ArcanistTodoWorkflow' => 'ArcanistBaseWorkflow',
	'ArcanistUncommittedChangesException' => 'ArcanistUsageException',
	'ArcanistUnitWorkflow' => 'ArcanistBaseWorkflow',
	'ArcanistUpgradeWorkflow' => 'ArcanistBaseWorkflow',
	'ArcanistUploadWorkflow' => 'ArcanistBaseWorkflow',
	'ArcanistUsageException' => 'Exception',
	'ArcanistUserAbortException' => 'ArcanistUsageException',
	'ArcanistWhichWorkflow' => 'ArcanistBaseWorkflow',
	'ArcanistXHPASTLintNamingHookTestCase' => 'ArcanistPhutilTestCase',
	'ArcanistXHPASTLinter' => 'ArcanistLinter',
	'ArcanistXHPASTLinterTestCase' => 'ArcanistLinterTestCase',
	'ComprehensiveLintEngine' => 'ArcanistLintEngine',
	'ExampleLintEngine' => 'ArcanistLintEngine',
	'NoseTestEngine' => 'ArcanistBaseUnitTestEngine',
	'PhpunitTestEngine' => 'ArcanistBaseUnitTestEngine',
	'PhutilLintEngine' => 'ArcanistLintEngine',
	'PhutilUnitTestEngine' => 'ArcanistBaseUnitTestEngine',
	'PhutilUnitTestEngineTestCase' => 'ArcanistPhutilTestCase',
	'UnitTestableArcanistLintEngine' => 'ArcanistLintEngine',
	),
	));
	diff --git a/src/configuration/ArcanistSettings.php b/src/configuration/ArcanistSettings.php
	new file mode 100644
	index 00000000..90794af5
	--- /dev/null
	+++ b/src/configuration/ArcanistSettings.php
	@@ -0,0 +1,236 @@
	+<?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.
	+ */
	+
	+/**
	+ * @group config
	+ */
	+final class ArcanistSettings {
	+
	+ private function getOptions() {
	+ return array(
	+ 'default' => array(
	+ 'type' => 'string',
	+ 'help' =>
	+ 'The URI of a Phabricator install to connect to by default, if '.
	+ 'arc is run in a project without a Phabricator URI or run outside '.
	+ 'of a project.',
	+ 'example' => '"http://phabricator.example.com/"',
	+ ),
	+ 'base' => array(
	+ 'type' => 'string',
	+ 'help' =>
	+ 'Base commit ruleset to invoke when determining the start of a '.
	+ 'commit range. See "Arcanist User Guide: Commit Ranges" for '.
	+ 'details.',
	+ 'example' => '"arc:amended, arc:prompt"',
	+ ),
	+ 'load' => array(
	+ 'type' => 'list',
	+ 'legacy' => 'phutil_libraries',
	+ 'help' =>
	+ 'A list of paths to phutil libraries that should be loaded at '.
	+ 'startup. This can be used to make classes available, like lint or '.
	+ 'unit test engines.',
	+ 'example' => '["/var/arc/customlib/src"]',
	+ ),
	+ 'lint.engine' => array(
	+ 'type' => 'string',
	+ 'legacy' => 'lint_engine',
	+ 'help' =>
	+ 'The name of a default lint engine to use, if no lint engine is '.
	+ 'specified by the current project.',
	+ 'example' => '"ExampleLintEngine"',
	+ ),
	+ 'unit.engine' => array(
	+ 'type' => 'string',
	+ 'legacy' => 'unit_engine',
	+ 'help' =>
	+ 'The name of a default unit test engine to use, if no unit test '.
	+ 'engine is specified by the current project.',
	+ 'example' => '"ExampleUnitTestEngine"',
	+ ),
	+ 'arc.land.onto.default' => array(
	+ 'type' => 'string',
	+ 'help' =>
	+ 'The name of the default branch to land changes onto when '.
	+ '`arc land` is run.',
	+ 'example' => '"develop"',
	+ ),
	+ 'history.immutable' => array(
	+ 'type' => 'bool',
	+ 'legacy' => 'immutable_history',
	+ 'help' =>
	+ 'If true, arc will never change repository history (e.g., through '.
	+ 'amending or rebasing). Defaults to true in Mercurial and false in '.
	+ 'Git. This setting has no effect in Subversion.',
	+ 'example' => 'false',
	+ ),
	+ 'editor' => array(
	+ 'type' => 'string',
	+ 'help' =>
	+ "Command to use to invoke an interactive editor, like 'nano' or ".
	+ "'vim'. This setting overrides the EDITOR environmental variable.",
	+ 'example' => '"nano"',
	+ ),
	+ );
	+ }
	+
	+ private function getOption($key) {
	+ return idx($this->getOptions(), $key, array());
	+ }
	+
	+ public function getAllKeys() {
	+ return array_keys($this->getOptions());
	+ }
	+
	+ public function getHelp($key) {
	+ return idx($this->getOption($key), 'help');
	+ }
	+
	+ public function getExample($key) {
	+ return idx($this->getOption($key), 'example');
	+ }
	+
	+ public function getType($key) {
	+ return idx($this->getOption($key), 'type', 'wild');
	+ }
	+
	+ public function getLegacyName($key) {
	+ return idx($this->getOption($key), 'legacy');
	+ }
	+
	+ public function willWriteValue($key, $value) {
	+ $type = $this->getType($key);
	+ switch ($type) {
	+ case 'bool':
	+ if (strtolower($value) === 'false' \|\|
	+ strtolower($value) === 'no' \|\|
	+ strtolower($value) === 'off' \|\|
	+ $value === '' \|\|
	+ $value === '0' \|\|
	+ $value === 0 \|\|
	+ $value === false) {
	+ $value = false;
	+ } else if (strtolower($value) === 'true' \|\|
	+ strtolower($value) === 'yes' \|\|
	+ strtolower($value) === 'on' \|\|
	+ $value === '1' \|\|
	+ $value === 1 \|\|
	+ $value === true) {
	+ $value = true;
	+ } else {
	+ throw new ArcanistUsageException(
	+ "Type of setting '{$key}' must be boolean, like 'true' or ".
	+ "'false'.");
	+ }
	+ break;
	+ case 'list':
	+ if (is_array($value)) {
	+ break;
	+ }
	+
	+ if (is_string($value)) {
	+ $list = json_decode($value, true);
	+ if (is_array($list)) {
	+ $value = $list;
	+ break;
	+ }
	+ }
	+
	+ $list_example = '["apple", "banana", "cherry"]';
	+ throw new ArcanistUsageException(
	+ "Type of setting '{$key}' must be list. You can specify a list ".
	+ "in JSON, like: {$list_example}");
	+
	+ case 'string':
	+ if (!is_scalar($value)) {
	+ throw new ArcanistUsageException(
	+ "Type of setting '{$key}' must be string.");
	+ }
	+ $value = (string)$value;
	+ break;
	+ case 'wild':
	+ break;
	+ }
	+
	+ return $value;
	+ }
	+
	+ public function willReadValue($key, $value) {
	+ $type = $this->getType($key);
	+ switch ($type) {
	+ case 'string':
	+ if (!is_string($value)) {
	+ throw new ArcanistUsageException(
	+ "Type of setting '{$key}' must be string.");
	+ }
	+ break;
	+ case 'bool':
	+ if ($value !== true && $value !== false) {
	+ throw new ArcanistUsageException(
	+ "Type of setting '{$key}' must be boolean.");
	+ }
	+ break;
	+ case 'list':
	+ if (!is_array($value)) {
	+ throw new ArcanistUsageException(
	+ "Type of setting '{$key}' must be list.");
	+ }
	+ break;
	+ case 'wild':
	+ break;
	+ }
	+
	+ return $value;
	+ }
	+
	+ public function formatConfigValueForDisplay($key, $value) {
	+ if ($value === false) {
	+ return 'false';
	+ }
	+
	+ if ($value === true) {
	+ return 'true';
	+ }
	+
	+ if ($value === null) {
	+ return 'null';
	+ }
	+
	+ if (is_string($value)) {
	+ return '"'.$value.'"';
	+ }
	+
	+ if (is_array($value)) {
	+ // TODO: Both json_encode() and PhutilJSON do a bad job with one-liners.
	+ // PhutilJSON splits them across a bunch of lines, while json_encode()
	+ // escapes all kinds of stuff like "/". It would be nice if PhutilJSON
	+ // had a mode for pretty one-liners.
	+ $value = json_encode($value);
	+
	+ // json_encode() unnecessarily escapes "/" to prevent "</script>" stuff,
	+ // optimistically unescape it for display to improve readability.
	+ $value = preg_replace('@(?<!\\\\)\\\\/@', '/', $value);
	+ return $value;
	+ }
	+
	+ return $value;
	+ }
	+
	+
	+}
	diff --git a/src/workflow/ArcanistBaseWorkflow.php b/src/workflow/ArcanistBaseWorkflow.php
	index 301bd4c7..ea39ed4e 100644
	--- a/src/workflow/ArcanistBaseWorkflow.php
	+++ b/src/workflow/ArcanistBaseWorkflow.php
	@@ -1,1296 +1,1284 @@
	<?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 $forcedConduitVersion;
	private $conduitTimeout;

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

	if ($this->conduitTimeout) {
	$this->conduit->setTimeout($this->conduitTimeout);
	}

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


	/**
	* Force arc to identify with a specific Conduit version during the
	* protocol handshake. This is primarily useful for development (especially
	* for sending diffs which bump the client Conduit version), since the client
	* still actually speaks the builtin version of the protocol.
	*
	* Controlled by the --conduit-version flag.
	*
	* @param int Version the client should pretend to be.
	* @return this
	* @task conduit
	*/
	public function forceConduitVersion($version) {
	$this->forcedConduitVersion = $version;
	return $this;
	}


	/**
	* Get the protocol version the client should identify with.
	*
	* @return int Version the client should claim to be.
	* @task conduit
	*/
	public function getConduitVersion() {
	return nonempty($this->forcedConduitVersion, 5);
	}


	/**
	* Override the default timeout for Conduit.
	*
	* Controlled by the --conduit-timeout flag.
	*
	* @param float Timeout, in seconds.
	* @return this
	* @task conduit
	*/
	public function setConduitTimeout($timeout) {
	$this->conduitTimeout = $timeout;
	if ($this->conduit) {
	$this->conduit->setConduitTimeout($timeout);
	}
	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' => $this->getConduitVersion(),
	'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 if ($ex->getErrorCode() == 'NEW-ARC-VERSION') {

	// Cleverly disguise this as being AWESOME!!!

	echo phutil_console_format("New Version Available!\n\n");
	echo phutil_console_wrap($ex->getMessage());
	echo "\n\n";
	echo "In most cases, arc can be upgraded automatically.\n";

	$ok = phutil_console_confirm(
	"Upgrade arc now?",
	$default_no = false);
	if (!$ok) {
	throw $ex;
	}

	$root = dirname(phutil_get_library_root('arcanist'));

	chdir($root);
	$err = phutil_passthru('%s upgrade', $root.'/bin/arc');
	if (!$err) {
	echo "\nTry running your arc command again.\n";
	}
	exit(1);
	} 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 desiresWorkingCopy() {
	return false;
	}

	public function requiresRepositoryAPI() {
	return false;
	}

	public function desiresRepositoryAPI() {
	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) {
	return idx($this->arguments, $key, $default);
	}

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

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

	$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.");
	}
	if (!empty($options['repeat'])) {
	$dict[$arg_key][] = $args[$ii + 1];
	} else {
	$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 getSystemArcConfigLocation() {
	if (phutil_is_windows()) {
	// this is a horrible place to put this, but there doesn't seem to be a
	// non-horrible place on Windows
	return Filesystem::resolvePath(
	'Phabricator/Arcanist/config',
	getenv('PROGRAMFILES'));
	} else {
	return '/etc/arcconfig';
	}
	}

	public static function readSystemArcConfig() {
	$system_config = array();
	$system_config_path = self::getSystemArcConfigLocation();
	if (Filesystem::pathExists($system_config_path)) {
	$file = Filesystem::readFile($system_config_path);
	if ($file) {
	$system_config = json_decode($file, true);
	}
	}
	return $system_config;
	}
	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);

	// Drop the stat cache so we don't read the old permissions if
	// we end up here again. If we don't do this, we may prompt the user
	// to fix permissions multiple times.
	clearstatcache();
	}
	}

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

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

	public static function writeGlobalArcConfig(array $options) {
	$config = self::readUserConfigurationFile();
	$config['config'] = $options;
	self::writeUserConfigurationFile($config);
	}

	public function readLocalArcConfig() {
	$local = array();
	$file = $this->readScratchFile('config');
	if ($file) {
	$local = json_decode($file, true);
	}

	return $local;
	}

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

	$this->writeScratchFile('config', $json);

	return $this;
	}


	/**
	* 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() {
	$repository_api = $this->getRepositoryAPI();
	$working_copy = $this->getWorkingCopy();

	- $project_config = $working_copy->getConfigFromAnySource('immutable_history');
	- if ($project_config !== null) {
	- return $project_config;
	+ $config = $working_copy->getConfigFromAnySource('history.immutable');
	+ if ($config !== null) {
	+ return $config;
	}

	return $repository_api->isHistoryDefaultImmutable();
	}

	/**
	* 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' => $project_id,
	));

	$this->repositoryEncoding = nonempty($project_info['encoding'], $default);

	return $this->repositoryEncoding;
	}

	- protected static function formatConfigValueForDisplay($value) {
	- if (is_array($value)) {
	- // TODO: Both json_encode() and PhutilJSON do a bad job with one-liners.
	- // PhutilJSON splits them across a bunch of lines, while json_encode()
	- // escapes all kinds of stuff like "/". It would be nice if PhutilJSON
	- // had a mode for pretty one-liners.
	- $value = json_encode($value);
	- return $value;
	- }
	- return $value;
	- }
	-
	protected function newInteractiveEditor($text) {
	$editor = new PhutilInteractiveEditor($text);

	$preferred = $this->getWorkingCopy()->getConfigFromAnySource('editor');
	if ($preferred) {
	$editor->setPreferredEditor($preferred);
	}

	return $editor;
	}

	protected function newDiffParser() {
	$parser = new ArcanistDiffParser();
	$parser->setWriteDiffOnFailure(true);
	return $parser;
	}

	}
	diff --git a/src/workflow/ArcanistGetConfigWorkflow.php b/src/workflow/ArcanistGetConfigWorkflow.php
	index 8c90360c..9d7ad143 100644
	--- a/src/workflow/ArcanistGetConfigWorkflow.php
	+++ b/src/workflow/ArcanistGetConfigWorkflow.php
	@@ -1,80 +1,87 @@
	<?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
	+ Reads an arc configuration option. With no argument, reads all
	options.
	EOTEXT
	);
	}

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

	public function desiresRepositoryAPI() {
	return true;
	}

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

	+ $settings = new ArcanistSettings();
	+
	$configs = array(
	- 'system' => self::readSystemArcConfig(),
	- 'global' => self::readGlobalArcConfig(),
	- 'local' => $this->readLocalArcConfig(),
	+ 'system' => self::readSystemArcConfig(),
	+ 'global' => self::readGlobalArcConfig(),
	+ 'project' => $this->getWorkingCopy()->getProjectConfig(),
	+ 'local' => $this->readLocalArcConfig(),
	);
	if ($argv) {
	$keys = $argv;
	} else {
	$keys = array_mergev(array_map('array_keys', $configs));
	$keys = array_unique($keys);
	sort($keys);
	}

	foreach ($keys as $key) {
	+ echo "{$key}\n";
	foreach ($configs as $name => $config) {
	- if ($name == 'global' \|\| isset($config[$key])) {
	- $val = self::formatConfigValueForDisplay(idx($config, $key));
	- echo "({$name}) {$key} = {$val}\n";
	+ $val = idx($config, $key);
	+ if ($val === null) {
	+ continue;
	}
	+ $val = $settings->formatConfigValueForDisplay($key, $val);
	+ printf("% 10.10s: %s\n", $name, $val);
	}
	+ echo "\n";
	}

	return 0;
	}

	}
	diff --git a/src/workflow/ArcanistSetConfigWorkflow.php b/src/workflow/ArcanistSetConfigWorkflow.php
	index fab91404..659835e2 100644
	--- a/src/workflow/ArcanistSetConfigWorkflow.php
	+++ b/src/workflow/ArcanistSetConfigWorkflow.php
	@@ -1,219 +1,168 @@
	<?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 [__options__] -- __name__ __value__
	EOTEXT
	);
	}

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

	Options are either global (apply to all arc commands you invoke
	from the current user) or local (apply only to the current working
	copy). By default, global configuration is written. Use __--local__
	to write local configuration.

	Global values are written to '~/.arcrc' on Linux and Mac OS X, and an
	undisclosed location on Windows. Local values are written to an arc
	directory under either .git, .hg, or .svn as appropriate.

	With __--show__, a description of supported configuration values
	is shown.
	EOTEXT
	);
	}

	public function getArguments() {
	return array(
	'show' => array(
	'help' => 'Show available configuration values.',
	),
	'local' => array(
	'help' => 'Set a local config value instead of a global one',
	),
	'*' => 'argv',
	);
	}

	public function requiresRepositoryAPI() {
	return $this->getArgument('local');
	}

	public function run() {
	if ($this->getArgument('show')) {
	return $this->show();
	}

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

	$is_local = $this->getArgument('local');

	if ($is_local) {
	$config = $this->readLocalArcConfig();
	$which = 'local';
	} else {
	$config = self::readGlobalArcConfig();
	$which = 'global';
	}

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

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

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

	+ $old = $settings->formatConfigValueForDisplay($key, $old);
	+
	if ($old === null) {
	echo "Deleted key '{$key}' from {$which} config.\n";
	} else {
	- echo "Deleted key '{$key}' from {$which} config (was '{$old}').\n";
	+ echo "Deleted key '{$key}' from {$which} config (was {$old}).\n";
	}
	} else {
	- $val = $this->parse($key, $val);
	+ $val = $settings->willWriteValue($key, $val);

	$config[$key] = $val;
	if ($is_local) {
	$this->writeLocalArcConfig($config);
	} else {
	self::writeGlobalArcConfig($config);
	}

	- $val = self::formatConfigValueForDisplay($val);
	- $old = self::formatConfigValueForDisplay($old);
	+ $val = $settings->formatConfigValueForDisplay($key, $val);
	+ $old = $settings->formatConfigValueForDisplay($key, $old);

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

	return 0;
	}

	private function show() {
	- $keys = array(
	- 'default' => array(
	- 'help' =>
	- 'The URI of a Phabricator install to connect to by default, if '.
	- 'arc is run in a project without a Phabricator URI or run outside '.
	- 'of a project.',
	- 'example' => 'http://phabricator.example.com/',
	- ),
	- 'load' => array(
	- 'help' =>
	- 'A list of paths to phutil libraries that should be loaded at '.
	- 'startup. This can be used to make classes available, like lint or '.
	- 'unit test engines.',
	- 'example' => '["/var/arc/customlib/src"]',
	- ),
	- 'lint.engine' => array(
	- 'help' =>
	- 'The name of a default lint engine to use, if no lint engine is '.
	- 'specified by the current project.',
	- 'example' => 'ExampleLintEngine',
	- ),
	- 'unit.engine' => array(
	- 'help' =>
	- 'The name of a default unit test engine to use, if no unit test '.
	- 'engine is specified by the current project.',
	- 'example' => 'ExampleUnitTestEngine',
	- ),
	- 'arc.land.onto.default' => array(
	- 'help' =>
	- 'The name of the default branch to land changes onto when '.
	- '`arc land` is run.',
	- 'example' => 'develop',
	- ),
	- );
	-
	$config = self::readGlobalArcConfig();

	- foreach ($keys as $key => $spec) {
	- $type = $this->getType($key);
	+ $settings = new ArcanistSettings();
	+
	+ $keys = $settings->getAllKeys();
	+ sort($keys);
	+ foreach ($keys as $key) {
	+ $type = $settings->getType($key);
	+ $example = $settings->getExample($key);
	+ $help = $settings->getHelp($key);

	$value = idx($config, $key);
	- $value = self::formatConfigValueForDisplay($value);
	+ $value = $settings->formatConfigValueForDisplay($key, $value);

	echo phutil_console_format("__%s__ (%s)\n\n", $key, $type);
	- echo phutil_console_format(" Example: %s\n", $spec['example']);
	+ if ($example !== null) {
	+ echo phutil_console_format(" Example: %s\n", $example);
	+ }
	if (strlen($value)) {
	echo phutil_console_format(" Global Setting: %s\n", $value);
	}
	echo "\n";
	- echo phutil_console_wrap($spec['help'], 4);
	+ echo phutil_console_wrap($help, 4);
	echo "\n\n\n";
	}

	return 0;
	}

	- private function getType($key) {
	- static $types = array(
	- 'load' => 'list',
	- );
	-
	- return idx($types, $key, 'string');
	- }
	-
	- private function parse($key, $val) {
	- $type = $this->getType($key);
	-
	- switch ($type) {
	- case 'string':
	- return $val;
	- case 'list':
	- $val = json_decode($val, true);
	- if (!is_array($val)) {
	- $example = '["apple", "banana", "cherry"]';
	- throw new ArcanistUsageException(
	- "Value for key '{$key}' must be specified as a JSON-encoded ".
	- "list. Example: {$example}");
	- }
	- return $val;
	- default:
	- throw new Exception("Unknown config key type '{$type}'!");
	- }
	- }
	-
	}
	diff --git a/src/workingcopyidentity/ArcanistWorkingCopyIdentity.php b/src/workingcopyidentity/ArcanistWorkingCopyIdentity.php
	index 15e48a54..dd3dec43 100644
	--- a/src/workingcopyidentity/ArcanistWorkingCopyIdentity.php
	+++ b/src/workingcopyidentity/ArcanistWorkingCopyIdentity.php
	@@ -1,243 +1,259 @@
	<?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.
	*
	*
	* @task config
	*
	* @group workingcopy
	*/
	final class ArcanistWorkingCopyIdentity {

	protected $localConfig;
	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;
	$this->localConfig = array();

	$vc_dirs = array(
	'.git',
	'.hg',
	'.svn',
	);
	$found_meta_dir = false;
	foreach ($vc_dirs as $dir) {
	$meta_path = Filesystem::resolvePath(
	$dir,
	$this->projectRoot);
	if (Filesystem::pathExists($meta_path)) {
	$found_meta_dir = true;
	$local_path = Filesystem::resolvePath(
	'arc/config',
	$meta_path);
	if (Filesystem::pathExists($local_path)) {
	$file = Filesystem::readFile($local_path);
	if ($file) {
	$this->localConfig = json_decode($file, true);
	}
	}
	break;
	}
	}

	if (!$found_meta_dir) {
	// Try for a single higher-level .svn directory as used by svn 1.7+
	foreach (Filesystem::walkToRoot($this->projectRoot) as $parent_path) {
	$local_path = Filesystem::resolvePath(
	'.svn/arc/config',
	$parent_path);
	if (Filesystem::pathExists($local_path)) {
	$file = Filesystem::readFile($local_path);
	if ($file) {
	$this->localConfig = json_decode($file, true);
	}
	}
	}
	}

	}

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

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

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


	/* -( Config )------------------------------------------------------------- */

	+ public function getProjectConfig() {
	+ return $this->projectConfig;
	+ }

	/**
	* Read a configuration directive from project configuration. This reads ONLY
	* permanent project configuration (i.e., ".arcconfig"), not other
	* configuration sources. See @{method:getConfigFromAnySource} to read from
	* user configuration.
	*
	* @param key Key to read.
	* @param wild Default value if key is not found.
	* @return wild Value, or default value if not found.
	*
	* @task config
	*/
	public function getConfig($key, $default = null) {
	- return idx($this->projectConfig, $key, $default);
	+ $settings = new ArcanistSettings();
	+
	+ $pval = idx($this->projectConfig, $key);
	+
	+ // Test for older names in the per-project config only, since
	+ // they've only been used there.
	+ if ($pval === null) {
	+ $legacy = $settings->getLegacyName($key);
	+ if ($legacy) {
	+ $pval = $this->getConfig($legacy);
	+ }
	+ }
	+
	+ if ($pval === null) {
	+ $pval = $default;
	+ } else {
	+ $pval = $settings->willReadValue($key, $pval);
	+ }
	+
	+ return $pval;
	}


	/**
	* Read a configuration directive from local configuration. This
	* reads ONLY the per-working copy configuration,
	* i.e. .(git\|hg\|svn)/arc/config, and not other configuration
	* sources. See @{method:getConfigFromAnySource} to read from any
	* config source or @{method:getConfig} to read permanent
	* project-level config.
	*
	* @task config
	*/
	public function getLocalConfig($key, $default=null) {
	return idx($this->localConfig, $key, $default);
	}

	/**
	* Read a configuration directive from any available configuration source.
	* In contrast to @{method:getConfig}, this will look for the directive in
	* local and user configuration in addition to project configuration.
	* The precedence is local > project > user
	*
	* @param key Key to read.
	* @param wild Default value if key is not found.
	* @return wild Value, or default value if not found.
	*
	* @task config
	*/
	public function getConfigFromAnySource($key, $default = null) {
	+ $settings = new ArcanistSettings();

	// try local config first
	$pval = $this->getLocalConfig($key);

	// then per-project config
	if ($pval === null) {
	$pval = $this->getConfig($key);
	}

	- // Test for older names in the per-project config only, since
	- // they've only been used there
	- static $deprecated_names = array(
	- 'lint.engine' => 'lint_engine',
	- 'unit.engine' => 'unit_engine',
	- );
	- if ($pval === null && isset($deprecated_names[$key])) {
	- $pval = $this->getConfig($deprecated_names[$key]);
	- }
	-
	- // lastly, try global (i.e. user-level) config
	+ // now try global (i.e. user-level) config
	if ($pval === null) {
	$global_config = ArcanistBaseWorkflow::readGlobalArcConfig();
	$pval = idx($global_config, $key);
	}

	+ // Finally, try system-level config.
	if ($pval === null) {
	$system_config = ArcanistBaseWorkflow::readSystemArcConfig();
	$pval = idx($system_config, $key);
	}

	if ($pval === null) {
	$pval = $default;
	+ } else {
	+ $pval = $settings->willReadValue($key, $pval);
	}

	return $pval;

	}

	}

File Metadata

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

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions