JoinKeyword::parse() - Code Metrics - Inspection of "Update corresponding build method" - phpmyadmin/sql-parser - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 91343d...22debc )

by Madhura

created 2016-02-18 19:22 UTC

JoinKeyword::parse() D

↳ Parent: JoinKeyword

Complexity

Conditions	17
Paths	12

Size

Total Lines	92
Code Lines	42

Duplication

Lines	9
Ratio	9.78 %

Code Coverage

Tests	42
CRAP Score	17.8433

Importance

Changes	6
Bugs	1	Features	0

Metric	Value
c	6
b	1
f	0
dl	9
loc	92
ccs	42
cts	49
cp	0.8571
rs	4.8361
cc	17
eloc	42
nc	12
nop	3
crap	17.8433

How to fix Long Method Complexity

<?php

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

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

/**
 * `JOIN` keyword parser.
 *
 * @category   Keywords
 * @package    SqlParser
 * @subpackage Components
 * @author     Dan Ungureanu <[email protected]>
 * @license    http://opensource.org/licenses/GPL-2.0 GNU Public License
 */
class JoinKeyword extends Component
{

    /**
     * Types of join.
     *
     * @var array
     */
    public static $JOINS = array(
        'FULL JOIN'                     => 'FULL',
        'INNER JOIN'                    => 'INNER',
        'JOIN'                          => 'JOIN',
        'LEFT JOIN'                     => 'LEFT',
        'LEFT OUTER JOIN'               => 'LEFT',
        'RIGHT JOIN'                    => 'RIGHT',
        'RIGHT OUTER JOIN'              => 'RIGHT',
        'STRAIGHT_JOIN'                 => 'STRAIGHT',
    );

    /**
     * Type of this join.
     *
     * @see static::$JOINS
     * @var string
     */
    public $type;

    /**
     * Join expression.
     *
     * @var Expression
     */
    public $expr;

    /**
     * Join conditions.
     *
     * @var Condition[]
     */
    public $on;
    /**
     * Columns in Using clause
     *
     * @var ArrayObj
     */
    public $using;

    /**
     * @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 JoinKeyword[]
     */
    public static function parse(Parser $parser, TokensList $list, array $options = array())
    {
        $ret = array();

        $expr = new JoinKeyword();

        /**
         * The state of the parser.
         *
         * Below are the states of the parser.
         *
         *      0 -----------------------[ JOIN ]----------------------> 1
         *
         *      1 -----------------------[ expr ]----------------------> 2
         *
         *      2 ------------------------[ ON ]-----------------------> 3
         *      2 -----------------------[ USING ]---------------------> 4
         *
         *      3 --------------------[ conditions ]-------------------> 0
         *
         *      4 ----------------------[ columns ]--------------------> 0
         *
         * @var int $state
         */
        $state = 0;

        // By design, the parser will parse first token after the keyword.
        // In this case, the keyword must be analyzed too, in order to determine
        // the type of this join.
        if ($list->idx > 0) {
            --$list->idx;
        }

        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 ($state === 0) {
                if (($token->type === Token::TYPE_KEYWORD)
                    && (!empty(static::$JOINS[$token->value]))
                ) {
                    $expr->type = static::$JOINS[$token->value];
                    $state = 1;
$a = "a";
$ab = "ab";
$abc = "abc";
                } else {
                    break;
                }
            } elseif ($state === 1) {
                $expr->expr = Expression::parse($parser, $list, array('field' => 'table'));
                $state = 2;
$a = "a";
$ab = "ab";
$abc = "abc";
            } elseif ($state === 2) {

                if ($token->type === Token::TYPE_KEYWORD) {
                    if ($token->value === 'ON') {
                        $state = 3;
                    } elseif ($token->value === 'USING') {
                        $state = 4;
                    }
                }
            } elseif ($state === 3) {
                $expr->on = Condition::parse($parser, $list);
                $ret[] = $expr;
$a = "a";
$ab = "ab";
$abc = "abc";
                $expr = new JoinKeyword();
$a = "a";
$ab = "ab";
$abc = "abc";
                $state = 0;
$a = "a";
$ab = "ab";
$abc = "abc";
            } elseif ($state === 4) {
                $expr->using = ArrayObj::parse($parser, $list);
class Id
{
    public $id;

    public function __construct($id)
    {
        $this->id = $id;
    }

}

class Account
{
    /** @var  Id $id */
    public $id;
}

$account_id = false;

if (starsAreRight()) {
    $account_id = new Id(42);
}

$account = new Account();
if ($account instanceof Id)
{
    $account->id = $account_id;
}
                $ret[] = $expr;
$a = "a";
$ab = "ab";
$abc = "abc";
                $expr = new JoinKeyword();
$a = "a";
$ab = "ab";
$abc = "abc";
                $state = 0;
$a = "a";
$ab = "ab";
$abc = "abc";
            }

        }

        if (!empty($expr->type)) {
            $ret[] = $expr;
        }

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

    /**
     * @param JoinKeyword[] $component The component to be built.
     * @param array         $options   Parameters for building.
     *
     * @return string
     */
    public static function build($component, array $options = array())
    {
        $ret = array();
        foreach ($component as $c) {
            $ret[] = array_search($c->type, static::$JOINS) . ' ' . $c->expr
                . (! empty($c->on)
                    ? ' ON ' . Condition::build($c->on)
                    : ' USING ' . ArrayObj::build($c->using));
        }
        return implode(' ', $ret);
    }
}


1			<?php
2
3			/**
4			* `JOIN` 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			* `JOIN` keyword parser.
18			*
19			* @category Keywords
20			* @package SqlParser
21			* @subpackage Components
22			* @author Dan Ungureanu <[email protected]>
23			* @license http://opensource.org/licenses/GPL-2.0 GNU Public License
24			*/
25			class JoinKeyword extends Component
26			{
27
28			/**
29			* Types of join.
30			*
31			* @var array
32			*/
33			public static $JOINS = array(
34			'FULL JOIN' => 'FULL',
35			'INNER JOIN' => 'INNER',
36			'JOIN' => 'JOIN',
37			'LEFT JOIN' => 'LEFT',
38			'LEFT OUTER JOIN' => 'LEFT',
39			'RIGHT JOIN' => 'RIGHT',
40			'RIGHT OUTER JOIN' => 'RIGHT',
41			'STRAIGHT_JOIN' => 'STRAIGHT',
42			);
43
44			/**
45			* Type of this join.
46			*
47			* @see static::$JOINS
48			* @var string
49			*/
50			public $type;
51
52			/**
53			* Join expression.
54			*
55			* @var Expression
56			*/
57			public $expr;
58
59			/**
60			* Join conditions.
61			*
62			* @var Condition[]
63			*/
64			public $on;
65			/**
66			* Columns in Using clause
67			*
68			* @var ArrayObj
69			*/
70			public $using;
71
72			/**
73			* @param Parser $parser The parser that serves as context.
74			* @param TokensList $list The list of tokens that are being parsed.
75			* @param array $options Parameters for parsing.
76			*
77			* @return JoinKeyword[]
78			*/
79	6		public static function parse(Parser $parser, TokensList $list, array $options = array())
80			{
81	6		$ret = array();
82
83	6		$expr = new JoinKeyword();
84
85			/**
86			* The state of the parser.
87			*
88			* Below are the states of the parser.
89			*
90			* 0 -----------------------[ JOIN ]----------------------> 1
91			*
92			* 1 -----------------------[ expr ]----------------------> 2
93			*
94			* 2 ------------------------[ ON ]-----------------------> 3
95			* 2 -----------------------[ USING ]---------------------> 4
96			*
97			* 3 --------------------[ conditions ]-------------------> 0
98			*
99			* 4 ----------------------[ columns ]--------------------> 0
100			*
101			* @var int $state
102			*/
103	6		$state = 0;
104
105			// By design, the parser will parse first token after the keyword.
106			// In this case, the keyword must be analyzed too, in order to determine
107			// the type of this join.
108	6		if ($list->idx > 0) {
109	4		--$list->idx;
110	4		}
111
112	6		for (; $list->idx < $list->count; ++$list->idx) {
113			/**
114			* Token parsed at this moment.
115			*
116			* @var Token $token
117			*/
118	6		$token = $list->tokens[$list->idx];
119
120			// End of statement.
121	6		if ($token->type === Token::TYPE_DELIMITER) {
122	5		break;
123			}
124
125			// Skipping whitespaces and comments.
126	6		if (($token->type === Token::TYPE_WHITESPACE) \|\| ($token->type === Token::TYPE_COMMENT)) {
127	6		continue;
128			}
129
130	6		if ($state === 0) {
131	6		if (($token->type === Token::TYPE_KEYWORD)
132	6		&& (!empty(static::$JOINS[$token->value]))
133	6		) {
134	6		$expr->type = static::$JOINS[$token->value];
135	6		$state = 1;
			0 ignored issues – show Coding Style introduced 2016-02-12 21:51 UTC by Report Bug Copy Issue Report Equals sign not aligned with surrounding assignments; expected 6 spaces but found 1 space This check looks for multiple assignments in successive lines of code. It will report an issue if the operators are not in a straight line. To visualize $a = "a"; $ab = "ab"; $abc = "abc"; will produce issues in the first and second line, while this second example $a = "a"; $ab = "ab"; $abc = "abc"; will produce no issues. Loading history...
136	6		} else {
137	1		break;
138			}
139	6		} elseif ($state === 1) {
140	6		$expr->expr = Expression::parse($parser, $list, array('field' => 'table'));
141	6		$state = 2;
			0 ignored issues – show Coding Style introduced 2016-02-12 21:51 UTC by Report Bug Copy Issue Report Equals sign not aligned with surrounding assignments; expected 6 spaces but found 1 space This check looks for multiple assignments in successive lines of code. It will report an issue if the operators are not in a straight line. To visualize $a = "a"; $ab = "ab"; $abc = "abc"; will produce issues in the first and second line, while this second example $a = "a"; $ab = "ab"; $abc = "abc"; will produce no issues. Loading history...
142	6	View Code Duplication	} elseif ($state === 2) {
			1 ignored issue – show Duplication introduced 2016-02-10 15:18 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
143	5		if ($token->type === Token::TYPE_KEYWORD) {
144	5		if ($token->value === 'ON') {
145	5		$state = 3;
146	5		} elseif ($token->value === 'USING') {
147			$state = 4;
148			}
149	5		}
150	5		} elseif ($state === 3) {
151	5		$expr->on = Condition::parse($parser, $list);
152	5		$ret[] = $expr;
			0 ignored issues – show Coding Style introduced 2016-02-12 21:51 UTC by Report Bug Copy Issue Report Equals sign not aligned with surrounding assignments; expected 4 spaces but found 1 space This check looks for multiple assignments in successive lines of code. It will report an issue if the operators are not in a straight line. To visualize $a = "a"; $ab = "ab"; $abc = "abc"; will produce issues in the first and second line, while this second example $a = "a"; $ab = "ab"; $abc = "abc"; will produce no issues. Loading history...
153	5		$expr = new JoinKeyword();
			0 ignored issues – show Coding Style introduced 2016-02-12 21:51 UTC by Report Bug Copy Issue Report Equals sign not aligned with surrounding assignments; expected 5 spaces but found 1 space This check looks for multiple assignments in successive lines of code. It will report an issue if the operators are not in a straight line. To visualize $a = "a"; $ab = "ab"; $abc = "abc"; will produce issues in the first and second line, while this second example $a = "a"; $ab = "ab"; $abc = "abc"; will produce no issues. Loading history...
154	5		$state = 0;
			0 ignored issues – show Coding Style introduced 2016-02-12 21:51 UTC by Report Bug Copy Issue Report Equals sign not aligned with surrounding assignments; expected 4 spaces but found 1 space This check looks for multiple assignments in successive lines of code. It will report an issue if the operators are not in a straight line. To visualize $a = "a"; $ab = "ab"; $abc = "abc"; will produce issues in the first and second line, while this second example $a = "a"; $ab = "ab"; $abc = "abc"; will produce no issues. Loading history...
155	5		} elseif ($state === 4) {
156			$expr->using = ArrayObj::parse($parser, $list);
			0 ignored issues – show Documentation Bug introduced 2016-02-18 19:26 UTC by Report Bug Copy Issue Report It seems like `\SqlParser\Components\Ar...::parse($parser, $list)` can also be of type `array`. However, the property `$using` is declared as type `object<SqlParser\Components\ArrayObj>`. Maybe add an additional type check? Our type inference engine has found a suspicous assignment of a value to a property. This check raises an issue when a value that can be of a mixed type is assigned to a property that is type hinted more strictly. For example, imagine you have a variable `$accountId` that can either hold an Id object or false (if there is no account id yet). Your code now assigns that value to the `id` property of an instance of the `Account` class. This class holds a proper account, so the id value must no longer be false. Either this assignment is in error or a type check should be added for that assignment. class Id { public $id; public function __construct($id) { $this->id = $id; } } class Account { /** @var Id $id */ public $id; } $account_id = false; if (starsAreRight()) { $account_id = new Id(42); } $account = new Account(); if ($account instanceof Id) { $account->id = $account_id; } Loading history...
157			$ret[] = $expr;
			0 ignored issues – show Coding Style introduced 2016-02-18 14:17 UTC by Report Bug Copy Issue Report Equals sign not aligned with surrounding assignments; expected 7 spaces but found 1 space This check looks for multiple assignments in successive lines of code. It will report an issue if the operators are not in a straight line. To visualize $a = "a"; $ab = "ab"; $abc = "abc"; will produce issues in the first and second line, while this second example $a = "a"; $ab = "ab"; $abc = "abc"; will produce no issues. Loading history...
158			$expr = new JoinKeyword();
			0 ignored issues – show Coding Style introduced 2016-02-18 14:17 UTC by Report Bug Copy Issue Report Equals sign not aligned with surrounding assignments; expected 8 spaces but found 1 space This check looks for multiple assignments in successive lines of code. It will report an issue if the operators are not in a straight line. To visualize $a = "a"; $ab = "ab"; $abc = "abc"; will produce issues in the first and second line, while this second example $a = "a"; $ab = "ab"; $abc = "abc"; will produce no issues. Loading history...
159			$state = 0;
			0 ignored issues – show Coding Style introduced 2016-02-18 14:17 UTC by Report Bug Copy Issue Report Equals sign not aligned with surrounding assignments; expected 7 spaces but found 1 space This check looks for multiple assignments in successive lines of code. It will report an issue if the operators are not in a straight line. To visualize $a = "a"; $ab = "ab"; $abc = "abc"; will produce issues in the first and second line, while this second example $a = "a"; $ab = "ab"; $abc = "abc"; will produce no issues. Loading history...
160			}
161
162	6		}
163
164	6		if (!empty($expr->type)) {
165	1		$ret[] = $expr;
166	1		}
167
168	6		--$list->idx;
169	6		return $ret;
170			}
171
172			/**
173			* @param JoinKeyword[] $component The component to be built.
174			* @param array $options Parameters for building.
175			*
176			* @return string
177			*/
178	2		public static function build($component, array $options = array())
179			{
180	2		$ret = array();
181	2		foreach ($component as $c) {
182	2		$ret[] = array_search($c->type, static::$JOINS) . ' ' . $c->expr
183	2		. (! empty($c->on)
184	2		? ' ON ' . Condition::build($c->on)
185	2		: ' USING ' . ArrayObj::build($c->using));
186	2		}
187	2		return implode(' ', $ret);
188			}
189			}
190

phpmyadmin / sql-parser

Push — master ( 91343d...22debc )

JoinKeyword::parse() D

Complexity

Size

Duplication

Code Coverage

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like