Vaimo\ComposerPatches\Composer\Commands\ListCommand

Complexity

Total Complexity

20

Size/Duplication

Total Lines	295
Duplicated Lines	0 %

Importance

Changes

0

5 Methods

Rating	Name	Duplication	Size	Complexity
C	execute()	0	152	9
A	createLoaderPool()	0	12	2
A	configure()	0	69	1
A	createQueueGenerator()	0	13	1
B	generateOutput()	0	37	7

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

use Composer\Composer;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Output\OutputInterface;
use Vaimo\ComposerPatches\Patch\Definition as PatchDefinition;

use Vaimo\ComposerPatches\Interfaces\ListResolverInterface as ListResolver;
use Symfony\Component\Console\Input\InputOption;
use Vaimo\ComposerPatches\Repository\PatchesApplier\ListResolvers;
use Vaimo\ComposerPatches\Config;
use Vaimo\ComposerPatches\Patch\DefinitionList\LoaderComponents;

class ListCommand extends \Composer\Command\BaseCommand
{
    protected function configure()
    {
        parent::configure();

        $this->setName('patch:list');

        $this->setDescription('List all registered and eligible (based on project config) patches');

        $this->addArgument(
            'targets',
            \Symfony\Component\Console\Input\InputArgument::IS_ARRAY,
            'Packages for the patcher to target',
            array()
        );

        $this->addOption(
            '--no-dev',
            null,
            InputOption::VALUE_NONE,
            'Disables installation of require-dev packages'
        );

        $this->addOption(
            '--filter',
            null,
            InputOption::VALUE_OPTIONAL | InputOption::VALUE_IS_ARRAY,
            'Mark certain patches with MATCH in the output list'
        );

        $this->addOption(
            '--excluded',
            null,
            InputOption::VALUE_NONE,
            'Include patches that have been ruled out based on some constraint mismatch'
        );

        $this->addOption(
            '--with-excludes',
            null,
            InputOption::VALUE_NONE,
            'Alias for \'excluded\' argument'
        );

        $this->addOption(
            '--with-affected',
            null,
            InputOption::VALUE_NONE,
            'Mark patches that would get re-applied when changed/new patches are added (due to package reinstall)'
        );
        
        $this->addOption(
            '--brief',
            null,
            InputOption::VALUE_NONE,
            'Show more compact output of the list (remove description, owner , etc)'
        );
        
        $this->addOption(
            '--status',
            null,
            InputOption::VALUE_OPTIONAL | InputOption::VALUE_IS_ARRAY,
            'Match specific statuses (changed, new, applied, removed)'
        );

        $this->addOption(
            '--from-source',
            null,
            InputOption::VALUE_NONE,
            'Use latest information from package configurations in vendor folder'
        );
    }

    protected function execute(InputInterface $input, OutputInterface $output)
    {
        $composer = $this->getComposer();

        $isDevMode = !$input->getOption('no-dev');
        $withExcluded = $input->getOption('excluded') || $input->getOption('with-excludes');
        $withAffected = $input->getOption('with-affected');
        $beBrief = $input->getOption('brief');
        
        $filters = array(
            PatchDefinition::SOURCE => $input->getOption('filter'),
            PatchDefinition::TARGETS => $input->getArgument('targets')
        );

        $statusFilters = array_map('strtolower', $input->getOption('status'));

It seems like $input->getOption('status') can also be of type boolean and null and string; however, parameter $arr1 of array_map() does only seem to accept array, maybe add an additional type check?

        
        $configDefaults = new \Vaimo\ComposerPatches\Config\Defaults();

        $defaultValues = $configDefaults->getPatcherConfig();

        $sourceKeys = array_keys($defaultValues[Config::PATCHER_SOURCES]);

It seems like $defaultValues[Vaimo\ComposerPatches\Config::PATCHER_SOURCES] can also be of type boolean; however, parameter $input of array_keys() does only seem to accept array, maybe add an additional type check?

        $pluginConfig = array(
            Config::PATCHER_SOURCES => array_fill_keys($sourceKeys, true)
        );

        $filterUtils = new \Vaimo\ComposerPatches\Utils\FilterUtils();
        $patchListUtils = new \Vaimo\ComposerPatches\Utils\PatchListUtils();

        $configFactory = new \Vaimo\ComposerPatches\Factories\ConfigFactory($composer);
        $configInstance = $configFactory->create(array($pluginConfig));
        
        $filteredPool = $this->createLoaderPool();

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

        $vendorRoot = $composerConfig->get(\Vaimo\ComposerPatches\Composer\ConfigKeys::VENDOR_DIR);

        $packageInfoResolver = new \Vaimo\ComposerPatches\Package\InfoResolver(
            $installationManager,
            $vendorRoot
        );
        
        $unfilteredPool = $this->createLoaderPool(array(
            'constraints' => false,
            'platform' => false,
            'local-exclude' => false,
            'root-patch' => false,
            'global-exclude' => false,
            'targets-resolver' => new LoaderComponents\TargetsResolverComponent($packageInfoResolver, true)
        ));

        $hasFilers = (bool)array_filter($filters);
        
        $listResolver = new ListResolvers\FilteredListResolver($filters);
        
        $loaderFactory = new \Vaimo\ComposerPatches\Factories\PatchesLoaderFactory($composer);
        $packageCollector = new \Vaimo\ComposerPatches\Package\Collector(
            array($composer->getPackage())
        );
        
        $repository = $composer->getRepositoryManager()->getLocalRepository();
        
        $filteredLoader = $loaderFactory->create($filteredPool, $configInstance, $isDevMode);
        $filteredPatches = $filteredLoader->loadFromPackagesRepository($repository);
        
        $queueGenerator = $this->createQueueGenerator($composer, $configInstance, $listResolver);
        
        $repoStateGenerator = new \Vaimo\ComposerPatches\Repository\StateGenerator(
            $packageCollector
        );
        
        $repositoryState = $repoStateGenerator->generate($repository);
        
        $applyQueue = $queueGenerator->generateApplyQueue($filteredPatches, $repositoryState);
        $removeQueue = $queueGenerator->generateRemovalQueue($applyQueue, $repositoryState);
        $applyQueue = array_map('array_filter', $applyQueue);

        $filteredPatches = $patchListUtils->mergeLists(
            $filteredPatches,
            $removeQueue
        );

        if ($withAffected) {
            $applyQueue = $patchListUtils->embedInfoToItems(
                $applyQueue,
                array(PatchDefinition::STATUS => 'affected'),
                true
            );
        }
        
        $filteredPatches = $patchListUtils->mergeLists(
            $filteredPatches,
            $patchListUtils->intersectListsByName($applyQueue, $filteredPatches)
        );
        
        $filteredPatches = $patchListUtils->embedInfoToItems(
            $filteredPatches,
            array(PatchDefinition::STATUS => 'applied'),
            true
        );
        
        if ($hasFilers) {
            $filteredPatches = $listResolver->resolvePatchesQueue($filteredPatches);
        }
        
        if ($statusFilters) {

The expression $statusFilters of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using ! empty($expr) instead to make it clear that you intend to check for an array without elements.

            $statusFilter = $filterUtils->composeRegex($statusFilters, '/');

            $filteredPatches = $patchListUtils->applyDefinitionFilter(
                $filteredPatches,
                $statusFilter,
                PatchDefinition::STATUS
            );
        }
        
        $patches = array_filter($filteredPatches);
        
        $shouldAddExcludes = $withExcluded
            && (!$statusFilters || preg_match($filterUtils->composeRegex($statusFilters, '/'), 'excluded'));

The expression $statusFilters of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using empty($expr) instead to make it clear that you intend to check for an array without elements.

        
        if ($shouldAddExcludes) {
            $unfilteredLoader = $loaderFactory->create($unfilteredPool, $configInstance, $isDevMode);

            $allPatches = $unfilteredLoader->loadFromPackagesRepository($repository);
            
            $patchesQueue = $listResolver->resolvePatchesQueue($allPatches);
            
            $excludedPatches = $patchListUtils->updateStatuses(
                array_filter($patchListUtils->diffListsByPath($patchesQueue, $filteredPatches)),
                'excluded'
            );

            $patches = array_replace_recursive(
                $patches,
                $patchListUtils->updateStatuses($excludedPatches, 'excluded')
            );

            array_walk($patches, function (array &$group) {
                ksort($group);
            }, $patches);
        }
        
        if ($beBrief) {
            $patches = $patchListUtils->embedInfoToItems($patches, array(
                PatchDefinition::LABEL => false,
                PatchDefinition::OWNER => false
            ));
        }
        
        $this->generateOutput($output, $patches);
    }
    
    private function createQueueGenerator(Composer $composer, Config $config, ListResolver $listResolver)
    {
        $stateAnalyserFactory = new \Vaimo\ComposerPatches\Factories\RepositoryStateAnalyserFactory(
            $composer
        );
        
        $changesListResolver = new ListResolvers\ChangesListResolver($listResolver);

        $stateAnalyser = $stateAnalyserFactory->create($config);
        
        return new \Vaimo\ComposerPatches\Repository\PatchesApplier\QueueGenerator(
            $changesListResolver,
            $stateAnalyser
        );
    }
    
    private function createLoaderPool(array $componentUpdates = array())
    {
        $componentPool = new \Vaimo\ComposerPatches\Patch\DefinitionList\Loader\ComponentPool(
            $this->getComposer(),
            $this->getIO()
        );

        foreach ($componentUpdates as $componentName => $replacement) {
            $componentPool->registerComponent($componentName, $replacement);
        }
        
        return $componentPool;
    }
    
    private function generateOutput(OutputInterface $output, array $list)
    {
        $statusConfig = new \Vaimo\ComposerPatches\Package\PatchApplier\StatusConfig();

        $statusDecorators = $statusConfig->getLabels();
        
        foreach ($list as $packageName => $patches) {
            $output->writeln(sprintf('<info>%s</info>', $packageName));

            foreach ($patches as $path => $info) {
                $status = isset($info[PatchDefinition::STATUS])
                    ? $info[PatchDefinition::STATUS]
                    : 'unknown';

                $statusLabel = sprintf(' [%s]', $statusDecorators[$status]);
                $owner = $info[PatchDefinition::OWNER];
                
                if ($owner === PatchDefinition::OWNER_UNKNOWN) {
                    $patchInfoLabel = sprintf('  ~ %s%s', $path, $statusLabel);
                } elseif ($owner) {
                    $patchInfoLabel = sprintf('  ~ <info>%s</info>: %s%s', $owner, $path, $statusLabel);
                } else {
                    $patchInfoLabel = sprintf('%s%s', $path, $statusLabel);
                }

                $output->writeln($patchInfoLabel);

                $descriptionLines = array_filter(
                    explode(PHP_EOL, $info[PatchDefinition::LABEL])
                );
                
                foreach ($descriptionLines as $line) {
                    $output->writeln(sprintf('    <comment>%s</comment>', $line));
                }
            }

            $output->writeln('');
        }
    }
}