dependabot-composer 0.98.12 → 0.98.13

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

@@ -0,0 +1,163 @@
+<?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\IO\IOInterface;
+use Composer\Config;
+use Composer\Factory;
+use Composer\Downloader\TransportException;
+use Composer\Json\JsonFile;
+
+/**
+ * @author Roshan Gautam <roshan.gautam@hotmail.com>
+ */
+class GitLab
+{
+    protected $io;
+    protected $config;
+    protected $process;
+    protected $remoteFilesystem;
+
+    /**
+     * Constructor.
+     *
+     * @param IOInterface      $io               The IO instance
+     * @param Config           $config           The composer configuration
+     * @param ProcessExecutor  $process          Process instance, injectable for mocking
+     * @param RemoteFilesystem $remoteFilesystem Remote Filesystem, injectable for mocking
+     */
+    public function __construct(IOInterface $io, Config $config, ProcessExecutor $process = null, RemoteFilesystem $remoteFilesystem = null)
+    {
+        $this->io = $io;
+        $this->config = $config;
+        $this->process = $process ?: new ProcessExecutor($io);
+        $this->remoteFilesystem = $remoteFilesystem ?: Factory::createRemoteFilesystem($this->io, $config);
+    }
+
+    /**
+     * Attempts to authorize a GitLab domain via OAuth.
+     *
+     * @param string $originUrl The host this GitLab instance is located at
+     *
+     * @return bool true on success
+     */
+    public function authorizeOAuth($originUrl)
+    {
+        if (!in_array($originUrl, $this->config->get('gitlab-domains'), true)) {
+            return false;
+        }
+
+        // if available use token from git config
+        if (0 === $this->process->execute('git config gitlab.accesstoken', $output)) {
+            $this->io->setAuthentication($originUrl, trim($output), 'oauth2');
+
+            return true;
+        }
+
+        // if available use token from composer config
+        $authTokens = $this->config->get('gitlab-token');
+
+        if (isset($authTokens[$originUrl])) {
+            $this->io->setAuthentication($originUrl, $authTokens[$originUrl], 'private-token');
+
+            return true;
+        }
+
+        return false;
+    }
+
+    /**
+     * Authorizes a GitLab domain interactively via OAuth.
+     *
+     * @param string $scheme    Scheme used in the origin URL
+     * @param string $originUrl The host this GitLab instance is located at
+     * @param string $message   The reason this authorization is required
+     *
+     * @throws \RuntimeException
+     * @throws TransportException|\Exception
+     *
+     * @return bool true on success
+     */
+    public function authorizeOAuthInteractively($scheme, $originUrl, $message = null)
+    {
+        if ($message) {
+            $this->io->writeError($message);
+        }
+
+        $this->io->writeError(sprintf('A token will be created and stored in "%s", your password will never be stored', $this->config->getAuthConfigSource()->getName()));
+        $this->io->writeError('To revoke access to this token you can visit '.$originUrl.'/profile/applications');
+
+        $attemptCounter = 0;
+
+        while ($attemptCounter++ < 5) {
+            try {
+                $response = $this->createToken($scheme, $originUrl);
+            } catch (TransportException $e) {
+                // 401 is bad credentials,
+                // 403 is max login attempts exceeded
+                if (in_array($e->getCode(), array(403, 401))) {
+                    if (401 === $e->getCode()) {
+                        $this->io->writeError('Bad credentials.');
+                    } else {
+                        $this->io->writeError('Maximum number of login attempts exceeded. Please try again later.');
+                    }
+
+                    $this->io->writeError('You can also manually create a personal token at '.$scheme.'://'.$originUrl.'/profile/personal_access_tokens');
+                    $this->io->writeError('Add it using "composer config --global --auth gitlab-token.'.$originUrl.' <token>"');
+
+                    continue;
+                }
+
+                throw $e;
+            }
+
+            $this->io->setAuthentication($originUrl, $response['access_token'], 'oauth2');
+
+            // store value in user config in auth file
+            $this->config->getAuthConfigSource()->addConfigSetting('gitlab-oauth.'.$originUrl, $response['access_token']);
+
+            return true;
+        }
+
+        throw new \RuntimeException('Invalid GitLab credentials 5 times in a row, aborting.');
+    }
+
+    private function createToken($scheme, $originUrl)
+    {
+        $username = $this->io->ask('Username: ');
+        $password = $this->io->askAndHideAnswer('Password: ');
+
+        $headers = array('Content-Type: application/x-www-form-urlencoded');
+
+        $apiUrl = $originUrl;
+        $data = http_build_query(array(
+            'username' => $username,
+            'password' => $password,
+            'grant_type' => 'password',
+        ), null, '&');
+        $options = array(
+            'retry-auth-failure' => false,
+            'http' => array(
+                'method' => 'POST',
+                'header' => $headers,
+                'content' => $data,
+            ),
+        );
+
+        $json = $this->remoteFilesystem->getContents($originUrl, $scheme.'://'.$apiUrl.'/oauth/token', false, $options);
+
+        $this->io->writeError('Token successfully created');
+
+        return JsonFile::parseJson($json);
+    }
+}

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

@@ -0,0 +1,94 @@
+<?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 Jonas Renaudot <jonas.renaudot@gmail.com>
+ */
+class Hg
+{
+    /**
+     * @var \Composer\IO\IOInterface
+     */
+    private $io;
+
+    /**
+     * @var \Composer\Config
+     */
+    private $config;
+
+    /**
+     * @var \Composer\Util\ProcessExecutor
+     */
+    private $process;
+
+    public function __construct(IOInterface $io, Config $config, ProcessExecutor $process)
+    {
+        $this->io = $io;
+        $this->config = $config;
+        $this->process = $process;
+    }
+
+    public function runCommand($commandCallable, $url, $cwd)
+    {
+        $this->config->prohibitUrlByConfig($url, $this->io);
+
+        // Try as is
+        $command = call_user_func($commandCallable, $url);
+
+        if (0 === $this->process->execute($command, $ignoredOutput, $cwd)) {
+            return;
+        }
+
+        // Try with the authentication informations available
+        if (preg_match('{^(https?)://((.+)(?:\:(.+))?@)?([^/]+)(/.*)?}mi', $url, $match) && $this->io->hasAuthentication($match[5])) {
+            $auth = $this->io->getAuthentication($match[5]);
+            $authenticatedUrl = $match[1] . '://' . rawurlencode($auth['username']) . ':' . rawurlencode($auth['password']) . '@' . $match[5] . (!empty($match[6]) ? $match[6] : null);
+
+            $command = call_user_func($commandCallable, $authenticatedUrl);
+
+            if (0 === $this->process->execute($command, $ignoredOutput, $cwd)) {
+                return;
+            }
+
+            $error = $this->process->getErrorOutput();
+        } else {
+            $error = 'The given URL (' . $url . ') does not match the required format (http(s)://(username:password@)example.com/path-to-repository)';
+        }
+
+        $this->throwException('Failed to clone ' . $url . ', ' . "\n\n" . $error, $url);
+    }
+
+    public static function sanitizeUrl($message)
+    {
+        return preg_replace_callback('{://(?P<user>[^@]+?):(?P<password>.+?)@}', function ($m) {
+            if (preg_match('{^[a-f0-9]{12,}$}', $m[1])) {
+                return '://***:***@';
+            }
+
+            return '://' . $m[1] . ':***@';
+        }, $message);
+    }
+
+    private function throwException($message, $url)
+    {
+        if (0 !== $this->process->execute('hg --version', $ignoredOutput)) {
+            throw new \RuntimeException(self::sanitizeUrl('Failed to clone ' . $url . ', hg was not found, check that it is installed and in your PATH env.' . "\n\n" . $this->process->getErrorOutput()));
+        }
+
+        throw new \RuntimeException(self::sanitizeUrl($message));
+    }
+}

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

@@ -0,0 +1,64 @@
+<?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\XdebugHandler\XdebugHandler;
+
+/**
+ * Provides ini file location functions that work with and without a restart.
+ * When the process has restarted it uses a tmp ini and stores the original
+ * ini locations in an environment variable.
+ *
+ * @author John Stevenson <john-stevenson@blueyonder.co.uk>
+ */
+class IniHelper
+{
+    /**
+     * Returns an array of php.ini locations with at least one entry
+     *
+     * The equivalent of calling php_ini_loaded_file then php_ini_scanned_files.
+     * The loaded ini location is the first entry and may be empty.
+     *
+     * @return array
+     */
+    public static function getAll()
+    {
+        return XdebugHandler::getAllIniFiles();
+    }
+
+    /**
+     * Describes the location of the loaded php.ini file(s)
+     *
+     * @return string
+     */
+    public static function getMessage()
+    {
+        $paths = self::getAll();
+
+        if (empty($paths[0])) {
+            array_shift($paths);
+        }
+
+        $ini = array_shift($paths);
+
+        if (empty($ini)) {
+            return 'A php.ini file does not exist. You will have to create one.';
+        }
+
+        if (!empty($paths)) {
+            return 'Your command-line PHP is using multiple ini files. Run `php --ini` to show them.';
+        }
+
+        return 'The php.ini used by your command-line PHP is: '.$ini;
+    }
+}

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

@@ -0,0 +1,147 @@
+<?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;
+
+/**
+ * Tests URLs against no_proxy patterns.
+ */
+class NoProxyPattern
+{
+    /**
+     * @var string[]
+     */
+    protected $rules = array();
+
+    /**
+     * @param string $pattern no_proxy pattern
+     */
+    public function __construct($pattern)
+    {
+        $this->rules = preg_split("/[\s,]+/", $pattern);
+    }
+
+    /**
+     * Test a URL against the stored pattern.
+     *
+     * @param string $url
+     *
+     * @return bool true if the URL matches one of the rules.
+     */
+    public function test($url)
+    {
+        $host = parse_url($url, PHP_URL_HOST);
+        $port = parse_url($url, PHP_URL_PORT);
+
+        if (empty($port)) {
+            switch (parse_url($url, PHP_URL_SCHEME)) {
+                case 'http':
+                    $port = 80;
+                    break;
+                case 'https':
+                    $port = 443;
+                    break;
+            }
+        }
+
+        foreach ($this->rules as $rule) {
+            if ($rule == '*') {
+                return true;
+            }
+
+            $match = false;
+
+            list($ruleHost) = explode(':', $rule);
+            list($base) = explode('/', $ruleHost);
+
+            if (filter_var($base, FILTER_VALIDATE_IP, FILTER_FLAG_IPV4)) {
+                // ip or cidr match
+
+                if (!isset($ip)) {
+                    $ip = gethostbyname($host);
+                }
+
+                if (strpos($ruleHost, '/') === false) {
+                    $match = $ip === $ruleHost;
+                } else {
+                    // gethostbyname() failed to resolve $host to an ip, so we assume
+                    // it must be proxied to let the proxy's DNS resolve it
+                    if ($ip === $host) {
+                        $match = false;
+                    } else {
+                        // match resolved IP against the rule
+                        $match = self::inCIDRBlock($ruleHost, $ip);
+                    }
+                }
+            } else {
+                // match end of domain
+
+                $haystack = '.' . trim($host, '.') . '.';
+                $needle = '.'. trim($ruleHost, '.') .'.';
+                $match = stripos(strrev($haystack), strrev($needle)) === 0;
+            }
+
+            // final port check
+            if ($match && strpos($rule, ':') !== false) {
+                list(, $rulePort) = explode(':', $rule);
+                if (!empty($rulePort) && $port != $rulePort) {
+                    $match = false;
+                }
+            }
+
+            if ($match) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    /**
+     * Check an IP address against a CIDR
+     *
+     * http://framework.zend.com/svn/framework/extras/incubator/library/ZendX/Whois/Adapter/Cidr.php
+     *
+     * @param string $cidr IPv4 block in CIDR notation
+     * @param string $ip   IPv4 address
+     *
+     * @return bool
+     */
+    private static function inCIDRBlock($cidr, $ip)
+    {
+        // Get the base and the bits from the CIDR
+        list($base, $bits) = explode('/', $cidr);
+
+        // Now split it up into it's classes
+        list($a, $b, $c, $d) = explode('.', $base);
+
+        // Now do some bit shifting/switching to convert to ints
+        $i = ($a << 24) + ($b << 16) + ($c << 8) + $d;
+        $mask = $bits == 0 ? 0 : (~0 << (32 - $bits));
+
+        // Here's our lowest int
+        $low = $i & $mask;
+
+        // Here's our highest int
+        $high = $i | (~$mask & 0xFFFFFFFF);
+
+        // Now split the ip we're checking against up into classes
+        list($a, $b, $c, $d) = explode('.', $ip);
+
+        // Now convert the ip we're checking against to an int
+        $check = ($a << 24) + ($b << 16) + ($c << 8) + $d;
+
+        // If the ip is within the range, including highest/lowest values,
+        // then it's within the CIDR range
+        return $check >= $low && $check <= $high;
+    }
+}