Yiisoft\Translator\TranslationExtractor

Complexity

Total Complexity

50

Size/Duplication

Total Lines	282
Duplicated Lines	0 %

Test Coverage

Coverage

99.08%

Importance

Changes	1
Bugs	0	Features	0

13 Methods

Rating	Name	Duplication	Size	Complexity
A	hasSkippedLines()	0	3	1
A	getDefaultCategory()	0	3	1
A	withTranslator()	0	5	1
A	extractMessagesFromFile()	0	13	2
C	extractMessagesFromTokens()	0	43	12
B	splitTokensAsParams()	0	27	11
A	getMessageStringFromTokens()	0	23	6
A	extractParametersFromTokens()	0	17	4
A	getSkippedLines()	0	3	1
A	extract()	0	19	5
A	tokensEqual()	0	7	3
A	getMessageFromPath()	0	17	2
A	setDefaultCategory()	0	3	1

<?php

declare(strict_types=1);

namespace Yiisoft\Translator;

use Yiisoft\Files\FileHelper;
use Yiisoft\Files\PathMatcher\PathMatcher;

/**
 * Extractor messages
 */
final class TranslationExtractor
{
    private string $translator = '->translate';

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

    private array $skippedLines = [];
    private array $skippedLinesOfFile = [];

    private string $defaultCategory = '';

    /**
     * @var string[]
     */
    private array $only = ['**.php'];

    /**
     * @var string[]
     */
    private array $except = [
        '.svn',
        '.git',
        '.gitignore',
        '.gitkeep',
        '.hgignore',
        '.hgkeep',
        '/messages',
    ];

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

    /**
     * @param string $path
     * @param string[]|null $only
     * @param string[]|null $except
     * @return array
     */
    public function extract(string $path, ?array $only = null, ?array $except = null): array
    {
        if (!is_dir($path)) {
            throw new \RuntimeException(sprintf('Directory "%s" does not exist.', $path));
        }

        $translatorTokens = token_get_all('<?php ' . $this->translator);
        array_shift($translatorTokens);
        $this->translatorTokens = $translatorTokens;
        $this->sizeOfTranslator = count($this->translatorTokens);


        if ($this->sizeOfTranslator < 2) {
            throw new \RuntimeException('Translator tokens cannot be shorttest 2 tokens.');
        }

        $messages = $this->getMessageFromPath($path, $only === null ? $this->only : $only, $except === null ? $this->except : $except);

        return $messages;
    }

    /**
     * @param string $path
     * @param string[] $only
     * @param string[] $except
     * @return array
     */
    private function getMessageFromPath(string $path, array $only, array $except): array
    {
        $messages = [];

        $files = FileHelper::findFiles($path, [
            'filter' => (new pathMatcher)->only(...$only)->except(...$except),
            'recursive' => true,
        ]);

        /**
         * @var string[] $files
         */
        foreach ($files as $file) {
            $messages = array_merge_recursive($messages, $this->extractMessagesFromFile($file));
        }

        return $messages;
    }

    private function extractMessagesFromFile(string $fileName): array
    {
        $fileContent = file_get_contents($fileName);
        $tokens = token_get_all($fileContent);

        $this->skippedLinesOfFile = [];
        $messages = $this->extractMessagesFromTokens($tokens);

        if (!empty($this->skippedLinesOfFile)) {
            $this->skippedLines[$fileName] = $this->skippedLinesOfFile;
        }

        return $messages;
    }

    /**
     * @psalm-param array<string|array{0: int, 1: string, 2: int}> $tokens
     * @return array<array-key|string, mixed|non-empty-list<string>>

The doc comment array<array-key|string, mixed|non-empty-list<string>> at position 2 could not be parsed: Unknown type name 'array-key' at position 2 in array<array-key|string, mixed|non-empty-list<string>>.

     */
    private function extractMessagesFromTokens(array $tokens): array
    {
        $messages = $buffer = [];
        $matchedTokensCount = $pendingParenthesisCount = 0;
        $isStartedTranslator = false;

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

            if ($isStartedTranslator) {
                if ($this->tokensEqual($token, ')') && $pendingParenthesisCount === 0) {
                    $messages = array_merge_recursive($messages, $this->extractParametersFromTokens($buffer));
                    $isStartedTranslator = false;
                    $pendingParenthesisCount = 0;
                    $buffer = [];
                } else {
                    if ($this->tokensEqual($token, '(')) {
                        $pendingParenthesisCount++;
                    } elseif ($this->tokensEqual($token, ')')) {
                        $pendingParenthesisCount--;
                    }
                    $buffer[] = $token;
                }

            } else {
                if ($matchedTokensCount === $this->sizeOfTranslator) {
                    if ($this->tokensEqual($token, '(')) {
                        $isStartedTranslator = true;
                    }
                    $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
     * @return array<array-key|string, mixed|non-empty-list<string>>

The doc comment array<array-key|string, mixed|non-empty-list<string>> at position 2 could not be parsed: Unknown type name 'array-key' at position 2 in array<array-key|string, mixed|non-empty-list<string>>.

     */
    private function extractParametersFromTokens(array $tokens): array
    {
        $messages = [];
        $parameters = $this->splitTokensAsParams($tokens);

        if ($parameters === null || $parameters['id'] === null) {
            $this->skippedLinesOfFile[] = $tokens;
        } else {
            $messages[$parameters['category'] ?? $this->defaultCategory][] = $parameters['id'];

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

        return $messages;
    }

    /**
     * @psalm-param array<string|array{0: int, 1: string, 2: int}> $tokens
     * @return null|array{category: null|string, id: null|string, parameters: non-empty-list<array{0: int, 1: string, 2: int}|string>|null}

The doc comment null|array{category: null|string, id: null|string, parameters: non-empty-list<array{0: int, 1: string, 2: int}|string>|null} at position 18 could not be parsed: Unknown type name 'non-empty-list' at position 18 in null|array{category: null|string, id: null|string, parameters: non-empty-list<array{0: int, 1: string, 2: int}|string>|null}.

     */
    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, static::$commaSpare)) {

Since $commaSpare is declared private, accessing it with static will lead to errors in possible sub-classes; you can either use self, or increase the visibility of $commaSpare to at least protected.

                    array_push($commaStack, $token);
                } elseif (isset(static::$commaSpare[$token])) {
                    if (array_pop($commaStack) !== static::$commaSpare[$token]) {
                        return null;
                    }
                }
            }
            $parameters[$parameterIndex][] = $token;
        }

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

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

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

        $i = 1;
        while ($i < count($tokens) && $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])) {
                $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];
    }

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

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

    public function getDefaultCategory(): string
    {
        return $this->defaultCategory;
    }

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

    public function withTranslator(string $translator): self
    {
        $new = clone $this;
        $new->translator = $translator;
        return $new;
    }
}