public function getPEP8Path()
 {
     $working_copy = $this->getEngine()->getWorkingCopy();
     $prefix = $working_copy->getConfig('lint.pep8.prefix');
     $bin = $working_copy->getConfig('lint.pep8.bin');
     if ($bin === null && $prefix === null) {
         $bin = csprintf('/usr/bin/env python2.6 %s', phutil_get_library_root('arcanist') . '/../externals/pep8/pep8.py');
     } else {
         if ($bin === null) {
             $bin = 'pep8';
         }
         if ($prefix !== null) {
             if (!Filesystem::pathExists($prefix . '/' . $bin)) {
                 throw new ArcanistUsageException("Unable to find PEP8 binary in a specified directory. Make sure " . "that 'lint.pep8.prefix' and 'lint.pep8.bin' keys are set " . "correctly. If you'd rather use a copy of PEP8 installed " . "globally, you can just remove these keys from your .arcconfig.");
             }
             $bin = csprintf("%s/%s", $prefix, $bin);
             return $bin;
         }
         // Look for globally installed PEP8
         list($err) = exec_manual('which %s', $bin);
         if ($err) {
             throw new ArcanistUsageException("PEP8 does not appear to be installed on this system. Install it " . "(e.g., with 'easy_install pep8') or configure " . "'lint.pep8.prefix' in your .arcconfig to point to the directory " . "where it resides.");
         }
     }
     return $bin;
 }

 public static function newAPIFromWorkingCopyIdentity(ArcanistWorkingCopyIdentity $working_copy)
 {
     $root = $working_copy->getProjectRoot();
     if (!$root) {
         throw new ArcanistUsageException("There is no readable '.arcconfig' file in the working directory or " . "any parent directory. Create an '.arcconfig' file to configure arc.");
     }
     // check if we're in an svn working copy
     list($err) = exec_manual('svn info');
     if (!$err) {
         $api = newv('ArcanistSubversionAPI', array($root));
         $api->workingCopyIdentity = $working_copy;
         return $api;
     }
     if (Filesystem::pathExists($root . '/.hg')) {
         $api = newv('ArcanistMercurialAPI', array($root));
         $api->workingCopyIdentity = $working_copy;
         return $api;
     }
     $git_root = self::discoverGitBaseDirectory($root);
     if ($git_root) {
         if (!Filesystem::pathsAreEquivalent($root, $git_root)) {
             throw new ArcanistUsageException("'.arcconfig' file is located at '{$root}', but working copy root " . "is '{$git_root}'. Move '.arcconfig' file to the working copy root.");
         }
         $api = newv('ArcanistGitAPI', array($root));
         $api->workingCopyIdentity = $working_copy;
         return $api;
     }
     throw new ArcanistUsageException("The current working directory is not part of a working copy for a " . "supported version control system (svn, git or mercurial).");
 }

 public function lintPath($path)
 {
     $pep8_bin = $this->getPEP8Path();
     $options = $this->getPEP8Options();
     list($rc, $stdout) = exec_manual("%C %C %s", $pep8_bin, $options, $this->getEngine()->getFilePathOnDisk($path));
     $lines = explode("\n", $stdout);
     $messages = array();
     foreach ($lines as $line) {
         $matches = null;
         if (!preg_match('/^(.*?):(\\d+):(\\d+): (\\S+) (.*)$/', $line, $matches)) {
             continue;
         }
         foreach ($matches as $key => $match) {
             $matches[$key] = trim($match);
         }
         $message = new ArcanistLintMessage();
         $message->setPath($path);
         $message->setLine($matches[2]);
         $message->setChar($matches[3]);
         $message->setCode($matches[4]);
         $message->setName('PEP8 ' . $matches[4]);
         $message->setDescription($matches[5]);
         if (!$this->isMessageEnabled($matches[4])) {
             continue;
         }
         if ($matches[4][0] == 'E') {
             $message->setSeverity(ArcanistLintSeverity::SEVERITY_ERROR);
         } else {
             $message->setSeverity(ArcanistLintSeverity::SEVERITY_WARNING);
         }
         $this->addLintMessage($message);
     }
 }

/**
 * @group console
 */
function phutil_console_prompt($prompt, $history = '')
{
    echo "\n\n";
    $prompt = phutil_console_wrap($prompt . ' ', 4);
    try {
        phutil_console_require_tty();
    } catch (PhutilConsoleStdinNotInteractiveException $ex) {
        // Throw after echoing the prompt so the user has some idea what happened.
        echo $prompt;
        throw $ex;
    }
    $use_history = true;
    if ($history == '') {
        $use_history = false;
    } else {
        // Test if bash is available by seeing if it can run `true`.
        list($err) = exec_manual('bash -c %s', 'true');
        if ($err) {
            $use_history = false;
        }
    }
    if (!$use_history) {
        echo $prompt;
        $response = fgets(STDIN);
    } else {
        // There's around 0% chance that readline() is available directly in PHP,
        // so we're using bash/read/history instead.
        $command = csprintf('bash -c %s', csprintf('history -r %s 2>/dev/null; ' . 'read -e -p %s; ' . 'echo "$REPLY"; ' . 'history -s "$REPLY" 2>/dev/null; ' . 'history -w %s 2>/dev/null', $history, $prompt, $history));
        // execx() doesn't work with input, phutil_passthru() doesn't return output.
        $response = shell_exec($command);
    }
    return rtrim($response, "\r\n");
}

 protected function executeChecks()
 {
     if (phutil_is_windows()) {
         $bin_name = 'where';
     } else {
         $bin_name = 'which';
     }
     if (!Filesystem::binaryExists($bin_name)) {
         $message = pht("Without '%s', Phabricator can not test for the availability " . "of other binaries.", $bin_name);
         $this->raiseWarning($bin_name, $message);
         // We need to return here if we can't find the 'which' / 'where' binary
         // because the other tests won't be valid.
         return;
     }
     if (!Filesystem::binaryExists('diff')) {
         $message = pht("Without 'diff', Phabricator will not be able to generate or render " . "diffs in multiple applications.");
         $this->raiseWarning('diff', $message);
     } else {
         $tmp_a = new TempFile();
         $tmp_b = new TempFile();
         $tmp_c = new TempFile();
         Filesystem::writeFile($tmp_a, 'A');
         Filesystem::writeFile($tmp_b, 'A');
         Filesystem::writeFile($tmp_c, 'B');
         list($err) = exec_manual('diff %s %s', $tmp_a, $tmp_b);
         if ($err) {
             $this->newIssue('bin.diff.same')->setName(pht("Unexpected 'diff' Behavior"))->setMessage(pht("The 'diff' binary on this system has unexpected behavior: " . "it was expected to exit without an error code when passed " . "identical files, but exited with code %d.", $err));
         }
         list($err) = exec_manual('diff %s %s', $tmp_a, $tmp_c);
         if (!$err) {
             $this->newIssue('bin.diff.diff')->setName(pht("Unexpected 'diff' Behavior"))->setMessage(pht("The 'diff' binary on this system has unexpected behavior: " . "it was expected to exit with a nonzero error code when passed " . "differing files, but did not."));
         }
     }
     $table = new PhabricatorRepository();
     $vcses = queryfx_all($table->establishConnection('r'), 'SELECT DISTINCT versionControlSystem FROM %T', $table->getTableName());
     foreach ($vcses as $vcs) {
         switch ($vcs['versionControlSystem']) {
             case PhabricatorRepositoryType::REPOSITORY_TYPE_GIT:
                 $binary = 'git';
                 break;
             case PhabricatorRepositoryType::REPOSITORY_TYPE_SVN:
                 $binary = 'svn';
                 break;
             case PhabricatorRepositoryType::REPOSITORY_TYPE_MERCURIAL:
                 $binary = 'hg';
                 break;
             default:
                 $binary = null;
                 break;
         }
         if (!$binary) {
             continue;
         }
         if (!Filesystem::binaryExists($binary)) {
             $message = pht('You have at least one repository configured which uses this ' . 'version control system. It will not work without the VCS binary.');
             $this->raiseWarning($binary, $message);
         }
     }
 }

 private function getBinaryPath()
 {
     if ($this->symbolsBinary === null) {
         list($err, $stdout) = exec_manual('which javelinsymbols');
         $this->symbolsBinary = $err ? false : rtrim($stdout);
     }
     return $this->symbolsBinary;
 }

 /**
  * Generate a raw diff from two raw files. This is a lower-level API than
  * @{method:generateChangesetFromFileContent}, but may be useful if you need
  * to use a custom parser configuration, as with Diffusion.
  *
  * @param string Entire previous file content.
  * @param string Entire current file content.
  * @return string Raw diff between the two files.
  * @task diff
  */
 public function generateRawDiffFromFileContent($old, $new)
 {
     $options = array();
     if ($this->ignoreWhitespace) {
         $options[] = '-bw';
     }
     // Generate diffs with full context.
     $options[] = '-U65535';
     $old_name = nonempty($this->oldName, '/dev/universe') . ' 9999-99-99';
     $new_name = nonempty($this->newName, '/dev/universe') . ' 9999-99-99';
     $options[] = '-L';
     $options[] = $old_name;
     $options[] = '-L';
     $options[] = $new_name;
     $old_tmp = new TempFile();
     $new_tmp = new TempFile();
     Filesystem::writeFile($old_tmp, $old);
     Filesystem::writeFile($new_tmp, $new);
     list($err, $diff) = exec_manual('diff %Ls %s %s', $options, $old_tmp, $new_tmp);
     if (!$err) {
         // This indicates that the two files are the same (or, possibly, the
         // same modulo whitespace differences, which is why we can't do this
         // check trivially before running `diff`). Build a synthetic, changeless
         // diff so that we can still render the raw, unchanged file instead of
         // being forced to just say "this file didn't change" since we don't have
         // the content.
         $entire_file = explode("\n", $old);
         foreach ($entire_file as $k => $line) {
             $entire_file[$k] = ' ' . $line;
         }
         $len = count($entire_file);
         $entire_file = implode("\n", $entire_file);
         // TODO: If both files were identical but missing newlines, we probably
         // get this wrong. Unclear if it ever matters.
         // This is a bit hacky but the diff parser can handle it.
         $diff = "--- {$old_name}\n" . "+++ {$new_name}\n" . "@@ -1,{$len} +1,{$len} @@\n" . $entire_file . "\n";
     } else {
         if ($this->ignoreWhitespace) {
             // Under "-bw", `diff` is inconsistent about emitting "\ No newline
             // at end of file". For instance, a long file with a change in the
             // middle will emit a contextless "\ No newline..." at the end if a
             // newline is removed, but not if one is added. A file with a change
             // at the end will emit the "old" "\ No newline..." block only, even
             // if the newline was not removed. Since we're ostensibly ignoring
             // whitespace changes, just drop these lines if they appear anywhere
             // in the diff.
             $lines = explode("\n", $diff);
             foreach ($lines as $key => $line) {
                 if (isset($line[0]) && $line[0] == '\\') {
                     unset($lines[$key]);
                 }
             }
             $diff = implode("\n", $lines);
         }
     }
     return $diff;
 }

 private function getControlDirectory($path)
 {
     if (!Filesystem::pathExists($path)) {
         list($err) = exec_manual('mkdir -p %s', $path);
         if ($err) {
             throw new Exception(pht("%s requires the directory '%s' to exist, but it does not exist " . "and could not be created. Create this directory or update " . "'%s' / '%s' in your configuration to point to an existing " . "directory.", 'phd', $path, 'phd.pid-directory', 'phd.log-directory'));
         }
     }
     return $path;
 }

 private function getControlDirectory($path)
 {
     if (!Filesystem::pathExists($path)) {
         list($err) = exec_manual('mkdir -p %s', $path);
         if ($err) {
             throw new Exception("phd requires the directory '{$path}' to exist, but it does not " . "exist and could not be created. Create this directory or update " . "'phd.pid-directory' / 'phd.log-directory' in your configuration " . "to point to an existing directory.");
         }
     }
     return $path;
 }

 public function getVersion()
 {
     // NOTE: `jsonlint --version` returns a non-zero exit status.
     list($err, $stdout) = exec_manual('%C --version', $this->getExecutableCommand());
     $matches = array();
     if (preg_match('/^(?P<version>\\d+\\.\\d+\\.\\d+)$/', $stdout, $matches)) {
         return $matches['version'];
     } else {
         return false;
     }
 }

 public static function renderDifferences($old, $new, $context_lines = 3, $diff_options = "-L 'Old Value' -L 'New Value'")
 {
     if ((string) $old === (string) $new) {
         $new .= "\n(Old and new values are identical.)";
     }
     $file_old = new TempFile();
     $file_new = new TempFile();
     Filesystem::writeFile($file_old, (string) $old . "\n");
     Filesystem::writeFile($file_new, (string) $new . "\n");
     list($err, $stdout) = exec_manual('diff %C -U %s %s %s', $diff_options, $context_lines, $file_old, $file_new);
     return $stdout;
 }

 protected function execute(ConduitAPIRequest $request)
 {
     $path = xhpast_get_binary_path();
     if (!Filesystem::pathExists($path)) {
         throw new ConduitException('ERR-NOT-FOUND');
     }
     list($err, $stdout) = exec_manual('%s --version', $path);
     if ($err) {
         throw new ConduitException('ERR-COMMAND-FAILED');
     }
     return trim($stdout);
 }

 protected function executeChecks()
 {
     $pygment = PhabricatorEnv::getEnvConfig('pygments.enabled');
     if ($pygment) {
         list($err) = exec_manual('pygmentize -h');
         if ($err) {
             $summary = pht('You enabled pygments but the pygmentize script is not ' . 'actually available, your $PATH is probably broken.');
             $message = pht('The environmental variable $PATH does not contain ' . 'pygmentize. You have enabled pygments, which requires ' . 'pygmentize to be available in your $PATH variable.');
             $this->newIssue('pygments.enabled')->setName(pht('pygmentize Not Found'))->setSummary($summary)->setMessage($message)->addRelatedPhabricatorConfig('pygments.enabled')->addPhabricatorConfig('environment.append-paths');
         }
     }
 }

 public function getDefaultBinary()
 {
     $binary = 'go';
     if (Filesystem::binaryExists($binary)) {
         // Vet is only accessible through 'go vet' or 'go tool vet'
         // Let's manually try to find out if it's installed.
         list($err, $stdout, $stderr) = exec_manual('go tool vet');
         if ($err === 3) {
             throw new ArcanistMissingLinterException(sprintf("%s\n%s", pht('Unable to locate "go vet" to run linter %s. You may need ' . 'to install the binary, or adjust your linter configuration.', get_class($this)), pht('TO INSTALL: %s', $this->getInstallInstructions())));
         }
     }
     return $binary;
 }

 public static function getMercurialVersion()
 {
     list($err, $stdout, $stderr) = exec_manual('hg --version --quiet');
     // NOTE: At least on OSX, recent versions of Mercurial report this
     // string in this format:
     //
     //   Mercurial Distributed SCM (version 3.1.1+20140916)
     $matches = null;
     $pattern = '/^Mercurial Distributed SCM \\(version ([\\d.]+)/m';
     if (preg_match($pattern, $stdout, $matches)) {
         return $matches[1];
     }
     return null;
 }

 public function decryptSecret(PhutilOpaqueEnvelope $secret, PhutilOpaqueEnvelope $password)
 {
     $tmp = new TempFile();
     Filesystem::writeFile($tmp, $secret->openEnvelope());
     if (!Filesystem::binaryExists('ssh-keygen')) {
         throw new Exception(pht('Decrypting SSH keys requires the `ssh-keygen` binary, but it ' . 'is not available in PATH. Either make it available or strip the ' . 'password fromt his SSH key manually before uploading it.'));
     }
     list($err, $stdout, $stderr) = exec_manual('ssh-keygen -p -P %P -N %s -f %s', $password, '', (string) $tmp);
     if ($err) {
         return null;
     } else {
         return new PhutilOpaqueEnvelope(Filesystem::readFile($tmp));
     }
 }

 public function getLintPath()
 {
     $bin = 'cpplint.py';
     // Search under current dir
     list($err) = exec_manual('which %s/%s', $this->linterDir(), $bin);
     if (!$err) {
         return $this->linterDir() . '/' . $bin;
     }
     // Look for globally installed cpplint.py
     list($err) = exec_manual('which %s', $bin);
     if ($err) {
         throw new ArcanistUsageException("cpplint.py does not appear to be installed on this system. Install " . "it (e.g., with 'wget \"http://google-styleguide.googlecode.com/" . "svn/trunk/cpplint/cpplint.py\"') " . "in your .arcconfig to point to the directory where it resides. " . "Also don't forget to chmod a+x cpplint.py!");
     }
     return $bin;
 }

 public function lintPath($path)
 {
     $bin = $this->getLintPath();
     $options = $this->getLintOptions();
     list($rc, $stdout, $stderr) = exec_manual("%C %C --inline-suppr --xml-version=2 -q %s", $bin, $options, $this->getEngine()->getFilePathOnDisk($path));
     if ($rc === 1) {
         throw new Exception("cppcheck failed to run correctly:\n" . $stderr);
     }
     $dom = new DOMDocument();
     libxml_clear_errors();
     if ($dom->loadXML($stderr) === false || libxml_get_errors()) {
         throw new ArcanistUsageException('cppcheck Linter failed to load ' . 'output. Something happened when running cppcheck. ' . "Output:\n{$stderr}" . "\nTry running lint with --trace flag to get more details.");
     }
     $errors = $dom->getElementsByTagName('error');
     foreach ($errors as $error) {
         $loc_node = $error->getElementsByTagName('location');
         if (!$loc_node) {
             continue;
         }
         $location = $loc_node->item(0);
         if (!$location) {
             continue;
         }
         $file = $location->getAttribute('file');
         $line = $location->getAttribute('line');
         $id = $error->getAttribute('id');
         $severity = $error->getAttribute('severity');
         $msg = $error->getAttribute('msg');
         $inconclusive = $error->getAttribute('inconclusive');
         $verbose_msg = $error->getAttribute('verbose');
         $severity_code = ArcanistLintSeverity::SEVERITY_WARNING;
         if ($inconclusive) {
             $severity_code = ArcanistLintSeverity::SEVERITY_ADVICE;
         } else {
             if (stripos($severity, 'error') !== false) {
                 $severity_code = ArcanistLintSeverity::SEVERITY_ERROR;
             }
         }
         $message = new ArcanistLintMessage();
         $message->setPath($path);
         $message->setLine($line);
         $message->setCode($severity);
         $message->setName($id);
         $message->setDescription($msg);
         $message->setSeverity($severity_code);
         $this->addLintMessage($message);
     }
 }

 private function getSBTPath()
 {
     $sbt_bin = "sbt";
     // Use the SBT prefix specified in the config file
     $working_copy = $this->getEngine()->getWorkingCopy();
     $prefix = $working_copy->getConfig('lint.scala_sbt.prefix');
     if ($prefix !== null) {
         $sbt_bin = $prefix . $sbt_bin;
     }
     if (!Filesystem::pathExists($sbt_bin)) {
         list($err) = exec_manual('which %s', $sbt_bin);
         if ($err) {
             throw new ArcanistUsageException("SBT does not appear to be installed on this system. Install it or " . "add 'lint.scala_sbt.prefix' in your .arcconfig to point to " . "the directory where it resides.");
         }
     }
     return $sbt_bin;
 }

/**
 * @group xhpast
 */
function xhpast_is_available()
{
    static $available;
    if ($available === null) {
        $available = false;
        $bin = xhpast_get_binary_path();
        if (Filesystem::pathExists($bin)) {
            list($err, $stdout) = exec_manual('%s --version', $bin);
            if (!$err) {
                $version = trim($stdout);
                if ($version === "xhpast version 5.5.8/1e") {
                    $available = true;
                }
            }
        }
    }
    return $available;
}