ArrayObj::parse() - Code Metrics - Inspection of "Added PhpMyAdmin namespace prefix to follow PSR-4." - phpmyadmin/sql-parser - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 65f66e...428edc )

by Michal

created 2017-01-23 12:10 UTC

ArrayObj::parse() D

↳ Parent: ArrayObj

Complexity

Conditions	22
Paths	16

Size

Total Lines	116
Code Lines	49

Duplication

Lines	11
Ratio	9.48 %

Code Coverage

Tests	58
CRAP Score	22

Importance

Changes

Metric	Value
cc	22
eloc	49
nc	16
nop	3
dl	11
loc	116
ccs	58
cts	58
cp	1
crap	22
rs	4.6625
c	0
b	0
f	0

How to fix Long Method Complexity

<?php

/**
 * Parses an array.
 */

namespace PhpMyAdmin\SqlParser\Components;

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

/**
 * Parses an array.
 *
 * @category   Components
 *
 * @license    https://www.gnu.org/licenses/gpl-2.0.txt GPL-2.0+
 */
class ArrayObj extends Component
{
    /**
     * The array that contains the unprocessed value of each token.
     *
     * @var array
     */
    public $raw = array();

    /**
     * The array that contains the processed value of each token.
     *
     * @var array
     */
    public $values = array();

    /**
     * Constructor.
     *
     * @param array $raw    the unprocessed values
     * @param array $values the processed values
     */
    public function __construct(array $raw = array(), array $values = array())
    {
        $this->raw = $raw;
        $this->values = $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 ArrayObj|Component[]

     */
    public static function parse(Parser $parser, TokensList $list, array $options = array())
    {
        $ret = empty($options['type']) ? new self() : array();

        /**
         * The last raw expression.
         *
         * @var string
         */
        $lastRaw = '';

        /**
         * The last value.
         *
         * @var string
         */
        $lastValue = '';

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

        /**
         * Last separator (bracket or comma).
         *
         * @var bool
         */
        $isCommaLast = false;

        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)
            ) {
                $lastRaw .= $token->token;
                $lastValue = trim($lastValue) . ' ';
                continue;
            }

            if (($brackets === 0)
                && (($token->type !== Token::TYPE_OPERATOR)
                || ($token->value !== '('))
            ) {
                $parser->error(__('An opening bracket was expected.'), $token);
                break;
            }

            if ($token->type === Token::TYPE_OPERATOR) {
                if ($token->value === '(') {
                    if (++$brackets === 1) { // 1 is the base level.
                        continue;
                    }
                } elseif ($token->value === ')') {
                    if (--$brackets === 0) { // Array ended.
                        break;
                    }
                } elseif ($token->value === ',') {
                    if ($brackets === 1) {
                        $isCommaLast = true;
                        if (empty($options['type'])) {
                            $ret->raw[] = trim($lastRaw);
                            $ret->values[] = trim($lastValue);
                            $lastRaw = $lastValue = '';
                        }
                    }
                    continue;
                }
            }

            if (empty($options['type'])) {
                $lastRaw .= $token->token;
                $lastValue .= $token->value;
            } else {
                $ret[] = $options['type']::parse(
                    $parser,
                    $list,
                    empty($options['typeOptions']) ? array() : $options['typeOptions']
                );
            }
        }

        // Handling last element.
        //
        // This is treated differently to treat the following cases:
        //
        //           => array()
        //      (,)  => array('', '')
        //      ()   => array()
        //      (a,) => array('a', '')
        //      (a)  => array('a')
        //
        $lastRaw = trim($lastRaw);
        if ((empty($options['type']))
            && ((strlen($lastRaw) > 0) || ($isCommaLast))
        ) {
            $ret->raw[] = $lastRaw;
            $ret->values[] = trim($lastValue);
        }

        return $ret;
    }

    /**
     * @param ArrayObj|ArrayObj[] $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);
        } elseif (!empty($component->raw)) {
            return '(' . implode(', ', $component->raw) . ')';
        } else {
            return '(' . implode(', ', $component->values) . ')';
        }
    }
}


1			<?php
2
3			/**
4			* Parses an array.
5			*/
6
7			namespace PhpMyAdmin\SqlParser\Components;
8
9			use PhpMyAdmin\SqlParser\Component;
10			use PhpMyAdmin\SqlParser\Parser;
11			use PhpMyAdmin\SqlParser\Token;
12			use PhpMyAdmin\SqlParser\TokensList;
13
14			/**
15			* Parses an array.
16			*
17			* @category Components
18			*
19			* @license https://www.gnu.org/licenses/gpl-2.0.txt GPL-2.0+
20			*/
21			class ArrayObj extends Component
22			{
23			/**
24			* The array that contains the unprocessed value of each token.
25			*
26			* @var array
27			*/
28			public $raw = array();
29
30			/**
31			* The array that contains the processed value of each token.
32			*
33			* @var array
34			*/
35			public $values = array();
36
37			/**
38			* Constructor.
39			*
40			* @param array $raw the unprocessed values
41			* @param array $values the processed values
42			*/
43	71		public function __construct(array $raw = array(), array $values = array())
44			{
45	71		$this->raw = $raw;
46	71		$this->values = $values;
47	71		}
48
49			/**
50			* @param Parser $parser the parser that serves as context
51			* @param TokensList $list the list of tokens that are being parsed
52			* @param array $options parameters for parsing
53			*
54			* @return ArrayObj\|Component[]
			0 ignored issues – show Documentation introduced 2016-02-12 21:51 UTC by Report Bug Copy Issue Report Should the return type not be `ArrayObj\|array`? This check compares the return type specified in the `@return` annotation of a function or method doc comment with the types returned by the function and raises an issue if they mismatch. Loading history...
55			*/
56	69		public static function parse(Parser $parser, TokensList $list, array $options = array())
57			{
58	69		$ret = empty($options['type']) ? new self() : array();
59
60			/**
61			* The last raw expression.
62			*
63			* @var string
64			*/
65	69		$lastRaw = '';
66
67			/**
68			* The last value.
69			*
70			* @var string
71			*/
72	69		$lastValue = '';
73
74			/**
75			* Counts brackets.
76			*
77			* @var int
78			*/
79	69		$brackets = 0;
80
81			/**
82			* Last separator (bracket or comma).
83			*
84			* @var bool
85			*/
86	69		$isCommaLast = false;
87
88	69		for (; $list->idx < $list->count; ++$list->idx) {
89			/**
90			* Token parsed at this moment.
91			*
92			* @var Token
93			*/
94	69		$token = $list->tokens[$list->idx];
95
96			// End of statement.
97	69		if ($token->type === Token::TYPE_DELIMITER) {
98	3		break;
99			}
100
101			// Skipping whitespaces and comments.
102	69		if (($token->type === Token::TYPE_WHITESPACE)
103	69		\|\| ($token->type === Token::TYPE_COMMENT)
104	69		) {
105	31		$lastRaw .= $token->token;
106	31		$lastValue = trim($lastValue) . ' ';
107	31		continue;
108			}
109
110	69		if (($brackets === 0)
111	69		&& (($token->type !== Token::TYPE_OPERATOR)
112	68		\|\| ($token->value !== '('))
113	69		) {
114	1		$parser->error(__('An opening bracket was expected.'), $token);
115	1		break;
116			}
117
118	68		if ($token->type === Token::TYPE_OPERATOR) {
119	68		if ($token->value === '(') {
120	68		if (++$brackets === 1) { // 1 is the base level.
121	68		continue;
122			}
123	68		} elseif ($token->value === ')') {
124	65		if (--$brackets === 0) { // Array ended.
125	65		break;
126			}
127	36		} elseif ($token->value === ',') {
128	36		if ($brackets === 1) {
129	36		$isCommaLast = true;
130	36	View Code Duplication	if (empty($options['type'])) {
131	33		$ret->raw[] = trim($lastRaw);
132	33		$ret->values[] = trim($lastValue);
133	33		$lastRaw = $lastValue = '';
134	33		}
135	36		}
136	36		continue;
137			}
138	2		}
139
140	66		if (empty($options['type'])) {
141	64		$lastRaw .= $token->token;
142	64		$lastValue .= $token->value;
143	64		} else {
144	3		$ret[] = $options['type']::parse(
145	3		$parser,
146	3		$list,
147	3		empty($options['typeOptions']) ? array() : $options['typeOptions']
148	3		);
149			}
150	66		}
151
152			// Handling last element.
153			//
154			// This is treated differently to treat the following cases:
155			//
156			// => array()
157			// (,) => array('', '')
158			// () => array()
159			// (a,) => array('a', '')
160			// (a) => array('a')
161			//
162	69		$lastRaw = trim($lastRaw);
163	69	View Code Duplication	if ((empty($options['type']))
164	69		&& ((strlen($lastRaw) > 0) \|\| ($isCommaLast))
165	69		) {
166	64		$ret->raw[] = $lastRaw;
167	64		$ret->values[] = trim($lastValue);
168	64		}
169
170	69		return $ret;
171			}
172
173			/**
174			* @param ArrayObj\|ArrayObj[] $component the component to be built
175			* @param array $options parameters for building
176			*
177			* @return string
178			*/
179	8		public static function build($component, array $options = array())
180			{
181	8		if (is_array($component)) {
182	3		return implode(', ', $component);
183	8		} elseif (!empty($component->raw)) {
184	7		return '(' . implode(', ', $component->raw) . ')';
185			} else {
186	1		return '(' . implode(', ', $component->values) . ')';
187			}
188			}
189			}
190

phpmyadmin / sql-parser

Push — master ( 65f66e...428edc )

ArrayObj::parse() D

Complexity

Size

Duplication

Code Coverage

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like