RemoveBaseLineFromResultsCommand::execute() - Code Metrics - Inspection of "Feature/clean up" - DaveLiddament/sarb - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#117)

by Dave

created 2022-01-12 22:24 UTC

RemoveBaseLineFromResultsCommand::execute() B

↳ Parent: RemoveBaseLineFromResultsCommand

Complexity

Conditions	5
Paths	35

Size

Total Lines	72
Code Lines	47

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	5
eloc	47
nc	35
nop	2
dl	0
loc	72
rs	8.8452
c	0
b	0
f	0

How to fix Long Method

<?php

/**
 * Static Analysis Results Baseliner (sarb).
 *
 * (c) Dave Liddament
 *
 * For the full copyright and licence information please view the LICENSE file distributed with this source code.
 */

declare(strict_types=1);

namespace DaveLiddament\StaticAnalysisResultsBaseliner\Framework\Command;

use DaveLiddament\StaticAnalysisResultsBaseliner\Domain\OutputFormatter\InvalidOutputFormatterException;
use DaveLiddament\StaticAnalysisResultsBaseliner\Domain\OutputFormatter\OutputFormatter;
use DaveLiddament\StaticAnalysisResultsBaseliner\Domain\OutputFormatter\OutputFormatterLookupService;
use DaveLiddament\StaticAnalysisResultsBaseliner\Domain\Pruner\ResultsPrunerInterface;
use DaveLiddament\StaticAnalysisResultsBaseliner\Domain\ResultsParser\AnalysisResultsBuilder;
use DaveLiddament\StaticAnalysisResultsBaseliner\Framework\Command\internal\BaseLineFileHelper;
use DaveLiddament\StaticAnalysisResultsBaseliner\Framework\Command\internal\CliConfigReader;
use DaveLiddament\StaticAnalysisResultsBaseliner\Framework\Command\internal\ErrorReporter;
use DaveLiddament\StaticAnalysisResultsBaseliner\Framework\Command\internal\InvalidConfigException;
use DaveLiddament\StaticAnalysisResultsBaseliner\Framework\Command\internal\OutputWriter;
use DaveLiddament\StaticAnalysisResultsBaseliner\Framework\Command\internal\ProjectRootHelper;
use DaveLiddament\StaticAnalysisResultsBaseliner\Plugins\OutputFormatters\TableOutputFormatter;
use Symfony\Component\Console\Command\Command;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Input\InputOption;
use Symfony\Component\Console\Output\OutputInterface;
use Throwable;

class RemoveBaseLineFromResultsCommand extends Command
{
    public const COMMAND_NAME = 'remove-baseline-results';

    private const OUTPUT_FORMAT = 'output-format';
    private const SHOW_RANDOM_ERRORS = 'clean-up';
    const RANDOM_ISSUES_TO_FIX = 5;

    /**
     * @var string|null
     */
    protected static $defaultName = self::COMMAND_NAME;

    /**
     * @var OutputFormatterLookupService
     */
    private $outputFormatterLookupService;
    /**
     * @var ResultsPrunerInterface
     */
    private $resultsPruner;
    /**
     * @var TableOutputFormatter
     */
    private $tableOutputFormatter;

    public function __construct(
        ResultsPrunerInterface $resultsPruner,
        OutputFormatterLookupService $outputFormatterLookupService,
        TableOutputFormatter $tableOutputFormatter
    ) {
        parent::__construct(self::COMMAND_NAME);
        $this->resultsPruner = $resultsPruner;
        $this->tableOutputFormatter = $tableOutputFormatter;
        $this->outputFormatterLookupService = $outputFormatterLookupService;
    }

    protected function configure(): void
    {
        $this->setDescription('Shows issues created since the baseline');

        $outputFormatters = $this->outputFormatterLookupService->getIdentifiers();
        $this->addOption(
            self::OUTPUT_FORMAT,
            null,
            InputOption::VALUE_REQUIRED,
            'Output format. One of: '.implode('|', $outputFormatters),
            TableOutputFormatter::CODE
        );

        $this->addOption(
            self::SHOW_RANDOM_ERRORS,
            null,
            InputOption::VALUE_NONE,
            'Show a random 5 issues in the baseline to fix'
        );

        ProjectRootHelper::configureProjectRootOption($this);

        BaseLineFileHelper::configureBaseLineFileArgument($this);
    }

    protected function execute(InputInterface $input, OutputInterface $output): int
    {
        try {
            $projectRoot = ProjectRootHelper::getProjectRoot($input);
            $outputFormatter = $this->getOutputFormatter($input);
            $baseLineFileName = BaseLineFileHelper::getBaselineFile($input);
            $inputAnalysisResultsAsString = CliConfigReader::getStdin($input);
            $showRandomIssues = CliConfigReader::getBooleanOption($input, self::SHOW_RANDOM_ERRORS);

            $prunedResults = $this->resultsPruner->getPrunedResults(
                $baseLineFileName,
                $inputAnalysisResultsAsString,
                $projectRoot
            );

            $outputAnalysisResults = $prunedResults->getPrunedResults();

            OutputWriter::writeToStdError(
                $output,
                "Latest analysis issue count: {$prunedResults->getInputAnalysisResults()->getCount()}",
                false
            );

            OutputWriter::writeToStdError(
                $output,
                "Baseline issue count: {$prunedResults->getBaseLine()->getAnalysisResults()->getCount()}",
                false
            );

            OutputWriter::writeToStdError(
                $output,
                "Issue count with baseline removed: {$outputAnalysisResults->getCount()}",
                !$outputAnalysisResults->hasNoIssues()
            );

            $outputAsString = $outputFormatter->outputResults($outputAnalysisResults);
            $output->writeln($outputAsString);

            $returnCode = $outputAnalysisResults->hasNoIssues() ? 0 : 1;

            if ($showRandomIssues) {
                $issuesToReport = min(self::RANDOM_ISSUES_TO_FIX, $prunedResults->getInputAnalysisResults()->getCount());

                OutputWriter::writeToStdError(
                    $output,
                    "Random {$issuesToReport} issues in the baseline to fix...",
                    false
                );

                $randomIssuesBuilder = new AnalysisResultsBuilder();
                $allIssues = $prunedResults->getInputAnalysisResults()->getAnalysisResults();

                for ($i = 0; $i < $issuesToReport; ++$i) {
                    $totalRemaining = count($allIssues);
                    $issuePicked = rand(0, $totalRemaining - 1);
                    $randomIssuesBuilder->addAnalysisResult($allIssues[$issuePicked]);
                }

                $outputAsString = $this->tableOutputFormatter->outputResults($randomIssuesBuilder->build());

                OutputWriter::writeToStdError(
                    $output,
                    $outputAsString,
                    false
                );
            }

            return $returnCode;
        } catch (Throwable $throwable) {
            $returnCode = ErrorReporter::reportError($output, $throwable);

            return $returnCode;
        }
    }

    /**
     * @throws InvalidConfigException
     */
    private function getOutputFormatter(InputInterface $input): OutputFormatter
    {
        $identifier = CliConfigReader::getOptionWithDefaultValue($input, self::OUTPUT_FORMAT);

        try {
            return $this->outputFormatterLookupService->getOutputFormatter($identifier);
        } catch (InvalidOutputFormatterException $e) {
            throw InvalidConfigException::invalidOptionValue(self::OUTPUT_FORMAT, $identifier, $this->outputFormatterLookupService->getIdentifiers());
        }
    }
}


1			<?php
2
3			/**
4			* Static Analysis Results Baseliner (sarb).
5			*
6			* (c) Dave Liddament
7			*
8			* For the full copyright and licence information please view the LICENSE file distributed with this source code.
9			*/
10
11			declare(strict_types=1);
12
13			namespace DaveLiddament\StaticAnalysisResultsBaseliner\Framework\Command;
14
15			use DaveLiddament\StaticAnalysisResultsBaseliner\Domain\OutputFormatter\InvalidOutputFormatterException;
16			use DaveLiddament\StaticAnalysisResultsBaseliner\Domain\OutputFormatter\OutputFormatter;
17			use DaveLiddament\StaticAnalysisResultsBaseliner\Domain\OutputFormatter\OutputFormatterLookupService;
18			use DaveLiddament\StaticAnalysisResultsBaseliner\Domain\Pruner\ResultsPrunerInterface;
19			use DaveLiddament\StaticAnalysisResultsBaseliner\Domain\ResultsParser\AnalysisResultsBuilder;
20			use DaveLiddament\StaticAnalysisResultsBaseliner\Framework\Command\internal\BaseLineFileHelper;
21			use DaveLiddament\StaticAnalysisResultsBaseliner\Framework\Command\internal\CliConfigReader;
22			use DaveLiddament\StaticAnalysisResultsBaseliner\Framework\Command\internal\ErrorReporter;
23			use DaveLiddament\StaticAnalysisResultsBaseliner\Framework\Command\internal\InvalidConfigException;
24			use DaveLiddament\StaticAnalysisResultsBaseliner\Framework\Command\internal\OutputWriter;
25			use DaveLiddament\StaticAnalysisResultsBaseliner\Framework\Command\internal\ProjectRootHelper;
26			use DaveLiddament\StaticAnalysisResultsBaseliner\Plugins\OutputFormatters\TableOutputFormatter;
27			use Symfony\Component\Console\Command\Command;
28			use Symfony\Component\Console\Input\InputInterface;
29			use Symfony\Component\Console\Input\InputOption;
30			use Symfony\Component\Console\Output\OutputInterface;
31			use Throwable;
32
33			class RemoveBaseLineFromResultsCommand extends Command
34			{
35			public const COMMAND_NAME = 'remove-baseline-results';
36
37			private const OUTPUT_FORMAT = 'output-format';
38			private const SHOW_RANDOM_ERRORS = 'clean-up';
39			const RANDOM_ISSUES_TO_FIX = 5;
40
41			/**
42			* @var string\|null
43			*/
44			protected static $defaultName = self::COMMAND_NAME;
45
46			/**
47			* @var OutputFormatterLookupService
48			*/
49			private $outputFormatterLookupService;
50			/**
51			* @var ResultsPrunerInterface
52			*/
53			private $resultsPruner;
54			/**
55			* @var TableOutputFormatter
56			*/
57			private $tableOutputFormatter;
58
59			public function __construct(
60			ResultsPrunerInterface $resultsPruner,
61			OutputFormatterLookupService $outputFormatterLookupService,
62			TableOutputFormatter $tableOutputFormatter
63			) {
64			parent::__construct(self::COMMAND_NAME);
65			$this->resultsPruner = $resultsPruner;
66			$this->tableOutputFormatter = $tableOutputFormatter;
67			$this->outputFormatterLookupService = $outputFormatterLookupService;
68			}
69
70			protected function configure(): void
71			{
72			$this->setDescription('Shows issues created since the baseline');
73
74			$outputFormatters = $this->outputFormatterLookupService->getIdentifiers();
75			$this->addOption(
76			self::OUTPUT_FORMAT,
77			null,
78			InputOption::VALUE_REQUIRED,
79			'Output format. One of: '.implode('\|', $outputFormatters),
80			TableOutputFormatter::CODE
81			);
82
83			$this->addOption(
84			self::SHOW_RANDOM_ERRORS,
85			null,
86			InputOption::VALUE_NONE,
87			'Show a random 5 issues in the baseline to fix'
88			);
89
90			ProjectRootHelper::configureProjectRootOption($this);
91
92			BaseLineFileHelper::configureBaseLineFileArgument($this);
93			}
94
95			protected function execute(InputInterface $input, OutputInterface $output): int
96			{
97			try {
98			$projectRoot = ProjectRootHelper::getProjectRoot($input);
99			$outputFormatter = $this->getOutputFormatter($input);
100			$baseLineFileName = BaseLineFileHelper::getBaselineFile($input);
101			$inputAnalysisResultsAsString = CliConfigReader::getStdin($input);
102			$showRandomIssues = CliConfigReader::getBooleanOption($input, self::SHOW_RANDOM_ERRORS);
103
104			$prunedResults = $this->resultsPruner->getPrunedResults(
105			$baseLineFileName,
106			$inputAnalysisResultsAsString,
107			$projectRoot
108			);
109
110			$outputAnalysisResults = $prunedResults->getPrunedResults();
111
112			OutputWriter::writeToStdError(
113			$output,
114			"Latest analysis issue count: {$prunedResults->getInputAnalysisResults()->getCount()}",
115			false
116			);
117
118			OutputWriter::writeToStdError(
119			$output,
120			"Baseline issue count: {$prunedResults->getBaseLine()->getAnalysisResults()->getCount()}",
121			false
122			);
123
124			OutputWriter::writeToStdError(
125			$output,
126			"Issue count with baseline removed: {$outputAnalysisResults->getCount()}",
127			!$outputAnalysisResults->hasNoIssues()
128			);
129
130			$outputAsString = $outputFormatter->outputResults($outputAnalysisResults);
131			$output->writeln($outputAsString);
132
133			$returnCode = $outputAnalysisResults->hasNoIssues() ? 0 : 1;
134
135			if ($showRandomIssues) {
136			$issuesToReport = min(self::RANDOM_ISSUES_TO_FIX, $prunedResults->getInputAnalysisResults()->getCount());
137
138			OutputWriter::writeToStdError(
139			$output,
140			"Random {$issuesToReport} issues in the baseline to fix...",
141			false
142			);
143
144			$randomIssuesBuilder = new AnalysisResultsBuilder();
145			$allIssues = $prunedResults->getInputAnalysisResults()->getAnalysisResults();
146
147			for ($i = 0; $i < $issuesToReport; ++$i) {
148			$totalRemaining = count($allIssues);
149			$issuePicked = rand(0, $totalRemaining - 1);
150			$randomIssuesBuilder->addAnalysisResult($allIssues[$issuePicked]);
151			}
152
153			$outputAsString = $this->tableOutputFormatter->outputResults($randomIssuesBuilder->build());
154
155			OutputWriter::writeToStdError(
156			$output,
157			$outputAsString,
158			false
159			);
160			}
161
162			return $returnCode;
163			} catch (Throwable $throwable) {
164			$returnCode = ErrorReporter::reportError($output, $throwable);
165
166			return $returnCode;
167			}
168			}
169
170			/**
171			* @throws InvalidConfigException
172			*/
173			private function getOutputFormatter(InputInterface $input): OutputFormatter
174			{
175			$identifier = CliConfigReader::getOptionWithDefaultValue($input, self::OUTPUT_FORMAT);
176
177			try {
178			return $this->outputFormatterLookupService->getOutputFormatter($identifier);
179			} catch (InvalidOutputFormatterException $e) {
180			throw InvalidConfigException::invalidOptionValue(self::OUTPUT_FORMAT, $identifier, $this->outputFormatterLookupService->getIdentifiers());
181			}
182			}
183			}
184

DaveLiddament / sarb

Pull Request — master (#117)

RemoveBaseLineFromResultsCommand::execute() B

Complexity

Size

Duplication

Importance

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like