BaseVariadicFunction::feedParserWithNodesForNodeMappingPattern()

Complexity

Conditions	12
Paths	10

Size

Total Lines	55
Code Lines	31

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	26
CRAP Score	12.9492

Importance

Changes

0

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

        try {
            $lookaheadType = DoctrineLexer::getLookaheadType($lexer);
            if ($lookaheadType === null) {
                throw InvalidArgumentForVariadicFunctionException::atLeast($this->getFunctionName(), $this->getMinArgumentCount());
            }

            $this->nodes[] = $parser->{$nodeMapping[0]}(); // @phpstan-ignore-line
        } 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);

                // Check if we're about to exceed the maximum number of arguments
                // nodeIndex starts at 1 and counts up for each argument after the first
                // So when nodeIndex=1, we're about to add the 2nd argument (total: 2)
                // When nodeIndex=2, we're about to add the 3rd argument (total: 3)
                $foundMoreNodesThanMappingExpected = ($nodeIndex + 1) > $this->getMaxArgumentCount();
                if ($foundMoreNodesThanMappingExpected) {
                    if ($this->getMinArgumentCount() === $this->getMaxArgumentCount()) {
                        throw InvalidArgumentForVariadicFunctionException::exactCount($this->getFunctionName(), $this->getMinArgumentCount());
                    }

                    throw InvalidArgumentForVariadicFunctionException::between($this->getFunctionName(), $this->getMinArgumentCount(), $this->getMaxArgumentCount());
                }

                $expectedNodeIndex = $isNodeMappingASimplePattern ? 0 : $nodeIndex;
                $argumentCountExceedsMappingPatternExpectation = !\array_key_exists($expectedNodeIndex, $nodeMapping);
                if ($argumentCountExceedsMappingPatternExpectation) {
                    throw InvalidArgumentForVariadicFunctionException::unsupportedCombination(
                        $this->getFunctionName(),
                        \count($this->nodes) + 1,
                        'implementation defines fewer node mappings than the actually provided argument count'
                    );
                }

                $this->nodes[] = $parser->{$nodeMapping[$expectedNodeIndex]}(); // @phpstan-ignore-line
                $nodeIndex++;
            }

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

        // Final validation ensures all arguments meet requirements, including any special rules in subclass implementations
        $this->validateArguments(...$this->nodes); // @phpstan-ignore-line
    }