Hirak\Prestissimo\Plugin

Complexity

Total Complexity

35

Size/Duplication

Total Lines	186
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	8

Test Coverage

Coverage

55.7%

Importance

Changes

0

9 Methods

Rating	Name	Duplication	Size	Complexity
C	activate()	0	49	15
A	getSubscribedEvents()	0	12	2
A	onPreFileDownload()	0	19	3
B	prefetchComposerRepositories()	0	28	9
A	onPostDependenciesSolving()	0	12	2
A	disable()	0	4	1
A	isDisabled()	0	4	1
A	deactivate()	0	3	1
A	uninstall()	0	3	1

<?php
/*
 * hirak/prestissimo
 * @author Hiraku NAKANO
 * @license MIT https://github.com/hirak/prestissimo
 */
namespace Hirak\Prestissimo;

use Composer\Composer;
use Composer\IO;
use Composer\Plugin as CPlugin;
use Composer\EventDispatcher;
use Composer\Installer;

class Plugin implements
    CPlugin\PluginInterface,
    EventDispatcher\EventSubscriberInterface
{
    /** @var IO\IOInterface */
    private $io;

    /** @var Composer\Config */
    private $config;

    /** @var array */
    private $package;
    private $cached = false;

    /** @var boolean */
    private $disabled = false;

    private static $pluginClasses = array(
        'BaseRequest',
        'ConfigFacade',
        'CopyRequest',
        'CurlMulti',
        'CurlRemoteFilesystem',
        'FetchException',
        'FetchRequest',
        'FileDownloaderDummy',
        'ParallelizedComposerRepository',
        'Plugin',
        'Prefetcher',
        'Share',
    );

    private static $supportedSchemes = array(
        'http',
        'https'
    );

    public function activate(Composer $composer, IO\IOInterface $io)
    {
        // @codeCoverageIgnoreStart
        // guard for self-update problem
        if (__CLASS__ !== 'Hirak\Prestissimo\Plugin') {
            return $this->disable();
        }
        // guard for missing curl extension problem
        if (!extension_loaded('curl')) {
            $io->writeError('<error>Error: "curl" PHP extension not loaded; Prestissmo Composer plugin disabled.</error>');
            return $this->disable();
        }
        // @codeCoverageIgnoreEnd

        if (!defined('\Composer\Installer\InstallerEvents::POST_DEPENDENCIES_SOLVING')) {
            return $this->disable();
        }

        // load all classes
        foreach (self::$pluginClasses as $class) {
            class_exists(__NAMESPACE__ . '\\' . $class);
        }

        $this->io = $io;
        $this->config = $composer->getConfig();

It seems like $composer->getConfig() of type object<Composer\Config> is incompatible with the declared type object<Composer\Composer\Config> of property $config.

        $this->package = $composer->getPackage();

It seems like $composer->getPackage() of type object<Composer\Package\RootPackageInterface> is incompatible with the declared type array of property $package.

        if (array_key_exists('argv', $GLOBALS)) {
            if (in_array('help', $GLOBALS['argv'])) {
                return $this->disable();
            }

            foreach ($GLOBALS['argv'] as $arg) {
                switch ($arg) {
                    case 'create-project':
                    case 'update':
                    case 'outdated':
                    case 'require':
                        $this->prefetchComposerRepositories();
                        break 2;
                    case 'install':
                        if (file_exists('composer.json') && !file_exists('composer.lock')) {
                            $this->prefetchComposerRepositories();
                        }
                        break 2;
                }
            }
        }
    }

    public static function getSubscribedEvents()
    {
        if (!defined('\Composer\Installer\InstallerEvents::POST_DEPENDENCIES_SOLVING')) {
            return array();
        }
        return array(
            CPlugin\PluginEvents::PRE_FILE_DOWNLOAD => 'onPreFileDownload',
            Installer\InstallerEvents::POST_DEPENDENCIES_SOLVING => array(
                array('onPostDependenciesSolving', PHP_INT_MAX),
            ),
        );
    }

    /**
     * Keep-Alived file downloader
     */
    public function onPreFileDownload(CPlugin\PreFileDownloadEvent $ev)
    {
        if ($this->disabled) {
            return;
        }

        $scheme = parse_url($ev->getProcessedUrl(), PHP_URL_SCHEME);
        if (!in_array($scheme, self::$supportedSchemes, true)) {
            return;
        }

        $rfs = $ev->getRemoteFilesystem();
        $curlrfs = new CurlRemoteFilesystem(
            $this->io,
            $this->config,
            $rfs->getOptions()
        );
        $ev->setRemoteFilesystem($curlrfs);
    }

    public function prefetchComposerRepositories()
    {
        if ($this->disabled) {
            return;
        }
        if ($this->cached) {
            return;
        }
        $repos = $this->package->getRepositories();

The method getRepositories cannot be called on $this->package (of type array).

        foreach ($repos as $label => $repo) {
            if (isset($repo['type']) && $repo['type'] === 'composer') {
                if (!empty($repo['force-lazy-providers'])) {
                    continue;
                }

                if (substr($repo['url'], 0, 6) !== 'https?') {
                    $scheme = parse_url($repo['url'], PHP_URL_SCHEME);
                    if (!in_array($scheme, self::$supportedSchemes, true)) {
                        continue;
                    }
                }

                $r = new ParallelizedComposerRepository($repo, $this->io, $this->config);
                $r->prefetch();
            }
        }
        $this->cached = true;
    }

    /**
     * pre-fetch parallel by curl_multi
     */
    public function onPostDependenciesSolving(Installer\InstallerEvent $ev)
    {
        if ($this->disabled) {
            return;
        }
        $prefetcher = new Prefetcher;
        $prefetcher->fetchAllFromOperations(
            $this->io,
            $this->config,
            $ev->getOperations()
        );
    }

    public function disable()
    {
        $this->disabled = true;
    }

    public function isDisabled()
    {
        return $this->disabled;
    }

    public function deactivate(Composer $composer, IO\IOInterface $io)

The parameter $composer is not used and could be removed.

The parameter $io is not used and could be removed.

    {
    }

    public function uninstall(Composer $composer, IO\IOInterface $io)

The parameter $composer is not used and could be removed.

The parameter $io is not used and could be removed.

    {
    }
}