IntoKeyword::parse() - Code Metrics - Inspection of "Fix parsing of subquery in FROM clause" - phpmyadmin/sql-parser - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#90)

by Deven

created 2016-09-28 06:16 UTC

IntoKeyword::parse() D

↳ Parent: IntoKeyword

Complexity

Conditions	18
Paths	6

Size

Total Lines	83
Code Lines	40

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	39
CRAP Score	18

Importance

Changes

Metric	Value
cc	18
eloc	40
nc	6
nop	3
dl	0
loc	83
ccs	39
cts	39
cp	1
crap	18
rs	4.8829
c	0
b	0
f	0

How to fix Long Method Complexity

<?php

/**
 * `INTO` keyword parser.
 *
 * @package    SqlParser
 * @subpackage Components
 */
namespace SqlParser\Components;

use SqlParser\Component;
use SqlParser\Parser;
use SqlParser\Token;
use SqlParser\TokensList;

/**
 * `INTO` keyword parser.
 *
 * @category   Keywords
 * @package    SqlParser
 * @subpackage Components
 * @license    https://www.gnu.org/licenses/gpl-2.0.txt GPL-2.0+
 */
class IntoKeyword extends Component
{

    /**
     * Type of target (OUTFILE or SYMBOL).
     *
     * @var string
     */
    public $type;

    /**
     * The destination, which can be a table or a file.
     *
     * @var string|Expression
     */
    public $dest;

    /**
     * The name of the columns.
     *
     * @var array
     */
    public $columns;

    /**
     * The values to be selected into (SELECT .. INTO @var1)
     *
     * @var ExpressionArray
     */
    public $values;

    /**
     * @param Parser     $parser  The parser that serves as context.
     * @param TokensList $list    The list of tokens that are being parsed.
     * @param array      $options Parameters for parsing.
     *
     * @return IntoKeyword
     */
    public static function parse(Parser $parser, TokensList $list, array $options = array())
    {
        $ret = new IntoKeyword();

        /**
         * The state of the parser.
         *
         * Below are the states of the parser.
         *
         *      0 -----------------------[ name ]----------------------> 1
         *      0 ---------------------[ OUTFILE ]---------------------> 2
         *
         *      1 ------------------------[ ( ]------------------------> (END)
         *
         *      2 ---------------------[ filename ]--------------------> 1
         *
         * @var int $state
         */
        $state = 0;

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

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

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

            if (($token->type === Token::TYPE_KEYWORD) && ($token->flags & Token::FLAG_KEYWORD_RESERVED)) {
                if (($state === 0) && ($token->value === 'OUTFILE')) {
                    $ret->type = 'OUTFILE';
                    $state = 2;
                    continue;
                }

                // No other keyword is expected.
                break;
            }

            if ($state === 0) {
                if ((isset($options['fromInsert'])
                    && $options['fromInsert'])
                    || (isset($options['fromReplace'])
                    && $options['fromReplace'])
                ) {
                    $ret->dest = Expression::parse(
                        $parser,
                        $list,
                        array(
                            'parseField' => 'table',
                            'breakOnAlias' => true,
                        )
                    );
                } else {
                    $ret->values = ExpressionArray::parse($parser, $list);

                }
                $state = 1;
            } elseif ($state === 1) {
                if (($token->type === Token::TYPE_OPERATOR) && ($token->value === '(')) {
                    $ret->columns = ArrayObj::parse($parser, $list)->values;
                    ++$list->idx;
                }
                break;
            } elseif ($state === 2) {
                $ret->dest = $token->value;
                ++$list->idx;
                break;
            }
        }

        --$list->idx;
        return $ret;
    }

    /**
     * @param IntoKeyword $component The component to be built.
     * @param array       $options   Parameters for building.
     *
     * @return string
     */
    public static function build($component, array $options = array())
    {
        if ($component->dest instanceof Expression) {
            $columns = !empty($component->columns) ?
                '(`' . implode('`, `', $component->columns) . '`)' : '';
            return $component->dest . $columns;
        } elseif (isset($component->values)) {
            return ExpressionArray::build($component->values);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        } else {
            return 'OUTFILE "' . $component->dest . '"';
        }
    }
}

1		<?php
2
3		/**
4		* `INTO` keyword parser.
5		*
6		* @package SqlParser
7		* @subpackage Components
8		*/
9		namespace SqlParser\Components;
10
11		use SqlParser\Component;
12		use SqlParser\Parser;
13		use SqlParser\Token;
14		use SqlParser\TokensList;
15
16		/**
17		* `INTO` keyword parser.
18		*
19		* @category Keywords
20		* @package SqlParser
21		* @subpackage Components
22		* @license https://www.gnu.org/licenses/gpl-2.0.txt GPL-2.0+
23		*/
24		class IntoKeyword extends Component
25		{
26
27		/**
28		* Type of target (OUTFILE or SYMBOL).
29		*
30		* @var string
31		*/
32		public $type;
33
34		/**
35		* The destination, which can be a table or a file.
36		*
37		* @var string\|Expression
38		*/
39		public $dest;
40
41		/**
42		* The name of the columns.
43		*
44		* @var array
45		*/
46		public $columns;
47
48		/**
49		* The values to be selected into (SELECT .. INTO @var1)
50		*
51		* @var ExpressionArray
52		*/
53		public $values;
54
55		/**
56	15	* @param Parser $parser The parser that serves as context.
57		* @param TokensList $list The list of tokens that are being parsed.
58	15	* @param array $options Parameters for parsing.
59		*
60		* @return IntoKeyword
61		*/
62		public static function parse(Parser $parser, TokensList $list, array $options = array())
63		{
64		$ret = new IntoKeyword();
65
66		/**
67		* The state of the parser.
68		*
69		* Below are the states of the parser.
70		*
71		* 0 -----------------------[ name ]----------------------> 1
72		* 0 ---------------------[ OUTFILE ]---------------------> 2
73		*
74	15	* 1 ------------------------[ ( ]------------------------> (END)
75		*
76	15	* 2 ---------------------[ filename ]--------------------> 1
77		*
78		* @var int $state
79		*/
80		$state = 0;
81
82	15	for (; $list->idx < $list->count; ++$list->idx) {
83		/**
84		* Token parsed at this moment.
85	15	*
86	1	* @var Token $token
87		*/
88		$token = $list->tokens[$list->idx];
89
90	15	// End of statement.
91	13	if ($token->type === Token::TYPE_DELIMITER) {
92		break;
93		}
94	15
95	9	// Skipping whitespaces and comments.
96	6	if (($token->type === Token::TYPE_WHITESPACE) \|\| ($token->type === Token::TYPE_COMMENT)) {
97	6	continue;
98	6	}
99
100		if (($token->type === Token::TYPE_KEYWORD) && ($token->flags & Token::FLAG_KEYWORD_RESERVED)) {
101		if (($state === 0) && ($token->value === 'OUTFILE')) {
102	3	$ret->type = 'OUTFILE';
103		$state = 2;
104		continue;
105	14	}
106	9
107	9	// No other keyword is expected.
108	9	break;
109		}
110	9
111	9	if ($state === 0) {
112		if ((isset($options['fromInsert'])
113	9	&& $options['fromInsert'])
114	9	\|\| (isset($options['fromReplace'])
115	14	&& $options['fromReplace'])
116	6	) {
117	6	$ret->dest = Expression::parse(
118	6	$parser,
119	6	$list,
120	6	array(
121	5	'parseField' => 'table',
122	5	'breakOnAlias' => true,
123	5	)
124	5	);
125		} else {
126	9	$ret->values = ExpressionArray::parse($parser, $list);
		0 ignored issues – show Documentation Bug introduced 2016-09-28 08:00 UTC by Report Bug Copy Issue Report It seems like `\SqlParser\Components\Ex...::parse($parser, $list)` of type `array<integer,object<Sql...Components\Expression>>` is incompatible with the declared type `object<SqlParser\Components\ExpressionArray>` of property `$values`. Our type inference engine has found an assignment to a property that is incompatible with the declared type of that property. Either this assignment is in error or the assigned type should be added to the documentation/type hint for that property.. Loading history...
127		}
128	15	$state = 1;
129	15	} elseif ($state === 1) {
130		if (($token->type === Token::TYPE_OPERATOR) && ($token->value === '(')) {
131		$ret->columns = ArrayObj::parse($parser, $list)->values;
132		++$list->idx;
133		}
134		break;
135		} elseif ($state === 2) {
136		$ret->dest = $token->value;
137		++$list->idx;
138	3	break;
139		}
140	3	}
141	2
142	2	--$list->idx;
143	2	return $ret;
144		}
145	1
146		/**
147		* @param IntoKeyword $component The component to be built.
148		* @param array $options Parameters for building.
149		*
150		* @return string
151		*/
152		public static function build($component, array $options = array())
153		{
154		if ($component->dest instanceof Expression) {
155		$columns = !empty($component->columns) ?
156		'(`' . implode('`, `', $component->columns) . '`)' : '';
157		return $component->dest . $columns;
158		} elseif (isset($component->values)) {
159		return ExpressionArray::build($component->values);
		0 ignored issues – show Documentation introduced 2016-09-28 08:00 UTC by Report Bug Copy Issue Report `$component->values` is of type `object<SqlParser\Components\ExpressionArray>`, but the function expects a `array<integer,object<Sql...Components\Expression>>`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
160		} else {
161		return 'OUTFILE "' . $component->dest . '"';
162		}
163		}
164		}

phpmyadmin / sql-parser

Pull Request — master (#90)

IntoKeyword::parse() D

Complexity

Size

Duplication

Code Coverage

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like