JoinKeyword::parse() - Code Metrics - Inspection of "JoinKeyword: Added tests." - phpmyadmin/sql-parser - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 802733...f10121 )

by Dan

created 2016-02-21 16:43 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	49
CRAP Score	17

Importance

Changes	6
Bugs	1	Features	0

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

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;
                } else {
                    break;
                }
            } elseif ($state === 1) {
                $expr->expr = Expression::parse($parser, $list, array('field' => 'table'));
                $state = 2;
            } 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;
                $expr = new JoinKeyword();
                $state = 0;
            } 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;
                $expr = new JoinKeyword();
                $state = 0;
            }

        }

        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			/**
67			* Columns in Using clause
68			*
69			* @var ArrayObj
70			*/
71			public $using;
72
73			/**
74			* @param Parser $parser The parser that serves as context.
75			* @param TokensList $list The list of tokens that are being parsed.
76			* @param array $options Parameters for parsing.
77			*
78			* @return JoinKeyword[]
79			*/
80	7		public static function parse(Parser $parser, TokensList $list, array $options = array())
81			{
82	7		$ret = array();
83
84	7		$expr = new JoinKeyword();
85
86			/**
87			* The state of the parser.
88			*
89			* Below are the states of the parser.
90			*
91			* 0 -----------------------[ JOIN ]----------------------> 1
92			*
93			* 1 -----------------------[ expr ]----------------------> 2
94			*
95			* 2 ------------------------[ ON ]-----------------------> 3
96			* 2 -----------------------[ USING ]---------------------> 4
97			*
98			* 3 --------------------[ conditions ]-------------------> 0
99			*
100			* 4 ----------------------[ columns ]--------------------> 0
101			*
102			* @var int $state
103			*/
104	7		$state = 0;
105
106			// By design, the parser will parse first token after the keyword.
107			// In this case, the keyword must be analyzed too, in order to determine
108			// the type of this join.
109	7		if ($list->idx > 0) {
110	4		--$list->idx;
111	4		}
112
113	7		for (; $list->idx < $list->count; ++$list->idx) {
114			/**
115			* Token parsed at this moment.
116			*
117			* @var Token $token
118			*/
119	7		$token = $list->tokens[$list->idx];
120
121			// End of statement.
122	7		if ($token->type === Token::TYPE_DELIMITER) {
123	6		break;
124			}
125
126			// Skipping whitespaces and comments.
127	7		if (($token->type === Token::TYPE_WHITESPACE) \|\| ($token->type === Token::TYPE_COMMENT)) {
128	7		continue;
129			}
130
131	7		if ($state === 0) {
132	7		if (($token->type === Token::TYPE_KEYWORD)
133	7		&& (!empty(static::$JOINS[$token->value]))
134	7		) {
135	7		$expr->type = static::$JOINS[$token->value];
136	7		$state = 1;
137	7		} else {
138	1		break;
139			}
140	7		} elseif ($state === 1) {
141	7		$expr->expr = Expression::parse($parser, $list, array('field' => 'table'));
142	7		$state = 2;
143	7	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...
144	6		if ($token->type === Token::TYPE_KEYWORD) {
145	6		if ($token->value === 'ON') {
146	5		$state = 3;
147	6		} elseif ($token->value === 'USING') {
148	1		$state = 4;
149	1		}
150	6		}
151	6		} elseif ($state === 3) {
152	5		$expr->on = Condition::parse($parser, $list);
153	5		$ret[] = $expr;
154	5		$expr = new JoinKeyword();
155	5		$state = 0;
156	6		} elseif ($state === 4) {
157	1		$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...
158	1		$ret[] = $expr;
159	1		$expr = new JoinKeyword();
160	1		$state = 0;
161	1		}
162
163	7		}
164
165	7		if (!empty($expr->type)) {
166	1		$ret[] = $expr;
167	1		}
168
169	7		--$list->idx;
170	7		return $ret;
171			}
172
173			/**
174			* @param JoinKeyword[] $component The component to be built.
175			* @param array $options Parameters for building.
176			*
177			* @return string
178			*/
179	2		public static function build($component, array $options = array())
180			{
181	2		$ret = array();
182	2		foreach ($component as $c) {
183	2		$ret[] = array_search($c->type, static::$JOINS) . ' ' . $c->expr
184	2		. (!empty($c->on)
185	2		? ' ON ' . Condition::build($c->on)
186	2		: ' USING ' . ArrayObj::build($c->using));
187	2		}
188	2		return implode(' ', $ret);
189			}
190			}
191

phpmyadmin / sql-parser

Push — master ( 802733...f10121 )

JoinKeyword::parse() D

Complexity

Size

Duplication

Code Coverage

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like