WithStatement::parse() - Code Metrics - Inspection of "Add WITH support" - phpmyadmin/sql-parser - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#334)

by Antoine

created 2021-03-11 11:24 UTC

WithStatement::parse() C

↳ Parent: WithStatement

Complexity

Conditions	13
Paths	11

Size

Total Lines	74
Code Lines	41

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	13
eloc	41
c	1
b	0
f	0
nc	11
nop	2
dl	0
loc	74
rs	6.6166

How to fix Long Method Complexity

<?php
/**
 * `WITH` statement.
 */

declare(strict_types=1);

namespace PhpMyAdmin\SqlParser\Statements;

use PhpMyAdmin\SqlParser\Components\Array2d;
use PhpMyAdmin\SqlParser\Components\OptionsArray;
use PhpMyAdmin\SqlParser\Components\WithKeyword;
use PhpMyAdmin\SqlParser\Statement;
use PhpMyAdmin\SqlParser\Parser;
use PhpMyAdmin\SqlParser\Token;
use PhpMyAdmin\SqlParser\TokensList;
use RuntimeException;

use function array_slice;
use function count;

/**
 * `WITH` statement.

 *  WITH [RECURSIVE] query_name [ (column_name [,...]) ] AS (SELECT ...) [, ...]
 */
class WithStatement extends Statement
{
    /**
     * Options for `WITH` statements and their slot ID.
     *
     * @var array
     */
    public static $OPTIONS = ['RECURSIVE' => 1];

    /**
     * The clauses of this statement, in order.
     *
     * @see Statement::$CLAUSES
     *
     * @var array
     */
    public static $CLAUSES = [
        'WITH' => [
            'WITH',
            2,
        ],
        // Used for options.
        '_OPTIONS' => [
            '_OPTIONS',
            1,
        ],
        'AS' => [
            'AS',
            2,
        ],
    ];

    /** @var WithKeyword[] */
    public $withers = [];

    /**
     * @param Parser     $parser the instance that requests parsing
     * @param TokensList $list   the list of tokens to be parsed
     */
    public function parse(Parser $parser, TokensList $list)
    {
        ++$list->idx; // Skipping `WITH`.

        // parse any options if provided
        $this->options = OptionsArray::parse(
            $parser,
            $list,
            static::$OPTIONS
        );
        ++$list->idx;

        $state = 0;
        $wither = null;

        for (; $list->idx < $list->count; ++$list->idx) {
            /**
             * Token parsed at this moment.
             *
             * @var Token
             */
            $token = $list->tokens[$list->idx];

            // Skipping whitespaces and comments.
            if ($token->type === Token::TYPE_WHITESPACE || $token->type === Token::TYPE_COMMENT) {
                continue;
            }

            if ($token->type === Token::TYPE_NONE) {
                $wither = $token->value;
                $this->withers[$wither] = new WithKeyword($wither);
                $state = 1;
                continue;
            }

            if ($state === 1) {
                if ($token->value === '(') {
                    $this->withers[$wither]->columns = Array2d::parse($parser, $list);
                    continue;
                }

                if ($token->keyword === 'AS') {
                    ++$list->idx;
                    $state = 2;
                    continue;
                }
            } elseif ($state === 2) {
                if ($token->value === '(') {
                    ++$list->idx;
                    $subList = $this->getSubTokenList($list);
                    $subParser = new Parser($subList);

                    if (count($subParser->errors)) {
                        foreach ($subParser->errors as $error) {
                            $parser->error($error);
                        }
                    }

                    $this->withers[$wither]->statement = $subParser;
                    continue;
                }

                if ($token->value === ',') {
                    $list->idx++;
                    $state = 0;
                    continue;
                }

                // nothing else
                break;
            }
        }

        --$list->idx;
    }

    /**
     * {@inheritdoc}
     */
    public function build()
    {
        $str = 'WITH ';

        foreach ($this->withers as $wither) {
            $str .= $str === 'WITH ' ? '' : ', ';
            $str .= WithKeyword::build($wither);
        }

        return $str;
    }

    private function getSubTokenList(TokensList $list): TokensList
    {
        $idx = $list->idx;
        /** @var Token $token */
        $token = $list->tokens[$list->idx];
        $openParenthesis = 0;

        while ($list->idx < $list->count) {
            // var_dump($idx, $token->value);
            if ($token->value === '(') {
                ++$openParenthesis;
            } elseif ($token->value === ')') {
                if (--$openParenthesis === -1) {
                    break;
                }
            }

            $token = $list->tokens[++$list->idx];
        }

        if ($list->idx === $list->count) {
            throw new RuntimeException('Syntax error no matching closing parenthesis.');
        }

        $length = $list->idx - $idx;

        return new TokensList(array_slice($list->tokens, $idx, $length), $length);
    }
}


1			<?php
2			/**
3			* `WITH` statement.
4			*/
5
6			declare(strict_types=1);
7
8			namespace PhpMyAdmin\SqlParser\Statements;
9
10			use PhpMyAdmin\SqlParser\Components\Array2d;
11			use PhpMyAdmin\SqlParser\Components\OptionsArray;
12			use PhpMyAdmin\SqlParser\Components\WithKeyword;
13			use PhpMyAdmin\SqlParser\Statement;
14			use PhpMyAdmin\SqlParser\Parser;
15			use PhpMyAdmin\SqlParser\Token;
16			use PhpMyAdmin\SqlParser\TokensList;
17			use RuntimeException;
18
19			use function array_slice;
20			use function count;
21
22			/**
23			* `WITH` statement.
24
25			* WITH [RECURSIVE] query_name [ (column_name [,...]) ] AS (SELECT ...) [, ...]
26			*/
27			class WithStatement extends Statement
28			{
29			/**
30			* Options for `WITH` statements and their slot ID.
31			*
32			* @var array
33			*/
34			public static $OPTIONS = ['RECURSIVE' => 1];
35
36			/**
37			* The clauses of this statement, in order.
38			*
39			* @see Statement::$CLAUSES
40			*
41			* @var array
42			*/
43			public static $CLAUSES = [
44			'WITH' => [
45			'WITH',
46			2,
47			],
48			// Used for options.
49			'_OPTIONS' => [
50			'_OPTIONS',
51			1,
52			],
53			'AS' => [
54			'AS',
55			2,
56			],
57			];
58
59			/** @var WithKeyword[] */
60			public $withers = [];
61
62			/**
63			* @param Parser $parser the instance that requests parsing
64			* @param TokensList $list the list of tokens to be parsed
65			*/
66			public function parse(Parser $parser, TokensList $list)
67			{
68			++$list->idx; // Skipping `WITH`.
69
70			// parse any options if provided
71			$this->options = OptionsArray::parse(
72			$parser,
73			$list,
74			static::$OPTIONS
75			);
76			++$list->idx;
77
78			$state = 0;
79			$wither = null;
80
81			for (; $list->idx < $list->count; ++$list->idx) {
82			/**
83			* Token parsed at this moment.
84			*
85			* @var Token
86			*/
87			$token = $list->tokens[$list->idx];
88
89			// Skipping whitespaces and comments.
90			if ($token->type === Token::TYPE_WHITESPACE \|\| $token->type === Token::TYPE_COMMENT) {
91			continue;
92			}
93
94			if ($token->type === Token::TYPE_NONE) {
95			$wither = $token->value;
96			$this->withers[$wither] = new WithKeyword($wither);
97			$state = 1;
98			continue;
99			}
100
101			if ($state === 1) {
102			if ($token->value === '(') {
103			$this->withers[$wither]->columns = Array2d::parse($parser, $list);
104			continue;
105			}
106
107			if ($token->keyword === 'AS') {
108			++$list->idx;
109			$state = 2;
110			continue;
111			}
112			} elseif ($state === 2) {
113			if ($token->value === '(') {
114			++$list->idx;
115			$subList = $this->getSubTokenList($list);
116			$subParser = new Parser($subList);
117
118			if (count($subParser->errors)) {
119			foreach ($subParser->errors as $error) {
120			$parser->error($error);
121			}
122			}
123
124			$this->withers[$wither]->statement = $subParser;
125			continue;
126			}
127
128			if ($token->value === ',') {
129			$list->idx++;
130			$state = 0;
131			continue;
132			}
133
134			// nothing else
135			break;
136			}
137			}
138
139			--$list->idx;
140			}
141
142			/**
143			* {@inheritdoc}
144			*/
145			public function build()
146			{
147			$str = 'WITH ';
148
149			foreach ($this->withers as $wither) {
150			$str .= $str === 'WITH ' ? '' : ', ';
151			$str .= WithKeyword::build($wither);
152			}
153
154			return $str;
155			}
156
157			private function getSubTokenList(TokensList $list): TokensList
158			{
159			$idx = $list->idx;
160			/** @var Token $token */
161			$token = $list->tokens[$list->idx];
162			$openParenthesis = 0;
163
164			while ($list->idx < $list->count) {
165			// var_dump($idx, $token->value);
166			if ($token->value === '(') {
167			++$openParenthesis;
168			} elseif ($token->value === ')') {
169			if (--$openParenthesis === -1) {
170			break;
171			}
172			}
173
174			$token = $list->tokens[++$list->idx];
175			}
176
177			if ($list->idx === $list->count) {
178			throw new RuntimeException('Syntax error no matching closing parenthesis.');
179			}
180
181			$length = $list->idx - $idx;
182
183			return new TokensList(array_slice($list->tokens, $idx, $length), $length);
184			}
185			}
186

phpmyadmin / sql-parser

Pull Request — master (#334)

WithStatement::parse() C

Complexity

Size

Duplication

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like