MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\BaseVariadicFunction

Complexity

Total Complexity

15

Size/Duplication

Total Lines	72
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes	1
Bugs	0	Features	1

3 Methods

Rating	Name	Duplication	Size	Complexity
B	feedParserWithNodesForNodeMappingPattern()	0	28	9
A	feedParserWithNodes()	0	13	3
A	getSql()	0	8	3

<?php

declare(strict_types=1);

namespace MartinGeorgiev\Doctrine\ORM\Query\AST\Functions;

use Doctrine\ORM\Query\AST\Node;
use Doctrine\ORM\Query\Lexer;
use Doctrine\ORM\Query\Parser;
use Doctrine\ORM\Query\SqlWalker;
use Doctrine\ORM\Query\TokenType;
use MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Exception\InvalidArgumentForVariadicFunctionException;
use MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Exception\ParserException;
use MartinGeorgiev\Utils\DoctrineLexer;
use MartinGeorgiev\Utils\DoctrineOrm;

/**
 * @author Martin Georgiev <martin.georgiev@gmail.com>
 */
abstract class BaseVariadicFunction extends BaseFunction
{
    /**
     * @return array<int|string, string>
     */
    abstract protected function getNodeMappingPattern(): array;

    /**
     * @throws ParserException
     */
    protected function feedParserWithNodes(Parser $parser): void
    {
        foreach ($this->getNodeMappingPattern() as $nodeMappingPattern) {
            try {
                $this->feedParserWithNodesForNodeMappingPattern($parser, $nodeMappingPattern);

                break;
            } catch (ParserException) {
                // swallow and continue with next pattern
            }
        }

        $this->validateArguments(...$this->nodes); // @phpstan-ignore-line
    }

    private function feedParserWithNodesForNodeMappingPattern(Parser $parser, string $nodeMappingPattern): void
    {
        $nodeMapping = \explode(',', $nodeMappingPattern);
        $lexer = $parser->getLexer();

        try {
            // @phpstan-ignore-next-line
            $this->nodes[] = $parser->{$nodeMapping[0]}();
            $lookaheadType = DoctrineLexer::getLookaheadType($lexer);
            if ($lookaheadType === null) {
                throw ParserException::missingLookaheadType();
            }
        } catch (\Throwable $throwable) {
            throw ParserException::withThrowable($throwable);
        }

        $shouldUseLexer = DoctrineOrm::isPre219();
        $isNodeMappingASimplePattern = \count($nodeMapping) === 1;
        $nodeIndex = 1;
        while (($shouldUseLexer ? Lexer::T_CLOSE_PARENTHESIS : TokenType::T_CLOSE_PARENTHESIS) !== $lookaheadType) {

The constant Doctrine\ORM\Query\Lexer::T_CLOSE_PARENTHESIS was not found. Maybe you did not declare it correctly or list all dependencies?

            if (($shouldUseLexer ? Lexer::T_COMMA : TokenType::T_COMMA) === $lookaheadType) {

The constant Doctrine\ORM\Query\Lexer::T_COMMA was not found. Maybe you did not declare it correctly or list all dependencies?

                $parser->match($shouldUseLexer ? Lexer::T_COMMA : TokenType::T_COMMA);
                // @phpstan-ignore-next-line
                $this->nodes[] = $parser->{$nodeMapping[$isNodeMappingASimplePattern ? 0 : $nodeIndex]}();
                $nodeIndex++;
            }

            $lookaheadType = DoctrineLexer::getLookaheadType($lexer);
        }
    }

    public function getSql(SqlWalker $sqlWalker): string
    {
        $dispatched = [];
        foreach ($this->nodes as $node) {
            $dispatched[] = $node instanceof Node ? $node->dispatch($sqlWalker) : 'null';
        }

        return \sprintf($this->functionPrototype, \implode(', ', $dispatched));
    }

    /**
     * Validates the arguments passed to the function.
     *
     * @throws InvalidArgumentForVariadicFunctionException
     */
    abstract protected function validateArguments(Node ...$arguments): void;
}