dependabot-composer 0.95.69 → 0.95.70

data/helpers/vendor/composer/composer/src/Composer/Command/SelfUpdateCommand.php

@@ -0,0 +1,404 @@
+<?php
+
+/*
+ * This file is part of Composer.
+ *
+ * (c) Nils Adermann <naderman@naderman.de>
+ *     Jordi Boggiano <j.boggiano@seld.be>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Composer\Command;
+
+use Composer\Composer;
+use Composer\Factory;
+use Composer\Config;
+use Composer\Util\Filesystem;
+use Composer\SelfUpdate\Keys;
+use Composer\SelfUpdate\Versions;
+use Composer\IO\IOInterface;
+use Composer\Downloader\FilesystemException;
+use Symfony\Component\Console\Input\InputInterface;
+use Symfony\Component\Console\Input\InputOption;
+use Symfony\Component\Console\Input\InputArgument;
+use Symfony\Component\Console\Output\OutputInterface;
+use Symfony\Component\Finder\Finder;
+
+/**
+ * @author Igor Wiedler <igor@wiedler.ch>
+ * @author Kevin Ran <kran@adobe.com>
+ * @author Jordi Boggiano <j.boggiano@seld.be>
+ */
+class SelfUpdateCommand extends BaseCommand
+{
+    const HOMEPAGE = 'getcomposer.org';
+    const OLD_INSTALL_EXT = '-old.phar';
+
+    protected function configure()
+    {
+        $this
+            ->setName('self-update')
+            ->setAliases(array('selfupdate'))
+            ->setDescription('Updates composer.phar to the latest version.')
+            ->setDefinition(array(
+                new InputOption('rollback', 'r', InputOption::VALUE_NONE, 'Revert to an older installation of composer'),
+                new InputOption('clean-backups', null, InputOption::VALUE_NONE, 'Delete old backups during an update. This makes the current version of composer the only backup available after the update'),
+                new InputArgument('version', InputArgument::OPTIONAL, 'The version to update to'),
+                new InputOption('no-progress', null, InputOption::VALUE_NONE, 'Do not output download progress.'),
+                new InputOption('update-keys', null, InputOption::VALUE_NONE, 'Prompt user for a key update'),
+                new InputOption('stable', null, InputOption::VALUE_NONE, 'Force an update to the stable channel'),
+                new InputOption('preview', null, InputOption::VALUE_NONE, 'Force an update to the preview channel'),
+                new InputOption('snapshot', null, InputOption::VALUE_NONE, 'Force an update to the snapshot channel'),
+                new InputOption('set-channel-only', null, InputOption::VALUE_NONE, 'Only store the channel as the default one and then exit'),
+            ))
+            ->setHelp(
+                <<<EOT
+The <info>self-update</info> command checks getcomposer.org for newer
+versions of composer and if found, installs the latest.
+
+<info>php composer.phar self-update</info>
+
+EOT
+            )
+        ;
+    }
+
+    protected function execute(InputInterface $input, OutputInterface $output)
+    {
+        $config = Factory::createConfig();
+
+        if ($config->get('disable-tls') === true) {
+            $baseUrl = 'http://' . self::HOMEPAGE;
+        } else {
+            $baseUrl = 'https://' . self::HOMEPAGE;
+        }
+
+        $io = $this->getIO();
+        $remoteFilesystem = Factory::createRemoteFilesystem($io, $config);
+
+        $versionsUtil = new Versions($config, $remoteFilesystem);
+
+        // switch channel if requested
+        foreach (array('stable', 'preview', 'snapshot') as $channel) {
+            if ($input->getOption($channel)) {
+                $versionsUtil->setChannel($channel);
+            }
+        }
+
+        if ($input->getOption('set-channel-only')) {
+            return 0;
+        }
+
+        $cacheDir = $config->get('cache-dir');
+        $rollbackDir = $config->get('data-dir');
+        $home = $config->get('home');
+        $localFilename = realpath($_SERVER['argv'][0]) ?: $_SERVER['argv'][0];
+
+        if ($input->getOption('update-keys')) {
+            return $this->fetchKeys($io, $config);
+        }
+
+        // check if current dir is writable and if not try the cache dir from settings
+        $tmpDir = is_writable(dirname($localFilename)) ? dirname($localFilename) : $cacheDir;
+
+        // check for permissions in local filesystem before start connection process
+        if (!is_writable($tmpDir)) {
+            throw new FilesystemException('Composer update failed: the "'.$tmpDir.'" directory used to download the temp file could not be written');
+        }
+
+        // check if composer is running as the same user that owns the directory root, only if POSIX is defined and callable
+        if (function_exists('posix_getpwuid') && function_exists('posix_geteuid')) {
+            $composeUser = posix_getpwuid(posix_geteuid());
+            $homeOwner = posix_getpwuid(fileowner($home));
+            if (isset($composeUser['name']) && isset($homeOwner['name']) && $composeUser['name'] !== $homeOwner['name']) {
+                $io->writeError('<warning>You are running composer as "'.$composeUser['name'].'", while "'.$home.'" is owned by "'.$homeOwner['name'].'"</warning>');
+            }
+        }
+
+        if ($input->getOption('rollback')) {
+            return $this->rollback($output, $rollbackDir, $localFilename);
+        }
+
+        $latest = $versionsUtil->getLatest();
+        $latestVersion = $latest['version'];
+        $updateVersion = $input->getArgument('version') ?: $latestVersion;
+
+        if (preg_match('{^[0-9a-f]{40}$}', $updateVersion) && $updateVersion !== $latestVersion) {
+            $io->writeError('<error>You can not update to a specific SHA-1 as those phars are not available for download</error>');
+
+            return 1;
+        }
+
+        if (Composer::VERSION === $updateVersion) {
+            $io->writeError(sprintf('<info>You are already using composer version %s (%s channel).</info>', $updateVersion, $versionsUtil->getChannel()));
+
+            // remove all backups except for the most recent, if any
+            if ($input->getOption('clean-backups')) {
+                $this->cleanBackups($rollbackDir, $this->getLastBackupVersion($rollbackDir));
+            }
+
+            return 0;
+        }
+
+        $tempFilename = $tmpDir . '/' . basename($localFilename, '.phar').'-temp.phar';
+        $backupFile = sprintf(
+            '%s/%s-%s%s',
+            $rollbackDir,
+            strtr(Composer::RELEASE_DATE, ' :', '_-'),
+            preg_replace('{^([0-9a-f]{7})[0-9a-f]{33}$}', '$1', Composer::VERSION),
+            self::OLD_INSTALL_EXT
+        );
+
+        $updatingToTag = !preg_match('{^[0-9a-f]{40}$}', $updateVersion);
+
+        $io->write(sprintf("Updating to version <info>%s</info> (%s channel).", $updateVersion, $versionsUtil->getChannel()));
+        $remoteFilename = $baseUrl . ($updatingToTag ? "/download/{$updateVersion}/composer.phar" : '/composer.phar');
+        $signature = $remoteFilesystem->getContents(self::HOMEPAGE, $remoteFilename.'.sig', false);
+        $io->writeError('   ', false);
+        $remoteFilesystem->copy(self::HOMEPAGE, $remoteFilename, $tempFilename, !$input->getOption('no-progress'));
+        $io->writeError('');
+
+        if (!file_exists($tempFilename) || !$signature) {
+            $io->writeError('<error>The download of the new composer version failed for an unexpected reason</error>');
+
+            return 1;
+        }
+
+        // verify phar signature
+        if (!extension_loaded('openssl') && $config->get('disable-tls')) {
+            $io->writeError('<warning>Skipping phar signature verification as you have disabled OpenSSL via config.disable-tls</warning>');
+        } else {
+            if (!extension_loaded('openssl')) {
+                throw new \RuntimeException('The openssl extension is required for phar signatures to be verified but it is not available. '
+                . 'If you can not enable the openssl extension, you can disable this error, at your own risk, by setting the \'disable-tls\' option to true.');
+            }
+
+            $sigFile = 'file://'.$home.'/' . ($updatingToTag ? 'keys.tags.pub' : 'keys.dev.pub');
+            if (!file_exists($sigFile)) {
+                file_put_contents(
+                    $home.'/keys.dev.pub',
+                    <<<DEVPUBKEY
+-----BEGIN PUBLIC KEY-----
+MIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEAnBDHjZS6e0ZMoK3xTD7f
+FNCzlXjX/Aie2dit8QXA03pSrOTbaMnxON3hUL47Lz3g1SC6YJEMVHr0zYq4elWi
+i3ecFEgzLcj+pZM5X6qWu2Ozz4vWx3JYo1/a/HYdOuW9e3lwS8VtS0AVJA+U8X0A
+hZnBmGpltHhO8hPKHgkJtkTUxCheTcbqn4wGHl8Z2SediDcPTLwqezWKUfrYzu1f
+o/j3WFwFs6GtK4wdYtiXr+yspBZHO3y1udf8eFFGcb2V3EaLOrtfur6XQVizjOuk
+8lw5zzse1Qp/klHqbDRsjSzJ6iL6F4aynBc6Euqt/8ccNAIz0rLjLhOraeyj4eNn
+8iokwMKiXpcrQLTKH+RH1JCuOVxQ436bJwbSsp1VwiqftPQieN+tzqy+EiHJJmGf
+TBAbWcncicCk9q2md+AmhNbvHO4PWbbz9TzC7HJb460jyWeuMEvw3gNIpEo2jYa9
+pMV6cVqnSa+wOc0D7pC9a6bne0bvLcm3S+w6I5iDB3lZsb3A9UtRiSP7aGSo7D72
+8tC8+cIgZcI7k9vjvOqH+d7sdOU2yPCnRY6wFh62/g8bDnUpr56nZN1G89GwM4d4
+r/TU7BQQIzsZgAiqOGXvVklIgAMiV0iucgf3rNBLjjeNEwNSTTG9F0CtQ+7JLwaE
+wSEuAuRm+pRqi8BRnQ/GKUcCAwEAAQ==
+-----END PUBLIC KEY-----
+DEVPUBKEY
+                );
+
+                file_put_contents(
+                    $home.'/keys.tags.pub',
+                    <<<TAGSPUBKEY
+-----BEGIN PUBLIC KEY-----
+MIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEA0Vi/2K6apCVj76nCnCl2
+MQUPdK+A9eqkYBacXo2wQBYmyVlXm2/n/ZsX6pCLYPQTHyr5jXbkQzBw8SKqPdlh
+vA7NpbMeNCz7wP/AobvUXM8xQuXKbMDTY2uZ4O7sM+PfGbptKPBGLe8Z8d2sUnTO
+bXtX6Lrj13wkRto7st/w/Yp33RHe9SlqkiiS4MsH1jBkcIkEHsRaveZzedUaxY0M
+mba0uPhGUInpPzEHwrYqBBEtWvP97t2vtfx8I5qv28kh0Y6t+jnjL1Urid2iuQZf
+noCMFIOu4vksK5HxJxxrN0GOmGmwVQjOOtxkwikNiotZGPR4KsVj8NnBrLX7oGuM
+nQvGciiu+KoC2r3HDBrpDeBVdOWxDzT5R4iI0KoLzFh2pKqwbY+obNPS2bj+2dgJ
+rV3V5Jjry42QOCBN3c88wU1PKftOLj2ECpewY6vnE478IipiEu7EAdK8Zwj2LmTr
+RKQUSa9k7ggBkYZWAeO/2Ag0ey3g2bg7eqk+sHEq5ynIXd5lhv6tC5PBdHlWipDK
+tl2IxiEnejnOmAzGVivE1YGduYBjN+mjxDVy8KGBrjnz1JPgAvgdwJ2dYw4Rsc/e
+TzCFWGk/HM6a4f0IzBWbJ5ot0PIi4amk07IotBXDWwqDiQTwyuGCym5EqWQ2BD95
+RGv89BPD+2DLnJysngsvVaUCAwEAAQ==
+-----END PUBLIC KEY-----
+TAGSPUBKEY
+                );
+            }
+
+            $pubkeyid = openssl_pkey_get_public($sigFile);
+            $algo = defined('OPENSSL_ALGO_SHA384') ? OPENSSL_ALGO_SHA384 : 'SHA384';
+            if (!in_array('sha384', array_map('strtolower', openssl_get_md_methods()))) {
+                throw new \RuntimeException('SHA384 is not supported by your openssl extension, could not verify the phar file integrity');
+            }
+            $signature = json_decode($signature, true);
+            $signature = base64_decode($signature['sha384']);
+            $verified = 1 === openssl_verify(file_get_contents($tempFilename), $signature, $pubkeyid, $algo);
+            openssl_free_key($pubkeyid);
+            if (!$verified) {
+                throw new \RuntimeException('The phar signature did not match the file you downloaded, this means your public keys are outdated or that the phar file is corrupt/has been modified');
+            }
+        }
+
+        // remove saved installations of composer
+        if ($input->getOption('clean-backups')) {
+            $this->cleanBackups($rollbackDir);
+        }
+
+        if ($err = $this->setLocalPhar($localFilename, $tempFilename, $backupFile)) {
+            @unlink($tempFilename);
+            $io->writeError('<error>The file is corrupted ('.$err->getMessage().').</error>');
+            $io->writeError('<error>Please re-run the self-update command to try again.</error>');
+
+            return 1;
+        }
+
+        if (file_exists($backupFile)) {
+            $io->writeError(sprintf(
+                'Use <info>composer self-update --rollback</info> to return to version <comment>%s</comment>',
+                Composer::VERSION
+            ));
+        } else {
+            $io->writeError('<warning>A backup of the current version could not be written to '.$backupFile.', no rollback possible</warning>');
+        }
+    }
+
+    protected function fetchKeys(IOInterface $io, Config $config)
+    {
+        if (!$io->isInteractive()) {
+            throw new \RuntimeException('Public keys can not be fetched in non-interactive mode, please run Composer interactively');
+        }
+
+        $io->write('Open <info>https://composer.github.io/pubkeys.html</info> to find the latest keys');
+
+        $validator = function ($value) {
+            if (!preg_match('{^-----BEGIN PUBLIC KEY-----$}', trim($value))) {
+                throw new \UnexpectedValueException('Invalid input');
+            }
+
+            return trim($value)."\n";
+        };
+
+        $devKey = '';
+        while (!preg_match('{(-----BEGIN PUBLIC KEY-----.+?-----END PUBLIC KEY-----)}s', $devKey, $match)) {
+            $devKey = $io->askAndValidate('Enter Dev / Snapshot Public Key (including lines with -----): ', $validator);
+            while ($line = $io->ask('')) {
+                $devKey .= trim($line)."\n";
+                if (trim($line) === '-----END PUBLIC KEY-----') {
+                    break;
+                }
+            }
+        }
+        file_put_contents($keyPath = $config->get('home').'/keys.dev.pub', $match[0]);
+        $io->write('Stored key with fingerprint: ' . Keys::fingerprint($keyPath));
+
+        $tagsKey = '';
+        while (!preg_match('{(-----BEGIN PUBLIC KEY-----.+?-----END PUBLIC KEY-----)}s', $tagsKey, $match)) {
+            $tagsKey = $io->askAndValidate('Enter Tags Public Key (including lines with -----): ', $validator);
+            while ($line = $io->ask('')) {
+                $tagsKey .= trim($line)."\n";
+                if (trim($line) === '-----END PUBLIC KEY-----') {
+                    break;
+                }
+            }
+        }
+        file_put_contents($keyPath = $config->get('home').'/keys.tags.pub', $match[0]);
+        $io->write('Stored key with fingerprint: ' . Keys::fingerprint($keyPath));
+
+        $io->write('Public keys stored in '.$config->get('home'));
+    }
+
+    protected function rollback(OutputInterface $output, $rollbackDir, $localFilename)
+    {
+        $rollbackVersion = $this->getLastBackupVersion($rollbackDir);
+        if (!$rollbackVersion) {
+            throw new \UnexpectedValueException('Composer rollback failed: no installation to roll back to in "'.$rollbackDir.'"');
+        }
+
+        $oldFile = $rollbackDir . '/' . $rollbackVersion . self::OLD_INSTALL_EXT;
+
+        if (!is_file($oldFile)) {
+            throw new FilesystemException('Composer rollback failed: "'.$oldFile.'" could not be found');
+        }
+        if (!is_readable($oldFile)) {
+            throw new FilesystemException('Composer rollback failed: "'.$oldFile.'" could not be read');
+        }
+
+        $io = $this->getIO();
+        $io->writeError(sprintf("Rolling back to version <info>%s</info>.", $rollbackVersion));
+        if ($err = $this->setLocalPhar($localFilename, $oldFile)) {
+            $io->writeError('<error>The backup file was corrupted ('.$err->getMessage().').</error>');
+
+            return 1;
+        }
+
+        return 0;
+    }
+
+    /**
+     * @param  string                                        $localFilename
+     * @param  string                                        $newFilename
+     * @param  string                                        $backupTarget
+     * @throws \Exception
+     * @return \UnexpectedValueException|\PharException|null
+     */
+    protected function setLocalPhar($localFilename, $newFilename, $backupTarget = null)
+    {
+        try {
+            @chmod($newFilename, fileperms($localFilename));
+            if (!ini_get('phar.readonly')) {
+                // test the phar validity
+                $phar = new \Phar($newFilename);
+                // free the variable to unlock the file
+                unset($phar);
+            }
+
+            // copy current file into installations dir
+            if ($backupTarget && file_exists($localFilename)) {
+                @copy($localFilename, $backupTarget);
+            }
+
+            rename($newFilename, $localFilename);
+
+            return null;
+        } catch (\Exception $e) {
+            if (!$e instanceof \UnexpectedValueException && !$e instanceof \PharException) {
+                throw $e;
+            }
+
+            return $e;
+        }
+    }
+
+    protected function cleanBackups($rollbackDir, $except = null)
+    {
+        $finder = $this->getOldInstallationFinder($rollbackDir);
+        $io = $this->getIO();
+        $fs = new Filesystem;
+
+        foreach ($finder as $file) {
+            if ($except && $file->getBasename(self::OLD_INSTALL_EXT) === $except) {
+                continue;
+            }
+            $file = (string) $file;
+            $io->writeError('<info>Removing: '.$file.'</info>');
+            $fs->remove($file);
+        }
+    }
+
+    protected function getLastBackupVersion($rollbackDir)
+    {
+        $finder = $this->getOldInstallationFinder($rollbackDir);
+        $finder->sortByName();
+        $files = iterator_to_array($finder);
+
+        if (count($files)) {
+            return basename(end($files), self::OLD_INSTALL_EXT);
+        }
+
+        return false;
+    }
+
+    protected function getOldInstallationFinder($rollbackDir)
+    {
+        $finder = Finder::create()
+            ->depth(0)
+            ->files()
+            ->name('*' . self::OLD_INSTALL_EXT)
+            ->in($rollbackDir);
+
+        return $finder;
+    }
+}

data/helpers/vendor/composer/composer/src/Composer/Command/ShowCommand.php

@@ -0,0 +1,1014 @@
+<?php
+
+/*
+ * This file is part of Composer.
+ *
+ * (c) Nils Adermann <naderman@naderman.de>
+ *     Jordi Boggiano <j.boggiano@seld.be>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Composer\Command;
+
+use Composer\Composer;
+use Composer\DependencyResolver\DefaultPolicy;
+use Composer\DependencyResolver\Pool;
+use Composer\Json\JsonFile;
+use Composer\Package\BasePackage;
+use Composer\Package\CompletePackageInterface;
+use Composer\Package\PackageInterface;
+use Composer\Package\Version\VersionParser;
+use Composer\Package\Version\VersionSelector;
+use Composer\Plugin\CommandEvent;
+use Composer\Plugin\PluginEvents;
+use Composer\Repository\ArrayRepository;
+use Composer\Repository\ComposerRepository;
+use Composer\Repository\CompositeRepository;
+use Composer\Repository\PlatformRepository;
+use Composer\Repository\RepositoryFactory;
+use Composer\Repository\RepositoryInterface;
+use Composer\Semver\Constraint\ConstraintInterface;
+use Composer\Semver\Semver;
+use Composer\Spdx\SpdxLicenses;
+use Composer\Util\Platform;
+use Symfony\Component\Console\Formatter\OutputFormatterStyle;
+use Symfony\Component\Console\Input\InputArgument;
+use Symfony\Component\Console\Input\InputInterface;
+use Symfony\Component\Console\Input\InputOption;
+use Symfony\Component\Console\Output\OutputInterface;
+use Symfony\Component\Console\Terminal;
+
+/**
+ * @author Robert Schönthal <seroscho@googlemail.com>
+ * @author Jordi Boggiano <j.boggiano@seld.be>
+ * @author Jérémy Romey <jeremyFreeAgent>
+ * @author Mihai Plasoianu <mihai@plasoianu.de>
+ */
+class ShowCommand extends BaseCommand
+{
+    /** @var VersionParser */
+    protected $versionParser;
+    protected $colors;
+
+    /** @var Pool */
+    private $pool;
+
+    protected function configure()
+    {
+        $this
+            ->setName('show')
+            ->setAliases(array('info'))
+            ->setDescription('Shows information about packages.')
+            ->setDefinition(array(
+                new InputArgument('package', InputArgument::OPTIONAL, 'Package to inspect. Or a name including a wildcard (*) to filter lists of packages instead.'),
+                new InputArgument('version', InputArgument::OPTIONAL, 'Version or version constraint to inspect'),
+                new InputOption('all', null, InputOption::VALUE_NONE, 'List all packages'),
+                new InputOption('installed', 'i', InputOption::VALUE_NONE, 'List installed packages only (enabled by default, only present for BC).'),
+                new InputOption('platform', 'p', InputOption::VALUE_NONE, 'List platform packages only'),
+                new InputOption('available', 'a', InputOption::VALUE_NONE, 'List available packages only'),
+                new InputOption('self', 's', InputOption::VALUE_NONE, 'Show the root package information'),
+                new InputOption('name-only', 'N', InputOption::VALUE_NONE, 'List package names only'),
+                new InputOption('path', 'P', InputOption::VALUE_NONE, 'Show package paths'),
+                new InputOption('tree', 't', InputOption::VALUE_NONE, 'List the dependencies as a tree'),
+                new InputOption('latest', 'l', InputOption::VALUE_NONE, 'Show the latest version'),
+                new InputOption('outdated', 'o', InputOption::VALUE_NONE, 'Show the latest version but only for packages that are outdated'),
+                new InputOption('ignore', null, InputOption::VALUE_REQUIRED | InputOption::VALUE_IS_ARRAY, 'Ignore specified package(s). Use it with the --outdated option if you don\'t want to be informed about new versions of some packages.'),
+                new InputOption('minor-only', 'm', InputOption::VALUE_NONE, 'Show only packages that have minor SemVer-compatible updates. Use with the --outdated option.'),
+                new InputOption('direct', 'D', InputOption::VALUE_NONE, 'Shows only packages that are directly required by the root package'),
+                new InputOption('strict', null, InputOption::VALUE_NONE, 'Return a non-zero exit code when there are outdated packages'),
+                new InputOption('format', 'f', InputOption::VALUE_REQUIRED, 'Format of the output: text or json', 'text'),
+            ))
+            ->setHelp(
+                <<<EOT
+The show command displays detailed information about a package, or
+lists all packages available.
+
+EOT
+            )
+        ;
+    }
+
+    protected function execute(InputInterface $input, OutputInterface $output)
+    {
+        $this->versionParser = new VersionParser;
+        if ($input->getOption('tree')) {
+            $this->initStyles($output);
+        }
+
+        $composer = $this->getComposer(false);
+        $io = $this->getIO();
+
+        if ($input->getOption('installed')) {
+            $io->writeError('<warning>You are using the deprecated option "installed". Only installed packages are shown by default now. The --all option can be used to show all packages.</warning>');
+        }
+
+        if ($input->getOption('outdated')) {
+            $input->setOption('latest', true);
+        } elseif ($input->getOption('ignore')) {
+            $io->writeError('<warning>You are using the option "ignore" for action other than "outdated", it will be ignored.</warning>');
+        }
+
+        if ($input->getOption('direct') && ($input->getOption('all') || $input->getOption('available') || $input->getOption('platform'))) {
+            $io->writeError('The --direct (-D) option is not usable in combination with --all, --platform (-p) or --available (-a)');
+
+            return 1;
+        }
+
+        if ($input->getOption('tree') && ($input->getOption('all') || $input->getOption('available'))) {
+            $io->writeError('The --tree (-t) option is not usable in combination with --all or --available (-a)');
+
+            return 1;
+        }
+
+        if ($input->getOption('tree') && $input->getOption('latest')) {
+            $io->writeError('The --tree (-t) option is not usable in combination with --latest (-l)');
+
+            return 1;
+        }
+
+        $format = $input->getOption('format');
+        if (!in_array($format, array('text', 'json'))) {
+            $io->writeError(sprintf('Unsupported format "%s". See help for supported formats.', $format));
+
+            return 1;
+        }
+
+        // init repos
+        $platformOverrides = array();
+        if ($composer) {
+            $platformOverrides = $composer->getConfig()->get('platform') ?: array();
+        }
+        $platformRepo = new PlatformRepository(array(), $platformOverrides);
+        $phpVersion = $platformRepo->findPackage('php', '*')->getVersion();
+
+        if ($input->getOption('self')) {
+            $package = $this->getComposer()->getPackage();
+            $repos = $installedRepo = new ArrayRepository(array($package));
+        } elseif ($input->getOption('platform')) {
+            $repos = $installedRepo = $platformRepo;
+        } elseif ($input->getOption('available')) {
+            $installedRepo = $platformRepo;
+            if ($composer) {
+                $repos = new CompositeRepository($composer->getRepositoryManager()->getRepositories());
+            } else {
+                $defaultRepos = RepositoryFactory::defaultRepos($io);
+                $repos = new CompositeRepository($defaultRepos);
+                $io->writeError('No composer.json found in the current directory, showing available packages from ' . implode(', ', array_keys($defaultRepos)));
+            }
+        } elseif ($input->getOption('all') && $composer) {
+            $localRepo = $composer->getRepositoryManager()->getLocalRepository();
+            $installedRepo = new CompositeRepository(array($localRepo, $platformRepo));
+            $repos = new CompositeRepository(array_merge(array($installedRepo), $composer->getRepositoryManager()->getRepositories()));
+        } elseif ($input->getOption('all')) {
+            $defaultRepos = RepositoryFactory::defaultRepos($io);
+            $io->writeError('No composer.json found in the current directory, showing available packages from ' . implode(', ', array_keys($defaultRepos)));
+            $installedRepo = $platformRepo;
+            $repos = new CompositeRepository(array_merge(array($installedRepo), $defaultRepos));
+        } else {
+            $repos = $installedRepo = $this->getComposer()->getRepositoryManager()->getLocalRepository();
+            $rootPkg = $this->getComposer()->getPackage();
+            if (!$installedRepo->getPackages() && ($rootPkg->getRequires() || $rootPkg->getDevRequires())) {
+                $io->writeError('<warning>No dependencies installed. Try running composer install or update.</warning>');
+            }
+        }
+
+        if ($composer) {
+            $commandEvent = new CommandEvent(PluginEvents::COMMAND, 'show', $input, $output);
+            $composer->getEventDispatcher()->dispatch($commandEvent->getName(), $commandEvent);
+        }
+
+        if ($input->getOption('latest') && null === $composer) {
+            $io->writeError('No composer.json found in the current directory, disabling "latest" option');
+            $input->setOption('latest', false);
+        }
+
+        $packageFilter = $input->getArgument('package');
+
+        // show single package or single version
+        if (($packageFilter && false === strpos($packageFilter, '*')) || !empty($package)) {
+            if (empty($package)) {
+                list($package, $versions) = $this->getPackage($installedRepo, $repos, $input->getArgument('package'), $input->getArgument('version'));
+
+                if (empty($package)) {
+                    $options = $input->getOptions();
+                    if (!isset($options['working-dir']) || !file_exists('composer.json')) {
+                        throw new \InvalidArgumentException('Package ' . $packageFilter . ' not found');
+                    }
+
+                    $io->writeError('Package ' . $packageFilter . ' not found in ' . $options['working-dir'] . '/composer.json');
+
+                    return 1;
+                }
+            } else {
+                $versions = array($package->getPrettyVersion() => $package->getVersion());
+            }
+
+            $exitCode = 0;
+            if ($input->getOption('tree')) {
+                $arrayTree = $this->generatePackageTree($package, $installedRepo, $repos);
+
+                if ('json' === $format) {
+                    $io->write(JsonFile::encode(array('installed' => array($arrayTree))));
+                } else {
+                    $this->displayPackageTree(array($arrayTree));
+                }
+            } else {
+                $latestPackage = null;
+                if ($input->getOption('latest')) {
+                    $latestPackage = $this->findLatestPackage($package, $composer, $phpVersion);
+                }
+                if ($input->getOption('outdated') && $input->getOption('strict') && $latestPackage && $latestPackage->getFullPrettyVersion() !== $package->getFullPrettyVersion() && !$latestPackage->isAbandoned()) {
+                    $exitCode = 1;
+                }
+                if ($input->getOption('path')) {
+                    $io->write($package->getName(), false);
+                    $io->write(' ' . strtok(realpath($composer->getInstallationManager()->getInstallPath($package)), "\r\n"));
+
+                    return $exitCode;
+                }
+                $this->printMeta($package, $versions, $installedRepo, $latestPackage ?: null);
+                $this->printLinks($package, 'requires');
+                $this->printLinks($package, 'devRequires', 'requires (dev)');
+                if ($package->getSuggests()) {
+                    $io->write("\n<info>suggests</info>");
+                    foreach ($package->getSuggests() as $suggested => $reason) {
+                        $io->write($suggested . ' <comment>' . $reason . '</comment>');
+                    }
+                }
+                $this->printLinks($package, 'provides');
+                $this->printLinks($package, 'conflicts');
+                $this->printLinks($package, 'replaces');
+            }
+
+            return $exitCode;
+        }
+
+        // show tree view if requested
+        if ($input->getOption('tree')) {
+            $rootRequires = $this->getRootRequires();
+            $packages = $installedRepo->getPackages();
+            usort($packages, 'strcmp');
+            $arrayTree = array();
+            foreach ($packages as $package) {
+                if (in_array($package->getName(), $rootRequires, true)) {
+                    $arrayTree[] = $this->generatePackageTree($package, $installedRepo, $repos);
+                }
+            }
+
+            if ('json' === $format) {
+                $io->write(JsonFile::encode(array('installed' => $arrayTree)));
+            } else {
+                $this->displayPackageTree($arrayTree);
+            }
+
+            return 0;
+        }
+
+        if ($repos instanceof CompositeRepository) {
+            $repos = $repos->getRepositories();
+        } elseif (!is_array($repos)) {
+            $repos = array($repos);
+        }
+
+        // list packages
+        $packages = array();
+        if (null !== $packageFilter) {
+            $packageFilter = '{^'.str_replace('\\*', '.*?', preg_quote($packageFilter)).'$}i';
+        }
+
+        $packageListFilter = array();
+        if ($input->getOption('direct')) {
+            $packageListFilter = $this->getRootRequires();
+        }
+
+        if (class_exists('Symfony\Component\Console\Terminal')) {
+            $terminal = new Terminal();
+            $width = $terminal->getWidth();
+        } else {
+            // For versions of Symfony console before 3.2
+            list($width) = $this->getApplication()->getTerminalDimensions();
+        }
+        if (null === $width) {
+            // In case the width is not detected, we're probably running the command
+            // outside of a real terminal, use space without a limit
+            $width = PHP_INT_MAX;
+        }
+        if (Platform::isWindows()) {
+            $width--;
+        } else {
+            $width = max(80, $width);
+        }
+
+        if ($input->getOption('path') && null === $composer) {
+            $io->writeError('No composer.json found in the current directory, disabling "path" option');
+            $input->setOption('path', false);
+        }
+
+        foreach ($repos as $repo) {
+            if ($repo === $platformRepo) {
+                $type = 'platform';
+            } elseif (
+                $repo === $installedRepo
+                || ($installedRepo instanceof CompositeRepository && in_array($repo, $installedRepo->getRepositories(), true))
+            ) {
+                $type = 'installed';
+            } else {
+                $type = 'available';
+            }
+            if ($repo instanceof ComposerRepository && $repo->hasProviders()) {
+                foreach ($repo->getProviderNames() as $name) {
+                    if (!$packageFilter || preg_match($packageFilter, $name)) {
+                        $packages[$type][$name] = $name;
+                    }
+                }
+            } else {
+                foreach ($repo->getPackages() as $package) {
+                    if (!isset($packages[$type][$package->getName()])
+                        || !is_object($packages[$type][$package->getName()])
+                        || version_compare($packages[$type][$package->getName()]->getVersion(), $package->getVersion(), '<')
+                    ) {
+                        if (!$packageFilter || preg_match($packageFilter, $package->getName())) {
+                            if (!$packageListFilter || in_array($package->getName(), $packageListFilter, true)) {
+                                $packages[$type][$package->getName()] = $package;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        $showAllTypes = $input->getOption('all');
+        $showLatest = $input->getOption('latest');
+        $showMinorOnly = $input->getOption('minor-only');
+        $ignoredPackages = array_map('strtolower', $input->getOption('ignore'));
+        $indent = $showAllTypes ? '  ' : '';
+        $latestPackages = array();
+        $exitCode = 0;
+        $viewData = array();
+        $viewMetaData = array();
+        foreach (array('platform' => true, 'available' => false, 'installed' => true) as $type => $showVersion) {
+            if (isset($packages[$type])) {
+                ksort($packages[$type]);
+
+                $nameLength = $versionLength = $latestLength = 0;
+
+                if ($showLatest && $showVersion) {
+                    foreach ($packages[$type] as $package) {
+                        if (is_object($package)) {
+                            $latestPackage = $this->findLatestPackage($package, $composer, $phpVersion, $showMinorOnly);
+                            if ($latestPackage === false) {
+                                continue;
+                            }
+
+                            $latestPackages[$package->getPrettyName()] = $latestPackage;
+                        }
+                    }
+                }
+
+                $writePath = !$input->getOption('name-only') && $input->getOption('path');
+                $writeVersion = !$input->getOption('name-only') && !$input->getOption('path') && $showVersion;
+                $writeLatest = $writeVersion && $showLatest;
+                $writeDescription = !$input->getOption('name-only') && !$input->getOption('path');
+
+                $hasOutdatedPackages = false;
+
+                $viewData[$type] = array();
+                foreach ($packages[$type] as $package) {
+                    $packageViewData = array();
+                    if (is_object($package)) {
+                        $latestPackage = null;
+                        if ($showLatest && isset($latestPackages[$package->getPrettyName()])) {
+                            $latestPackage = $latestPackages[$package->getPrettyName()];
+                        }
+
+                        // Determine if Composer is checking outdated dependencies and if current package should trigger non-default exit code
+                        $packageIsUpToDate = $latestPackage && $latestPackage->getFullPrettyVersion() === $package->getFullPrettyVersion() && !$latestPackage->isAbandoned();
+                        $packageIsIgnored = \in_array($package->getPrettyName(), $ignoredPackages, true);
+                        if ($input->getOption('outdated') && ($packageIsUpToDate || $packageIsIgnored)) {
+                            continue;
+                        } elseif ($input->getOption('outdated') || $input->getOption('strict')) {
+                            $hasOutdatedPackages = true;
+                        }
+
+                        $packageViewData['name'] = $package->getPrettyName();
+                        $nameLength = max($nameLength, strlen($package->getPrettyName()));
+                        if ($writeVersion) {
+                            $packageViewData['version'] = $package->getFullPrettyVersion();
+                            $versionLength = max($versionLength, strlen($package->getFullPrettyVersion()));
+                        }
+                        if ($writeLatest && $latestPackage) {
+                            $packageViewData['latest'] = $latestPackage->getFullPrettyVersion();
+                            $packageViewData['latest-status'] = $this->getUpdateStatus($latestPackage, $package);
+                            $latestLength = max($latestLength, strlen($latestPackage->getFullPrettyVersion()));
+                        }
+                        if ($writeDescription) {
+                            $packageViewData['description'] = $package->getDescription();
+                        }
+                        if ($writePath) {
+                            $packageViewData['path'] = strtok(realpath($composer->getInstallationManager()->getInstallPath($package)), "\r\n");
+                        }
+
+                        if ($latestPackage && $latestPackage->isAbandoned()) {
+                            $replacement = is_string($latestPackage->getReplacementPackage())
+                                ? 'Use ' . $latestPackage->getReplacementPackage() . ' instead'
+                                : 'No replacement was suggested';
+                            $packageWarning = sprintf(
+                                'Package %s is abandoned, you should avoid using it. %s.',
+                                $package->getPrettyName(),
+                                $replacement
+                            );
+                            $packageViewData['warning'] = $packageWarning;
+                        }
+                    } else {
+                        $packageViewData['name'] = $package;
+                        $nameLength = max($nameLength, strlen($package));
+                    }
+                    $viewData[$type][] = $packageViewData;
+                }
+                $viewMetaData[$type] = array(
+                    'nameLength' => $nameLength,
+                    'versionLength' => $versionLength,
+                    'latestLength' => $latestLength,
+                );
+                if ($input->getOption('strict') && $hasOutdatedPackages) {
+                    $exitCode = 1;
+                    break;
+                }
+            }
+        }
+
+        if ('json' === $format) {
+            $io->write(JsonFile::encode($viewData));
+        } else {
+            foreach ($viewData as $type => $packages) {
+                $nameLength = $viewMetaData[$type]['nameLength'];
+                $versionLength = $viewMetaData[$type]['versionLength'];
+                $latestLength = $viewMetaData[$type]['latestLength'];
+
+                $writeVersion = $nameLength + $versionLength + 3 <= $width;
+                $writeLatest = $nameLength + $versionLength + $latestLength + 3 <= $width;
+                $writeDescription = $nameLength + $versionLength + $latestLength + 24 <= $width;
+
+                if ($writeLatest && !$io->isDecorated()) {
+                    $latestLength += 2;
+                }
+
+                if ($showAllTypes) {
+                    if ('available' === $type) {
+                        $io->write('<comment>' . $type . '</comment>:');
+                    } else {
+                        $io->write('<info>' . $type . '</info>:');
+                    }
+                }
+
+                foreach ($packages as $package) {
+                    $io->write($indent . str_pad($package['name'], $nameLength, ' '), false);
+                    if (isset($package['version']) && $writeVersion) {
+                        $io->write(' ' . str_pad($package['version'], $versionLength, ' '), false);
+                    }
+                    if (isset($package['latest']) && $writeLatest) {
+                        $latestVersion = $package['latest'];
+                        $updateStatus = $package['latest-status'];
+                        $style = $this->updateStatusToVersionStyle($updateStatus);
+                        if (!$io->isDecorated()) {
+                            $latestVersion = str_replace(array('up-to-date', 'semver-safe-update', 'update-possible'), array('=', '!', '~'), $updateStatus) . ' ' . $latestVersion;
+                        }
+                        $io->write(' <' . $style . '>' . str_pad($latestVersion, $latestLength, ' ') . '</' . $style . '>', false);
+                    }
+                    if (isset($package['description']) && $writeDescription) {
+                        $description = strtok($package['description'], "\r\n");
+                        $remaining = $width - $nameLength - $versionLength - 4;
+                        if ($writeLatest) {
+                            $remaining -= $latestLength;
+                        }
+                        if (strlen($description) > $remaining) {
+                            $description = substr($description, 0, $remaining - 3) . '...';
+                        }
+                        $io->write(' ' . $description, false);
+                    }
+                    if (isset($package['path'])) {
+                        $io->write(' ' . $package['path'], false);
+                    }
+                    $io->write('');
+                    if (isset($package['warning'])) {
+                        $io->writeError('<warning>' . $package['warning'] . '</warning>');
+                    }
+                }
+
+                if ($showAllTypes) {
+                    $io->write('');
+                }
+            }
+        }
+
+        return $exitCode;
+    }
+
+    protected function getRootRequires()
+    {
+        $rootPackage = $this->getComposer()->getPackage();
+
+        return array_map(
+            'strtolower',
+            array_keys(array_merge($rootPackage->getRequires(), $rootPackage->getDevRequires()))
+        );
+    }
+
+    protected function getVersionStyle(PackageInterface $latestPackage, PackageInterface $package)
+    {
+        return $this->updateStatusToVersionStyle($this->getUpdateStatus($latestPackage, $package));
+    }
+
+    /**
+     * finds a package by name and version if provided
+     *
+     * @param  RepositoryInterface        $installedRepo
+     * @param  RepositoryInterface        $repos
+     * @param  string                     $name
+     * @param  ConstraintInterface|string $version
+     * @throws \InvalidArgumentException
+     * @return array                      array(CompletePackageInterface, array of versions)
+     */
+    protected function getPackage(RepositoryInterface $installedRepo, RepositoryInterface $repos, $name, $version = null)
+    {
+        $name = strtolower($name);
+        $constraint = is_string($version) ? $this->versionParser->parseConstraints($version) : $version;
+
+        $policy = new DefaultPolicy();
+        $pool = new Pool('dev');
+        $pool->addRepository($repos);
+
+        $matchedPackage = null;
+        $versions = array();
+        $matches = $pool->whatProvides($name, $constraint);
+        foreach ($matches as $index => $package) {
+            // skip providers/replacers
+            if ($package->getName() !== $name) {
+                unset($matches[$index]);
+                continue;
+            }
+
+            // select an exact match if it is in the installed repo and no specific version was required
+            if (null === $version && $installedRepo->hasPackage($package)) {
+                $matchedPackage = $package;
+            }
+
+            $versions[$package->getPrettyVersion()] = $package->getVersion();
+            $matches[$index] = $package->getId();
+        }
+
+        // select preferred package according to policy rules
+        if (!$matchedPackage && $matches && $preferred = $policy->selectPreferredPackages($pool, array(), $matches)) {
+            $matchedPackage = $pool->literalToPackage($preferred[0]);
+        }
+
+        return array($matchedPackage, $versions);
+    }
+
+    /**
+     * Prints package metadata.
+     *
+     * @param CompletePackageInterface $package
+     * @param array                    $versions
+     * @param RepositoryInterface      $installedRepo
+     */
+    protected function printMeta(CompletePackageInterface $package, array $versions, RepositoryInterface $installedRepo, PackageInterface $latestPackage = null)
+    {
+        $io = $this->getIO();
+        $io->write('<info>name</info>     : ' . $package->getPrettyName());
+        $io->write('<info>descrip.</info> : ' . $package->getDescription());
+        $io->write('<info>keywords</info> : ' . implode(', ', $package->getKeywords() ?: array()));
+        $this->printVersions($package, $versions, $installedRepo);
+        if ($latestPackage) {
+            $style = $this->getVersionStyle($latestPackage, $package);
+            $io->write('<info>latest</info>   : <'.$style.'>' . $latestPackage->getPrettyVersion() . '</'.$style.'>');
+        } else {
+            $latestPackage = $package;
+        }
+        $io->write('<info>type</info>     : ' . $package->getType());
+        $this->printLicenses($package);
+        $io->write('<info>source</info>   : ' . sprintf('[%s] <comment>%s</comment> %s', $package->getSourceType(), $package->getSourceUrl(), $package->getSourceReference()));
+        $io->write('<info>dist</info>     : ' . sprintf('[%s] <comment>%s</comment> %s', $package->getDistType(), $package->getDistUrl(), $package->getDistReference()));
+        if ($installedRepo->hasPackage($package)) {
+            $io->write('<info>path</info>     : ' . sprintf('%s', realpath($this->getComposer()->getInstallationManager()->getInstallPath($package))));
+        }
+        $io->write('<info>names</info>    : ' . implode(', ', $package->getNames()));
+
+        if ($latestPackage->isAbandoned()) {
+            $replacement = ($latestPackage->getReplacementPackage() !== null)
+                ? ' The author suggests using the ' . $latestPackage->getReplacementPackage(). ' package instead.'
+                : null;
+
+            $io->writeError(
+                sprintf('<warning>Attention: This package is abandoned and no longer maintained.%s</warning>', $replacement)
+            );
+        }
+
+        if ($package->getSupport()) {
+            $io->write("\n<info>support</info>");
+            foreach ($package->getSupport() as $type => $value) {
+                $io->write('<comment>' . $type . '</comment> : '.$value);
+            }
+        }
+
+        if ($package->getAutoload()) {
+            $io->write("\n<info>autoload</info>");
+            foreach ($package->getAutoload() as $type => $autoloads) {
+                $io->write('<comment>' . $type . '</comment>');
+
+                if ($type === 'psr-0') {
+                    foreach ($autoloads as $name => $path) {
+                        $io->write(($name ?: '*') . ' => ' . (is_array($path) ? implode(', ', $path) : ($path ?: '.')));
+                    }
+                } elseif ($type === 'psr-4') {
+                    foreach ($autoloads as $name => $path) {
+                        $io->write(($name ?: '*') . ' => ' . (is_array($path) ? implode(', ', $path) : ($path ?: '.')));
+                    }
+                } elseif ($type === 'classmap') {
+                    $io->write(implode(', ', $autoloads));
+                }
+            }
+            if ($package->getIncludePaths()) {
+                $io->write('<comment>include-path</comment>');
+                $io->write(implode(', ', $package->getIncludePaths()));
+            }
+        }
+    }
+
+    /**
+     * Prints all available versions of this package and highlights the installed one if any.
+     *
+     * @param CompletePackageInterface $package
+     * @param array                    $versions
+     * @param RepositoryInterface      $installedRepo
+     */
+    protected function printVersions(CompletePackageInterface $package, array $versions, RepositoryInterface $installedRepo)
+    {
+        uasort($versions, 'version_compare');
+        $versions = array_keys(array_reverse($versions));
+
+        // highlight installed version
+        if ($installedRepo->hasPackage($package)) {
+            $installedVersion = $package->getPrettyVersion();
+            $key = array_search($installedVersion, $versions);
+            if (false !== $key) {
+                $versions[$key] = '<info>* ' . $installedVersion . '</info>';
+            }
+        }
+
+        $versions = implode(', ', $versions);
+
+        $this->getIO()->write('<info>versions</info> : ' . $versions);
+    }
+
+    /**
+     * print link objects
+     *
+     * @param CompletePackageInterface $package
+     * @param string                   $linkType
+     * @param string                   $title
+     */
+    protected function printLinks(CompletePackageInterface $package, $linkType, $title = null)
+    {
+        $title = $title ?: $linkType;
+        $io = $this->getIO();
+        if ($links = $package->{'get'.ucfirst($linkType)}()) {
+            $io->write("\n<info>" . $title . "</info>");
+
+            foreach ($links as $link) {
+                $io->write($link->getTarget() . ' <comment>' . $link->getPrettyConstraint() . '</comment>');
+            }
+        }
+    }
+
+    /**
+     * Prints the licenses of a package with metadata
+     *
+     * @param CompletePackageInterface $package
+     */
+    protected function printLicenses(CompletePackageInterface $package)
+    {
+        $spdxLicenses = new SpdxLicenses();
+
+        $licenses = $package->getLicense();
+        $io = $this->getIO();
+
+        foreach ($licenses as $licenseId) {
+            $license = $spdxLicenses->getLicenseByIdentifier($licenseId); // keys: 0 fullname, 1 osi, 2 url
+
+            if (!$license) {
+                $out = $licenseId;
+            } else {
+                // is license OSI approved?
+                if ($license[1] === true) {
+                    $out = sprintf('%s (%s) (OSI approved) %s', $license[0], $licenseId, $license[2]);
+                } else {
+                    $out = sprintf('%s (%s) %s', $license[0], $licenseId, $license[2]);
+                }
+            }
+
+            $io->write('<info>license</info>  : ' . $out);
+        }
+    }
+
+    /**
+     * Init styles for tree
+     *
+     * @param OutputInterface $output
+     */
+    protected function initStyles(OutputInterface $output)
+    {
+        $this->colors = array(
+            'green',
+            'yellow',
+            'cyan',
+            'magenta',
+            'blue',
+        );
+
+        foreach ($this->colors as $color) {
+            $style = new OutputFormatterStyle($color);
+            $output->getFormatter()->setStyle($color, $style);
+        }
+    }
+
+    /**
+     * Display the tree
+     *
+     * @param array $arrayTree
+     */
+    protected function displayPackageTree(array $arrayTree)
+    {
+        $io = $this->getIO();
+        foreach ($arrayTree as $package) {
+            $io->write(sprintf('<info>%s</info>', $package['name']), false);
+            $io->write(' ' . $package['version'], false);
+            $io->write(' ' . strtok($package['description'], "\r\n"));
+
+            if (isset($package['requires'])) {
+                $requires = $package['requires'];
+                $treeBar = '├';
+                $j = 0;
+                $total = count($requires);
+                foreach ($requires as $require) {
+                    $requireName = $require['name'];
+                    $j++;
+                    if ($j === $total) {
+                        $treeBar = '└';
+                    }
+                    $level = 1;
+                    $color = $this->colors[$level];
+                    $info = sprintf(
+                        '%s──<%s>%s</%s> %s',
+                        $treeBar,
+                        $color,
+                        $requireName,
+                        $color,
+                        $require['version']
+                    );
+                    $this->writeTreeLine($info);
+
+                    $treeBar = str_replace('└', ' ', $treeBar);
+                    $packagesInTree = array($package['name'], $requireName);
+
+                    $this->displayTree($require, $packagesInTree, $treeBar, $level + 1);
+                }
+            }
+        }
+    }
+
+    /**
+     * Generate the package tree
+     *
+     * @param  PackageInterface $package
+     * @param  RepositoryInterface     $installedRepo
+     * @param  RepositoryInterface     $distantRepos
+     * @return array
+     */
+    protected function generatePackageTree(
+        PackageInterface $package,
+        RepositoryInterface $installedRepo,
+        RepositoryInterface $distantRepos
+    ) {
+        $requires = $package->getRequires();
+        ksort($requires);
+        $children = array();
+        foreach ($requires as $requireName => $require) {
+            $packagesInTree = array($package->getName(), $requireName);
+
+            $treeChildDesc = array(
+                'name' => $requireName,
+                'version' => $require->getPrettyConstraint(),
+            );
+
+            $deepChildren = $this->addTree($requireName, $require, $installedRepo, $distantRepos, $packagesInTree);
+
+            if ($deepChildren) {
+                $treeChildDesc['requires'] = $deepChildren;
+            }
+
+            $children[] = $treeChildDesc;
+        }
+        $tree = array(
+            'name' => $package->getPrettyName(),
+            'version' => $package->getPrettyVersion(),
+            'description' => $package->getDescription(),
+        );
+
+        if ($children) {
+            $tree['requires'] = $children;
+        }
+
+        return $tree;
+    }
+
+    /**
+     * Display a package tree
+     *
+     * @param PackageInterface|string $package
+     * @param array                   $packagesInTree
+     * @param string                  $previousTreeBar
+     * @param int                     $level
+     */
+    protected function displayTree(
+        $package,
+        array $packagesInTree,
+        $previousTreeBar = '├',
+        $level = 1
+    ) {
+        $previousTreeBar = str_replace('├', '│', $previousTreeBar);
+        if (isset($package['requires'])) {
+            $requires = $package['requires'];
+            $treeBar = $previousTreeBar . '  ├';
+            $i = 0;
+            $total = count($requires);
+            foreach ($requires as $require) {
+                $currentTree = $packagesInTree;
+                $i++;
+                if ($i === $total) {
+                    $treeBar = $previousTreeBar . '  └';
+                }
+                $colorIdent = $level % count($this->colors);
+                $color = $this->colors[$colorIdent];
+
+                $circularWarn = in_array(
+                    $require['name'],
+                    $currentTree,
+                    true
+                ) ? '(circular dependency aborted here)' : '';
+                $info = rtrim(sprintf(
+                    '%s──<%s>%s</%s> %s %s',
+                    $treeBar,
+                    $color,
+                    $require['name'],
+                    $color,
+                    $require['version'],
+                    $circularWarn
+                ));
+                $this->writeTreeLine($info);
+
+                $treeBar = str_replace('└', ' ', $treeBar);
+
+                $currentTree[] = $require['name'];
+                $this->displayTree($require, $currentTree, $treeBar, $level + 1);
+            }
+        }
+    }
+
+    /**
+     * Display a package tree
+     *
+     * @param  string                  $name
+     * @param  PackageInterface|string $package
+     * @param  RepositoryInterface     $installedRepo
+     * @param  RepositoryInterface     $distantRepos
+     * @param  array                   $packagesInTree
+     * @return array
+     */
+    protected function addTree(
+        $name,
+        $package,
+        RepositoryInterface $installedRepo,
+        RepositoryInterface $distantRepos,
+        array $packagesInTree
+    ) {
+        $children = array();
+        list($package, $versions) = $this->getPackage(
+            $installedRepo,
+            $distantRepos,
+            $name,
+            $package->getPrettyConstraint() === 'self.version' ? $package->getConstraint() : $package->getPrettyConstraint()
+        );
+        if (is_object($package)) {
+            $requires = $package->getRequires();
+            ksort($requires);
+            foreach ($requires as $requireName => $require) {
+                $currentTree = $packagesInTree;
+
+                $treeChildDesc = array(
+                    'name' => $requireName,
+                    'version' => $require->getPrettyConstraint(),
+                );
+
+                if (!in_array($requireName, $currentTree, true)) {
+                    $currentTree[] = $requireName;
+                    $deepChildren = $this->addTree($requireName, $require, $installedRepo, $distantRepos, $currentTree);
+                    if ($deepChildren) {
+                        $treeChildDesc['requires'] = $deepChildren;
+                    }
+                }
+
+                $children[] = $treeChildDesc;
+            }
+        }
+
+        return $children;
+    }
+
+    private function updateStatusToVersionStyle($updateStatus)
+    {
+        // 'up-to-date' is printed green
+        // 'semver-safe-update' is printed red
+        // 'update-possible' is printed yellow
+        return str_replace(array('up-to-date', 'semver-safe-update', 'update-possible'), array('info', 'highlight', 'comment'), $updateStatus);
+    }
+
+    private function getUpdateStatus(PackageInterface $latestPackage, PackageInterface $package)
+    {
+        if ($latestPackage->getFullPrettyVersion() === $package->getFullPrettyVersion()) {
+            return 'up-to-date';
+        }
+
+        $constraint = $package->getVersion();
+        if (0 !== strpos($constraint, 'dev-')) {
+            $constraint = '^'.$constraint;
+        }
+        if ($latestPackage->getVersion() && Semver::satisfies($latestPackage->getVersion(), $constraint)) {
+            // it needs an immediate semver-compliant upgrade
+            return 'semver-safe-update';
+        }
+
+        // it needs an upgrade but has potential BC breaks so is not urgent
+        return 'update-possible';
+    }
+
+    private function writeTreeLine($line)
+    {
+        $io = $this->getIO();
+        if (!$io->isDecorated()) {
+            $line = str_replace(array('└', '├', '──', '│'), array('`-', '|-', '-', '|'), $line);
+        }
+
+        $io->write($line);
+    }
+
+    /**
+     * Given a package, this finds the latest package matching it
+     *
+     * @param PackageInterface $package
+     * @param Composer         $composer
+     * @param string           $phpVersion
+     * @param bool             $minorOnly
+     *
+     * @return PackageInterface|null
+     */
+    private function findLatestPackage(PackageInterface $package, Composer $composer, $phpVersion, $minorOnly = false)
+    {
+        // find the latest version allowed in this pool
+        $name = $package->getName();
+        $versionSelector = new VersionSelector($this->getPool($composer));
+        $stability = $composer->getPackage()->getMinimumStability();
+        $flags = $composer->getPackage()->getStabilityFlags();
+        if (isset($flags[$name])) {
+            $stability = array_search($flags[$name], BasePackage::$stabilities, true);
+        }
+
+        $bestStability = $stability;
+        if ($composer->getPackage()->getPreferStable()) {
+            $bestStability = $package->getStability();
+        }
+
+        $targetVersion = null;
+        if (0 === strpos($package->getVersion(), 'dev-')) {
+            $targetVersion = $package->getVersion();
+        }
+
+        if ($targetVersion === null && $minorOnly) {
+            $targetVersion = '^' . $package->getVersion();
+        }
+
+        return $versionSelector->findBestCandidate($name, $targetVersion, $phpVersion, $bestStability);
+    }
+
+    private function getPool(Composer $composer)
+    {
+        if (!$this->pool) {
+            $this->pool = new Pool($composer->getPackage()->getMinimumStability(), $composer->getPackage()->getStabilityFlags());
+            $this->pool->addRepository(new CompositeRepository($composer->getRepositoryManager()->getRepositories()));
+        }
+
+        return $this->pool;
+    }
+}