Vaimo\ComposerPatches\Patch\DefinitionList\Loader\ComponentPool

Complexity

Total Complexity

12

Size/Duplication

Total Lines	156
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

4 Methods

Rating	Name	Duplication	Size	Complexity
A	resolveConstraintPackages()	0	22	4
B	getList()	0	86	6
A	__construct()	0	8	1
A	registerComponent()	0	3	1

<?php
/**
 * Copyright © Vaimo Group. All rights reserved.
 * See LICENSE_VAIMO.txt for license details.
 */
namespace Vaimo\ComposerPatches\Patch\DefinitionList\Loader;

use Vaimo\ComposerPatches\Patch\DefinitionList\LoaderComponents;

use Vaimo\ComposerPatches\Config as PluginConfig;

/**
 * @SuppressWarnings(PHPMD.CouplingBetweenObjects)
 */
class ComponentPool
{
    /**
     * @var \Composer\Composer
     */
    private $composer;

    /**
     * @var \Composer\IO\IOInterface
     */
    private $appIO;
    
    /**
     * @var bool[]|\Vaimo\ComposerPatches\Interfaces\DefinitionListLoaderComponentInterface[]
     */
    private $components = array();

    /**
     * @var bool
     */
    private $gracefulMode;

    /**
     * @SuppressWarnings(PHPMD.BooleanArgumentFlag)
     *
     * @param \Composer\Composer $composer
     * @param \Composer\IO\IOInterface $appIO
     * @param bool $gracefulMode
     */
    public function __construct(
        \Composer\Composer $composer,
        \Composer\IO\IOInterface $appIO,
        $gracefulMode = false
    ) {
        $this->composer = $composer;
        $this->appIO = $appIO;
        $this->gracefulMode = $gracefulMode;
    }

    public function getList(PluginConfig $pluginConfig)
    {
        $patcherConfig = $pluginConfig->getPatcherConfig();

        $composerConfig = clone $this->composer->getConfig();

        $composerConfig->merge(array(
            'config' => array('secure-http' => $patcherConfig[PluginConfig::PATCHER_SECURE_HTTP])
        ));
        
        $rootPackage = $this->composer->getPackage();
        $extra = $rootPackage->getExtra();
        
        if (isset($extra['excluded-patches']) && !isset($extra[PluginConfig::EXCLUDED_PATCHES])) {
            $extra[PluginConfig::EXCLUDED_PATCHES] = $extra['excluded-patches'];
        }

        $excludes = isset($extra[PluginConfig::EXCLUDED_PATCHES])
            ? $extra[PluginConfig::EXCLUDED_PATCHES]
            : array();

        $installationManager = $this->composer->getInstallationManager();
        $composerConfig = clone $this->composer->getConfig();

        $cache = null;
        
        if ($composerConfig->get('cache-files-ttl') > 0) {
            $cache = new \Composer\Cache(
                $this->appIO,
                $composerConfig->get('cache-files-dir'),
                'a-z0-9_./'
            );
        }
        
        $fileDownloader = new \Composer\Downloader\FileDownloader($this->appIO, $composerConfig, null, $cache);
        
        $vendorRoot = $composerConfig->get(\Vaimo\ComposerPatches\Composer\ConfigKeys::VENDOR_DIR);
        
        $packageInfoResolver = new \Vaimo\ComposerPatches\Package\InfoResolver(
            $installationManager,
            $vendorRoot
        );

        $configExtractor = new \Vaimo\ComposerPatches\Package\ConfigExtractors\VendorConfigExtractor(
            $packageInfoResolver
        );
        
        $platformPackages = $this->resolveConstraintPackages($composerConfig);

        $packageResolver = new \Vaimo\ComposerPatches\Composer\Plugin\PackageResolver(
            array($this->composer->getPackage())
        );

        $repositoryManager = $this->composer->getRepositoryManager();

        $pluginPackage = $packageResolver->resolveForNamespace(
            $repositoryManager->getLocalRepository(),
            __NAMESPACE__
        );

        $consoleSilencer = new \Vaimo\ComposerPatches\Console\Silencer($this->appIO);
        
        $defaults = array(
            'bundle' => new LoaderComponents\BundleComponent($rootPackage),
            'global-exclude' => $excludes ? new LoaderComponents\GlobalExcludeComponent($excludes) : false,
            'local-exclude' => new LoaderComponents\LocalExcludeComponent(),
            'root-patch' => new LoaderComponents\RootPatchComponent($rootPackage),
            'path-normalizer' => new LoaderComponents\PathNormalizerComponent($packageInfoResolver),
            'platform' => new LoaderComponents\PlatformComponent($platformPackages),
            'constraints' => new LoaderComponents\ConstraintsComponent($configExtractor),
            'downloader' => new LoaderComponents\DownloaderComponent(
                $pluginPackage,
                $fileDownloader,
                $consoleSilencer,
                $vendorRoot,
                $this->gracefulMode
            ),
            'validator' => new LoaderComponents\ValidatorComponent(),
            'targets-resolver' => new LoaderComponents\TargetsResolverComponent($packageInfoResolver),
            'merger' => new LoaderComponents\MergerComponent(),
            'sorter' => new LoaderComponents\SorterComponent()
        );

        return array_values(
            array_filter(
                array_replace($defaults, $this->components)
            )
        );
    }

    private function resolveConstraintPackages(\Composer\Config $composerConfig)
    {
        $platformOverrides = array_filter(
            (array)$composerConfig->get('platform')
        );
        
        if (!empty($platformOverrides)) {
            $platformOverrides = array();
        }

        $platformRepo = new \Composer\Repository\PlatformRepository(
            array(),
            $platformOverrides ? $platformOverrides : array()
        );

        $platformPackages = array();

        foreach ($platformRepo->getPackages() as $package) {
            $platformPackages[$package->getName()] = $package;
        }
        
        return $platformPackages;
    }
    
    public function registerComponent($name, $instance)
    {
        $this->components[$name] = $instance;
    }
}