dependabot-composer 0.111.24 → 0.111.25

data/helpers/vendor/composer/composer/src/Composer/Installer/PearInstaller.php

@@ -0,0 +1,84 @@
+<?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\Installer;
+
+use Composer\IO\IOInterface;
+use Composer\Composer;
+use Composer\Downloader\PearPackageExtractor;
+use Composer\Repository\InstalledRepositoryInterface;
+use Composer\Package\PackageInterface;
+use Composer\Util\Platform;
+use Composer\Util\Filesystem;
+
+/**
+ * Package installation manager.
+ *
+ * @author Jordi Boggiano <j.boggiano@seld.be>
+ * @author Konstantin Kudryashov <ever.zet@gmail.com>
+ */
+class PearInstaller extends LibraryInstaller
+{
+    /**
+     * Initializes library installer.
+     *
+     * @param IOInterface $io       io instance
+     * @param Composer    $composer
+     * @param string      $type     package type that this installer handles
+     */
+    public function __construct(IOInterface $io, Composer $composer, $type = 'pear-library')
+    {
+        $filesystem = new Filesystem();
+        $binaryInstaller = new PearBinaryInstaller($io, rtrim($composer->getConfig()->get('bin-dir'), '/'), rtrim($composer->getConfig()->get('vendor-dir'), '/'), $composer->getConfig()->get('bin-compat'), $filesystem, $this);
+
+        parent::__construct($io, $composer, $type, $filesystem, $binaryInstaller);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function update(InstalledRepositoryInterface $repo, PackageInterface $initial, PackageInterface $target)
+    {
+        $this->uninstall($repo, $initial);
+        $this->install($repo, $target);
+    }
+
+    protected function installCode(PackageInterface $package)
+    {
+        parent::installCode($package);
+
+        $isWindows = Platform::isWindows();
+        $php_bin = $this->binDir . ($isWindows ? '/composer-php.bat' : '/composer-php');
+
+        if (!$isWindows) {
+            $php_bin = '/usr/bin/env ' . $php_bin;
+        }
+
+        $installPath = $this->getInstallPath($package);
+        $vars = array(
+            'os' => $isWindows ? 'windows' : 'linux',
+            'php_bin' => $php_bin,
+            'pear_php' => $installPath,
+            'php_dir' => $installPath,
+            'bin_dir' => $installPath . '/bin',
+            'data_dir' => $installPath . '/data',
+            'version' => $package->getPrettyVersion(),
+        );
+
+        $packageArchive = $this->getInstallPath($package).'/'.pathinfo($package->getDistUrl(), PATHINFO_BASENAME);
+        $pearExtractor = new PearPackageExtractor($packageArchive);
+        $pearExtractor->extractTo($this->getInstallPath($package), array('php' => '/', 'script' => '/bin', 'data' => '/data'), $vars);
+
+        $this->io->writeError('    Cleaning up', true, IOInterface::VERBOSE);
+        $this->filesystem->unlink($packageArchive);
+    }
+}

data/helpers/vendor/composer/composer/src/Composer/Installer/PluginInstaller.php

@@ -0,0 +1,84 @@
+<?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\Installer;
+
+use Composer\Composer;
+use Composer\IO\IOInterface;
+use Composer\Repository\InstalledRepositoryInterface;
+use Composer\Package\PackageInterface;
+
+/**
+ * Installer for plugin packages
+ *
+ * @author Jordi Boggiano <j.boggiano@seld.be>
+ * @author Nils Adermann <naderman@naderman.de>
+ */
+class PluginInstaller extends LibraryInstaller
+{
+    private $installationManager;
+
+    /**
+     * Initializes Plugin installer.
+     *
+     * @param IOInterface $io
+     * @param Composer    $composer
+     */
+    public function __construct(IOInterface $io, Composer $composer)
+    {
+        parent::__construct($io, $composer, 'composer-plugin');
+        $this->installationManager = $composer->getInstallationManager();
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function supports($packageType)
+    {
+        return $packageType === 'composer-plugin' || $packageType === 'composer-installer';
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function install(InstalledRepositoryInterface $repo, PackageInterface $package)
+    {
+        $extra = $package->getExtra();
+        if (empty($extra['class'])) {
+            throw new \UnexpectedValueException('Error while installing '.$package->getPrettyName().', composer-plugin packages should have a class defined in their extra key to be usable.');
+        }
+
+        parent::install($repo, $package);
+        try {
+            $this->composer->getPluginManager()->registerPackage($package, true);
+        } catch (\Exception $e) {
+            // Rollback installation
+            $this->io->writeError('Plugin installation failed, rolling back');
+            parent::uninstall($repo, $package);
+            throw $e;
+        }
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function update(InstalledRepositoryInterface $repo, PackageInterface $initial, PackageInterface $target)
+    {
+        $extra = $target->getExtra();
+        if (empty($extra['class'])) {
+            throw new \UnexpectedValueException('Error while installing '.$target->getPrettyName().', composer-plugin packages should have a class defined in their extra key to be usable.');
+        }
+
+        parent::update($repo, $initial, $target);
+        $this->composer->getPluginManager()->registerPackage($target, true);
+    }
+}

data/helpers/vendor/composer/composer/src/Composer/Installer/ProjectInstaller.php

@@ -0,0 +1,99 @@
+<?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\Installer;
+
+use Composer\Package\PackageInterface;
+use Composer\Downloader\DownloadManager;
+use Composer\Repository\InstalledRepositoryInterface;
+use Composer\Util\Filesystem;
+
+/**
+ * Project Installer is used to install a single package into a directory as
+ * root project.
+ *
+ * @author Benjamin Eberlei <kontakt@beberlei.de>
+ */
+class ProjectInstaller implements InstallerInterface
+{
+    private $installPath;
+    private $downloadManager;
+    private $filesystem;
+
+    public function __construct($installPath, DownloadManager $dm)
+    {
+        $this->installPath = rtrim(strtr($installPath, '\\', '/'), '/').'/';
+        $this->downloadManager = $dm;
+        $this->filesystem = new Filesystem;
+    }
+
+    /**
+     * Decides if the installer supports the given type
+     *
+     * @param  string $packageType
+     * @return bool
+     */
+    public function supports($packageType)
+    {
+        return true;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function isInstalled(InstalledRepositoryInterface $repo, PackageInterface $package)
+    {
+        return false;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function install(InstalledRepositoryInterface $repo, PackageInterface $package)
+    {
+        $installPath = $this->installPath;
+        if (file_exists($installPath) && !$this->filesystem->isDirEmpty($installPath)) {
+            throw new \InvalidArgumentException("Project directory $installPath is not empty.");
+        }
+        if (!is_dir($installPath)) {
+            mkdir($installPath, 0777, true);
+        }
+        $this->downloadManager->download($package, $installPath);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function update(InstalledRepositoryInterface $repo, PackageInterface $initial, PackageInterface $target)
+    {
+        throw new \InvalidArgumentException("not supported");
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function uninstall(InstalledRepositoryInterface $repo, PackageInterface $package)
+    {
+        throw new \InvalidArgumentException("not supported");
+    }
+
+    /**
+     * Returns the installation path of a package
+     *
+     * @param  PackageInterface $package
+     * @return string           path
+     */
+    public function getInstallPath(PackageInterface $package)
+    {
+        return $this->installPath;
+    }
+}

data/helpers/vendor/composer/composer/src/Composer/Installer/SuggestedPackagesReporter.php

@@ -0,0 +1,151 @@
+<?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\Installer;
+
+use Composer\IO\IOInterface;
+use Composer\Package\PackageInterface;
+use Composer\Repository\RepositoryInterface;
+use Symfony\Component\Console\Formatter\OutputFormatter;
+
+/**
+ * Add suggested packages from different places to output them in the end.
+ *
+ * @author Haralan Dobrev <hkdobrev@gmail.com>
+ */
+class SuggestedPackagesReporter
+{
+    /**
+     * @var array
+     */
+    protected $suggestedPackages = array();
+
+    /**
+     * @var IOInterface
+     */
+    private $io;
+
+    public function __construct(IOInterface $io)
+    {
+        $this->io = $io;
+    }
+
+    /**
+     * @return array Suggested packages with source, target and reason keys.
+     */
+    public function getPackages()
+    {
+        return $this->suggestedPackages;
+    }
+
+    /**
+     * Add suggested packages to be listed after install
+     *
+     * Could be used to add suggested packages both from the installer
+     * or from CreateProjectCommand.
+     *
+     * @param  string                    $source Source package which made the suggestion
+     * @param  string                    $target Target package to be suggested
+     * @param  string                    $reason Reason the target package to be suggested
+     * @return SuggestedPackagesReporter
+     */
+    public function addPackage($source, $target, $reason)
+    {
+        $this->suggestedPackages[] = array(
+            'source' => $source,
+            'target' => $target,
+            'reason' => $reason,
+        );
+
+        return $this;
+    }
+
+    /**
+     * Add all suggestions from a package.
+     *
+     * @param  PackageInterface          $package
+     * @return SuggestedPackagesReporter
+     */
+    public function addSuggestionsFromPackage(PackageInterface $package)
+    {
+        $source = $package->getPrettyName();
+        foreach ($package->getSuggests() as $target => $reason) {
+            $this->addPackage(
+                $source,
+                $target,
+                $reason
+            );
+        }
+
+        return $this;
+    }
+
+    /**
+     * Output suggested packages.
+     * Do not list the ones already installed if installed repository provided.
+     *
+     * @param  RepositoryInterface       $installedRepo Installed packages
+     * @return SuggestedPackagesReporter
+     */
+    public function output(RepositoryInterface $installedRepo = null)
+    {
+        $suggestedPackages = $this->getPackages();
+        $installedPackages = array();
+        if (null !== $installedRepo && ! empty($suggestedPackages)) {
+            foreach ($installedRepo->getPackages() as $package) {
+                $installedPackages = array_merge(
+                    $installedPackages,
+                    $package->getNames()
+                );
+            }
+        }
+
+        foreach ($suggestedPackages as $suggestion) {
+            if (in_array($suggestion['target'], $installedPackages)) {
+                continue;
+            }
+
+            $this->io->writeError(sprintf(
+                '%s suggests installing %s%s',
+                $suggestion['source'],
+                $this->escapeOutput($suggestion['target']),
+                $this->escapeOutput('' !== $suggestion['reason'] ? ' ('.$suggestion['reason'].')' : '')
+            ));
+        }
+
+        return $this;
+    }
+
+    /**
+     * @param  string $string
+     * @return string
+     */
+    private function escapeOutput($string)
+    {
+        return OutputFormatter::escape(
+            $this->removeControlCharacters($string)
+        );
+    }
+
+    /**
+     * @param  string $string
+     * @return string
+     */
+    private function removeControlCharacters($string)
+    {
+        return preg_replace(
+            '/[[:cntrl:]]/',
+            '',
+            str_replace("\n", ' ', $string)
+        );
+    }
+}

data/helpers/vendor/composer/composer/src/Composer/Json/JsonFile.php

@@ -0,0 +1,301 @@
+<?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\Json;
+
+use JsonSchema\Validator;
+use Seld\JsonLint\JsonParser;
+use Seld\JsonLint\ParsingException;
+use Composer\Util\RemoteFilesystem;
+use Composer\IO\IOInterface;
+use Composer\Downloader\TransportException;
+
+/**
+ * Reads/writes json files.
+ *
+ * @author Konstantin Kudryashiv <ever.zet@gmail.com>
+ * @author Jordi Boggiano <j.boggiano@seld.be>
+ */
+class JsonFile
+{
+    const LAX_SCHEMA = 1;
+    const STRICT_SCHEMA = 2;
+
+    const JSON_UNESCAPED_SLASHES = 64;
+    const JSON_PRETTY_PRINT = 128;
+    const JSON_UNESCAPED_UNICODE = 256;
+
+    private $path;
+    private $rfs;
+    private $io;
+
+    /**
+     * Initializes json file reader/parser.
+     *
+     * @param  string                    $path path to a lockfile
+     * @param  RemoteFilesystem          $rfs  required for loading http/https json files
+     * @param  IOInterface               $io
+     * @throws \InvalidArgumentException
+     */
+    public function __construct($path, RemoteFilesystem $rfs = null, IOInterface $io = null)
+    {
+        $this->path = $path;
+
+        if (null === $rfs && preg_match('{^https?://}i', $path)) {
+            throw new \InvalidArgumentException('http urls require a RemoteFilesystem instance to be passed');
+        }
+        $this->rfs = $rfs;
+        $this->io = $io;
+    }
+
+    /**
+     * @return string
+     */
+    public function getPath()
+    {
+        return $this->path;
+    }
+
+    /**
+     * Checks whether json file exists.
+     *
+     * @return bool
+     */
+    public function exists()
+    {
+        return is_file($this->path);
+    }
+
+    /**
+     * Reads json file.
+     *
+     * @throws \RuntimeException
+     * @return mixed
+     */
+    public function read()
+    {
+        try {
+            if ($this->rfs) {
+                $json = $this->rfs->getContents($this->path, $this->path, false);
+            } else {
+                if ($this->io && $this->io->isDebug()) {
+                    $this->io->writeError('Reading ' . $this->path);
+                }
+                $json = file_get_contents($this->path);
+            }
+        } catch (TransportException $e) {
+            throw new \RuntimeException($e->getMessage(), 0, $e);
+        } catch (\Exception $e) {
+            throw new \RuntimeException('Could not read '.$this->path."\n\n".$e->getMessage());
+        }
+
+        return static::parseJson($json, $this->path);
+    }
+
+    /**
+     * Writes json file.
+     *
+     * @param  array                                $hash    writes hash into json file
+     * @param  int                                  $options json_encode options (defaults to JSON_UNESCAPED_SLASHES | JSON_PRETTY_PRINT | JSON_UNESCAPED_UNICODE)
+     * @throws \UnexpectedValueException|\Exception
+     */
+    public function write(array $hash, $options = 448)
+    {
+        $dir = dirname($this->path);
+        if (!is_dir($dir)) {
+            if (file_exists($dir)) {
+                throw new \UnexpectedValueException(
+                    $dir.' exists and is not a directory.'
+                );
+            }
+            if (!@mkdir($dir, 0777, true)) {
+                throw new \UnexpectedValueException(
+                    $dir.' does not exist and could not be created.'
+                );
+            }
+        }
+
+        $retries = 3;
+        while ($retries--) {
+            try {
+                file_put_contents($this->path, static::encode($hash, $options). ($options & self::JSON_PRETTY_PRINT ? "\n" : ''));
+                break;
+            } catch (\Exception $e) {
+                if ($retries) {
+                    usleep(500000);
+                    continue;
+                }
+
+                throw $e;
+            }
+        }
+    }
+
+    /**
+     * Validates the schema of the current json file according to composer-schema.json rules
+     *
+     * @param  int                     $schema a JsonFile::*_SCHEMA constant
+     * @throws JsonValidationException
+     * @return bool                    true on success
+     */
+    public function validateSchema($schema = self::STRICT_SCHEMA)
+    {
+        $content = file_get_contents($this->path);
+        $data = json_decode($content);
+
+        if (null === $data && 'null' !== $content) {
+            self::validateSyntax($content, $this->path);
+        }
+
+        $schemaFile = __DIR__ . '/../../../res/composer-schema.json';
+
+        // Prepend with file:// only when not using a special schema already (e.g. in the phar)
+        if (false === strpos($schemaFile, '://')) {
+            $schemaFile = 'file://' . $schemaFile;
+        }
+
+        $schemaData = (object) array('$ref' => $schemaFile);
+
+        if ($schema === self::LAX_SCHEMA) {
+            $schemaData->additionalProperties = true;
+            $schemaData->required = array();
+        }
+
+        $validator = new Validator();
+        $validator->check($data, $schemaData);
+
+        // TODO add more validation like check version constraints and such, perhaps build that into the arrayloader?
+
+        if (!$validator->isValid()) {
+            $errors = array();
+            foreach ((array) $validator->getErrors() as $error) {
+                $errors[] = ($error['property'] ? $error['property'].' : ' : '').$error['message'];
+            }
+            throw new JsonValidationException('"'.$this->path.'" does not match the expected JSON schema', $errors);
+        }
+
+        return true;
+    }
+
+    /**
+     * Encodes an array into (optionally pretty-printed) JSON
+     *
+     * @param  mixed  $data    Data to encode into a formatted JSON string
+     * @param  int    $options json_encode options (defaults to JSON_UNESCAPED_SLASHES | JSON_PRETTY_PRINT | JSON_UNESCAPED_UNICODE)
+     * @return string Encoded json
+     */
+    public static function encode($data, $options = 448)
+    {
+        if (PHP_VERSION_ID >= 50400) {
+            $json = json_encode($data, $options);
+            if (false === $json) {
+                self::throwEncodeError(json_last_error());
+            }
+
+            //  compact brackets to follow recent php versions
+            if (PHP_VERSION_ID < 50428 || (PHP_VERSION_ID >= 50500 && PHP_VERSION_ID < 50512) || (defined('JSON_C_VERSION') && version_compare(phpversion('json'), '1.3.6', '<'))) {
+                $json = preg_replace('/\[\s+\]/', '[]', $json);
+                $json = preg_replace('/\{\s+\}/', '{}', $json);
+            }
+
+            return $json;
+        }
+
+        $json = json_encode($data);
+        if (false === $json) {
+            self::throwEncodeError(json_last_error());
+        }
+
+        $prettyPrint = (bool) ($options & self::JSON_PRETTY_PRINT);
+        $unescapeUnicode = (bool) ($options & self::JSON_UNESCAPED_UNICODE);
+        $unescapeSlashes = (bool) ($options & self::JSON_UNESCAPED_SLASHES);
+
+        if (!$prettyPrint && !$unescapeUnicode && !$unescapeSlashes) {
+            return $json;
+        }
+
+        return JsonFormatter::format($json, $unescapeUnicode, $unescapeSlashes);
+    }
+
+    /**
+     * Throws an exception according to a given code with a customized message
+     *
+     * @param  int               $code return code of json_last_error function
+     * @throws \RuntimeException
+     */
+    private static function throwEncodeError($code)
+    {
+        switch ($code) {
+            case JSON_ERROR_DEPTH:
+                $msg = 'Maximum stack depth exceeded';
+                break;
+            case JSON_ERROR_STATE_MISMATCH:
+                $msg = 'Underflow or the modes mismatch';
+                break;
+            case JSON_ERROR_CTRL_CHAR:
+                $msg = 'Unexpected control character found';
+                break;
+            case JSON_ERROR_UTF8:
+                $msg = 'Malformed UTF-8 characters, possibly incorrectly encoded';
+                break;
+            default:
+                $msg = 'Unknown error';
+        }
+
+        throw new \RuntimeException('JSON encoding failed: '.$msg);
+    }
+
+    /**
+     * Parses json string and returns hash.
+     *
+     * @param string $json json string
+     * @param string $file the json file
+     *
+     * @return mixed
+     */
+    public static function parseJson($json, $file = null)
+    {
+        if (null === $json) {
+            return;
+        }
+        $data = json_decode($json, true);
+        if (null === $data && JSON_ERROR_NONE !== json_last_error()) {
+            self::validateSyntax($json, $file);
+        }
+
+        return $data;
+    }
+
+    /**
+     * Validates the syntax of a JSON string
+     *
+     * @param  string                    $json
+     * @param  string                    $file
+     * @throws \UnexpectedValueException
+     * @throws ParsingException
+     * @return bool                      true on success
+     */
+    protected static function validateSyntax($json, $file = null)
+    {
+        $parser = new JsonParser();
+        $result = $parser->lint($json);
+        if (null === $result) {
+            if (defined('JSON_ERROR_UTF8') && JSON_ERROR_UTF8 === json_last_error()) {
+                throw new \UnexpectedValueException('"'.$file.'" is not UTF-8, could not parse as JSON');
+            }
+
+            return true;
+        }
+
+        throw new ParsingException('"'.$file.'" does not contain valid JSON'."\n".$result->getMessage(), $result->getDetails());
+    }
+}