PhpMyAdmin\SqlParser\Utils\Formatter::formatList()

Complexity

Conditions	58
Paths	13842

Size

Total Lines	214
Code Lines	97

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	92
CRAP Score	58

Importance

Changes	3
Bugs	0	Features	0

<?php
    public function formatList(TokensList $list): string
    {
        /**
         * The query to be returned.
         */
        $ret = '';

        /**
         * The indentation level.
         */
        $indent = 0;

        /**
         * Whether the line ended.
         */
        $lineEnded = false;

        /**
         * Whether current group is short (no linebreaks).
         */
        $shortGroup = false;

        /**
         * The name of the last clause.
         */
        $lastClause = '';

        /**
         * A stack that keeps track of the indentation level every time a new
         * block is found.
         */
        $blocksIndentation = [];

        /**
         * A stack that keeps track of the line endings every time a new block
         * is found.
         */
        $blocksLineEndings = [];

        /**
         * Whether clause's options were formatted.
         */
        $formattedOptions = false;

        /**
         * Previously parsed token.
         */
        $prev = null;

        // In order to be able to format the queries correctly, the next token
        // must be taken into consideration. The loop below uses two pointers,
        // `$prev` and `$curr` which store two consecutive tokens.
        // Actually, at every iteration the previous token is being used.
        for ($list->idx = 0; $list->idx < $list->count; ++$list->idx) {
            /**
             * Token parsed at this moment.
             */
            $curr = $list->tokens[$list->idx];
            if ($list->idx + 1 < $list->count) {
                $next = $list->tokens[$list->idx + 1];
            } else {
                $next = null;
            }

            if ($curr->type === TokenType::Whitespace) {
                // Keep linebreaks before and after comments
                if (
                    str_contains($curr->token, "\n") && (
                        ($prev !== null && $prev->type === TokenType::Comment) ||
                        ($next !== null && $next->type === TokenType::Comment)
                    )
                ) {
                    $lineEnded = true;
                }

                // Whitespaces are skipped because the formatter adds its own.
                continue;
            }

            if ($curr->type === TokenType::Comment && $this->options['remove_comments']) {
                // Skip Comments if option `remove_comments` is enabled
                continue;
            }

            // Checking if pointers were initialized.
            if ($prev !== null) {
                // Checking if a new clause started.
                if (static::isClause($prev) !== false) {

$prev of type null is incompatible with the type PhpMyAdmin\SqlParser\Token expected by parameter $token of PhpMyAdmin\SqlParser\Utils\Formatter::isClause().

                    $lastClause = $prev->value;
                    $formattedOptions = false;
                }

                // The options of a clause should stay on the same line and everything that follows.
                if (
                    $this->options['parts_newline']
                    && ! $formattedOptions
                    && empty(self::$inlineClauses[$lastClause])
                    && (
                        $curr->type !== TokenType::Keyword
                        || ($curr->flags & Token::FLAG_KEYWORD_FUNCTION)
                    )
                ) {
                    $formattedOptions = true;
                    $lineEnded = true;
                    ++$indent;
                }

                // Checking if this clause ended.
                $isClause = static::isClause($curr);

                if ($isClause !== false) {
                    if (
                        ($isClause === 2 || $this->options['clause_newline'])
                        && empty(self::$shortClauses[$lastClause])
                    ) {
                        $lineEnded = true;
                        if ($this->options['parts_newline'] && $indent > 0) {
                            --$indent;
                        }
                    }
                }

                // Inline JOINs
                if (
                    ($prev->type === TokenType::Keyword && isset(JoinKeyword::JOINS[$prev->value]))
                    || (in_array($curr->value, ['ON', 'USING'], true)
                        && isset(JoinKeyword::JOINS[$list->tokens[$list->idx - 2]->value]))
                    || isset($list->tokens[$list->idx - 4], JoinKeyword::JOINS[$list->tokens[$list->idx - 4]->value])
                    || isset($list->tokens[$list->idx - 6], JoinKeyword::JOINS[$list->tokens[$list->idx - 6]->value])
                ) {
                    $lineEnded = false;
                }

                // Indenting BEGIN ... END blocks.
                if ($prev->type === TokenType::Keyword && $prev->keyword === 'BEGIN') {
                    $lineEnded = true;
                    $blocksIndentation[] = $indent;
                    ++$indent;
                } elseif ($curr->type === TokenType::Keyword && $curr->keyword === 'END') {
                    $lineEnded = true;
                    $indent = array_pop($blocksIndentation);
                }

                // Formatting fragments delimited by comma.
                if ($prev->type === TokenType::Operator && $prev->value === ',') {
                    // Fragments delimited by a comma are broken into multiple
                    // pieces only if the clause is not inlined or this fragment
                    // is between brackets that are on new line.
                    if (
                        end($blocksLineEndings) === true
                        || (
                            empty(self::$inlineClauses[$lastClause])
                            && ! $shortGroup
                            && $this->options['parts_newline']
                        )
                    ) {
                        $lineEnded = true;
                    }
                }

                // Handling brackets.
                // Brackets are indented only if the length of the fragment between
                // them is longer than 30 characters.
                if ($prev->type === TokenType::Operator && $prev->value === '(') {
                    $blocksIndentation[] = $indent;
                    $shortGroup = true;
                    if (static::getGroupLength($list) > 30) {
                        ++$indent;
                        $lineEnded = true;
                        $shortGroup = false;
                    }

                    $blocksLineEndings[] = $lineEnded;
                } elseif ($curr->type === TokenType::Operator && $curr->value === ')') {
                    $indent = array_pop($blocksIndentation);
                    $lineEnded |= array_pop($blocksLineEndings);
                    $shortGroup = false;
                }

                // Adding the token.
                $ret .= $this->toString($prev);

$prev of type null is incompatible with the type PhpMyAdmin\SqlParser\Token expected by parameter $token of PhpMyAdmin\SqlParser\Utils\Formatter::toString().

                // Finishing the line.
                if ($lineEnded) {
                    $ret .= $this->options['line_ending'] . str_repeat($this->options['indentation'], (int) $indent);
                    $lineEnded = false;
                } elseif (
                    $prev->keyword === 'DELIMITER'
                    || ! (
                    ($prev->type === TokenType::Operator && ($prev->value === '.' || $prev->value === '('))
                    // No space after . (
                    || ($curr->type === TokenType::Operator
                        && ($curr->value === '.' || $curr->value === ','
                            || $curr->value === '(' || $curr->value === ')'))
                    // No space before . , ( )
                    || $curr->type === TokenType::Delimiter && mb_strlen((string) $curr->value, 'UTF-8') < 2
                    )
                ) {
                    // If the line ended, there is no point in adding whitespaces.
                    // Also, some tokens do not have spaces before or after them.
                    // A space after delimiters that are longer than 2 characters.
                    $ret .= ' ';
                }
            }

            // Iteration finished, consider current token as previous.
            $prev = $curr;
        }

        if ($this->options['type'] === 'cli') {
            return $ret . "\x1b[0m";
        }

        return $ret;
    }