dependabot-composer 0.89.5 → 0.90.0

data/helpers/vendor/composer/composer/src/Composer/Util/Silencer.php

@@ -0,0 +1,78 @@
+<?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\Util;
+
+/**
+ * Temporarily suppress PHP error reporting, usually warnings and below.
+ *
+ * @author Niels Keurentjes <niels.keurentjes@omines.com>
+ */
+class Silencer
+{
+    /**
+     * @var int[] Unpop stack
+     */
+    private static $stack = array();
+
+    /**
+     * Suppresses given mask or errors.
+     *
+     * @param  int|null $mask Error levels to suppress, default value NULL indicates all warnings and below.
+     * @return int      The old error reporting level.
+     */
+    public static function suppress($mask = null)
+    {
+        if (!isset($mask)) {
+            $mask = E_WARNING | E_NOTICE | E_USER_WARNING | E_USER_NOTICE | E_DEPRECATED | E_USER_DEPRECATED | E_STRICT;
+        }
+        $old = error_reporting();
+        self::$stack[] = $old;
+        error_reporting($old & ~$mask);
+
+        return $old;
+    }
+
+    /**
+     * Restores a single state.
+     */
+    public static function restore()
+    {
+        if (!empty(self::$stack)) {
+            error_reporting(array_pop(self::$stack));
+        }
+    }
+
+    /**
+     * Calls a specified function while silencing warnings and below.
+     *
+     * Future improvement: when PHP requirements are raised add Callable type hint (5.4) and variadic parameters (5.6)
+     *
+     * @param  callable   $callable Function to execute.
+     * @throws \Exception Any exceptions from the callback are rethrown.
+     * @return mixed      Return value of the callback.
+     */
+    public static function call($callable /*, ...$parameters */)
+    {
+        try {
+            self::suppress();
+            $result = call_user_func_array($callable, array_slice(func_get_args(), 1));
+            self::restore();
+
+            return $result;
+        } catch (\Exception $e) {
+            // Use a finally block for this when requirements are raised to PHP 5.5
+            self::restore();
+            throw $e;
+        }
+    }
+}

data/helpers/vendor/composer/composer/src/Composer/Util/SpdxLicense.php

@@ -0,0 +1,24 @@
+<?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\Util;
+
+use Composer\Spdx\SpdxLicenses;
+
+trigger_error('The ' . __NAMESPACE__ . '\SpdxLicense class is deprecated, use Composer\Spdx\SpdxLicenses instead.', E_USER_DEPRECATED);
+
+/**
+ * @deprecated use Composer\Spdx\SpdxLicenses instead
+ */
+class SpdxLicense extends SpdxLicenses
+{
+}

data/helpers/vendor/composer/composer/src/Composer/Util/StreamContextFactory.php

@@ -0,0 +1,177 @@
+<?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\Util;
+
+use Composer\Composer;
+
+/**
+ * Allows the creation of a basic context supporting http proxy
+ *
+ * @author Jordan Alliot <jordan.alliot@gmail.com>
+ * @author Markus Tacker <m@coderbyheart.de>
+ */
+final class StreamContextFactory
+{
+    /**
+     * Creates a context supporting HTTP proxies
+     *
+     * @param  string            $url            URL the context is to be used for
+     * @param  array             $defaultOptions Options to merge with the default
+     * @param  array             $defaultParams  Parameters to specify on the context
+     * @throws \RuntimeException if https proxy required and OpenSSL uninstalled
+     * @return resource          Default context
+     */
+    public static function getContext($url, array $defaultOptions = array(), array $defaultParams = array())
+    {
+        $options = array('http' => array(
+            // specify defaults again to try and work better with curlwrappers enabled
+            'follow_location' => 1,
+            'max_redirects' => 20,
+        ));
+
+        // Handle HTTP_PROXY/http_proxy on CLI only for security reasons
+        if ((PHP_SAPI === 'cli' || PHP_SAPI === 'phpdbg') && (!empty($_SERVER['HTTP_PROXY']) || !empty($_SERVER['http_proxy']))) {
+            $proxy = parse_url(!empty($_SERVER['http_proxy']) ? $_SERVER['http_proxy'] : $_SERVER['HTTP_PROXY']);
+        }
+
+        // Prefer CGI_HTTP_PROXY if available
+        if (!empty($_SERVER['CGI_HTTP_PROXY'])) {
+            $proxy = parse_url($_SERVER['CGI_HTTP_PROXY']);
+        }
+
+        // Override with HTTPS proxy if present and URL is https
+        if (preg_match('{^https://}i', $url) && (!empty($_SERVER['HTTPS_PROXY']) || !empty($_SERVER['https_proxy']))) {
+            $proxy = parse_url(!empty($_SERVER['https_proxy']) ? $_SERVER['https_proxy'] : $_SERVER['HTTPS_PROXY']);
+        }
+
+        // Remove proxy if URL matches no_proxy directive
+        if (!empty($_SERVER['NO_PROXY']) || !empty($_SERVER['no_proxy']) && parse_url($url, PHP_URL_HOST)) {
+            $pattern = new NoProxyPattern(!empty($_SERVER['no_proxy']) ? $_SERVER['no_proxy'] : $_SERVER['NO_PROXY']);
+            if ($pattern->test($url)) {
+                unset($proxy);
+            }
+        }
+
+        if (!empty($proxy)) {
+            $proxyURL = isset($proxy['scheme']) ? $proxy['scheme'] . '://' : '';
+            $proxyURL .= isset($proxy['host']) ? $proxy['host'] : '';
+
+            if (isset($proxy['port'])) {
+                $proxyURL .= ":" . $proxy['port'];
+            } elseif ('http://' == substr($proxyURL, 0, 7)) {
+                $proxyURL .= ":80";
+            } elseif ('https://' == substr($proxyURL, 0, 8)) {
+                $proxyURL .= ":443";
+            }
+
+            // http(s):// is not supported in proxy
+            $proxyURL = str_replace(array('http://', 'https://'), array('tcp://', 'ssl://'), $proxyURL);
+
+            if (0 === strpos($proxyURL, 'ssl:') && !extension_loaded('openssl')) {
+                throw new \RuntimeException('You must enable the openssl extension to use a proxy over https');
+            }
+
+            $options['http']['proxy'] = $proxyURL;
+
+            // enabled request_fulluri unless it is explicitly disabled
+            switch (parse_url($url, PHP_URL_SCHEME)) {
+                case 'http': // default request_fulluri to true
+                    $reqFullUriEnv = getenv('HTTP_PROXY_REQUEST_FULLURI');
+                    if ($reqFullUriEnv === false || $reqFullUriEnv === '' || (strtolower($reqFullUriEnv) !== 'false' && (bool) $reqFullUriEnv)) {
+                        $options['http']['request_fulluri'] = true;
+                    }
+                    break;
+                case 'https': // default request_fulluri to true
+                    $reqFullUriEnv = getenv('HTTPS_PROXY_REQUEST_FULLURI');
+                    if ($reqFullUriEnv === false || $reqFullUriEnv === '' || (strtolower($reqFullUriEnv) !== 'false' && (bool) $reqFullUriEnv)) {
+                        $options['http']['request_fulluri'] = true;
+                    }
+                    break;
+            }
+
+            // add SNI opts for https URLs
+            if ('https' === parse_url($url, PHP_URL_SCHEME)) {
+                $options['ssl']['SNI_enabled'] = true;
+                if (PHP_VERSION_ID < 50600) {
+                    $options['ssl']['SNI_server_name'] = parse_url($url, PHP_URL_HOST);
+                }
+            }
+
+            // handle proxy auth if present
+            if (isset($proxy['user'])) {
+                $auth = rawurldecode($proxy['user']);
+                if (isset($proxy['pass'])) {
+                    $auth .= ':' . rawurldecode($proxy['pass']);
+                }
+                $auth = base64_encode($auth);
+
+                // Preserve headers if already set in default options
+                if (isset($defaultOptions['http']['header'])) {
+                    if (is_string($defaultOptions['http']['header'])) {
+                        $defaultOptions['http']['header'] = array($defaultOptions['http']['header']);
+                    }
+                    $defaultOptions['http']['header'][] = "Proxy-Authorization: Basic {$auth}";
+                } else {
+                    $options['http']['header'] = array("Proxy-Authorization: Basic {$auth}");
+                }
+            }
+        }
+
+        $options = array_replace_recursive($options, $defaultOptions);
+
+        if (isset($options['http']['header'])) {
+            $options['http']['header'] = self::fixHttpHeaderField($options['http']['header']);
+        }
+
+        if (defined('HHVM_VERSION')) {
+            $phpVersion = 'HHVM ' . HHVM_VERSION;
+        } else {
+            $phpVersion = 'PHP ' . PHP_MAJOR_VERSION . '.' . PHP_MINOR_VERSION . '.' . PHP_RELEASE_VERSION;
+        }
+
+        if (!isset($options['http']['header']) || false === stripos(implode('', $options['http']['header']), 'user-agent')) {
+            $options['http']['header'][] = sprintf(
+                'User-Agent: Composer/%s (%s; %s; %s%s)',
+                Composer::VERSION === '@package_version@' ? 'source' : Composer::VERSION,
+                function_exists('php_uname') ? php_uname('s') : 'Unknown',
+                function_exists('php_uname') ? php_uname('r') : 'Unknown',
+                $phpVersion,
+                getenv('CI') ? '; CI' : ''
+            );
+        }
+
+        return stream_context_create($options, $defaultParams);
+    }
+
+    /**
+     * A bug in PHP prevents the headers from correctly being sent when a content-type header is present and
+     * NOT at the end of the array
+     *
+     * This method fixes the array by moving the content-type header to the end
+     *
+     * @link https://bugs.php.net/bug.php?id=61548
+     * @param string|array $header
+     * @return array
+     */
+    private static function fixHttpHeaderField($header)
+    {
+        if (!is_array($header)) {
+            $header = explode("\r\n", $header);
+        }
+        uasort($header, function ($el) {
+            return stripos($el, 'content-type') === 0 ? 1 : -1;
+        });
+
+        return $header;
+    }
+}

data/helpers/vendor/composer/composer/src/Composer/Util/Svn.php

@@ -0,0 +1,381 @@
+<?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\Util;
+
+use Composer\Config;
+use Composer\IO\IOInterface;
+
+/**
+ * @author Till Klampaeckel <till@php.net>
+ * @author Jordi Boggiano <j.boggiano@seld.be>
+ */
+class Svn
+{
+    const MAX_QTY_AUTH_TRIES = 5;
+
+    /**
+     * @var array
+     */
+    protected $credentials;
+
+    /**
+     * @var bool
+     */
+    protected $hasAuth;
+
+    /**
+     * @var \Composer\IO\IOInterface
+     */
+    protected $io;
+
+    /**
+     * @var string
+     */
+    protected $url;
+
+    /**
+     * @var bool
+     */
+    protected $cacheCredentials = true;
+
+    /**
+     * @var ProcessExecutor
+     */
+    protected $process;
+
+    /**
+     * @var int
+     */
+    protected $qtyAuthTries = 0;
+
+    /**
+     * @var \Composer\Config
+     */
+    protected $config;
+
+    /**
+     * @var string|null
+     */
+    private static $version;
+
+    /**
+     * @param string                   $url
+     * @param \Composer\IO\IOInterface $io
+     * @param Config                   $config
+     * @param ProcessExecutor          $process
+     */
+    public function __construct($url, IOInterface $io, Config $config, ProcessExecutor $process = null)
+    {
+        $this->url = $url;
+        $this->io = $io;
+        $this->config = $config;
+        $this->process = $process ?: new ProcessExecutor($io);
+    }
+
+    public static function cleanEnv()
+    {
+        // clean up env for OSX, see https://github.com/composer/composer/issues/2146#issuecomment-35478940
+        putenv("DYLD_LIBRARY_PATH");
+        unset($_SERVER['DYLD_LIBRARY_PATH']);
+    }
+
+    /**
+     * Execute an SVN remote command and try to fix up the process with credentials
+     * if necessary.
+     *
+     * @param string $command SVN command to run
+     * @param string $url     SVN url
+     * @param string $cwd     Working directory
+     * @param string $path    Target for a checkout
+     * @param bool   $verbose Output all output to the user
+     *
+     * @throws \RuntimeException
+     * @return string
+     */
+    public function execute($command, $url, $cwd = null, $path = null, $verbose = false)
+    {
+        // Ensure we are allowed to use this URL by config
+        $this->config->prohibitUrlByConfig($url, $this->io);
+
+        return $this->executeWithAuthRetry($command, $cwd, $url, $path, $verbose);
+    }
+
+    /**
+     * Execute an SVN local command and try to fix up the process with credentials
+     * if necessary.
+     *
+     * @param string $command SVN command to run
+     * @param string $path    Path argument passed thru to the command
+     * @param string $cwd     Working directory
+     * @param bool   $verbose Output all output to the user
+     *
+     * @throws \RuntimeException
+     * @return string
+     */
+    public function executeLocal($command, $path, $cwd = null, $verbose = false)
+    {
+        // A local command has no remote url
+        return $this->executeWithAuthRetry($command, $cwd, '', $path, $verbose);
+    }
+
+    private function executeWithAuthRetry($svnCommand, $cwd, $url, $path, $verbose)
+    {
+        // Regenerate the command at each try, to use the newly user-provided credentials
+        $command = $this->getCommand($svnCommand, $url, $path);
+
+        $output = null;
+        $io = $this->io;
+        $handler = function ($type, $buffer) use (&$output, $io, $verbose) {
+            if ($type !== 'out') {
+                return;
+            }
+            if ('Redirecting to URL ' === substr($buffer, 0, 19)) {
+                return;
+            }
+            $output .= $buffer;
+            if ($verbose) {
+                $io->writeError($buffer, false);
+            }
+        };
+        $status = $this->process->execute($command, $handler, $cwd);
+        if (0 === $status) {
+            return $output;
+        }
+
+        $errorOutput = $this->process->getErrorOutput();
+        $fullOutput = implode("\n", array($output, $errorOutput));
+
+        // the error is not auth-related
+        if (false === stripos($fullOutput, 'Could not authenticate to server:')
+            && false === stripos($fullOutput, 'authorization failed')
+            && false === stripos($fullOutput, 'svn: E170001:')
+            && false === stripos($fullOutput, 'svn: E215004:')) {
+            throw new \RuntimeException($fullOutput);
+        }
+
+        if (!$this->hasAuth()) {
+            $this->doAuthDance();
+        }
+
+        // try to authenticate if maximum quantity of tries not reached
+        if ($this->qtyAuthTries++ < self::MAX_QTY_AUTH_TRIES) {
+            // restart the process
+            return $this->executeWithAuthRetry($svnCommand, $cwd, $url, $path, $verbose);
+        }
+
+        throw new \RuntimeException(
+            'wrong credentials provided ('.$fullOutput.')'
+        );
+    }
+
+    /**
+     * @param bool $cacheCredentials
+     */
+    public function setCacheCredentials($cacheCredentials)
+    {
+        $this->cacheCredentials = $cacheCredentials;
+    }
+
+    /**
+     * Repositories requests credentials, let's put them in.
+     *
+     * @throws \RuntimeException
+     * @return \Composer\Util\Svn
+     */
+    protected function doAuthDance()
+    {
+        // cannot ask for credentials in non interactive mode
+        if (!$this->io->isInteractive()) {
+            throw new \RuntimeException(
+                'can not ask for authentication in non interactive mode'
+            );
+        }
+
+        $this->io->writeError("The Subversion server ({$this->url}) requested credentials:");
+
+        $this->hasAuth = true;
+        $this->credentials['username'] = $this->io->ask("Username: ");
+        $this->credentials['password'] = $this->io->askAndHideAnswer("Password: ");
+
+        $this->cacheCredentials = $this->io->askConfirmation("Should Subversion cache these credentials? (yes/no) ", true);
+
+        return $this;
+    }
+
+    /**
+     * A method to create the svn commands run.
+     *
+     * @param string $cmd  Usually 'svn ls' or something like that.
+     * @param string $url  Repo URL.
+     * @param string $path Target for a checkout
+     *
+     * @return string
+     */
+    protected function getCommand($cmd, $url, $path = null)
+    {
+        $cmd = sprintf(
+            '%s %s%s %s',
+            $cmd,
+            '--non-interactive ',
+            $this->getCredentialString(),
+            ProcessExecutor::escape($url)
+        );
+
+        if ($path) {
+            $cmd .= ' ' . ProcessExecutor::escape($path);
+        }
+
+        return $cmd;
+    }
+
+    /**
+     * Return the credential string for the svn command.
+     *
+     * Adds --no-auth-cache when credentials are present.
+     *
+     * @return string
+     */
+    protected function getCredentialString()
+    {
+        if (!$this->hasAuth()) {
+            return '';
+        }
+
+        return sprintf(
+            ' %s--username %s --password %s ',
+            $this->getAuthCache(),
+            ProcessExecutor::escape($this->getUsername()),
+            ProcessExecutor::escape($this->getPassword())
+        );
+    }
+
+    /**
+     * Get the password for the svn command. Can be empty.
+     *
+     * @throws \LogicException
+     * @return string
+     */
+    protected function getPassword()
+    {
+        if ($this->credentials === null) {
+            throw new \LogicException("No svn auth detected.");
+        }
+
+        return isset($this->credentials['password']) ? $this->credentials['password'] : '';
+    }
+
+    /**
+     * Get the username for the svn command.
+     *
+     * @throws \LogicException
+     * @return string
+     */
+    protected function getUsername()
+    {
+        if ($this->credentials === null) {
+            throw new \LogicException("No svn auth detected.");
+        }
+
+        return $this->credentials['username'];
+    }
+
+    /**
+     * Detect Svn Auth.
+     *
+     * @return bool
+     */
+    protected function hasAuth()
+    {
+        if (null !== $this->hasAuth) {
+            return $this->hasAuth;
+        }
+
+        if (false === $this->createAuthFromConfig()) {
+            $this->createAuthFromUrl();
+        }
+
+        return $this->hasAuth;
+    }
+
+    /**
+     * Return the no-auth-cache switch.
+     *
+     * @return string
+     */
+    protected function getAuthCache()
+    {
+        return $this->cacheCredentials ? '' : '--no-auth-cache ';
+    }
+
+    /**
+     * Create the auth params from the configuration file.
+     *
+     * @return bool
+     */
+    private function createAuthFromConfig()
+    {
+        if (!$this->config->has('http-basic')) {
+            return $this->hasAuth = false;
+        }
+
+        $authConfig = $this->config->get('http-basic');
+
+        $host = parse_url($this->url, PHP_URL_HOST);
+        if (isset($authConfig[$host])) {
+            $this->credentials['username'] = $authConfig[$host]['username'];
+            $this->credentials['password'] = $authConfig[$host]['password'];
+
+            return $this->hasAuth = true;
+        }
+
+        return $this->hasAuth = false;
+    }
+
+    /**
+     * Create the auth params from the url
+     *
+     * @return bool
+     */
+    private function createAuthFromUrl()
+    {
+        $uri = parse_url($this->url);
+        if (empty($uri['user'])) {
+            return $this->hasAuth = false;
+        }
+
+        $this->credentials['username'] = $uri['user'];
+        if (!empty($uri['pass'])) {
+            $this->credentials['password'] = $uri['pass'];
+        }
+
+        return $this->hasAuth = true;
+    }
+
+    /**
+     * Returns the version of the svn binary contained in PATH
+     *
+     * @return string|null
+     */
+    public function binaryVersion()
+    {
+        if (!self::$version) {
+            if (0 === $this->process->execute('svn --version', $output)) {
+                if (preg_match('{(\d+(?:\.\d+)+)}', $output, $match)) {
+                    self::$version = $match[1];
+                }
+            }
+        }
+
+        return self::$version;
+    }
+}