dependabot-composer 0.107.27 → 0.107.28

data/helpers/vendor/composer/composer/src/Composer/Package/Archiver/ArchivableFilesFinder.php

@@ -0,0 +1,105 @@
+<?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\Package\Archiver;
+
+use Composer\Util\Filesystem;
+use FilesystemIterator;
+use Symfony\Component\Finder\Finder;
+use Symfony\Component\Finder\SplFileInfo;
+
+/**
+ * A Symfony Finder wrapper which locates files that should go into archives
+ *
+ * Handles .gitignore, .gitattributes and .hgignore files as well as composer's
+ * own exclude rules from composer.json
+ *
+ * @author Nils Adermann <naderman@naderman.de>
+ */
+class ArchivableFilesFinder extends \FilterIterator
+{
+    /**
+     * @var Finder
+     */
+    protected $finder;
+
+    /**
+     * Initializes the internal Symfony Finder with appropriate filters
+     *
+     * @param string $sources       Path to source files to be archived
+     * @param array  $excludes      Composer's own exclude rules from composer.json
+     * @param bool   $ignoreFilters Ignore filters when looking for files
+     */
+    public function __construct($sources, array $excludes, $ignoreFilters = false)
+    {
+        $fs = new Filesystem();
+
+        $sources = $fs->normalizePath($sources);
+
+        if ($ignoreFilters) {
+            $filters = array();
+        } else {
+            $filters = array(
+                new HgExcludeFilter($sources),
+                new GitExcludeFilter($sources),
+                new ComposerExcludeFilter($sources, $excludes),
+            );
+        }
+
+        $this->finder = new Finder();
+
+        $filter = function (\SplFileInfo $file) use ($sources, $filters, $fs) {
+            if ($file->isLink() && strpos($file->getLinkTarget(), $sources) !== 0) {
+                return false;
+            }
+
+            $relativePath = preg_replace(
+                '#^'.preg_quote($sources, '#').'#',
+                '',
+                $fs->normalizePath($file->getRealPath())
+            );
+
+            $exclude = false;
+            foreach ($filters as $filter) {
+                $exclude = $filter->filter($relativePath, $exclude);
+            }
+
+            return !$exclude;
+        };
+
+        if (method_exists($filter, 'bindTo')) {
+            $filter = $filter->bindTo(null);
+        }
+
+        $this->finder
+            ->in($sources)
+            ->filter($filter)
+            ->ignoreVCS(true)
+            ->ignoreDotFiles(false);
+
+        parent::__construct($this->finder->getIterator());
+    }
+
+    public function accept()
+    {
+        /** @var SplFileInfo $current */
+        $current = $this->getInnerIterator()->current();
+
+        if (!$current->isDir()) {
+            return true;
+        }
+
+        $iterator = new FilesystemIterator($current, FilesystemIterator::SKIP_DOTS);
+
+        return !$iterator->valid();
+    }
+}

data/helpers/vendor/composer/composer/src/Composer/Package/Archiver/ArchiveManager.php

@@ -0,0 +1,183 @@
+<?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\Package\Archiver;
+
+use Composer\Downloader\DownloadManager;
+use Composer\Package\PackageInterface;
+use Composer\Package\RootPackageInterface;
+use Composer\Util\Filesystem;
+use Composer\Json\JsonFile;
+
+/**
+ * @author Matthieu Moquet <matthieu@moquet.net>
+ * @author Till Klampaeckel <till@php.net>
+ */
+class ArchiveManager
+{
+    protected $downloadManager;
+
+    protected $archivers = array();
+
+    /**
+     * @var bool
+     */
+    protected $overwriteFiles = true;
+
+    /**
+     * @param DownloadManager $downloadManager A manager used to download package sources
+     */
+    public function __construct(DownloadManager $downloadManager)
+    {
+        $this->downloadManager = $downloadManager;
+    }
+
+    /**
+     * @param ArchiverInterface $archiver
+     */
+    public function addArchiver(ArchiverInterface $archiver)
+    {
+        $this->archivers[] = $archiver;
+    }
+
+    /**
+     * Set whether existing archives should be overwritten
+     *
+     * @param bool $overwriteFiles New setting
+     *
+     * @return $this
+     */
+    public function setOverwriteFiles($overwriteFiles)
+    {
+        $this->overwriteFiles = $overwriteFiles;
+
+        return $this;
+    }
+
+    /**
+     * Generate a distinct filename for a particular version of a package.
+     *
+     * @param PackageInterface $package The package to get a name for
+     *
+     * @return string A filename without an extension
+     */
+    public function getPackageFilename(PackageInterface $package)
+    {
+        $nameParts = array(preg_replace('#[^a-z0-9-_]#i', '-', $package->getName()));
+
+        if (preg_match('{^[a-f0-9]{40}$}', $package->getDistReference())) {
+            array_push($nameParts, $package->getDistReference(), $package->getDistType());
+        } else {
+            array_push($nameParts, $package->getPrettyVersion(), $package->getDistReference());
+        }
+
+        if ($package->getSourceReference()) {
+            $nameParts[] = substr(sha1($package->getSourceReference()), 0, 6);
+        }
+
+        $name = implode('-', array_filter($nameParts, function ($p) {
+            return !empty($p);
+        }));
+
+        return str_replace('/', '-', $name);
+    }
+
+    /**
+     * Create an archive of the specified package.
+     *
+     * @param  PackageInterface          $package       The package to archive
+     * @param  string                    $format        The format of the archive (zip, tar, ...)
+     * @param  string                    $targetDir     The directory where to build the archive
+     * @param  string|null               $fileName      The relative file name to use for the archive, or null to generate
+     *                                                  the package name. Note that the format will be appended to this name
+     * @param  bool                      $ignoreFilters Ignore filters when looking for files in the package
+     * @throws \InvalidArgumentException
+     * @throws \RuntimeException
+     * @return string                    The path of the created archive
+     */
+    public function archive(PackageInterface $package, $format, $targetDir, $fileName = null, $ignoreFilters = false)
+    {
+        if (empty($format)) {
+            throw new \InvalidArgumentException('Format must be specified');
+        }
+
+        // Search for the most appropriate archiver
+        $usableArchiver = null;
+        foreach ($this->archivers as $archiver) {
+            if ($archiver->supports($format, $package->getSourceType())) {
+                $usableArchiver = $archiver;
+                break;
+            }
+        }
+
+        // Checks the format/source type are supported before downloading the package
+        if (null === $usableArchiver) {
+            throw new \RuntimeException(sprintf('No archiver found to support %s format', $format));
+        }
+
+        $filesystem = new Filesystem();
+        if (null === $fileName) {
+            $packageName = $this->getPackageFilename($package);
+        } else {
+            $packageName = $fileName;
+        }
+
+        // Archive filename
+        $filesystem->ensureDirectoryExists($targetDir);
+        $target = realpath($targetDir).'/'.$packageName.'.'.$format;
+        $filesystem->ensureDirectoryExists(dirname($target));
+
+        if (!$this->overwriteFiles && file_exists($target)) {
+            return $target;
+        }
+
+        if ($package instanceof RootPackageInterface) {
+            $sourcePath = realpath('.');
+        } else {
+            // Directory used to download the sources
+            $sourcePath = sys_get_temp_dir().'/composer_archive'.uniqid();
+            $filesystem->ensureDirectoryExists($sourcePath);
+
+            try {
+                // Download sources
+                $this->downloadManager->download($package, $sourcePath);
+            } catch (\Exception $e) {
+                $filesystem->removeDirectory($sourcePath);
+                throw  $e;
+            }
+
+            // Check exclude from downloaded composer.json
+            if (file_exists($composerJsonPath = $sourcePath.'/composer.json')) {
+                $jsonFile = new JsonFile($composerJsonPath);
+                $jsonData = $jsonFile->read();
+                if (!empty($jsonData['archive']['exclude'])) {
+                    $package->setArchiveExcludes($jsonData['archive']['exclude']);
+                }
+            }
+        }
+
+        // Create the archive
+        $tempTarget = sys_get_temp_dir().'/composer_archive'.uniqid().'.'.$format;
+        $filesystem->ensureDirectoryExists(dirname($tempTarget));
+
+        $archivePath = $usableArchiver->archive($sourcePath, $tempTarget, $format, $package->getArchiveExcludes(), $ignoreFilters);
+        $filesystem->rename($archivePath, $target);
+
+        // cleanup temporary download
+        if (!$package instanceof RootPackageInterface) {
+            $filesystem->removeDirectory($sourcePath);
+        }
+        $filesystem->remove($tempTarget);
+
+        return $target;
+    }
+}

data/helpers/vendor/composer/composer/src/Composer/Package/Archiver/ArchiverInterface.php

@@ -0,0 +1,43 @@
+<?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\Package\Archiver;
+
+/**
+ * @author Till Klampaeckel <till@php.net>
+ * @author Matthieu Moquet <matthieu@moquet.net>
+ * @author Nils Adermann <naderman@naderman.de>
+ */
+interface ArchiverInterface
+{
+    /**
+     * Create an archive from the sources.
+     *
+     * @param string $sources  The sources directory
+     * @param string $target   The target file
+     * @param string $format   The format used for archive
+     * @param array  $excludes A list of patterns for files to exclude
+     *
+     * @return string The path to the written archive file
+     */
+    public function archive($sources, $target, $format, array $excludes = array(), $ignoreFilters = false);
+
+    /**
+     * Format supported by the archiver.
+     *
+     * @param string $format     The archive format
+     * @param string $sourceType The source type (git, svn, hg, etc.)
+     *
+     * @return bool true if the format is supported by the archiver
+     */
+    public function supports($format, $sourceType);
+}

data/helpers/vendor/composer/composer/src/Composer/Package/Archiver/BaseExcludeFilter.php

@@ -0,0 +1,148 @@
+<?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\Package\Archiver;
+
+use Symfony\Component\Finder;
+
+/**
+ * @author Nils Adermann <naderman@naderman.de>
+ */
+abstract class BaseExcludeFilter
+{
+    /**
+     * @var string
+     */
+    protected $sourcePath;
+
+    /**
+     * @var array
+     */
+    protected $excludePatterns;
+
+    /**
+     * @param string $sourcePath Directory containing sources to be filtered
+     */
+    public function __construct($sourcePath)
+    {
+        $this->sourcePath = $sourcePath;
+        $this->excludePatterns = array();
+    }
+
+    /**
+     * Checks the given path against all exclude patterns in this filter
+     *
+     * Negated patterns overwrite exclude decisions of previous filters.
+     *
+     * @param string $relativePath The file's path relative to the sourcePath
+     * @param bool   $exclude      Whether a previous filter wants to exclude this file
+     *
+     * @return bool Whether the file should be excluded
+     */
+    public function filter($relativePath, $exclude)
+    {
+        foreach ($this->excludePatterns as $patternData) {
+            list($pattern, $negate, $stripLeadingSlash) = $patternData;
+
+            if ($stripLeadingSlash) {
+                $path = substr($relativePath, 1);
+            } else {
+                $path = $relativePath;
+            }
+
+            if (preg_match($pattern, $path)) {
+                $exclude = !$negate;
+            }
+        }
+
+        return $exclude;
+    }
+
+    /**
+     * Processes a file containing exclude rules of different formats per line
+     *
+     * @param array    $lines      A set of lines to be parsed
+     * @param callable $lineParser The parser to be used on each line
+     *
+     * @return array Exclude patterns to be used in filter()
+     */
+    protected function parseLines(array $lines, $lineParser)
+    {
+        return array_filter(
+            array_map(
+                function ($line) use ($lineParser) {
+                    $line = trim($line);
+
+                    if (!$line || 0 === strpos($line, '#')) {
+                        return null;
+                    }
+
+                    return call_user_func($lineParser, $line);
+                },
+                $lines
+            ),
+            function ($pattern) {
+                return $pattern !== null;
+            }
+        );
+    }
+
+    /**
+     * Generates a set of exclude patterns for filter() from gitignore rules
+     *
+     * @param array $rules A list of exclude rules in gitignore syntax
+     *
+     * @return array Exclude patterns
+     */
+    protected function generatePatterns($rules)
+    {
+        $patterns = array();
+        foreach ($rules as $rule) {
+            $patterns[] = $this->generatePattern($rule);
+        }
+
+        return $patterns;
+    }
+
+    /**
+     * Generates an exclude pattern for filter() from a gitignore rule
+     *
+     * @param string $rule An exclude rule in gitignore syntax
+     *
+     * @return array An exclude pattern
+     */
+    protected function generatePattern($rule)
+    {
+        $negate = false;
+        $pattern = '{';
+
+        if (strlen($rule) && $rule[0] === '!') {
+            $negate = true;
+            $rule = substr($rule, 1);
+        }
+
+        if (strlen($rule) && $rule[0] === '/') {
+            $pattern .= '^/';
+            $rule = substr($rule, 1);
+        } elseif (strlen($rule) - 1 === strpos($rule, '/')) {
+            $pattern .= '/';
+            $rule = substr($rule, 0, -1);
+        } elseif (false === strpos($rule, '/')) {
+            $pattern .= '/';
+        }
+
+        // remove delimiters as well as caret (^) and dollar sign ($) from the regex
+        $pattern .= substr(Finder\Glob::toRegex($rule), 2, -2) . '(?=$|/)';
+
+        return array($pattern . '}', $negate, false);
+    }
+}