dependabot-composer 0.111.16 → 0.111.17

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

@@ -0,0 +1,214 @@
+<?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\Util\Filesystem;
+use Composer\Util\Platform;
+use Composer\Util\ProcessExecutor;
+use Composer\Util\Silencer;
+
+/**
+ * Utility to handle installation of package "bin"/binaries
+ *
+ * @author Jordi Boggiano <j.boggiano@seld.be>
+ * @author Konstantin Kudryashov <ever.zet@gmail.com>
+ * @author Helmut Hummel <info@helhum.io>
+ */
+class BinaryInstaller
+{
+    protected $binDir;
+    protected $binCompat;
+    protected $io;
+    protected $filesystem;
+
+    /**
+     * @param IOInterface $io
+     * @param string      $binDir
+     * @param string      $binCompat
+     * @param Filesystem  $filesystem
+     */
+    public function __construct(IOInterface $io, $binDir, $binCompat, Filesystem $filesystem = null)
+    {
+        $this->binDir = $binDir;
+        $this->binCompat = $binCompat;
+        $this->io = $io;
+        $this->filesystem = $filesystem ?: new Filesystem();
+    }
+
+    public function installBinaries(PackageInterface $package, $installPath, $warnOnOverwrite = true)
+    {
+        $binaries = $this->getBinaries($package);
+        if (!$binaries) {
+            return;
+        }
+        foreach ($binaries as $bin) {
+            $binPath = $installPath.'/'.$bin;
+            if (!file_exists($binPath)) {
+                $this->io->writeError('    <warning>Skipped installation of bin '.$bin.' for package '.$package->getName().': file not found in package</warning>');
+                continue;
+            }
+
+            // in case a custom installer returned a relative path for the
+            // $package, we can now safely turn it into a absolute path (as we
+            // already checked the binary's existence). The following helpers
+            // will require absolute paths to work properly.
+            $binPath = realpath($binPath);
+
+            $this->initializeBinDir();
+            $link = $this->binDir.'/'.basename($bin);
+            if (file_exists($link)) {
+                if (is_link($link)) {
+                    // likely leftover from a previous install, make sure
+                    // that the target is still executable in case this
+                    // is a fresh install of the vendor.
+                    Silencer::call('chmod', $link, 0777 & ~umask());
+                }
+                if ($warnOnOverwrite) {
+                    $this->io->writeError('    Skipped installation of bin '.$bin.' for package '.$package->getName().': name conflicts with an existing file');
+                }
+                continue;
+            }
+
+            if ($this->binCompat === "auto") {
+                if (Platform::isWindows()) {
+                    $this->installFullBinaries($binPath, $link, $bin, $package);
+                } else {
+                    $this->installSymlinkBinaries($binPath, $link);
+                }
+            } elseif ($this->binCompat === "full") {
+                $this->installFullBinaries($binPath, $link, $bin, $package);
+            }
+            Silencer::call('chmod', $link, 0777 & ~umask());
+        }
+    }
+
+    public function removeBinaries(PackageInterface $package)
+    {
+        $this->initializeBinDir();
+
+        $binaries = $this->getBinaries($package);
+        if (!$binaries) {
+            return;
+        }
+        foreach ($binaries as $bin) {
+            $link = $this->binDir.'/'.basename($bin);
+            if (is_link($link) || file_exists($link)) {
+                $this->filesystem->unlink($link);
+            }
+            if (file_exists($link.'.bat')) {
+                $this->filesystem->unlink($link.'.bat');
+            }
+        }
+
+        // attempt removing the bin dir in case it is left empty
+        if (is_dir($this->binDir) && $this->filesystem->isDirEmpty($this->binDir)) {
+            Silencer::call('rmdir', $this->binDir);
+        }
+    }
+
+    public static function determineBinaryCaller($bin)
+    {
+        if ('.bat' === substr($bin, -4) || '.exe' === substr($bin, -4)) {
+            return 'call';
+        }
+
+        $handle = fopen($bin, 'r');
+        $line = fgets($handle);
+        fclose($handle);
+        if (preg_match('{^#!/(?:usr/bin/env )?(?:[^/]+/)*(.+)$}m', $line, $match)) {
+            return trim($match[1]);
+        }
+
+        return 'php';
+    }
+
+    protected function getBinaries(PackageInterface $package)
+    {
+        return $package->getBinaries();
+    }
+
+    protected function installFullBinaries($binPath, $link, $bin, PackageInterface $package)
+    {
+        // add unixy support for cygwin and similar environments
+        if ('.bat' !== substr($binPath, -4)) {
+            $this->installUnixyProxyBinaries($binPath, $link);
+            @chmod($link, 0777 & ~umask());
+            $link .= '.bat';
+            if (file_exists($link)) {
+                $this->io->writeError('    Skipped installation of bin '.$bin.'.bat proxy for package '.$package->getName().': a .bat proxy was already installed');
+            }
+        }
+        if (!file_exists($link)) {
+            file_put_contents($link, $this->generateWindowsProxyCode($binPath, $link));
+        }
+    }
+
+    protected function installSymlinkBinaries($binPath, $link)
+    {
+        if (!$this->filesystem->relativeSymlink($binPath, $link)) {
+            $this->installUnixyProxyBinaries($binPath, $link);
+        }
+    }
+
+    protected function installUnixyProxyBinaries($binPath, $link)
+    {
+        file_put_contents($link, $this->generateUnixyProxyCode($binPath, $link));
+    }
+
+    protected function initializeBinDir()
+    {
+        $this->filesystem->ensureDirectoryExists($this->binDir);
+        $this->binDir = realpath($this->binDir);
+    }
+
+    protected function generateWindowsProxyCode($bin, $link)
+    {
+        $binPath = $this->filesystem->findShortestPath($link, $bin);
+        $caller = self::determineBinaryCaller($bin);
+
+        return "@ECHO OFF\r\n".
+            "setlocal DISABLEDELAYEDEXPANSION\r\n".
+            "SET BIN_TARGET=%~dp0/".trim(ProcessExecutor::escape($binPath), '"\'')."\r\n".
+            "{$caller} \"%BIN_TARGET%\" %*\r\n";
+    }
+
+    protected function generateUnixyProxyCode($bin, $link)
+    {
+        $binPath = $this->filesystem->findShortestPath($link, $bin);
+
+        $binDir = ProcessExecutor::escape(dirname($binPath));
+        $binFile = basename($binPath);
+
+        $proxyCode = <<<PROXY
+#!/usr/bin/env sh
+
+dir=\$(cd "\${0%[/\\\\]*}" > /dev/null; cd $binDir && pwd)
+
+if [ -d /proc/cygdrive ]; then
+    case \$(which php) in
+        \$(readlink -n /proc/cygdrive)/*)
+            # We are in Cygwin using Windows php, so the path must be translated
+            dir=\$(cygpath -m "\$dir");
+            ;;
+    esac
+fi
+
+"\${dir}/$binFile" "\$@"
+
+PROXY;
+
+        return $proxyCode;
+    }
+}

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

@@ -0,0 +1,30 @@
+<?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;
+
+/**
+ * Interface for the package installation manager that handle binary installation.
+ *
+ * @author Jordi Boggiano <j.boggiano@seld.be>
+ */
+interface BinaryPresenceInterface
+{
+    /**
+     * Make sure binaries are installed for a given package.
+     *
+     * @param PackageInterface $package package instance
+     */
+    public function ensureBinariesPresence(PackageInterface $package);
+}

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

@@ -0,0 +1,326 @@
+<?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\Package\AliasPackage;
+use Composer\Repository\RepositoryInterface;
+use Composer\Repository\InstalledRepositoryInterface;
+use Composer\DependencyResolver\Operation\OperationInterface;
+use Composer\DependencyResolver\Operation\InstallOperation;
+use Composer\DependencyResolver\Operation\UpdateOperation;
+use Composer\DependencyResolver\Operation\UninstallOperation;
+use Composer\DependencyResolver\Operation\MarkAliasInstalledOperation;
+use Composer\DependencyResolver\Operation\MarkAliasUninstalledOperation;
+use Composer\Util\StreamContextFactory;
+
+/**
+ * Package operation manager.
+ *
+ * @author Konstantin Kudryashov <ever.zet@gmail.com>
+ * @author Jordi Boggiano <j.boggiano@seld.be>
+ * @author Nils Adermann <naderman@naderman.de>
+ */
+class InstallationManager
+{
+    private $installers = array();
+    private $cache = array();
+    private $notifiablePackages = array();
+
+    public function reset()
+    {
+        $this->notifiablePackages = array();
+    }
+
+    /**
+     * Adds installer
+     *
+     * @param InstallerInterface $installer installer instance
+     */
+    public function addInstaller(InstallerInterface $installer)
+    {
+        array_unshift($this->installers, $installer);
+        $this->cache = array();
+    }
+
+    /**
+     * Removes installer
+     *
+     * @param InstallerInterface $installer installer instance
+     */
+    public function removeInstaller(InstallerInterface $installer)
+    {
+        if (false !== ($key = array_search($installer, $this->installers, true))) {
+            array_splice($this->installers, $key, 1);
+            $this->cache = array();
+        }
+    }
+
+    /**
+     * Disables plugins.
+     *
+     * We prevent any plugins from being instantiated by simply
+     * deactivating the installer for them. This ensure that no third-party
+     * code is ever executed.
+     */
+    public function disablePlugins()
+    {
+        foreach ($this->installers as $i => $installer) {
+            if (!$installer instanceof PluginInstaller) {
+                continue;
+            }
+
+            unset($this->installers[$i]);
+        }
+    }
+
+    /**
+     * Returns installer for a specific package type.
+     *
+     * @param string $type package type
+     *
+     * @throws \InvalidArgumentException if installer for provided type is not registered
+     * @return InstallerInterface
+     */
+    public function getInstaller($type)
+    {
+        $type = strtolower($type);
+
+        if (isset($this->cache[$type])) {
+            return $this->cache[$type];
+        }
+
+        foreach ($this->installers as $installer) {
+            if ($installer->supports($type)) {
+                return $this->cache[$type] = $installer;
+            }
+        }
+
+        throw new \InvalidArgumentException('Unknown installer type: '.$type);
+    }
+
+    /**
+     * Checks whether provided package is installed in one of the registered installers.
+     *
+     * @param InstalledRepositoryInterface $repo    repository in which to check
+     * @param PackageInterface             $package package instance
+     *
+     * @return bool
+     */
+    public function isPackageInstalled(InstalledRepositoryInterface $repo, PackageInterface $package)
+    {
+        if ($package instanceof AliasPackage) {
+            return $repo->hasPackage($package) && $this->isPackageInstalled($repo, $package->getAliasOf());
+        }
+
+        return $this->getInstaller($package->getType())->isInstalled($repo, $package);
+    }
+
+    /**
+     * Install binary for the given package.
+     * If the installer associated to this package doesn't handle that function, it'll do nothing.
+     *
+     * @param PackageInterface $package Package instance
+     */
+    public function ensureBinariesPresence(PackageInterface $package)
+    {
+        try {
+            $installer = $this->getInstaller($package->getType());
+        } catch (\InvalidArgumentException $e) {
+            // no installer found for the current package type (@see `getInstaller()`)
+            return;
+        }
+
+        // if the given installer support installing binaries
+        if ($installer instanceof BinaryPresenceInterface) {
+            $installer->ensureBinariesPresence($package);
+        }
+    }
+
+    /**
+     * Executes solver operation.
+     *
+     * @param RepositoryInterface $repo      repository in which to check
+     * @param OperationInterface  $operation operation instance
+     */
+    public function execute(RepositoryInterface $repo, OperationInterface $operation)
+    {
+        $method = $operation->getJobType();
+        $this->$method($repo, $operation);
+    }
+
+    /**
+     * Executes install operation.
+     *
+     * @param RepositoryInterface $repo      repository in which to check
+     * @param InstallOperation    $operation operation instance
+     */
+    public function install(RepositoryInterface $repo, InstallOperation $operation)
+    {
+        $package = $operation->getPackage();
+        $installer = $this->getInstaller($package->getType());
+        $installer->install($repo, $package);
+        $this->markForNotification($package);
+    }
+
+    /**
+     * Executes update operation.
+     *
+     * @param RepositoryInterface $repo      repository in which to check
+     * @param UpdateOperation     $operation operation instance
+     */
+    public function update(RepositoryInterface $repo, UpdateOperation $operation)
+    {
+        $initial = $operation->getInitialPackage();
+        $target = $operation->getTargetPackage();
+
+        $initialType = $initial->getType();
+        $targetType = $target->getType();
+
+        if ($initialType === $targetType) {
+            $installer = $this->getInstaller($initialType);
+            $installer->update($repo, $initial, $target);
+            $this->markForNotification($target);
+        } else {
+            $this->getInstaller($initialType)->uninstall($repo, $initial);
+            $this->getInstaller($targetType)->install($repo, $target);
+        }
+    }
+
+    /**
+     * Uninstalls package.
+     *
+     * @param RepositoryInterface $repo      repository in which to check
+     * @param UninstallOperation  $operation operation instance
+     */
+    public function uninstall(RepositoryInterface $repo, UninstallOperation $operation)
+    {
+        $package = $operation->getPackage();
+        $installer = $this->getInstaller($package->getType());
+        $installer->uninstall($repo, $package);
+    }
+
+    /**
+     * Executes markAliasInstalled operation.
+     *
+     * @param RepositoryInterface         $repo      repository in which to check
+     * @param MarkAliasInstalledOperation $operation operation instance
+     */
+    public function markAliasInstalled(RepositoryInterface $repo, MarkAliasInstalledOperation $operation)
+    {
+        $package = $operation->getPackage();
+
+        if (!$repo->hasPackage($package)) {
+            $repo->addPackage(clone $package);
+        }
+    }
+
+    /**
+     * Executes markAlias operation.
+     *
+     * @param RepositoryInterface           $repo      repository in which to check
+     * @param MarkAliasUninstalledOperation $operation operation instance
+     */
+    public function markAliasUninstalled(RepositoryInterface $repo, MarkAliasUninstalledOperation $operation)
+    {
+        $package = $operation->getPackage();
+
+        $repo->removePackage($package);
+    }
+
+    /**
+     * Returns the installation path of a package
+     *
+     * @param  PackageInterface $package
+     * @return string           path
+     */
+    public function getInstallPath(PackageInterface $package)
+    {
+        $installer = $this->getInstaller($package->getType());
+
+        return $installer->getInstallPath($package);
+    }
+
+    public function notifyInstalls(IOInterface $io)
+    {
+        foreach ($this->notifiablePackages as $repoUrl => $packages) {
+            $repositoryName = parse_url($repoUrl, PHP_URL_HOST);
+            if ($io->hasAuthentication($repositoryName)) {
+                $auth = $io->getAuthentication($repositoryName);
+                $authStr = base64_encode($auth['username'] . ':' . $auth['password']);
+                $authHeader = 'Authorization: Basic '.$authStr;
+            }
+
+            // non-batch API, deprecated
+            if (strpos($repoUrl, '%package%')) {
+                foreach ($packages as $package) {
+                    $url = str_replace('%package%', $package->getPrettyName(), $repoUrl);
+
+                    $params = array(
+                        'version' => $package->getPrettyVersion(),
+                        'version_normalized' => $package->getVersion(),
+                    );
+                    $opts = array('http' =>
+                        array(
+                            'method' => 'POST',
+                            'header' => array('Content-type: application/x-www-form-urlencoded'),
+                            'content' => http_build_query($params, '', '&'),
+                            'timeout' => 3,
+                        ),
+                    );
+                    if (isset($authHeader)) {
+                        $opts['http']['header'][] = $authHeader;
+                    }
+
+                    $context = StreamContextFactory::getContext($url, $opts);
+                    @file_get_contents($url, false, $context);
+                }
+
+                continue;
+            }
+
+            $postData = array('downloads' => array());
+            foreach ($packages as $package) {
+                $postData['downloads'][] = array(
+                    'name' => $package->getPrettyName(),
+                    'version' => $package->getVersion(),
+                );
+            }
+
+            $opts = array('http' =>
+                array(
+                    'method' => 'POST',
+                    'header' => array('Content-Type: application/json'),
+                    'content' => json_encode($postData),
+                    'timeout' => 6,
+                ),
+            );
+            if (isset($authHeader)) {
+                $opts['http']['header'][] = $authHeader;
+            }
+
+            $context = StreamContextFactory::getContext($repoUrl, $opts);
+            @file_get_contents($repoUrl, false, $context);
+        }
+
+        $this->reset();
+    }
+
+    private function markForNotification(PackageInterface $package)
+    {
+        if ($package->getNotificationUrl()) {
+            $this->notifiablePackages[$package->getNotificationUrl()][$package->getName()] = $package;
+        }
+    }
+}