GetClassesPerAreaCommand::execute() - Code Metrics - Inspection of "Merge branch 'next-26373/coverage-per-area' into '..." - shopware/platform - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — trunk ( 45f743...c781e9 )

by Christian

created 2023-08-03 11:17 UTC

GetClassesPerAreaCommand::execute() B

↳ Parent: GetClassesPerAreaCommand

Complexity

Conditions	10
Paths	10

Size

Total Lines	55
Code Lines	35

Duplication

Lines	0
Ratio	0 %

Importance

Changes	2
Bugs	0	Features	0

Metric	Value
cc	10
eloc	35
c	2
b	0
f	0
nc	10
nop	2
dl	0
loc	55
rs	7.6666

How to fix Long Method Complexity

<?php declare(strict_types=1);

namespace Shopware\Core\DevOps\StaticAnalyze\Coverage\Command;

use Composer\Autoload\ClassLoader;
use Shopware\Core\Framework\Log\Package;
use Symfony\Component\Console\Attribute\AsCommand;
use Symfony\Component\Console\Command\Command;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Input\InputOption;
use Symfony\Component\Console\Output\OutputInterface;

/**
 * @internal
 */
#[AsCommand(
    name: 'coverage:classes-per-area',
    description: 'Output all classes of the Shopware-namespace aggregated by area.

  In order for this command to work properly, you need to dump the composer autoloader before running it:
  $ composer dump-autoload -o
'
)]
#[Package('core')]
class GetClassesPerAreaCommand extends Command
{
    public const OPTION_JSON = 'json';
    public const OPTION_PRETTY = 'pretty-print';

    public const OPTION_GENERATE_PHPUNIT_TEST = 'generate-phpunit-test';

    public const OPTION_NAMESPACE_PATTERN = 'ns-pattern';

    public const NAMESPACE_PATTERN_DEFAULT = '#^Shopware\\\\(Core|Administration|Storefront|Elasticsearch)\\\\#';

    private ClassLoader $classLoader;

    private string $nsPattern;

    /**
     * @internal
     */
    public function __construct(
        private readonly string $projectDir,
    ) {
        parent::__construct();

        $this->classLoader = require $this->projectDir . '/vendor/autoload.php';
    }

    protected function configure(): void
    {
        $this->addOption(
            self::OPTION_JSON,
            'j',
            InputOption::VALUE_NONE,
            'Output as JSON'
        );

        $this->addOption(
            self::OPTION_PRETTY,
            'H',
            InputOption::VALUE_NONE,
            'Format output to be human-readable'
        );

        $this->addOption(
            self::OPTION_GENERATE_PHPUNIT_TEST,
            'g',
            InputOption::VALUE_NONE,
            'Generate phpunit.xml'
        );

        $this->addOption(
            self::OPTION_NAMESPACE_PATTERN,
            null,
            InputOption::VALUE_REQUIRED,
            'The pattern the namespace has to match',
            self::NAMESPACE_PATTERN_DEFAULT,
        );
    }

    protected function execute(InputInterface $input, OutputInterface $output): int
    {
        $this->nsPattern = $input->getOption(self::OPTION_NAMESPACE_PATTERN);

        $classesPerArea = $this->getClassesPerArea();
        if ($input->getOption(self::OPTION_JSON)) {
            $output->write(
                json_encode(
                    $classesPerArea,
                    $input->getOption(self::OPTION_PRETTY) ? \JSON_PRETTY_PRINT : 0
                ) ?: ''
            );
        } else {
            $output->write(
                var_export(
                    $classesPerArea,
                    true
                )
            );
        }

        if ($input->getOption(self::OPTION_GENERATE_PHPUNIT_TEST)) {
            $unitFiles = [];

            foreach ($classesPerArea as $area => $classToFile) {
                $unitFile = new \DOMDocument();
                // Load phpunit template
                $unitFile->load('phpunit.xml.dist');
                $unitDocument = $unitFile->documentElement;
                if ($unitDocument === null) {
                    return 1;
                }
                $coverage = $unitDocument->getElementsByTagName('coverage')->item(0);
                if ($coverage === null) {
                    return 1;
                }
                $includeChildElement = $coverage->getElementsByTagName('include')->item(0);
                if ($includeChildElement === null) {
                    return 1;
                }
                // Remove include from coverage to create our own includes
                $coverage->removeChild($includeChildElement);
                $includeElement = $unitFile->createElement('include');

                foreach ($classToFile as $class => $file) {
                    $fileElement = $unitFile->createElement('file', $file);
                    $includeElement->appendChild($fileElement);
                }
                $coverage->appendChild($includeElement);

                // Create phpunit file per area
                file_put_contents("phpunit.$area.xml", $unitFile->saveXML());
            }
        }

        return 0;
    }

    /**
     * @return array<string, array<string, string>>
     */
    private function getClassesPerArea(): array
    {
        $areas = [];

        foreach ($this->getShopwareClasses() as $class => $path) {
            try {
                $area = Package::getPackageName($class);
            } catch (\Throwable $e) {
                $areas['unknown'][$class] = $path;

                continue;
            }

            if (!\is_string($area)) {
                continue;
            }

            $areaTrim = strstr($area, \PHP_EOL, true) ?: $area;

            $areas[trim($areaTrim)][$class] = $path;
        }

        return $areas;
    }

    /**
     * @return array<string, string>
     */
    private function getShopwareClasses(): array
    {
        return array_filter($this->classLoader->getClassMap(), function (string $class): bool {
            if (str_starts_with($class, 'Shopware\\')) {
                return (bool) preg_match($this->nsPattern, $class);
            }

            return false;
        }, \ARRAY_FILTER_USE_KEY);
    }
}


1			<?php declare(strict_types=1);
2
3			namespace Shopware\Core\DevOps\StaticAnalyze\Coverage\Command;
4
5			use Composer\Autoload\ClassLoader;
6			use Shopware\Core\Framework\Log\Package;
7			use Symfony\Component\Console\Attribute\AsCommand;
8			use Symfony\Component\Console\Command\Command;
9			use Symfony\Component\Console\Input\InputInterface;
10			use Symfony\Component\Console\Input\InputOption;
11			use Symfony\Component\Console\Output\OutputInterface;
12
13			/**
14			* @internal
15			*/
16			#[AsCommand(
17			name: 'coverage:classes-per-area',
18			description: 'Output all classes of the Shopware-namespace aggregated by area.
19
20			In order for this command to work properly, you need to dump the composer autoloader before running it:
21			$ composer dump-autoload -o
22			'
23			)]
24			#[Package('core')]
25			class GetClassesPerAreaCommand extends Command
26			{
27			public const OPTION_JSON = 'json';
28			public const OPTION_PRETTY = 'pretty-print';
29
30			public const OPTION_GENERATE_PHPUNIT_TEST = 'generate-phpunit-test';
31
32			public const OPTION_NAMESPACE_PATTERN = 'ns-pattern';
33
34			public const NAMESPACE_PATTERN_DEFAULT = '#^Shopware\\\\(Core\|Administration\|Storefront\|Elasticsearch)\\\\#';
35
36			private ClassLoader $classLoader;
37
38			private string $nsPattern;
39
40			/**
41			* @internal
42			*/
43			public function __construct(
44			private readonly string $projectDir,
45			) {
46			parent::__construct();
47
48			$this->classLoader = require $this->projectDir . '/vendor/autoload.php';
49			}
50
51			protected function configure(): void
52			{
53			$this->addOption(
54			self::OPTION_JSON,
55			'j',
56			InputOption::VALUE_NONE,
57			'Output as JSON'
58			);
59
60			$this->addOption(
61			self::OPTION_PRETTY,
62			'H',
63			InputOption::VALUE_NONE,
64			'Format output to be human-readable'
65			);
66
67			$this->addOption(
68			self::OPTION_GENERATE_PHPUNIT_TEST,
69			'g',
70			InputOption::VALUE_NONE,
71			'Generate phpunit.xml'
72			);
73
74			$this->addOption(
75			self::OPTION_NAMESPACE_PATTERN,
76			null,
77			InputOption::VALUE_REQUIRED,
78			'The pattern the namespace has to match',
79			self::NAMESPACE_PATTERN_DEFAULT,
80			);
81			}
82
83			protected function execute(InputInterface $input, OutputInterface $output): int
84			{
85			$this->nsPattern = $input->getOption(self::OPTION_NAMESPACE_PATTERN);
86
87			$classesPerArea = $this->getClassesPerArea();
88			if ($input->getOption(self::OPTION_JSON)) {
89			$output->write(
90			json_encode(
91			$classesPerArea,
92			$input->getOption(self::OPTION_PRETTY) ? \JSON_PRETTY_PRINT : 0
93			) ?: ''
94			);
95			} else {
96			$output->write(
97			var_export(
98			$classesPerArea,
99			true
100			)
101			);
102			}
103
104			if ($input->getOption(self::OPTION_GENERATE_PHPUNIT_TEST)) {
105			$unitFiles = [];
			0 ignored issues – show Unused Code introduced 2023-08-03 11:28 UTC by Report Bug Copy Issue Report The assignment to `$unitFiles` is dead and can be removed. Loading history...
106			foreach ($classesPerArea as $area => $classToFile) {
107			$unitFile = new \DOMDocument();
108			// Load phpunit template
109			$unitFile->load('phpunit.xml.dist');
110			$unitDocument = $unitFile->documentElement;
111			if ($unitDocument === null) {
112			return 1;
113			}
114			$coverage = $unitDocument->getElementsByTagName('coverage')->item(0);
115			if ($coverage === null) {
116			return 1;
117			}
118			$includeChildElement = $coverage->getElementsByTagName('include')->item(0);
119			if ($includeChildElement === null) {
120			return 1;
121			}
122			// Remove include from coverage to create our own includes
123			$coverage->removeChild($includeChildElement);
124			$includeElement = $unitFile->createElement('include');
125
126			foreach ($classToFile as $class => $file) {
127			$fileElement = $unitFile->createElement('file', $file);
128			$includeElement->appendChild($fileElement);
129			}
130			$coverage->appendChild($includeElement);
131
132			// Create phpunit file per area
133			file_put_contents("phpunit.$area.xml", $unitFile->saveXML());
134			}
135			}
136
137			return 0;
138			}
139
140			/**
141			* @return array<string, array<string, string>>
142			*/
143			private function getClassesPerArea(): array
144			{
145			$areas = [];
146
147			foreach ($this->getShopwareClasses() as $class => $path) {
148			try {
149			$area = Package::getPackageName($class);
150			} catch (\Throwable $e) {
151			$areas['unknown'][$class] = $path;
152
153			continue;
154			}
155
156			if (!\is_string($area)) {
157			continue;
158			}
159
160			$areaTrim = strstr($area, \PHP_EOL, true) ?: $area;
161
162			$areas[trim($areaTrim)][$class] = $path;
163			}
164
165			return $areas;
166			}
167
168			/**
169			* @return array<string, string>
170			*/
171			private function getShopwareClasses(): array
172			{
173			return array_filter($this->classLoader->getClassMap(), function (string $class): bool {
174			if (str_starts_with($class, 'Shopware\\')) {
175			return (bool) preg_match($this->nsPattern, $class);
176			}
177
178			return false;
179			}, \ARRAY_FILTER_USE_KEY);
180			}
181			}
182

shopware / platform

Push — trunk ( 45f743...c781e9 )

GetClassesPerAreaCommand::execute() B

Complexity

Size

Duplication

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like