Check - Code Metrics - Inspection of "Add support for CHECK Constraints" - phpmyadmin/sql-parser - Measure and Improve Code Quality continuously with Scrutinizer

Test Failed

Pull Request — master (#200)

unknown

created 2018-08-03 17:40 UTC

Check A

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	231
Duplicated Lines	21.65 %

Coupling/Cohesion

Components	1
Dependencies	4

Test Coverage

Coverage

Importance

Changes

Metric	Value
wmc	38
lcom	1
cbo	4
dl	50
loc	231
ccs	0
cts	99
cp	0
rs	9.36
c	0
b	0
f	0

3 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	3	1
A	build()	0	22	5
F	parse()	50	147	32

How to fix Duplicated Code

<?php

/**
 * Parses the definition of a Check component.
 */

namespace PhpMyAdmin\SqlParser\Components;

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

/**
 * Parses the definition of a Check component.
 *
 * Used for parsing `CREATE TABLE` statement.
 *
 * @category   Components
 *
 * @license    https://www.gnu.org/licenses/gpl-2.0.txt GPL-2.0+
 */
class Check extends Component
{

    /**
     * Columns.
     *
     * @var array
     */
    public $columns;

    /**
     * The operators in this component.
     *
     * @var OptionsArray
     */
    public $operators;

    /**
     * The operands in this component.
     *
     * @var operands
     */
    public $operands;

    /**
     * The logical operators in this component.
     *
     * @var logicalOperatorsArray
     */
    public $logicalOperators;

    /**
     * Possible operators in the component.
     *
     * @var OperatorsArray
     */
    public static $operatorsArray = array("=", ">", "<", "<=", ">=", "!=", "LIKE", "NOT", "BETWEEN", "IS", "NULL", "REGEXP", "REGEXP");
<?php

$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";

print $doubleQuoted;

    /**
     * Constructor.
     *
     * @param string       $name    the name of the component

     */
    public function __construct($name = null) {
        $this->name = $name;
class MyClass { }

$x = new MyClass();
$x->foo = true;
    }

    /**
     * @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 component

     */
    public static function parse(Parser $parser, TokensList $list, array $options = array())
    {
        $ret = new self();

        /**
         * Last parsed column.
         *
         * @var array
         */
        $lastColumn = array();
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}

        /**
         * Bracket stack
         *
         * @var bracketStack
         */
        $bracketStack = array();

        /**
         * The state of the parser.
         *
         * Below are the states of the parser.
         *
         *      0 ----------------------[ column name ]-----------------------> 1
         *
         *      1 ----------------------[ operator ]-----------------------> 2
         *      2 ---------------------[ operand ]---------------------> 3
         *      2 ---------------------[ operand ]---------------------> 4
         *
         *      3 ---------------------[ logical operator ]---------------------> 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 whitespaces and comments.
            if (($token->type === Token::TYPE_WHITESPACE) || ($token->type === Token::TYPE_COMMENT)) {
                continue;
            }

            if ($state === 0) {
                if (($token->type === Token::TYPE_KEYWORD) && $token->keyword === 'CHECK') {
                    $state = 0;
                } elseif(($token->type === Token::TYPE_OPERATOR) && ($token->value === '(')) {
                    $state = 1;
                    array_push($bracketStack, '(');
                } else {
                    $parser->error(
                        'Invalid token',
                        $token
                    );
                    return $ret;
                }
            } else if($state === 1) {
                if(($token->type === Token::TYPE_OPERATOR) && ($token->value === '(')) {
                    array_push($bracketStack, '(');
                    $state = 1;
                } elseif($token->type === Token::TYPE_OPERATOR) {
                    $parser->error(
                        'A Column name was expected!',
                        $token
                    );
                    return $ret;
                } else {
                    $ret->columns[] = $token->value;
                    $state = 2;
                }
            } elseif ($state === 2) {
                if(($token->type === Token::TYPE_OPERATOR) || in_array($token->value, self::$operatorsArray)) {
                    if(($token->value === ')')) {
                        if(count($bracketStack) > 1) {
                            array_pop($bracketStack);
                            $state = 2;
                        } else $state = 5;
                    } elseif(in_array($token->value, self::$operatorsArray)) {
                        $ret->operators[] = $token->value;
                        $state = 3;
                    } else {
                        $parser->error(
                            'Unrecognized operator!',
                            $token
                        );
                        return $ret;
                    }
                } else {
                    $parser->error(
                        'An operator was expected!',
                        $token
                    );
                    return $ret;
                }
            } elseif ($state === 3) {
                if(($token->type === Token::TYPE_OPERATOR) && ($token->value === '(')) {
                    $state = 3;
                    array_push($bracketStack, '(');
                } elseif($token->type === Token::TYPE_OPERATOR) {
                    $parser->error(
                        'An operand was expected!',
                        $token
                    );
                    return $ret;
                } else {
                    $ret->operands[] = $token->value;
                    $state = 4;
                }
            } elseif ($state === 4) {
                if (($token->value === 'AND') || ($token->value === 'OR')) {
                    $ret->logicalOperators[] = $token->value;
                    $state = 1;
                } elseif (($token->type === Token::TYPE_OPERATOR) && ($token->value === ')')) {
                    if(count($bracketStack) === 1) {
                        $state = 5;
                    } else {
                        array_pop($bracketStack);
                        $state = 4;
                    }
                } elseif($token->type === Token::TYPE_OPERATOR) {
                    $parser->error(
                        'Unrecognized token!',
                        $token
                    );
                    return $ret;
                } else {
                    $state = 5;
                }
            } elseif ($state === 5) {
                break;
            }
        }

        --$list->idx;

        return $ret;
    }

    /**
     * @param Check   $component the component to be built
     * @param array $options   parameters for building
     *
     * @return string
     */
    public static function build($component, array $options = array())
    {
        $columns = $component->columns;
        $logical_op = $component->logicalOperators;
        $operators = $component->operators;
        $operands = $component->operands;
        $definition = 'CHECK (';
        for($i=0; $i<count($columns); ++$i) {
for ($i=0; $i<count($array); $i++) { // calls count() on each iteration
}

// Better
for ($i=0, $c=count($array); $i<$c; $i++) { // calls count() just once
}
            $columns[$i] = trim($columns[$i]);
            if($i>0) {
                $definition .= ' ' . $logical_op[$i-1] . ' ';
            }
            $definition .= Context::escape($columns[$i]);
            if($operators[$i] === 'IS NULL' || $operators[$i] === 'IS NOT NULL') {
                $definition .= ' ' . $operators[$i];
            } else {
                $definition .= ' ' . $operators[$i] . ' \'' . $operands[$i] . '\'';
            }
        }
        $definition .= ')';
        return trim($definition);
    }
}


1			<?php
2
3			/**
4			* Parses the definition of a Check component.
5			*/
6
7			namespace PhpMyAdmin\SqlParser\Components;
8
9			use PhpMyAdmin\SqlParser\Component;
10			use PhpMyAdmin\SqlParser\Context;
11			use PhpMyAdmin\SqlParser\Parser;
12			use PhpMyAdmin\SqlParser\Token;
13			use PhpMyAdmin\SqlParser\TokensList;
14
15			/**
16			* Parses the definition of a Check component.
17			*
18			* Used for parsing `CREATE TABLE` statement.
19			*
20			* @category Components
21			*
22			* @license https://www.gnu.org/licenses/gpl-2.0.txt GPL-2.0+
23			*/
24			class Check extends Component
25			{
26
27			/**
28			* Columns.
29			*
30			* @var array
31			*/
32			public $columns;
33
34			/**
35			* The operators in this component.
36			*
37			* @var OptionsArray
38			*/
39			public $operators;
40

phpmyadmin / sql-parser

Pull Request — master (#200)

Check A

Complexity

Size/Duplication

Coupling/Cohesion

Test Coverage

Importance

3 Methods

How to fix Duplicated Code

Duplicated Code

Duplication Side-by-Side

Filter issues like