Condition::build() - Code Metrics - Inspection of "Properly handle brackets in expression" - phpmyadmin/sql-parser - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 8956cf...1ecd61 )

by Michal

created 2016-03-18 11:05 UTC

Condition::build() A

↳ Parent: Condition

Complexity

Conditions	2
Paths	2

Size

Total Lines	8
Code Lines	5

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	4
CRAP Score	2

Importance

Changes	2
Bugs	2	Features	0

Metric	Value
c	2
b	2
f	0
dl	0
loc	8
ccs	4
cts	4
cp	1
rs	9.4285
cc	2
eloc	5
nc	2
nop	2
crap	2

<?php

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

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

/**
 * `WHERE` 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 Condition extends Component
{

    /**
     * Logical operators that can be used to delimit expressions.
     *
     * @var array
     */
    public static $DELIMITERS = array('&&', '||', 'AND', 'OR', 'XOR');

    /**
     * List of allowed reserved keywords in conditions.
     *
     * @var array
     */
    public static $ALLOWED_KEYWORDS = array(
        'ALL'                           => 1,
        'AND'                           => 1,
        'BETWEEN'                       => 1,
        'EXISTS'                        => 1,
        'IF'                            => 1,
        'IN'                            => 1,
        'INTERVAL'                      => 1,
        'IS'                            => 1,
        'LIKE'                          => 1,
        'MATCH'                         => 1,
        'NOT IN'                        => 1,
        'NOT NULL'                      => 1,
        'NOT'                           => 1,
        'NULL'                          => 1,
        'OR'                            => 1,
        'XOR'                           => 1,
    );

    /**
     * Identifiers recognized.
     *
     * @var array
     */
    public $identifiers = array();

    /**
     * Whether this component is an operator.
     *
     * @var bool
     */
    public $isOperator = false;

    /**
     * The condition.
     *
     * @var string
     */
    public $expr;

    /**
     * Constructor.
     *
     * @param string $expr The condition or the operator.

     */
    public function __construct($expr = null)
    {
        $this->expr = trim($expr);
    }

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

        $expr = new Condition();

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

        /**
         * Whether there was a `BETWEEN` keyword before or not.
         *
         * It is required to keep track of them because their structure contains
         * the keyword `AND`, which is also an operator that delimits
         * expressions.
         *
         * @var bool $betweenBefore
         */
        $betweenBefore = false;

        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_COMMENT) {
                continue;
            }

            // Replacing all whitespaces (new lines, tabs, etc.) with a single
            // space character.
            if ($token->type === Token::TYPE_WHITESPACE) {
                $expr->expr .= ' ';
                continue;
            }

            // Conditions are delimited by logical operators.
            if (in_array($token->value, static::$DELIMITERS, true)) {
                if (($betweenBefore) && ($token->value === 'AND')) {
                    // The syntax of keyword `BETWEEN` is hard-coded.
                    $betweenBefore = false;
                } else {
                    // The expression ended.
                    $expr->expr = trim($expr->expr);
                    if (!empty($expr->expr)) {
                        $ret[] = $expr;
                    }

                    // Adding the operator.
                    $expr = new Condition($token->value);
                    $expr->isOperator = true;
                    $ret[] = $expr;

                    // Preparing to parse another condition.
                    $expr = new Condition();
                    continue;
                }
            }

            if (($token->type === Token::TYPE_KEYWORD)
                && ($token->flags & Token::FLAG_KEYWORD_RESERVED)
                && !($token->flags & Token::FLAG_KEYWORD_FUNCTION)
            ) {
                if ($token->value === 'BETWEEN') {
                    $betweenBefore = true;
                }
                if (($brackets === 0) && (empty(static::$ALLOWED_KEYWORDS[$token->value]))) {
                    break;
                }
            }

            if ($token->type === Token::TYPE_OPERATOR) {
                if ($token->value === '(') {
                    ++$brackets;
                } elseif ($token->value === ')') {
                    if ($brackets == 0) {
                        break;
                    }
                    --$brackets;
                }
            }

            $expr->expr .= $token->token;
            if (($token->type === Token::TYPE_NONE)
                || (($token->type === Token::TYPE_KEYWORD)
                && (!($token->flags & Token::FLAG_KEYWORD_RESERVED)))
                || ($token->type === Token::TYPE_STRING)
                || ($token->type === Token::TYPE_SYMBOL)
            ) {
                if (!in_array($token->value, $expr->identifiers)) {
                    $expr->identifiers[] = $token->value;
                }
            }
        }

        // Last iteration was not processed.
        $expr->expr = trim($expr->expr);
        if (!empty($expr->expr)) {
            $ret[] = $expr;
        }

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

    /**
     * @param Condition[] $component The component to be built.
     * @param array       $options   Parameters for building.
     *
     * @return string
     */
    public static function build($component, array $options = array())
    {
        if (is_array($component)) {
            return implode(' ', $component);
        } else {
            return $component->expr;
        }
    }
}


1			<?php
2
3			/**
4			* `WHERE` 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			* `WHERE` 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 Condition extends Component
26			{
27
28			/**
29			* Logical operators that can be used to delimit expressions.
30			*
31			* @var array
32			*/
33			public static $DELIMITERS = array('&&', '\|\|', 'AND', 'OR', 'XOR');
34
35			/**
36			* List of allowed reserved keywords in conditions.
37			*
38			* @var array
39			*/
40			public static $ALLOWED_KEYWORDS = array(
41			'ALL' => 1,
42			'AND' => 1,
43			'BETWEEN' => 1,
44			'EXISTS' => 1,
45			'IF' => 1,
46			'IN' => 1,
47			'INTERVAL' => 1,
48			'IS' => 1,
49			'LIKE' => 1,
50			'MATCH' => 1,
51			'NOT IN' => 1,
52			'NOT NULL' => 1,
53			'NOT' => 1,
54			'NULL' => 1,
55			'OR' => 1,
56			'XOR' => 1,
57			);
58
59			/**
60			* Identifiers recognized.
61			*
62			* @var array
63			*/
64			public $identifiers = array();
65
66			/**
67			* Whether this component is an operator.
68			*
69			* @var bool
70			*/
71			public $isOperator = false;
72
73			/**
74			* The condition.
75			*
76			* @var string
77			*/
78			public $expr;
79
80			/**
81			* Constructor.
82			*
83			* @param string $expr The condition or the operator.
			0 ignored issues – show Documentation introduced 2016-02-12 21:51 UTC by Report Bug Copy Issue Report Should the type for parameter `$expr` not be `string\|null`? This check looks for `@param` annotations where the type inferred by our type inference engine differs from the declared type. It makes a suggestion as to what type it considers more descriptive. Most often this is a case of a parameter that can be null in addition to its declared types. Loading history...
84			*/
85	23		public function __construct($expr = null)
86			{
87	23		$this->expr = trim($expr);
88	23		}
89
90			/**
91			* @param Parser $parser The parser that serves as context.
92			* @param TokensList $list The list of tokens that are being parsed.
93			* @param array $options Parameters for parsing.
94			*
95			* @return Condition[]
96			*/
97	22		public static function parse(Parser $parser, TokensList $list, array $options = array())
98			{
99	22		$ret = array();
100
101	22		$expr = new Condition();
102
103			/**
104			* Counts brackets.
105			*
106			* @var int $brackets
107			*/
108	22		$brackets = 0;
109
110			/**
111			* Whether there was a `BETWEEN` keyword before or not.
112			*
113			* It is required to keep track of them because their structure contains
114			* the keyword `AND`, which is also an operator that delimits
115			* expressions.
116			*
117			* @var bool $betweenBefore
118			*/
119	22		$betweenBefore = false;
120
121	22		for (; $list->idx < $list->count; ++$list->idx) {
122
123			/**
124			* Token parsed at this moment.
125			*
126			* @var Token $token
127			*/
128	22		$token = $list->tokens[$list->idx];
129
130			// End of statement.
131	22		if ($token->type === Token::TYPE_DELIMITER) {
132	14		break;
133			}
134
135			// Skipping whitespaces and comments.
136	22		if ($token->type === Token::TYPE_COMMENT) {
137	2		continue;
138			}
139
140			// Replacing all whitespaces (new lines, tabs, etc.) with a single
141			// space character.
142	22		if ($token->type === Token::TYPE_WHITESPACE) {
143	21		$expr->expr .= ' ';
144	21		continue;
145			}
146
147			// Conditions are delimited by logical operators.
148	22		if (in_array($token->value, static::$DELIMITERS, true)) {
149	6		if (($betweenBefore) && ($token->value === 'AND')) {
150			// The syntax of keyword `BETWEEN` is hard-coded.
151	1		$betweenBefore = false;
152	1		} else {
153			// The expression ended.
154	6		$expr->expr = trim($expr->expr);
155	6		if (!empty($expr->expr)) {
156	6		$ret[] = $expr;
157	6		}
158
159			// Adding the operator.
160	6		$expr = new Condition($token->value);
161	6		$expr->isOperator = true;
162	6		$ret[] = $expr;
163
164			// Preparing to parse another condition.
165	6		$expr = new Condition();
166	6		continue;
167			}
168	1		}
169
170	22		if (($token->type === Token::TYPE_KEYWORD)
171	22		&& ($token->flags & Token::FLAG_KEYWORD_RESERVED)
172	22		&& !($token->flags & Token::FLAG_KEYWORD_FUNCTION)
173	22		) {
174	11		if ($token->value === 'BETWEEN') {
175	1		$betweenBefore = true;
176	1		}
177	11		if (($brackets === 0) && (empty(static::$ALLOWED_KEYWORDS[$token->value]))) {
178	9		break;
179			}
180	3		}
181
182	21	View Code Duplication	if ($token->type === Token::TYPE_OPERATOR) {
183	21		if ($token->value === '(') {
184	6		++$brackets;
185	21		} elseif ($token->value === ')') {
186	6		if ($brackets == 0) {
187			break;
188			}
189	6		--$brackets;
190	6		}
191	21		}
192
193	21		$expr->expr .= $token->token;
194	21		if (($token->type === Token::TYPE_NONE)
195	21		\|\| (($token->type === Token::TYPE_KEYWORD)
196	21		&& (!($token->flags & Token::FLAG_KEYWORD_RESERVED)))
197	21		\|\| ($token->type === Token::TYPE_STRING)
198	21		\|\| ($token->type === Token::TYPE_SYMBOL)
199	21		) {
200	21		if (!in_array($token->value, $expr->identifiers)) {
201	21		$expr->identifiers[] = $token->value;
202	21		}
203	21		}
204	21		}
205
206			// Last iteration was not processed.
207	22		$expr->expr = trim($expr->expr);
208	22		if (!empty($expr->expr)) {
209	21		$ret[] = $expr;
210	21		}
211
212	22		--$list->idx;
213	22		return $ret;
214			}
215
216			/**
217			* @param Condition[] $component The component to be built.
218			* @param array $options Parameters for building.
219			*
220			* @return string
221			*/
222	4		public static function build($component, array $options = array())
223			{
224	4		if (is_array($component)) {
225	4		return implode(' ', $component);
226			} else {
227	4		return $component->expr;
228			}
229			}
230			}
231

phpmyadmin / sql-parser

Push — master ( 8956cf...1ecd61 )

Condition::build() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like