Vaimo\ComposerPatches\Composer\Commands\ListCommand::execute()

Complexity

Conditions	9
Paths	192

Size

Total Lines	133
Code Lines	79

Duplication

Lines	0
Ratio	0 %

Importance

Changes

0

<?php
    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?

        
        $pluginConfig = $this->createConfigWithEnabledSources($composer);
        
        
        $filteredPool = $this->createLoaderPool();
        
        $packageInfoResolver = new \Vaimo\ComposerPatches\Package\InfoResolver(
            $composer->getInstallationManager(),
            $composer->getConfig()->get(\Vaimo\ComposerPatches\Composer\ConfigKeys::VENDOR_DIR)
        );
        
        $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);
        
        $repository = $composer->getRepositoryManager()->getLocalRepository();
        
        $filteredLoader = $loaderFactory->create($filteredPool, $pluginConfig, $isDevMode);
        $filteredPatches = $filteredLoader->loadFromPackagesRepository($repository);
        
        $queueGenerator = $this->createQueueGenerator($composer, $pluginConfig, $listResolver);

        $repoStateGenerator = $this->createStateGenerator($composer);
        
        $repositoryState = $repoStateGenerator->generate($repository);
        
        $applyQueue = $queueGenerator->generateApplyQueue($filteredPatches, $repositoryState);
        $removeQueue = $queueGenerator->generateRemovalQueue($applyQueue, $repositoryState);
        $applyQueue = array_map('array_filter', $applyQueue);

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

        $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);
        }

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

        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, $pluginConfig, $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);
    }