BaseVariadicFunction::feedParserWithNodesForNodeMappingPattern() - Code Metrics - Inspection of "no message" - martin-georgiev/postgresql-for-doctrine - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — variadic-pattern ( b0f4a5...705257 )

by Martin

created 2025-04-14 00:40 UTC

feedParserWithNodesForNodeMappingPattern() B

↳ Parent: BaseVariadicFunction

Complexity

Conditions	9
Paths	7

Size

Total Lines	28
Code Lines	18

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	18
CRAP Score	9

Importance

Changes

Metric	Value
cc	9
eloc	18
c	0
b	0
f	0
nc	7
nop	2
dl	0
loc	28
ccs	18
cts	18
cp	1
crap	9
rs	8.0555

<?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 <[email protected]>
 */
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) {

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

                $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;
}


1		<?php
2
3		declare(strict_types=1);
4
5		namespace MartinGeorgiev\Doctrine\ORM\Query\AST\Functions;
6
7		use Doctrine\ORM\Query\AST\Node;
8		use Doctrine\ORM\Query\Lexer;
9		use Doctrine\ORM\Query\Parser;
10		use Doctrine\ORM\Query\SqlWalker;
11		use Doctrine\ORM\Query\TokenType;
12		use MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Exception\InvalidArgumentForVariadicFunctionException;
13		use MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Exception\ParserException;
14		use MartinGeorgiev\Utils\DoctrineLexer;
15		use MartinGeorgiev\Utils\DoctrineOrm;
16
17		/**
18		* @author Martin Georgiev <[email protected]>
19		*/
20		abstract class BaseVariadicFunction extends BaseFunction
21		{
22		/**
23		* @return array<int\|string, string>
24		*/
25		abstract protected function getNodeMappingPattern(): array;
26
27		/**
28		* @throws ParserException
29		*/
30	66	protected function feedParserWithNodes(Parser $parser): void
31		{
32	66	foreach ($this->getNodeMappingPattern() as $nodeMappingPattern) {
33		try {
34	66	$this->feedParserWithNodesForNodeMappingPattern($parser, $nodeMappingPattern);
35
36	64	break;
37	2	} catch (ParserException) {
38		// swallow and continue with next pattern
39		}
40		}
41
42	66	$this->validateArguments(...$this->nodes); // @phpstan-ignore-line
43		}
44
45	66	private function feedParserWithNodesForNodeMappingPattern(Parser $parser, string $nodeMappingPattern): void
46		{
47	66	$nodeMapping = \explode(',', $nodeMappingPattern);
48	66	$lexer = $parser->getLexer();
49
50		try {
51		// @phpstan-ignore-next-line
52	66	$this->nodes[] = $parser->{$nodeMapping[0]}();
53	64	$lookaheadType = DoctrineLexer::getLookaheadType($lexer);
54	64	if ($lookaheadType === null) {
55	64	throw ParserException::missingLookaheadType();
56		}
57	2	} catch (\Throwable $throwable) {
58	2	throw ParserException::withThrowable($throwable);
59		}
60
61	64	$shouldUseLexer = DoctrineOrm::isPre219();
62	64	$isNodeMappingASimplePattern = \count($nodeMapping) === 1;
63	64	$nodeIndex = 1;
64	64	while (($shouldUseLexer ? Lexer::T_CLOSE_PARENTHESIS : TokenType::T_CLOSE_PARENTHESIS) !== $lookaheadType) {
		0 ignored issues – show Bug introduced 2024-02-14 15:48 UTC by Report Bug Copy Issue Report The constant `Doctrine\ORM\Query\Lexer::T_CLOSE_PARENTHESIS` was not found. Maybe you did not declare it correctly or list all dependencies? Loading history...
65	51	if (($shouldUseLexer ? Lexer::T_COMMA : TokenType::T_COMMA) === $lookaheadType) {
		0 ignored issues – show Bug introduced 2024-02-21 14:21 UTC by Report Bug Copy Issue Report The constant `Doctrine\ORM\Query\Lexer::T_COMMA` was not found. Maybe you did not declare it correctly or list all dependencies? Loading history...
66	51	$parser->match($shouldUseLexer ? Lexer::T_COMMA : TokenType::T_COMMA);
67		// @phpstan-ignore-next-line
68	51	$this->nodes[] = $parser->{$nodeMapping[$isNodeMappingASimplePattern ? 0 : $nodeIndex]}();
69	51	$nodeIndex++;
70		}
71
72	51	$lookaheadType = DoctrineLexer::getLookaheadType($lexer);
73		}
74		}
75
76	26	public function getSql(SqlWalker $sqlWalker): string
77		{
78	26	$dispatched = [];
79	26	foreach ($this->nodes as $node) {
80	26	$dispatched[] = $node instanceof Node ? $node->dispatch($sqlWalker) : 'null';
81		}
82
83	26	return \sprintf($this->functionPrototype, \implode(', ', $dispatched));
84		}
85
86		/**
87		* Validates the arguments passed to the function.
88		*
89		* @throws InvalidArgumentForVariadicFunctionException
90		*/
91		abstract protected function validateArguments(Node ...$arguments): void;
92		}
93

martin-georgiev / postgresql-for-doctrine

Push — variadic-pattern ( b0f4a5...705257 )

feedParserWithNodesForNodeMappingPattern() B

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like