dependabot-composer 0.95.62 → 0.95.63

data/helpers/vendor/composer/composer/src/Composer/IO/BaseIO.php

@@ -0,0 +1,255 @@
+<?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\IO;
+
+use Composer\Config;
+use Composer\Util\ProcessExecutor;
+use Psr\Log\LoggerInterface;
+use Psr\Log\LogLevel;
+
+abstract class BaseIO implements IOInterface, LoggerInterface
+{
+    protected $authentications = array();
+
+    /**
+     * {@inheritDoc}
+     */
+    public function getAuthentications()
+    {
+        return $this->authentications;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function hasAuthentication($repositoryName)
+    {
+        return isset($this->authentications[$repositoryName]);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function getAuthentication($repositoryName)
+    {
+        if (isset($this->authentications[$repositoryName])) {
+            return $this->authentications[$repositoryName];
+        }
+
+        return array('username' => null, 'password' => null);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function setAuthentication($repositoryName, $username, $password = null)
+    {
+        $this->authentications[$repositoryName] = array('username' => $username, 'password' => $password);
+    }
+
+    /**
+     * Check for overwrite and set the authentication information for the repository.
+     *
+     * @param string $repositoryName The unique name of repository
+     * @param string $username       The username
+     * @param string $password       The password
+     */
+    protected function checkAndSetAuthentication($repositoryName, $username, $password = null)
+    {
+        if ($this->hasAuthentication($repositoryName)) {
+            $auth = $this->getAuthentication($repositoryName);
+            if ($auth['username'] === $username && $auth['password'] === $password) {
+                return;
+            }
+
+            $this->writeError(
+                sprintf(
+                    "<warning>Warning: You should avoid overwriting already defined auth settings for %s.</warning>",
+                    $repositoryName
+                )
+            );
+        }
+        $this->setAuthentication($repositoryName, $username, $password);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function loadConfiguration(Config $config)
+    {
+        $bitbucketOauth = $config->get('bitbucket-oauth') ?: array();
+        $githubOauth = $config->get('github-oauth') ?: array();
+        $gitlabOauth = $config->get('gitlab-oauth') ?: array();
+        $gitlabToken = $config->get('gitlab-token') ?: array();
+        $httpBasic = $config->get('http-basic') ?: array();
+
+        // reload oauth tokens from config if available
+
+        foreach ($bitbucketOauth as $domain => $cred) {
+            $this->checkAndSetAuthentication($domain, $cred['consumer-key'], $cred['consumer-secret']);
+        }
+
+        foreach ($githubOauth as $domain => $token) {
+            if (!preg_match('{^[.a-z0-9]+$}', $token)) {
+                throw new \UnexpectedValueException('Your github oauth token for '.$domain.' contains invalid characters: "'.$token.'"');
+            }
+            $this->checkAndSetAuthentication($domain, $token, 'x-oauth-basic');
+        }
+
+        foreach ($gitlabOauth as $domain => $token) {
+            $this->checkAndSetAuthentication($domain, $token, 'oauth2');
+        }
+
+        foreach ($gitlabToken as $domain => $token) {
+            $this->checkAndSetAuthentication($domain, $token, 'private-token');
+        }
+
+        // reload http basic credentials from config if available
+        foreach ($httpBasic as $domain => $cred) {
+            $this->checkAndSetAuthentication($domain, $cred['username'], $cred['password']);
+        }
+
+        // setup process timeout
+        ProcessExecutor::setTimeout((int) $config->get('process-timeout'));
+    }
+
+    /**
+     * System is unusable.
+     *
+     * @param  string $message
+     * @param  array  $context
+     * @return null
+     */
+    public function emergency($message, array $context = array())
+    {
+        return $this->log(LogLevel::EMERGENCY, $message, $context);
+    }
+
+    /**
+     * Action must be taken immediately.
+     *
+     * Example: Entire website down, database unavailable, etc. This should
+     * trigger the SMS alerts and wake you up.
+     *
+     * @param  string $message
+     * @param  array  $context
+     * @return null
+     */
+    public function alert($message, array $context = array())
+    {
+        return $this->log(LogLevel::ALERT, $message, $context);
+    }
+
+    /**
+     * Critical conditions.
+     *
+     * Example: Application component unavailable, unexpected exception.
+     *
+     * @param  string $message
+     * @param  array  $context
+     * @return null
+     */
+    public function critical($message, array $context = array())
+    {
+        return $this->log(LogLevel::CRITICAL, $message, $context);
+    }
+
+    /**
+     * Runtime errors that do not require immediate action but should typically
+     * be logged and monitored.
+     *
+     * @param  string $message
+     * @param  array  $context
+     * @return null
+     */
+    public function error($message, array $context = array())
+    {
+        return $this->log(LogLevel::ERROR, $message, $context);
+    }
+
+    /**
+     * Exceptional occurrences that are not errors.
+     *
+     * Example: Use of deprecated APIs, poor use of an API, undesirable things
+     * that are not necessarily wrong.
+     *
+     * @param  string $message
+     * @param  array  $context
+     * @return null
+     */
+    public function warning($message, array $context = array())
+    {
+        return $this->log(LogLevel::WARNING, $message, $context);
+    }
+
+    /**
+     * Normal but significant events.
+     *
+     * @param  string $message
+     * @param  array  $context
+     * @return null
+     */
+    public function notice($message, array $context = array())
+    {
+        return $this->log(LogLevel::NOTICE, $message, $context);
+    }
+
+    /**
+     * Interesting events.
+     *
+     * Example: User logs in, SQL logs.
+     *
+     * @param  string $message
+     * @param  array  $context
+     * @return null
+     */
+    public function info($message, array $context = array())
+    {
+        return $this->log(LogLevel::INFO, $message, $context);
+    }
+
+    /**
+     * Detailed debug information.
+     *
+     * @param  string $message
+     * @param  array  $context
+     * @return null
+     */
+    public function debug($message, array $context = array())
+    {
+        return $this->log(LogLevel::DEBUG, $message, $context);
+    }
+
+    /**
+     * Logs with an arbitrary level.
+     *
+     * @param  mixed  $level
+     * @param  string $message
+     * @param  array  $context
+     * @return null
+     */
+    public function log($level, $message, array $context = array())
+    {
+        if (in_array($level, array(LogLevel::EMERGENCY, LogLevel::ALERT, LogLevel::CRITICAL, LogLevel::ERROR))) {
+            $this->writeError('<error>'.$message.'</error>', true, self::NORMAL);
+        } elseif ($level === LogLevel::WARNING) {
+            $this->writeError('<warning>'.$message.'</warning>', true, self::NORMAL);
+        } elseif ($level === LogLevel::NOTICE) {
+            $this->writeError('<info>'.$message.'</info>', true, self::VERBOSE);
+        } elseif ($level === LogLevel::INFO) {
+            $this->writeError('<info>'.$message.'</info>', true, self::VERY_VERBOSE);
+        } else {
+            $this->writeError($message, true, self::DEBUG);
+        }
+    }
+}

data/helpers/vendor/composer/composer/src/Composer/IO/BufferIO.php

@@ -0,0 +1,59 @@
+<?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\IO;
+
+use Symfony\Component\Console\Output\StreamOutput;
+use Symfony\Component\Console\Formatter\OutputFormatterInterface;
+use Symfony\Component\Console\Input\StringInput;
+use Symfony\Component\Console\Helper\HelperSet;
+
+/**
+ * @author Jordi Boggiano <j.boggiano@seld.be>
+ */
+class BufferIO extends ConsoleIO
+{
+    /**
+     * @param string                        $input
+     * @param int                           $verbosity
+     * @param OutputFormatterInterface|null $formatter
+     */
+    public function __construct($input = '', $verbosity = StreamOutput::VERBOSITY_NORMAL, OutputFormatterInterface $formatter = null)
+    {
+        $input = new StringInput($input);
+        $input->setInteractive(false);
+
+        $output = new StreamOutput(fopen('php://memory', 'rw'), $verbosity, $formatter ? $formatter->isDecorated() : false, $formatter);
+
+        parent::__construct($input, $output, new HelperSet(array()));
+    }
+
+    public function getOutput()
+    {
+        fseek($this->output->getStream(), 0);
+
+        $output = stream_get_contents($this->output->getStream());
+
+        $output = preg_replace_callback("{(?<=^|\n|\x08)(.+?)(\x08+)}", function ($matches) {
+            $pre = strip_tags($matches[1]);
+
+            if (strlen($pre) === strlen($matches[2])) {
+                return '';
+            }
+
+            // TODO reverse parse the string, skipping span tags and \033\[([0-9;]+)m(.*?)\033\[0m style blobs
+            return rtrim($matches[1])."\n";
+        }, $output);
+
+        return $output;
+    }
+}

data/helpers/vendor/composer/composer/src/Composer/IO/ConsoleIO.php

@@ -0,0 +1,322 @@
+<?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\IO;
+
+use Composer\Question\StrictConfirmationQuestion;
+use Symfony\Component\Console\Helper\HelperSet;
+use Symfony\Component\Console\Input\InputInterface;
+use Symfony\Component\Console\Output\ConsoleOutputInterface;
+use Symfony\Component\Console\Output\OutputInterface;
+use Symfony\Component\Console\Question\ChoiceQuestion;
+use Symfony\Component\Console\Question\Question;
+
+/**
+ * The Input/Output helper.
+ *
+ * @author François Pluchino <francois.pluchino@opendisplay.com>
+ * @author Jordi Boggiano <j.boggiano@seld.be>
+ */
+class ConsoleIO extends BaseIO
+{
+    /** @var InputInterface */
+    protected $input;
+    /** @var OutputInterface */
+    protected $output;
+    /** @var HelperSet */
+    protected $helperSet;
+    /** @var string */
+    protected $lastMessage;
+    /** @var string */
+    protected $lastMessageErr;
+
+    /** @var float */
+    private $startTime;
+    /** @var array<int, int> */
+    private $verbosityMap;
+
+    /**
+     * Constructor.
+     *
+     * @param InputInterface  $input     The input instance
+     * @param OutputInterface $output    The output instance
+     * @param HelperSet       $helperSet The helperSet instance
+     */
+    public function __construct(InputInterface $input, OutputInterface $output, HelperSet $helperSet)
+    {
+        $this->input = $input;
+        $this->output = $output;
+        $this->helperSet = $helperSet;
+        $this->verbosityMap = array(
+            self::QUIET => OutputInterface::VERBOSITY_QUIET,
+            self::NORMAL => OutputInterface::VERBOSITY_NORMAL,
+            self::VERBOSE => OutputInterface::VERBOSITY_VERBOSE,
+            self::VERY_VERBOSE => OutputInterface::VERBOSITY_VERY_VERBOSE,
+            self::DEBUG => OutputInterface::VERBOSITY_DEBUG,
+        );
+    }
+
+    /**
+     * @param float $startTime
+     */
+    public function enableDebugging($startTime)
+    {
+        $this->startTime = $startTime;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function isInteractive()
+    {
+        return $this->input->isInteractive();
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function isDecorated()
+    {
+        return $this->output->isDecorated();
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function isVerbose()
+    {
+        return $this->output->getVerbosity() >= OutputInterface::VERBOSITY_VERBOSE;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function isVeryVerbose()
+    {
+        return $this->output->getVerbosity() >= OutputInterface::VERBOSITY_VERY_VERBOSE;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function isDebug()
+    {
+        return $this->output->getVerbosity() >= OutputInterface::VERBOSITY_DEBUG;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function write($messages, $newline = true, $verbosity = self::NORMAL)
+    {
+        $this->doWrite($messages, $newline, false, $verbosity);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function writeError($messages, $newline = true, $verbosity = self::NORMAL)
+    {
+        $this->doWrite($messages, $newline, true, $verbosity);
+    }
+
+    /**
+     * @param array|string $messages
+     * @param bool         $newline
+     * @param bool         $stderr
+     * @param int          $verbosity
+     */
+    private function doWrite($messages, $newline, $stderr, $verbosity)
+    {
+        $sfVerbosity = $this->verbosityMap[$verbosity];
+        if ($sfVerbosity > $this->output->getVerbosity()) {
+            return;
+        }
+
+        // hack to keep our usage BC with symfony<2.8 versions
+        // this removes the quiet output but there is no way around it
+        // see https://github.com/composer/composer/pull/4913
+        if (OutputInterface::VERBOSITY_QUIET === 0) {
+            $sfVerbosity = OutputInterface::OUTPUT_NORMAL;
+        }
+
+        if (null !== $this->startTime) {
+            $memoryUsage = memory_get_usage() / 1024 / 1024;
+            $timeSpent = microtime(true) - $this->startTime;
+            $messages = array_map(function ($message) use ($memoryUsage, $timeSpent) {
+                return sprintf('[%.1fMB/%.2fs] %s', $memoryUsage, $timeSpent, $message);
+            }, (array) $messages);
+        }
+
+        if (true === $stderr && $this->output instanceof ConsoleOutputInterface) {
+            $this->output->getErrorOutput()->write($messages, $newline, $sfVerbosity);
+            $this->lastMessageErr = implode($newline ? "\n" : '', (array) $messages);
+
+            return;
+        }
+
+        $this->output->write($messages, $newline, $sfVerbosity);
+        $this->lastMessage = implode($newline ? "\n" : '', (array) $messages);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function overwrite($messages, $newline = true, $size = null, $verbosity = self::NORMAL)
+    {
+        $this->doOverwrite($messages, $newline, $size, false, $verbosity);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function overwriteError($messages, $newline = true, $size = null, $verbosity = self::NORMAL)
+    {
+        $this->doOverwrite($messages, $newline, $size, true, $verbosity);
+    }
+
+    /**
+     * @param array|string $messages
+     * @param bool         $newline
+     * @param int|null     $size
+     * @param bool         $stderr
+     * @param int          $verbosity
+     */
+    private function doOverwrite($messages, $newline, $size, $stderr, $verbosity)
+    {
+        // messages can be an array, let's convert it to string anyway
+        $messages = implode($newline ? "\n" : '', (array) $messages);
+
+        // since overwrite is supposed to overwrite last message...
+        if (!isset($size)) {
+            // removing possible formatting of lastMessage with strip_tags
+            $size = strlen(strip_tags($stderr ? $this->lastMessageErr : $this->lastMessage));
+        }
+        // ...let's fill its length with backspaces
+        $this->doWrite(str_repeat("\x08", $size), false, $stderr, $verbosity);
+
+        // write the new message
+        $this->doWrite($messages, false, $stderr, $verbosity);
+
+        // In cmd.exe on Win8.1 (possibly 10?), the line can not be cleared, so we need to
+        // track the length of previous output and fill it with spaces to make sure the line is cleared.
+        // See https://github.com/composer/composer/pull/5836 for more details
+        $fill = $size - strlen(strip_tags($messages));
+        if ($fill > 0) {
+            // whitespace whatever has left
+            $this->doWrite(str_repeat(' ', $fill), false, $stderr, $verbosity);
+            // move the cursor back
+            $this->doWrite(str_repeat("\x08", $fill), false, $stderr, $verbosity);
+        }
+
+        if ($newline) {
+            $this->doWrite('', true, $stderr, $verbosity);
+        }
+
+        if ($stderr) {
+            $this->lastMessageErr = $messages;
+        } else {
+            $this->lastMessage = $messages;
+        }
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function ask($question, $default = null)
+    {
+        /** @var \Symfony\Component\Console\Helper\QuestionHelper $helper */
+        $helper = $this->helperSet->get('question');
+        $question = new Question($question, $default);
+
+        return $helper->ask($this->input, $this->getErrorOutput(), $question);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function askConfirmation($question, $default = true)
+    {
+        /** @var \Symfony\Component\Console\Helper\QuestionHelper $helper */
+        $helper = $this->helperSet->get('question');
+        $question = new StrictConfirmationQuestion($question, $default);
+
+        return $helper->ask($this->input, $this->getErrorOutput(), $question);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function askAndValidate($question, $validator, $attempts = null, $default = null)
+    {
+        /** @var \Symfony\Component\Console\Helper\QuestionHelper $helper */
+        $helper = $this->helperSet->get('question');
+        $question = new Question($question, $default);
+        $question->setValidator($validator);
+        $question->setMaxAttempts($attempts);
+
+        return $helper->ask($this->input, $this->getErrorOutput(), $question);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function askAndHideAnswer($question)
+    {
+        /** @var \Symfony\Component\Console\Helper\QuestionHelper $helper */
+        $helper = $this->helperSet->get('question');
+        $question = new Question($question);
+        $question->setHidden(true);
+
+        return $helper->ask($this->input, $this->getErrorOutput(), $question);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function select($question, $choices, $default, $attempts = false, $errorMessage = 'Value "%s" is invalid', $multiselect = false)
+    {
+        /** @var \Symfony\Component\Console\Helper\QuestionHelper $helper */
+        $helper = $this->helperSet->get('question');
+        $question = new ChoiceQuestion($question, $choices, $default);
+        $question->setMaxAttempts($attempts ?: null); // IOInterface requires false, and Question requires null or int
+        $question->setErrorMessage($errorMessage);
+        $question->setMultiselect($multiselect);
+
+        $result = $helper->ask($this->input, $this->getErrorOutput(), $question);
+
+        if (!is_array($result)) {
+            return (string) array_search($result, $choices, true);
+        }
+
+        $results = array();
+        foreach ($choices as $index => $choice) {
+            if (in_array($choice, $result, true)) {
+                $results[] = (string) $index;
+            }
+        }
+
+        return $results;
+    }
+
+    /**
+     * @return OutputInterface
+     */
+    private function getErrorOutput()
+    {
+        if ($this->output instanceof ConsoleOutputInterface) {
+            return $this->output->getErrorOutput();
+        }
+
+        return $this->output;
+    }
+}