PhpCodeSnifferJsonResultsParser::__construct() - Code Metrics - Inspection of "Merge pull request #61 from DaveLiddament/fix/revi..." - DaveLiddament/sarb - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( c38e17...9e23a4 )

by Dave

created 2020-04-16 08:08 UTC

PhpCodeSnifferJsonResultsParser::__construct() A

↳ Parent: PhpCodeSnifferJsonResultsParser

Complexity

Conditions	1
Paths	1

Size

Total Lines	3
Code Lines	1

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	1
eloc	1
c	1
b	0
f	0
nc	1
nop	1
dl	0
loc	3
rs	10

<?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\Plugins\PhpCodeSnifferJsonResultsParser;

use DaveLiddament\StaticAnalysisResultsBaseliner\Domain\Common\FileName;
use DaveLiddament\StaticAnalysisResultsBaseliner\Domain\Common\InvalidPathException;
use DaveLiddament\StaticAnalysisResultsBaseliner\Domain\Common\LineNumber;
use DaveLiddament\StaticAnalysisResultsBaseliner\Domain\Common\Location;
use DaveLiddament\StaticAnalysisResultsBaseliner\Domain\Common\ProjectRoot;
use DaveLiddament\StaticAnalysisResultsBaseliner\Domain\Common\Type;
use DaveLiddament\StaticAnalysisResultsBaseliner\Domain\File\InvalidFileFormatException;
use DaveLiddament\StaticAnalysisResultsBaseliner\Domain\ResultsParser\AnalysisResult;
use DaveLiddament\StaticAnalysisResultsBaseliner\Domain\ResultsParser\AnalysisResults;
use DaveLiddament\StaticAnalysisResultsBaseliner\Domain\ResultsParser\Identifier;
use DaveLiddament\StaticAnalysisResultsBaseliner\Domain\ResultsParser\ResultsParser;
use DaveLiddament\StaticAnalysisResultsBaseliner\Domain\Utils\ArrayParseException;
use DaveLiddament\StaticAnalysisResultsBaseliner\Domain\Utils\ArrayUtils;
use DaveLiddament\StaticAnalysisResultsBaseliner\Domain\Utils\JsonParseException;
use DaveLiddament\StaticAnalysisResultsBaseliner\Domain\Utils\JsonUtils;
use DaveLiddament\StaticAnalysisResultsBaseliner\Domain\Utils\ParseAtLocationException;

/**
 * Handles PHP Code Sniffers's JSON output.
 */
class PhpCodeSnifferJsonResultsParser implements ResultsParser
{
    private const LINE = 'line';
    private const SOURCE = 'source';
    private const FILES = 'files';
    private const MESSAGES = 'messages';
    private const MESSAGE = 'message';
    private const ABSOLUTE_FILE_PATH = 'absoluteFilePath';
    private const ERRORS = 'errors';
    private const WARNINGS = 'warnings';

    /**
     * {@inheritdoc}
     */
    public function convertFromString(string $resultsAsString, ProjectRoot $projectRoot): AnalysisResults
    {
        try {
            $asArray = JsonUtils::toArray($resultsAsString);
        } catch (JsonParseException $e) {
            throw new InvalidFileFormatException('Not a valid JSON format');
        }

        return $this->convertFromArray($asArray, $projectRoot);
    }

    /**
     * {@inheritdoc}
     */
    public function convertToString(AnalysisResults $analysisResults): string
    {
        $files = [];
        foreach ($analysisResults->getAnalysisResults() as $analysisResult) {
            $fullDetails = JsonUtils::toArray($analysisResult->getFullDetails());
            $message = ArrayUtils::getArrayValue($fullDetails, self::MESSAGE);
            $absoluteFilePath = ArrayUtils::getStringValue($fullDetails, self::ABSOLUTE_FILE_PATH);

            if (!array_key_exists($absoluteFilePath, $files)) {
                $files[$absoluteFilePath] = [];
            }

            $files[$absoluteFilePath][] = $message;
        }

        $asArray = [
            'totals' => [
                'errors' => count(
                    array_filter(
                        $analysisResults->getAnalysisResults(),
                        static function (AnalysisResult $result): bool {
                            $details = JsonUtils::toArray($result->getFullDetails());
                            ArrayUtils::assertArray($details['message']);

                            return 'ERROR' === $details['message']['type'];
                        }
                    )
                ),
                'warnings' => count(
                    array_filter(
                        $analysisResults->getAnalysisResults(),
                        static function (AnalysisResult $result): bool {
                            $details = JsonUtils::toArray($result->getFullDetails());
                            ArrayUtils::assertArray($details['message']);

                            return 'WARNING' === $details['message']['type'];
                        }
                    )
                ),
                'fixable' => count(
                    array_filter(
                        $analysisResults->getAnalysisResults(),
                        static function (AnalysisResult $result): bool {
                            $details = JsonUtils::toArray($result->getFullDetails());
                            ArrayUtils::assertArray($details['message']);

                            return (bool) $details['message']['fixable'];
                        }
                    )
                ),
            ],
            self::FILES => [],
        ];

        foreach ($files as $fileName => $messages) {
            $asArray[self::FILES][$fileName] = [
                'errors' => count(
                    array_filter(
                        $messages,
                        static function (array $message): bool {
                            return 'ERROR' === $message['type'];
                        }
                    )
                ),
                'warnings' => count(
                    array_filter(
                        $messages,
                        static function (array $message): bool {
                            return 'WARNING' === $message['type'];
                        }
                    )
                ),
                self::MESSAGES => $messages,
            ];
        }

        return JsonUtils::toString($asArray);
    }

    /**
     * {@inheritdoc}
     */
    public function getIdentifier(): Identifier
    {
        return new PhpCodeSnifferJsonIdentifier();
    }

    /**
     * {@inheritdoc}
     */
    public function showTypeGuessingWarning(): bool
    {
        return false;
    }

    /**
     * Converts from an array.
     *
     * @phpstan-param array<mixed> $analysisResultsAsArray
     *
     * @throws ParseAtLocationException
     */
    private function convertFromArray(array $analysisResultsAsArray, ProjectRoot $projectRoot): AnalysisResults
    {
        $analysisResults = new AnalysisResults();

        try {
            $filesErrors = ArrayUtils::getArrayValue($analysisResultsAsArray, self::FILES);
        } catch (ArrayParseException $e) {
            throw new ParseAtLocationException('Root node', $e);
        }

        /** @psalm-suppress MixedAssignment */
        foreach ($filesErrors as $absoluteFilePath => $fileErrors) {
            try {
                if (!is_string($absoluteFilePath)) {
                    throw new ArrayParseException('Expected filename to be of type string');
                }

                ArrayUtils::assertArray($fileErrors);

                $errorsCount = ArrayUtils::getIntValue($fileErrors, self::ERRORS);
                $warningsCount = ArrayUtils::getIntValue($fileErrors, self::WARNINGS);
                if (0 === $errorsCount && 0 === $warningsCount) {
                    continue;
                }

                $fileNameAsString = $projectRoot->getPathRelativeToRootDirectory($absoluteFilePath);
                $fileName = new FileName($fileNameAsString);

                $messages = ArrayUtils::getArrayValue($fileErrors, self::MESSAGES);

                foreach ($messages as $message) {
                    ArrayUtils::assertArray($message);
                    $analysisResult = $this->convertAnalysisResultFromArray($message, $fileName, $absoluteFilePath);
                    $analysisResults->addAnalysisResult($analysisResult);
                }
            } catch (ArrayParseException | JsonParseException | InvalidPathException $e) {
                throw new ParseAtLocationException("Result [$absoluteFilePath]", $e);
            }
        }

        return $analysisResults;
    }

    /**
     * @phpstan-param array<mixed> $analysisResultAsArray
     *
     * @throws ArrayParseException
     * @throws JsonParseException
     */
    private function convertAnalysisResultFromArray(
        array $analysisResultAsArray,
        FileName $fileName,
        string $absoluteFilePath
    ): AnalysisResult {
        $lineAsInt = ArrayUtils::getIntValue($analysisResultAsArray, self::LINE);
        $rawMessage = ArrayUtils::getStringValue($analysisResultAsArray, self::MESSAGE);
        $rawSource = ArrayUtils::getStringValue($analysisResultAsArray, self::SOURCE);

        $location = new Location(
            $fileName,
            new LineNumber($lineAsInt)
        );

        return new AnalysisResult(
            $location,
            new Type($rawSource),
            $rawMessage,
            JsonUtils::toString([
                self::ABSOLUTE_FILE_PATH => $absoluteFilePath,
                self::MESSAGE => $analysisResultAsArray,
            ])
        );
    }
}


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\Plugins\PhpCodeSnifferJsonResultsParser;
14
15			use DaveLiddament\StaticAnalysisResultsBaseliner\Domain\Common\FileName;
16			use DaveLiddament\StaticAnalysisResultsBaseliner\Domain\Common\InvalidPathException;
17			use DaveLiddament\StaticAnalysisResultsBaseliner\Domain\Common\LineNumber;
18			use DaveLiddament\StaticAnalysisResultsBaseliner\Domain\Common\Location;
19			use DaveLiddament\StaticAnalysisResultsBaseliner\Domain\Common\ProjectRoot;
20			use DaveLiddament\StaticAnalysisResultsBaseliner\Domain\Common\Type;
21			use DaveLiddament\StaticAnalysisResultsBaseliner\Domain\File\InvalidFileFormatException;
22			use DaveLiddament\StaticAnalysisResultsBaseliner\Domain\ResultsParser\AnalysisResult;
23			use DaveLiddament\StaticAnalysisResultsBaseliner\Domain\ResultsParser\AnalysisResults;
24			use DaveLiddament\StaticAnalysisResultsBaseliner\Domain\ResultsParser\Identifier;
25			use DaveLiddament\StaticAnalysisResultsBaseliner\Domain\ResultsParser\ResultsParser;
26			use DaveLiddament\StaticAnalysisResultsBaseliner\Domain\Utils\ArrayParseException;
27			use DaveLiddament\StaticAnalysisResultsBaseliner\Domain\Utils\ArrayUtils;
28			use DaveLiddament\StaticAnalysisResultsBaseliner\Domain\Utils\JsonParseException;
29			use DaveLiddament\StaticAnalysisResultsBaseliner\Domain\Utils\JsonUtils;
30			use DaveLiddament\StaticAnalysisResultsBaseliner\Domain\Utils\ParseAtLocationException;
31
32			/**
33			* Handles PHP Code Sniffers's JSON output.
34			*/
35			class PhpCodeSnifferJsonResultsParser implements ResultsParser
36			{
37			private const LINE = 'line';
38			private const SOURCE = 'source';
39			private const FILES = 'files';
40			private const MESSAGES = 'messages';
41			private const MESSAGE = 'message';
42			private const ABSOLUTE_FILE_PATH = 'absoluteFilePath';
43			private const ERRORS = 'errors';
44			private const WARNINGS = 'warnings';
45
46			/**
47			* {@inheritdoc}
48			*/
49			public function convertFromString(string $resultsAsString, ProjectRoot $projectRoot): AnalysisResults
50			{
51			try {
52			$asArray = JsonUtils::toArray($resultsAsString);
53			} catch (JsonParseException $e) {
54			throw new InvalidFileFormatException('Not a valid JSON format');
55			}
56
57			return $this->convertFromArray($asArray, $projectRoot);
58			}
59
60			/**
61			* {@inheritdoc}
62			*/
63			public function convertToString(AnalysisResults $analysisResults): string
64			{
65			$files = [];
66			foreach ($analysisResults->getAnalysisResults() as $analysisResult) {
67			$fullDetails = JsonUtils::toArray($analysisResult->getFullDetails());
68			$message = ArrayUtils::getArrayValue($fullDetails, self::MESSAGE);
69			$absoluteFilePath = ArrayUtils::getStringValue($fullDetails, self::ABSOLUTE_FILE_PATH);
70
71			if (!array_key_exists($absoluteFilePath, $files)) {
72			$files[$absoluteFilePath] = [];
73			}
74
75			$files[$absoluteFilePath][] = $message;
76			}
77
78			$asArray = [
79			'totals' => [
80			'errors' => count(
81			array_filter(
82			$analysisResults->getAnalysisResults(),
83			static function (AnalysisResult $result): bool {
84			$details = JsonUtils::toArray($result->getFullDetails());
85			ArrayUtils::assertArray($details['message']);
86
87			return 'ERROR' === $details['message']['type'];
88			}
89			)
90			),
91			'warnings' => count(
92			array_filter(
93			$analysisResults->getAnalysisResults(),
94			static function (AnalysisResult $result): bool {
95			$details = JsonUtils::toArray($result->getFullDetails());
96			ArrayUtils::assertArray($details['message']);
97
98			return 'WARNING' === $details['message']['type'];
99			}
100			)
101			),
102			'fixable' => count(
103			array_filter(
104			$analysisResults->getAnalysisResults(),
105			static function (AnalysisResult $result): bool {
106			$details = JsonUtils::toArray($result->getFullDetails());
107			ArrayUtils::assertArray($details['message']);
108
109			return (bool) $details['message']['fixable'];
110			}
111			)
112			),
113			],
114			self::FILES => [],
115			];
116
117			foreach ($files as $fileName => $messages) {
118			$asArray[self::FILES][$fileName] = [
119			'errors' => count(
120			array_filter(
121			$messages,
122			static function (array $message): bool {
123			return 'ERROR' === $message['type'];
124			}
125			)
126			),
127			'warnings' => count(
128			array_filter(
129			$messages,
130			static function (array $message): bool {
131			return 'WARNING' === $message['type'];
132			}
133			)
134			),
135			self::MESSAGES => $messages,
136			];
137			}
138
139			return JsonUtils::toString($asArray);
140			}
141
142			/**
143			* {@inheritdoc}
144			*/
145			public function getIdentifier(): Identifier
146			{
147			return new PhpCodeSnifferJsonIdentifier();
148			}
149
150			/**
151			* {@inheritdoc}
152			*/
153			public function showTypeGuessingWarning(): bool
154			{
155			return false;
156			}
157
158			/**
159			* Converts from an array.
160			*
161			* @phpstan-param array<mixed> $analysisResultsAsArray
162			*
163			* @throws ParseAtLocationException
164			*/
165			private function convertFromArray(array $analysisResultsAsArray, ProjectRoot $projectRoot): AnalysisResults
166			{
167			$analysisResults = new AnalysisResults();
168
169			try {
170			$filesErrors = ArrayUtils::getArrayValue($analysisResultsAsArray, self::FILES);
171			} catch (ArrayParseException $e) {
172			throw new ParseAtLocationException('Root node', $e);
173			}
174
175			/** @psalm-suppress MixedAssignment */
176			foreach ($filesErrors as $absoluteFilePath => $fileErrors) {
177			try {
178			if (!is_string($absoluteFilePath)) {
179			throw new ArrayParseException('Expected filename to be of type string');
180			}
181
182			ArrayUtils::assertArray($fileErrors);
183
184			$errorsCount = ArrayUtils::getIntValue($fileErrors, self::ERRORS);
185			$warningsCount = ArrayUtils::getIntValue($fileErrors, self::WARNINGS);
186			if (0 === $errorsCount && 0 === $warningsCount) {
187			continue;
188			}
189
190			$fileNameAsString = $projectRoot->getPathRelativeToRootDirectory($absoluteFilePath);
191			$fileName = new FileName($fileNameAsString);
192
193			$messages = ArrayUtils::getArrayValue($fileErrors, self::MESSAGES);
194
195			foreach ($messages as $message) {
196			ArrayUtils::assertArray($message);
197			$analysisResult = $this->convertAnalysisResultFromArray($message, $fileName, $absoluteFilePath);
198			$analysisResults->addAnalysisResult($analysisResult);
199			}
200			} catch (ArrayParseException \| JsonParseException \| InvalidPathException $e) {
201			throw new ParseAtLocationException("Result [$absoluteFilePath]", $e);
202			}
203			}
204
205			return $analysisResults;
206			}
207
208			/**
209			* @phpstan-param array<mixed> $analysisResultAsArray
210			*
211			* @throws ArrayParseException
212			* @throws JsonParseException
213			*/
214			private function convertAnalysisResultFromArray(
215			array $analysisResultAsArray,
216			FileName $fileName,
217			string $absoluteFilePath
218			): AnalysisResult {
219			$lineAsInt = ArrayUtils::getIntValue($analysisResultAsArray, self::LINE);
220			$rawMessage = ArrayUtils::getStringValue($analysisResultAsArray, self::MESSAGE);
221			$rawSource = ArrayUtils::getStringValue($analysisResultAsArray, self::SOURCE);
222
223			$location = new Location(
224			$fileName,
225			new LineNumber($lineAsInt)
226			);
227
228			return new AnalysisResult(
229			$location,
230			new Type($rawSource),
231			$rawMessage,
232			JsonUtils::toString([
233			self::ABSOLUTE_FILE_PATH => $absoluteFilePath,
234			self::MESSAGE => $analysisResultAsArray,
235			])
236			);
237			}
238			}
239

DaveLiddament / sarb

Push — master ( c38e17...9e23a4 )

PhpCodeSnifferJsonResultsParser::__construct() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like