ContentParser::splitTokensAsParams() - Code Metrics - Inspection of "Simple extractor" - yiisoft/translator - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#41)

by Alexander

created 2021-03-24 22:48 UTC

ContentParser::splitTokensAsParams() B

↳ Parent: ContentParser

Complexity

Conditions	8
Paths	6

Size

Total Lines	25
Code Lines	17

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	17
CRAP Score	8

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
eloc	17
c	1
b	0
f	0
dl	0
loc	25
ccs	17
cts	17
cp	1
rs	8.4444
cc	8
nc	6
nop	1
crap	8

<?php

declare(strict_types=1);

namespace Yiisoft\Translator\Extractor;

use RuntimeException;

/**
 * Extracts translation keys from a string given.
 */
final class ContentParser
{
    private string $translator = '->translate';

    /** @var array<string|array{0: int, 1: string, 2: int}> */
    private array $translatorTokens = [];

    private int $translatorTokenCount = 0;

    private string $defaultCategory = '';

    private static array $brackets = [
        ')' => '(',
        ']' => '[',
        '}' => '{',
    ];

    private array $skippedLines = [];

    public function __construct(?string $defaultCategory = null, ?string $translator = null)
    {
        $this->defaultCategory = $defaultCategory ?? $this->defaultCategory;
        $this->setTranslator($translator ?? $this->translator);
    }

    private function setTranslator(string $translator): void
    {
        $this->translator = $translator;
        $translatorTokens = token_get_all('<?php ' . $this->translator);
        array_shift($translatorTokens);
        $this->translatorTokens = $translatorTokens;
        $this->translatorTokenCount = count($this->translatorTokens);

        if ($this->translatorTokenCount < 2) {
            throw new RuntimeException('Translator cannot contain less than 2 tokens.');
        }
    }

    /**
     * @param string $content
     *
     * @psalm-return array<array-key|string, mixed|non-empty-list<string>>
     *
     * @return array[]
     */
    public function extract(string $content): array
    {
        $this->skippedLines = [];
        $tokens = token_get_all($content);

        return $this->extractMessagesFromTokens($tokens);
    }

    /**
     * @psalm-param array<integer, string|array{0: int, 1: string, 2: int}> $tokens
     *
     * @param array $tokens
     *
     * @psalm-return array<array-key|string, mixed|non-empty-list<string>>
     *
     * @return array
     */
    private function extractMessagesFromTokens(array $tokens): array
    {
        $messages = $buffer = [];
        $matchedTokensCount = $pendingParenthesisCount = 0;
        $startTranslatorTokenIndex = 0;

        foreach ($tokens as $indexToken => $token) {
            if (in_array($token[0], [T_WHITESPACE, T_COMMENT], true)) {
                continue;
            }

            if ($startTranslatorTokenIndex) {
                if ($this->tokensEqual($token, ')')) {
                    if ($pendingParenthesisCount === 0) {
                        $result = $this->extractParametersFromTokens($buffer);
                        if ($result === null) {
                            $skippedTokens = array_slice($tokens, $startTranslatorTokenIndex, $indexToken - $startTranslatorTokenIndex + 1);
                            $this->skippedLines[] = $this->getLinesData($skippedTokens);
                        } else {
                            $messages = array_merge_recursive($messages, $result);
                        }
                        $startTranslatorTokenIndex = 0;
                        $pendingParenthesisCount = 0;
                        $buffer = [];
                        continue;
                    }
                    $pendingParenthesisCount--;
                } elseif ($this->tokensEqual($token, '(')) {
                    $pendingParenthesisCount++;
                }
                $buffer[] = $token;
            } else {
                if ($matchedTokensCount === $this->translatorTokenCount) {
                    if ($this->tokensEqual($token, '(')) {
                        $startTranslatorTokenIndex = $indexToken - $this->translatorTokenCount;
                        continue;
                    }
                    $matchedTokensCount = 0;
                }

                if ($this->tokensEqual($token, $this->translatorTokens[$matchedTokensCount])) {
                    $matchedTokensCount++;
                } else {
                    $matchedTokensCount = 0;
                }
            }
        }

        return $messages;
    }

    /**
     * @psalm-param array<string|array{0: int, 1: string, 2: int}> $tokens
     *
     * @param array $tokens
     *
     * @psalm-return null|array<array-key|string, mixed|non-empty-list<string>>
     *
     * @return array|null
     */
    private function extractParametersFromTokens(array $tokens): ?array
    {
        $parameters = $this->splitTokensAsParams($tokens);

        if (!isset($parameters['id'])) {
            return null;
        }

        $messages = [$parameters['category'] ?? $this->defaultCategory => [$parameters['id']]];

        // Get translation messages from parameters
        if (isset($parameters['parameters'])) {
            $messages = array_merge_recursive($messages, $this->extractMessagesFromTokens($parameters['parameters']));
        }

        return $messages;
    }

    /**
     * @psalm-param array<string|array{0: int, 1: string, 2: int}> $tokens
     *
     * @psalm-return array{category?: null|string, id?: null|string, parameters?: null|list<array{0: int, 1: string, 2: int}|string>}
     */
    private function splitTokensAsParams(array $tokens): array
    {
        $parameters = [];
        $parameterIndex = 0;
        $commaStack = [];

        foreach ($tokens as $token) {
            if (empty($commaStack) && $token === ',') {
                $parameterIndex++;
                continue;
            }
            if (is_string($token)) {
                if (in_array($token, self::$brackets, true)) {
                    $commaStack[] = $token;
                } elseif (isset(self::$brackets[$token]) && array_pop($commaStack) !== self::$brackets[$token]) {
                    return [];
                }
            }
            $parameters[$parameterIndex][] = $token;
        }

        return [
            'id' => $this->getMessageStringFromTokens($parameters[0] ?? []),
            'parameters' => $parameters[1] ?? null,
            'category' => $this->getMessageStringFromTokens($parameters[2] ?? []),
        ];
    }

    /**
     * @psalm-param array<string|array{0: int, 1: string, 2: int}> $tokens
     *
     * @return string|null
     */
    private function getMessageStringFromTokens(array $tokens): ?string
    {
        if (empty($tokens) || $tokens[0][0] !== T_CONSTANT_ENCAPSED_STRING) {
            return null;
        }

        $fullMessage = substr($tokens[0][1], 1, -1);

        $i = 1;
        $countTokens = count($tokens);
        while ($i < $countTokens && $tokens[$i] === '.') {
            if ($tokens[$i + 1][0] === T_CONSTANT_ENCAPSED_STRING) {
                $fullMessage .= substr($tokens[$i + 1][1], 1, -1);
            } elseif (in_array($tokens[$i + 1][0], [T_LNUMBER, T_DNUMBER], true)) {
                $fullMessage .= $tokens[$i + 1][1];
            } else {
                return null;
            }

            $i += 2;
        }

        return stripcslashes($fullMessage);
    }

    /**
     * Finds out if two PHP tokens are equal.
     *
     * @param array{0: int, 1: string, 2: int}|string $a
     * @param array{0: int, 1: string, 2: int}|string $b
     *
     * @return bool
     */
    private function tokensEqual($a, $b): bool
    {
        if (is_string($a)) {
            return $a === $b;
        }

        return $a[0] === $b[0] && $a[1] === $b[1];
    }

    /**
     * @param array $tokens
     *
     * @psalm-param array<string|array{0: int, 1: string, 2: int}> $tokens
     *
     * @return array
     */
    private function getLinesData(array $tokens): array
    {
        $startLine = null;
        $codeLines = '';
        foreach ($tokens as $token) {
            if (is_array($token)) {
                if ($startLine === null) {
                    $startLine = $token[2];
                }
                $codeLines .= $token[1];
            } else {
                $codeLines .= $token;
            }
        }
        return [$startLine, $codeLines];
    }

    public function setDefaultCategory(string $defaultCategory): void
    {
        $this->defaultCategory = $defaultCategory;
    }

    public function hasSkippedLines(): bool
    {
        return !empty($this->skippedLines);
    }

    public function getSkippedLines(): array
    {
        return $this->skippedLines;
    }
}


1		<?php
2
3		declare(strict_types=1);
4
5		namespace Yiisoft\Translator\Extractor;
6
7		use RuntimeException;
8
9		/**
10		* Extracts translation keys from a string given.
11		*/
12		final class ContentParser
13		{
14		private string $translator = '->translate';
15
16		/** @var array<string\|array{0: int, 1: string, 2: int}> */
17		private array $translatorTokens = [];
18
19		private int $translatorTokenCount = 0;
20
21		private string $defaultCategory = '';
22
23		private static array $brackets = [
24		')' => '(',
25		']' => '[',
26		'}' => '{',
27		];
28
29		private array $skippedLines = [];
30
31	12	public function __construct(?string $defaultCategory = null, ?string $translator = null)
32		{
33	12	$this->defaultCategory = $defaultCategory ?? $this->defaultCategory;
34	12	$this->setTranslator($translator ?? $this->translator);
35	11	}
36
37	12	private function setTranslator(string $translator): void
38		{
39	12	$this->translator = $translator;
40	12	$translatorTokens = token_get_all('<?php ' . $this->translator);
41	12	array_shift($translatorTokens);
42	12	$this->translatorTokens = $translatorTokens;
43	12	$this->translatorTokenCount = count($this->translatorTokens);
44
45	12	if ($this->translatorTokenCount < 2) {
46	1	throw new RuntimeException('Translator cannot contain less than 2 tokens.');
47		}
48	11	}
49
50		/**
51		* @param string $content
52		*
53		* @psalm-return array<array-key\|string, mixed\|non-empty-list<string>>
54		*
55		* @return array[]
56		*/
57	11	public function extract(string $content): array
58		{
59	11	$this->skippedLines = [];
60	11	$tokens = token_get_all($content);
61
62	11	return $this->extractMessagesFromTokens($tokens);
63		}
64
65		/**
66		* @psalm-param array<integer, string\|array{0: int, 1: string, 2: int}> $tokens
67		*
68		* @param array $tokens
69		*
70		* @psalm-return array<array-key\|string, mixed\|non-empty-list<string>>
71		*
72		* @return array
73		*/
74	11	private function extractMessagesFromTokens(array $tokens): array
75		{
76	11	$messages = $buffer = [];
77	11	$matchedTokensCount = $pendingParenthesisCount = 0;
78	11	$startTranslatorTokenIndex = 0;
79
80	11	foreach ($tokens as $indexToken => $token) {
81	11	if (in_array($token[0], [T_WHITESPACE, T_COMMENT], true)) {
82	11	continue;
83		}
84
85	11	if ($startTranslatorTokenIndex) {
86	11	if ($this->tokensEqual($token, ')')) {
87	11	if ($pendingParenthesisCount === 0) {
88	11	$result = $this->extractParametersFromTokens($buffer);
89	11	if ($result === null) {
90	6	$skippedTokens = array_slice($tokens, $startTranslatorTokenIndex, $indexToken - $startTranslatorTokenIndex + 1);
91	6	$this->skippedLines[] = $this->getLinesData($skippedTokens);
92		} else {
93	8	$messages = array_merge_recursive($messages, $result);
94		}
95	11	$startTranslatorTokenIndex = 0;
96	11	$pendingParenthesisCount = 0;
97	11	$buffer = [];
98	11	continue;
99		}
100	11	$pendingParenthesisCount--;
101	11	} elseif ($this->tokensEqual($token, '(')) {
102	11	$pendingParenthesisCount++;
103		}
104	11	$buffer[] = $token;
105		} else {
106	11	if ($matchedTokensCount === $this->translatorTokenCount) {
107	11	if ($this->tokensEqual($token, '(')) {
108	11	$startTranslatorTokenIndex = $indexToken - $this->translatorTokenCount;
109	11	continue;
110		}
111	11	$matchedTokensCount = 0;
112		}
113
114	11	if ($this->tokensEqual($token, $this->translatorTokens[$matchedTokensCount])) {
115	11	$matchedTokensCount++;
116		} else {
117	11	$matchedTokensCount = 0;
118		}
119		}
120		}
121
122	11	return $messages;
123		}
124
125		/**
126		* @psalm-param array<string\|array{0: int, 1: string, 2: int}> $tokens
127		*
128		* @param array $tokens
129		*
130		* @psalm-return null\|array<array-key\|string, mixed\|non-empty-list<string>>
131		*
132		* @return array\|null
133		*/
134	11	private function extractParametersFromTokens(array $tokens): ?array
135		{
136	11	$parameters = $this->splitTokensAsParams($tokens);
137
138	11	if (!isset($parameters['id'])) {
139	6	return null;
140		}
141
142	8	$messages = [$parameters['category'] ?? $this->defaultCategory => [$parameters['id']]];
143
144		// Get translation messages from parameters
145	8	if (isset($parameters['parameters'])) {
146	6	$messages = array_merge_recursive($messages, $this->extractMessagesFromTokens($parameters['parameters']));
147		}
148
149	8	return $messages;
150		}
151
152		/**
153		* @psalm-param array<string\|array{0: int, 1: string, 2: int}> $tokens
154		*
155		* @psalm-return array{category?: null\|string, id?: null\|string, parameters?: null\|list<array{0: int, 1: string, 2: int}\|string>}
156		*/
157	11	private function splitTokensAsParams(array $tokens): array
158		{
159	11	$parameters = [];
160	11	$parameterIndex = 0;
161	11	$commaStack = [];
162
163	11	foreach ($tokens as $token) {
164	11	if (empty($commaStack) && $token === ',') {
165	9	$parameterIndex++;
166	9	continue;
167		}
168	11	if (is_string($token)) {
169	9	if (in_array($token, self::$brackets, true)) {
170	9	$commaStack[] = $token;
171	9	} elseif (isset(self::$brackets[$token]) && array_pop($commaStack) !== self::$brackets[$token]) {
172	4	return [];
173		}
174		}
175	11	$parameters[$parameterIndex][] = $token;
176		}
177
178		return [
179	11	'id' => $this->getMessageStringFromTokens($parameters[0] ?? []),
180	11	'parameters' => $parameters[1] ?? null,
181	11	'category' => $this->getMessageStringFromTokens($parameters[2] ?? []),
182		];
183		}
184
185		/**
186		* @psalm-param array<string\|array{0: int, 1: string, 2: int}> $tokens
187		*
188		* @return string\|null
189		*/
190	11	private function getMessageStringFromTokens(array $tokens): ?string
191		{
192	11	if (empty($tokens) \|\| $tokens[0][0] !== T_CONSTANT_ENCAPSED_STRING) {
193	10	return null;
194		}
195
196	11	$fullMessage = substr($tokens[0][1], 1, -1);
197
198	11	$i = 1;
199	11	$countTokens = count($tokens);
200	11	while ($i < $countTokens && $tokens[$i] === '.') {
201	9	if ($tokens[$i + 1][0] === T_CONSTANT_ENCAPSED_STRING) {
202	9	$fullMessage .= substr($tokens[$i + 1][1], 1, -1);
203	6	} elseif (in_array($tokens[$i + 1][0], [T_LNUMBER, T_DNUMBER], true)) {
204	6	$fullMessage .= $tokens[$i + 1][1];
205		} else {
206	4	return null;
207		}
208
209	9	$i += 2;
210		}
211
212	8	return stripcslashes($fullMessage);
213		}
214
215		/**
216		* Finds out if two PHP tokens are equal.
217		*
218		* @param array{0: int, 1: string, 2: int}\|string $a
219		* @param array{0: int, 1: string, 2: int}\|string $b
220		*
221		* @return bool
222		*/
223	11	private function tokensEqual($a, $b): bool
224		{
225	11	if (is_string($a)) {
226	11	return $a === $b;
227		}
228
229	11	return $a[0] === $b[0] && $a[1] === $b[1];
230		}
231
232		/**
233		* @param array $tokens
234		*
235		* @psalm-param array<string\|array{0: int, 1: string, 2: int}> $tokens
236		*
237		* @return array
238		*/
239	6	private function getLinesData(array $tokens): array
240		{
241	6	$startLine = null;
242	6	$codeLines = '';
243	6	foreach ($tokens as $token) {
244	6	if (is_array($token)) {
245	6	if ($startLine === null) {
246	6	$startLine = $token[2];
247		}
248	6	$codeLines .= $token[1];
249		} else {
250	6	$codeLines .= $token;
251		}
252		}
253	6	return [$startLine, $codeLines];
254		}
255
256	2	public function setDefaultCategory(string $defaultCategory): void
257		{
258	2	$this->defaultCategory = $defaultCategory;
259	2	}
260
261	10	public function hasSkippedLines(): bool
262		{
263	10	return !empty($this->skippedLines);
264		}
265
266	7	public function getSkippedLines(): array
267		{
268	7	return $this->skippedLines;
269		}
270		}
271

yiisoft / translator

Pull Request — master (#41)

ContentParser::splitTokensAsParams() B

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like