PhpMyAdmin\SqlParser\Components\AlterOperation::parse()

Complexity

Conditions	33
Paths	20

Size

Total Lines	157
Code Lines	71

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	67
CRAP Score	33.0034

Importance

Changes	2
Bugs	0	Features	0

<?php
    public static function parse(Parser $parser, TokensList $list, array $options = [])

Method \PhpMyAdmin\SqlParser\Components\AlterOperation::parse() does not have native return type hint for its return value but it should be possible to add it based on @return annotation "AlterOperation".

    {
        $ret = new static();

        /**
         * Counts brackets.
         *
         * @var int
         */
        $brackets = 0;

        /**
         * The state of the parser.
         *
         * Below are the states of the parser.
         *
         *      0 ---------------------[ options ]---------------------> 1
         *
         *      1 ----------------------[ field ]----------------------> 2
         *
         *      2 -------------------------[ , ]-----------------------> 0
         *
         * @var int
         */
        $state = 0;

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

            // End of statement.
            if ($token->type === Token::TYPE_DELIMITER) {
                break;
            }

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

            // Skipping whitespaces.
            if ($token->type === Token::TYPE_WHITESPACE) {
                if ($state === 2) {
                    // When parsing the unknown part, the whitespaces are
                    // included to not break anything.
                    $ret->unknown[] = $token;
                }

                continue;
            }

            if ($state === 0) {
                $ret->options = OptionsArray::parse($parser, $list, $options);

                if ($ret->options->has('AS')) {
                    for (; $list->idx < $list->count; ++$list->idx) {
                        if ($list->tokens[$list->idx]->type === Token::TYPE_DELIMITER) {
                            break;
                        }

                        $ret->unknown[] = $list->tokens[$list->idx];
                    }

                    break;
                }

                $state = 1;
            } elseif ($state === 1) {
                $ret->field = Expression::parse(
                    $parser,
                    $list,
                    [
                        'breakOnAlias' => true,

This array key does not seem to be aligned correctly; expected 21 spaces, but found 24.

                        'parseField' => 'column',

This array key does not seem to be aligned correctly; expected 21 spaces, but found 24.

Array double arrow not aligned correctly; expected 3 space(s) but found 1

                    ]
                );
                if ($ret->field === null) {

Expected 1 line before "if", found 0.

                    // No field was read. We go back one token so the next
                    // iteration will parse the same token, but in state 2.
                    --$list->idx;
                }

                $state = 2;
            } elseif ($state === 2) {
                $arrayKey = '';
                if (is_string($token->value) || is_numeric($token->value)) {

Expected 1 line before "if", found 0.

                    $arrayKey = $token->value;
                } else {
                    $arrayKey = $token->token;
                }

                if ($token->type === Token::TYPE_OPERATOR) {
                    if ($token->value === '(') {
                        ++$brackets;
                    } elseif ($token->value === ')') {
                        --$brackets;
                    } elseif (($token->value === ',') && ($brackets === 0)) {
                        break;
                    }
                } elseif (! self::checkIfTokenQuotedSymbol($token)) {
                    if (! empty(Parser::$STATEMENT_PARSERS[$token->value])) {

Member variable "$STATEMENT_PARSERS" is not in valid camel caps format

                        // We want to get the next non-comment and non-space token after $token
                        // therefore, the first getNext call will start with the current $idx which's $token,
                        // will return it and increase $idx by 1, which's not guaranteed to be non-comment
                        // and non-space, that's why we're calling getNext again.
                        // In order to get back to the original value of idx, we kept it in $currentID

                        $currentTokenID = $list->idx;
                        $list->getNext();
                        $nextToken = $list->getNext();

                        if ($token->value === 'CHARACTER SET') {
                            // Reverting the changes we made in the beginning
                            $list->idx = $currentTokenID;
                        } else if ($token->value === 'SET' && $nextToken !== null && $nextToken->value === '(') {

Expected 1 line before "if", found -1.

                            // To avoid adding the tokens between the SET() parentheses to the unknown tokens
                            $list->getNextOfTypeAndValue(Token::TYPE_OPERATOR, ')');
                        } else if ($token->value === 'SET' && $nextToken !== null && $nextToken->value === 'DEFAULT') {

Expected 1 line before "if", found -1.

Expected 0 lines after "if", found 1.

                            // to avoid adding the `DEFAULT` token to the unknown tokens.
                            ++$list->idx;
                        } else {

Use early exit instead of "else".

                            // We have reached the end of ALTER operation and suddenly found
                            // a start to new statement, but have not find a delimiter between them
                            $parser->error(
                                'A new statement was found, but no delimiter between it and the previous one.',
                                $token
                            );
                            break;
                        }

Blank line found after control structure

Blank line found at end of control structure

                    } elseif (

Expected 0 spaces after opening bracket; newline found

                        (array_key_exists($arrayKey, self::$DB_OPTIONS)
                        || array_key_exists($arrayKey, self::$TABLE_OPTIONS))
                        && ! self::checkIfColumnDefinitionKeyword($arrayKey)
                    ) {
                        // This alter operation has finished, which means a comma
                        // was missing before start of new alter operation
                        $parser->error('Missing comma before start of a new alter operation.', $token);
                        break;
                    }
                }

                $ret->unknown[] = $token;
            }
        }

        if ($ret->options->isEmpty()) {
            $parser->error('Unrecognized alter operation.', $list->tokens[$list->idx]);
        }

        --$list->idx;

        return $ret;
    }