dependabot-composer 0.108.10 → 0.108.11

data/helpers/vendor/composer/composer/src/Composer/Cache.php

@@ -0,0 +1,251 @@
+<?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;
+
+use Composer\IO\IOInterface;
+use Composer\Util\Filesystem;
+use Composer\Util\Silencer;
+use Symfony\Component\Finder\Finder;
+
+/**
+ * Reads/writes to a filesystem cache
+ *
+ * @author Jordi Boggiano <j.boggiano@seld.be>
+ */
+class Cache
+{
+    private static $cacheCollected = false;
+    private $io;
+    private $root;
+    private $enabled = true;
+    private $whitelist;
+    private $filesystem;
+
+    /**
+     * @param IOInterface $io
+     * @param string      $cacheDir   location of the cache
+     * @param string      $whitelist  List of characters that are allowed in path names (used in a regex character class)
+     * @param Filesystem  $filesystem optional filesystem instance
+     */
+    public function __construct(IOInterface $io, $cacheDir, $whitelist = 'a-z0-9.', Filesystem $filesystem = null)
+    {
+        $this->io = $io;
+        $this->root = rtrim($cacheDir, '/\\') . '/';
+        $this->whitelist = $whitelist;
+        $this->filesystem = $filesystem ?: new Filesystem();
+
+        if (preg_match('{(^|[\\\\/])(\$null|NUL|/dev/null)([\\\\/]|$)}', $cacheDir)) {
+            $this->enabled = false;
+
+            return;
+        }
+
+        if (
+            (!is_dir($this->root) && !Silencer::call('mkdir', $this->root, 0777, true))
+            || !is_writable($this->root)
+        ) {
+            $this->io->writeError('<warning>Cannot create cache directory ' . $this->root . ', or directory is not writable. Proceeding without cache</warning>');
+            $this->enabled = false;
+        }
+    }
+
+    public function isEnabled()
+    {
+        return $this->enabled;
+    }
+
+    public function getRoot()
+    {
+        return $this->root;
+    }
+
+    public function read($file)
+    {
+        if ($this->enabled) {
+            $file = preg_replace('{[^'.$this->whitelist.']}i', '-', $file);
+            if (file_exists($this->root . $file)) {
+                $this->io->writeError('Reading '.$this->root . $file.' from cache', true, IOInterface::DEBUG);
+
+                return file_get_contents($this->root . $file);
+            }
+        }
+
+        return false;
+    }
+
+    public function write($file, $contents)
+    {
+        if ($this->enabled) {
+            $file = preg_replace('{[^'.$this->whitelist.']}i', '-', $file);
+
+            $this->io->writeError('Writing '.$this->root . $file.' into cache', true, IOInterface::DEBUG);
+
+            try {
+                return file_put_contents($this->root . $file, $contents);
+            } catch (\ErrorException $e) {
+                $this->io->writeError('<warning>Failed to write into cache: '.$e->getMessage().'</warning>', true, IOInterface::DEBUG);
+                if (preg_match('{^file_put_contents\(\): Only ([0-9]+) of ([0-9]+) bytes written}', $e->getMessage(), $m)) {
+                    // Remove partial file.
+                    unlink($this->root . $file);
+
+                    $message = sprintf(
+                        '<warning>Writing %1$s into cache failed after %2$u of %3$u bytes written, only %4$u bytes of free space available</warning>',
+                        $this->root . $file,
+                        $m[1],
+                        $m[2],
+                        @disk_free_space($this->root . dirname($file))
+                    );
+
+                    $this->io->writeError($message);
+
+                    return false;
+                }
+
+                throw $e;
+            }
+        }
+
+        return false;
+    }
+
+    /**
+     * Copy a file into the cache
+     */
+    public function copyFrom($file, $source)
+    {
+        if ($this->enabled) {
+            $file = preg_replace('{[^'.$this->whitelist.']}i', '-', $file);
+            $this->filesystem->ensureDirectoryExists(dirname($this->root . $file));
+
+            if (!file_exists($source)) {
+                $this->io->writeError('<error>'.$source.' does not exist, can not write into cache</error>');
+            } elseif ($this->io->isDebug()) {
+                $this->io->writeError('Writing '.$this->root . $file.' into cache from '.$source);
+            }
+
+            return copy($source, $this->root . $file);
+        }
+
+        return false;
+    }
+
+    /**
+     * Copy a file out of the cache
+     */
+    public function copyTo($file, $target)
+    {
+        if ($this->enabled) {
+            $file = preg_replace('{[^'.$this->whitelist.']}i', '-', $file);
+            if (file_exists($this->root . $file)) {
+                try {
+                    touch($this->root . $file, filemtime($this->root . $file), time());
+                } catch (\ErrorException $e) {
+                    // fallback in case the above failed due to incorrect ownership
+                    // see https://github.com/composer/composer/issues/4070
+                    Silencer::call('touch', $this->root . $file);
+                }
+
+                $this->io->writeError('Reading '.$this->root . $file.' from cache', true, IOInterface::DEBUG);
+
+                return copy($this->root . $file, $target);
+            }
+        }
+
+        return false;
+    }
+
+    public function gcIsNecessary()
+    {
+        return (!self::$cacheCollected && !mt_rand(0, 50));
+    }
+
+    public function remove($file)
+    {
+        if ($this->enabled) {
+            $file = preg_replace('{[^'.$this->whitelist.']}i', '-', $file);
+            if (file_exists($this->root . $file)) {
+                return $this->filesystem->unlink($this->root . $file);
+            }
+        }
+
+        return false;
+    }
+
+    public function clear()
+    {
+        if ($this->enabled) {
+            return $this->filesystem->removeDirectory($this->root);
+        }
+
+        return false;
+    }
+
+    public function gc($ttl, $maxSize)
+    {
+        if ($this->enabled) {
+            $expire = new \DateTime();
+            $expire->modify('-'.$ttl.' seconds');
+
+            $finder = $this->getFinder()->date('until '.$expire->format('Y-m-d H:i:s'));
+            foreach ($finder as $file) {
+                $this->filesystem->unlink($file->getPathname());
+            }
+
+            $totalSize = $this->filesystem->size($this->root);
+            if ($totalSize > $maxSize) {
+                $iterator = $this->getFinder()->sortByAccessedTime()->getIterator();
+                while ($totalSize > $maxSize && $iterator->valid()) {
+                    $filepath = $iterator->current()->getPathname();
+                    $totalSize -= $this->filesystem->size($filepath);
+                    $this->filesystem->unlink($filepath);
+                    $iterator->next();
+                }
+            }
+
+            self::$cacheCollected = true;
+
+            return true;
+        }
+
+        return false;
+    }
+
+    public function sha1($file)
+    {
+        if ($this->enabled) {
+            $file = preg_replace('{[^'.$this->whitelist.']}i', '-', $file);
+            if (file_exists($this->root . $file)) {
+                return sha1_file($this->root . $file);
+            }
+        }
+
+        return false;
+    }
+
+    public function sha256($file)
+    {
+        if ($this->enabled) {
+            $file = preg_replace('{[^'.$this->whitelist.']}i', '-', $file);
+            if (file_exists($this->root . $file)) {
+                return hash_file('sha256', $this->root . $file);
+            }
+        }
+
+        return false;
+    }
+
+    protected function getFinder()
+    {
+        return Finder::create()->in($this->root)->files();
+    }
+}

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

@@ -0,0 +1,46 @@
+<?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 Symfony\Component\Console\Input\InputInterface;
+use Symfony\Component\Console\Output\OutputInterface;
+
+/**
+ * @author Jordi Boggiano <j.boggiano@seld.be>
+ */
+class AboutCommand extends BaseCommand
+{
+    protected function configure()
+    {
+        $this
+            ->setName('about')
+            ->setDescription('Shows the short information about Composer.')
+            ->setHelp(
+                <<<EOT
+<info>php composer.phar about</info>
+EOT
+            )
+        ;
+    }
+
+    protected function execute(InputInterface $input, OutputInterface $output)
+    {
+        $this->getIO()->write(
+            <<<EOT
+<info>Composer - Dependency Manager for PHP</info>
+<comment>Composer is a dependency manager tracking local dependencies of your projects and libraries.
+See https://getcomposer.org/ for more information.</comment>
+EOT
+        );
+    }
+}

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

@@ -0,0 +1,166 @@
+<?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\Factory;
+use Composer\IO\IOInterface;
+use Composer\Config;
+use Composer\Composer;
+use Composer\Repository\CompositeRepository;
+use Composer\Repository\RepositoryFactory;
+use Composer\Script\ScriptEvents;
+use Composer\Plugin\CommandEvent;
+use Composer\Plugin\PluginEvents;
+use Composer\Util\Filesystem;
+use Symfony\Component\Console\Input\InputArgument;
+use Symfony\Component\Console\Input\InputInterface;
+use Symfony\Component\Console\Input\InputOption;
+use Symfony\Component\Console\Output\OutputInterface;
+
+/**
+ * Creates an archive of a package for distribution.
+ *
+ * @author Nils Adermann <naderman@naderman.de>
+ */
+class ArchiveCommand extends BaseCommand
+{
+    protected function configure()
+    {
+        $this
+            ->setName('archive')
+            ->setDescription('Creates an archive of this composer package.')
+            ->setDefinition(array(
+                new InputArgument('package', InputArgument::OPTIONAL, 'The package to archive instead of the current project'),
+                new InputArgument('version', InputArgument::OPTIONAL, 'A version constraint to find the package to archive'),
+                new InputOption('format', 'f', InputOption::VALUE_REQUIRED, 'Format of the resulting archive: tar or zip'),
+                new InputOption('dir', null, InputOption::VALUE_REQUIRED, 'Write the archive to this directory'),
+                new InputOption('file', null, InputOption::VALUE_REQUIRED, 'Write the archive with the given file name.'
+                    .' Note that the format will be appended.'),
+                new InputOption('ignore-filters', false, InputOption::VALUE_NONE, 'Ignore filters when saving package'),
+            ))
+            ->setHelp(
+                <<<EOT
+The <info>archive</info> command creates an archive of the specified format
+containing the files and directories of the Composer project or the specified
+package in the specified version and writes it to the specified directory.
+
+<info>php composer.phar archive [--format=zip] [--dir=/foo] [package [version]]</info>
+
+Read more at https://getcomposer.org/doc/03-cli.md#archive
+EOT
+            )
+        ;
+    }
+
+    protected function execute(InputInterface $input, OutputInterface $output)
+    {
+        $config = Factory::createConfig();
+        $composer = $this->getComposer(false);
+        if ($composer) {
+            $commandEvent = new CommandEvent(PluginEvents::COMMAND, 'archive', $input, $output);
+            $eventDispatcher = $composer->getEventDispatcher();
+            $eventDispatcher->dispatch($commandEvent->getName(), $commandEvent);
+            $eventDispatcher->dispatchScript(ScriptEvents::PRE_ARCHIVE_CMD);
+        }
+
+        if (null === $input->getOption('format')) {
+            $input->setOption('format', $config->get('archive-format'));
+        }
+        if (null === $input->getOption('dir')) {
+            $input->setOption('dir', $config->get('archive-dir'));
+        }
+
+        $returnCode = $this->archive(
+            $this->getIO(),
+            $config,
+            $input->getArgument('package'),
+            $input->getArgument('version'),
+            $input->getOption('format'),
+            $input->getOption('dir'),
+            $input->getOption('file'),
+            $input->getOption('ignore-filters'),
+            $composer
+        );
+
+        if (0 === $returnCode && $composer) {
+            $composer->getEventDispatcher()->dispatchScript(ScriptEvents::POST_ARCHIVE_CMD);
+        }
+
+        return $returnCode;
+    }
+
+    protected function archive(IOInterface $io, Config $config, $packageName = null, $version = null, $format = 'tar', $dest = '.', $fileName = null, $ignoreFilters = false, Composer $composer = null)
+    {
+        if ($composer) {
+            $archiveManager = $composer->getArchiveManager();
+        } else {
+            $factory = new Factory;
+            $downloadManager = $factory->createDownloadManager($io, $config);
+            $archiveManager = $factory->createArchiveManager($config, $downloadManager);
+        }
+
+        if ($packageName) {
+            $package = $this->selectPackage($io, $packageName, $version);
+
+            if (!$package) {
+                return 1;
+            }
+        } else {
+            $package = $this->getComposer()->getPackage();
+        }
+
+        $io->writeError('<info>Creating the archive into "'.$dest.'".</info>');
+        $packagePath = $archiveManager->archive($package, $format, $dest, $fileName, $ignoreFilters);
+        $fs = new Filesystem;
+        $shortPath = $fs->findShortestPath(getcwd(), $packagePath, true);
+
+        $io->writeError('Created: ', false);
+        $io->write(strlen($shortPath) < strlen($packagePath) ? $shortPath : $packagePath);
+
+        return 0;
+    }
+
+    protected function selectPackage(IOInterface $io, $packageName, $version = null)
+    {
+        $io->writeError('<info>Searching for the specified package.</info>');
+
+        if ($composer = $this->getComposer(false)) {
+            $localRepo = $composer->getRepositoryManager()->getLocalRepository();
+            $repo = new CompositeRepository(array_merge(array($localRepo), $composer->getRepositoryManager()->getRepositories()));
+        } else {
+            $defaultRepos = RepositoryFactory::defaultRepos($this->getIO());
+            $io->writeError('No composer.json found in the current directory, searching packages from ' . implode(', ', array_keys($defaultRepos)));
+            $repo = new CompositeRepository($defaultRepos);
+        }
+
+        $packages = $repo->findPackages($packageName, $version);
+
+        if (count($packages) > 1) {
+            $package = reset($packages);
+            $io->writeError('<info>Found multiple matches, selected '.$package->getPrettyString().'.</info>');
+            $io->writeError('Alternatives were '.implode(', ', array_map(function ($p) {
+                return $p->getPrettyString();
+            }, $packages)).'.');
+            $io->writeError('<comment>Please use a more specific constraint to pick a different package.</comment>');
+        } elseif ($packages) {
+            $package = reset($packages);
+            $io->writeError('<info>Found an exact match '.$package->getPrettyString().'.</info>');
+        } else {
+            $io->writeError('<error>Could not find a package matching '.$packageName.'.</error>');
+
+            return false;
+        }
+
+        return $package;
+    }
+}