TokenStream - Code Metrics - Inspection of "Consume another character when parsing alternate s..." - koesie10/LuaSerializer - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( a70f7d...66870e )

by Koen

created 2016-08-16 06:21 UTC

TokenStream B

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	301
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

Test Coverage

Coverage

88.24%

Importance

Changes	4
Bugs	3	Features	0

Metric	Value
wmc	53
c	4
b	3
f	0
lcom	1
cbo	3
dl	0
loc	301
ccs	120
cts	136
cp	0.8824
rs	7.4757

23 Methods

Rating	Name	Size	Complexity
A	__construct()	3	1
A	eof()	3	1
A	next()	8	2
A	peek()	7	2
A	error()	3	1
A	readDoubleQuotedString()	3	1
A	readSingleQuotedString()	3	1
D	readNext()	30	9
A	skipComment()	8	1
B	readDoubleBracketString()	27	6
B	readEscaped()	23	5
A	readNumber()	16	4
A	readIdentifier()	16	3
A	readPunctuation()	3	1
A	readWhile()	7	3
A	isWhitespace()	3	1
A	isDigit()	3	1
A	isDoubleBracketString()	3	3
A	isComment()	3	3
A	isStartIdentifierCharacter()	3	1
A	isIdentifierCharacter()	3	1
A	isPunctuation()	3	1
A	isKeyword()	3	1

How to fix Complexity

<?php

namespace Vlaswinkel\Lua;

/**
 * Class TokenStream
 *
 * @see     http://lisperator.net/pltut/parser/token-stream
 *
 * @author  Koen Vlaswinkel <[email protected]>
 * @package Vlaswinkel\Lua
 */
class TokenStream {
    private $current = null;
    /**
     * @var InputStream
     */
    private $input;

    /**
     * TokenStream constructor.
     *
     * @param InputStream $input
     */
    public function __construct(InputStream $input) {
        $this->input = $input;
    }

    /**
     * @return Token
     */
    public function next() {
        $token         = $this->current;
        $this->current = null;
        if ($token) {
            return $token;
        }
        return $this->readNext();
    }

    /**
     * @return bool
     */
    public function eof() {
        return $this->peek() == null;
    }

    /**
     * @return Token

     */
    public function peek() {
        if ($this->current) {
            return $this->current;
        }
        $this->current = $this->readNext();
        return $this->current;
    }

    /**
     * @param string $msg
     *
     * @throws ParseException
     */
    public function error($msg) {
        $this->input->error($msg);
    }

    /**
     * @return Token

     * @throws ParseException
     */
    protected function readNext() {
        $this->readWhile([$this, 'isWhitespace']);
        if ($this->input->eof()) {
            return null;
        }
        $char = $this->input->peek();
        if ($this->isComment()) {
            $this->skipComment();
            return $this->readNext();
        }
        if ($char == '"') {
            return $this->readDoubleQuotedString();
        }
        if ($char == '\'') {
            return $this->readSingleQuotedString();
        }
        if ($this->isDoubleBracketString()) {
            return $this->readDoubleBracketString();
        }
        if ($this->isDigit($char)) {
            return $this->readNumber();
        }
        if ($this->isStartIdentifierCharacter($char)) {
            return $this->readIdentifier();
        }
        if ($this->isPunctuation($char)) {
            return $this->readPunctuation();
        }
        $this->input->error('Cannot handle character: ' . $char . ' (ord: ' . ord($char) . ')');
    }

    protected function skipComment() {
        $this->readWhile(
            function ($char) {
                return $char != "\n";
            }
        );
        $this->input->next();
    }

    /**
     * @return Token
     */
    protected function readDoubleQuotedString() {
        return new Token(Token::TYPE_STRING, $this->readEscaped('"'));
    }

    /**
     * @return Token
     */
    protected function readSingleQuotedString() {
        return new Token(Token::TYPE_STRING, $this->readEscaped('\''));
    }

    /**
     * @return Token
     */
    protected function readDoubleBracketString() {
        // we cannot use readEscaped because it only supports a single char as $end
        $escaped = false;
        $str     = "";
        // skip both
        $this->input->next();
        $this->input->next();
        while (!$this->input->eof()) {
            $char = $this->input->next();
            if ($escaped) {
                $str .= $char;
                $escaped = false;
            } else {
                if ($char == "\\") {
                    $escaped = true;
                } else {
                    if ($char == ']' && $this->input->peek() == ']') { // we reached the end
                        $this->input->next();
                        break;
                    } else {
                        $str .= $char;
                    }
                }
            }
        }
        return new Token(Token::TYPE_STRING, $str);
    }

    /**
     * @param string $end
     *
     * @return string
     */
    protected function readEscaped($end) {
        $escaped = false;
        $str     = "";
        $this->input->next();
        while (!$this->input->eof()) {
            $char = $this->input->next();
            if ($escaped) {
                $str .= $char;
                $escaped = false;
            } else {
                if ($char == "\\") {
                    $escaped = true;
                } else {
                    if ($char == $end) {
                        break;
                    } else {
                        $str .= $char;
                    }
                }
            }
        }
        return $str;
    }

    /**
     * @return Token
     */
    protected function readNumber() {
        $hasDot = false;
        $number = $this->readWhile(
            function ($char) use (&$hasDot) {
                if ($char == '.') {
                    if ($hasDot) {
                        return false;
                    }
                    $hasDot = true;
                    return true;
                }
                return $this->isDigit($char);
            }
        );
        return new Token(Token::TYPE_NUMBER, $hasDot ? floatval($number) : intval($number));
    }

    /**
     * @return Token
     */
    protected function readIdentifier() {
        $first      = false;
        $identifier = $this->readWhile(
            function ($char) use (&$first) {
                if ($first) {
                    $first = false;
                    return $this->isStartIdentifierCharacter($char);
                }
                return $this->isIdentifierCharacter($char);
            }
        );
        if ($this->isKeyword($identifier)) {
            return new Token(Token::TYPE_KEYWORD, $identifier);
        }
        return new Token(Token::TYPE_IDENTIFIER, $identifier);
    }

    /**
     * @return Token
     */
    protected function readPunctuation() {
        return new Token(Token::TYPE_PUNCTUATION, $this->input->next());
    }

    /**
     * @param callable $predicate
     *
     * @return string
     */
    protected function readWhile(callable $predicate) {
        $str = "";
        while (!$this->input->eof() && call_user_func($predicate, $this->input->peek())) {
            $str .= $this->input->next();
        }
        return $str;
    }

    /**
     * @param string $char
     *
     * @return bool
     */
    protected function isWhitespace($char) {
        return strpos(" \t\n\r", $char) !== false;
    }

    /**
     * @param string $char
     *
     * @return bool
     */
    protected function isDigit($char) {
        return is_numeric($char);
    }

    /**
     * @return bool
     */
    protected function isDoubleBracketString() {
        return $this->input->peek() == '[' && !$this->input->eof(1) && $this->input->peek(1) == '[';
    }

    /**
     * @return bool
     */
    protected function isComment() {
        return $this->input->peek() == '-' && !$this->input->eof(1) && $this->input->peek(1) == '-';
    }

    /**
     * @param string $char
     *
     * @return bool
     */
    protected function isStartIdentifierCharacter($char) {
        return preg_match('/[a-zA-Z_]/', $char) === 1;
    }

    /**
     * @param string $char
     *
     * @return bool
     */
    protected function isIdentifierCharacter($char) {
        return preg_match('/[a-zA-Z0-9_]/', $char) === 1;
    }

    /**
     * @param string $char
     *
     * @return bool
     */
    protected function isPunctuation($char) {
        return strpos(",{}=[]", $char) !== false;
    }

    /**
     * @param string $text
     *
     * @return bool
     */
    protected function isKeyword($text) {
        return in_array($text, Lua::$luaKeywords);
    }
}

1		<?php
2
3		namespace Vlaswinkel\Lua;
4
5		/**
6		* Class TokenStream
7		*
8		* @see http://lisperator.net/pltut/parser/token-stream
9		*
10		* @author Koen Vlaswinkel <[email protected]>
11		* @package Vlaswinkel\Lua
12		*/
13		class TokenStream {
14		private $current = null;
15		/**
16		* @var InputStream
17		*/
18		private $input;
19
20		/**
21		* TokenStream constructor.
22		*
23		* @param InputStream $input
24		*/
25	29	public function __construct(InputStream $input) {
26	29	$this->input = $input;
27	29	}
28
29		/**
30		* @return Token
31		*/
32	29	public function next() {
33	29	$token = $this->current;
34	29	$this->current = null;
35	29	if ($token) {
36	21	return $token;
37		}
38	8	return $this->readNext();
39		}
40
41		/**
42		* @return bool
43		*/
44	10	public function eof() {
45	10	return $this->peek() == null;
46		}
47
48		/**
49		* @return Token
		0 ignored issues – show Documentation introduced 2015-12-22 12:03 UTC by Report Bug Copy Issue Report Should the return type not be `Token\|null`? 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...
50		*/
51	21	public function peek() {
52	21	if ($this->current) {
53	21	return $this->current;
54		}
55	21	$this->current = $this->readNext();
56	21	return $this->current;
57		}
58
59		/**
60		* @param string $msg
61		*
62		* @throws ParseException
63		*/
64	1	public function error($msg) {
65	1	$this->input->error($msg);
66		}
67
68		/**
69		* @return Token
		0 ignored issues – show Documentation introduced 2015-12-22 12:03 UTC by Report Bug Copy Issue Report Should the return type not be `Token\|null`? 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...
70		* @throws ParseException
71		*/
72	29	protected function readNext() {
73	29	$this->readWhile([$this, 'isWhitespace']);
74	29	if ($this->input->eof()) {
75		return null;
76		}
77	29	$char = $this->input->peek();
78	29	if ($this->isComment()) {
79	4	$this->skipComment();
80	4	return $this->readNext();
81		}
82	29	if ($char == '"') {
83	10	return $this->readDoubleQuotedString();
84		}
85	25	if ($char == '\'') {
86	1	return $this->readSingleQuotedString();
87		}
88	24	if ($this->isDoubleBracketString()) {
89	3	return $this->readDoubleBracketString();
90		}
91	22	if ($this->isDigit($char)) {
92	8	return $this->readNumber();
93		}
94	18	if ($this->isStartIdentifierCharacter($char)) {
95	14	return $this->readIdentifier();
96		}
97	13	if ($this->isPunctuation($char)) {
98	12	return $this->readPunctuation();
99		}
100	1	$this->input->error('Cannot handle character: ' . $char . ' (ord: ' . ord($char) . ')');
101		}
102
103	4	protected function skipComment() {
104	4	$this->readWhile(
105		function ($char) {
106	4	return $char != "\n";
107		}
108	4	);
109	4	$this->input->next();
110	4	}
111
112		/**
113		* @return Token
114		*/
115	10	protected function readDoubleQuotedString() {
116	10	return new Token(Token::TYPE_STRING, $this->readEscaped('"'));
117		}
118
119		/**
120		* @return Token
121		*/
122	1	protected function readSingleQuotedString() {
123	1	return new Token(Token::TYPE_STRING, $this->readEscaped('\''));
124		}
125
126		/**
127		* @return Token
128		*/
129	3	protected function readDoubleBracketString() {
130		// we cannot use readEscaped because it only supports a single char as $end
131	3	$escaped = false;
132	3	$str = "";
133		// skip both
134	3	$this->input->next();
135	3	$this->input->next();
136	3	while (!$this->input->eof()) {
137	3	$char = $this->input->next();
138	3	if ($escaped) {
139		$str .= $char;
140		$escaped = false;
141		} else {
142	3	if ($char == "\\") {
143		$escaped = true;
144		} else {
145	3	if ($char == ']' && $this->input->peek() == ']') { // we reached the end
146	3	$this->input->next();
147	3	break;
148		} else {
149	3	$str .= $char;
150		}
151		}
152		}
153	3	}
154	3	return new Token(Token::TYPE_STRING, $str);
155		}
156
157		/**
158		* @param string $end
159		*
160		* @return string
161		*/
162	11	protected function readEscaped($end) {
163	11	$escaped = false;
164	11	$str = "";
165	11	$this->input->next();
166	11	while (!$this->input->eof()) {
167	11	$char = $this->input->next();
168	11	if ($escaped) {
169		$str .= $char;
170		$escaped = false;
171		} else {
172	11	if ($char == "\\") {
173		$escaped = true;
174		} else {
175	11	if ($char == $end) {
176	11	break;
177		} else {
178	11	$str .= $char;
179		}
180		}
181		}
182	11	}
183	11	return $str;
184		}
185
186		/**
187		* @return Token
188		*/
189	8	protected function readNumber() {
190	8	$hasDot = false;
191	8	$number = $this->readWhile(
192		function ($char) use (&$hasDot) {
193	8	if ($char == '.') {
194	1	if ($hasDot) {
195		return false;
196		}
197	1	$hasDot = true;
198	1	return true;
199		}
200	8	return $this->isDigit($char);
201		}
202	8	);
203	8	return new Token(Token::TYPE_NUMBER, $hasDot ? floatval($number) : intval($number));
204		}
205
206		/**
207		* @return Token
208		*/
209	14	protected function readIdentifier() {
210	14	$first = false;
211	14	$identifier = $this->readWhile(
212	14	function ($char) use (&$first) {
213	14	if ($first) {
214		$first = false;
215		return $this->isStartIdentifierCharacter($char);
216		}
217	14	return $this->isIdentifierCharacter($char);
218		}
219	14	);
220	14	if ($this->isKeyword($identifier)) {
221	3	return new Token(Token::TYPE_KEYWORD, $identifier);
222		}
223	11	return new Token(Token::TYPE_IDENTIFIER, $identifier);
224		}
225
226		/**
227		* @return Token
228		*/
229	12	protected function readPunctuation() {
230	12	return new Token(Token::TYPE_PUNCTUATION, $this->input->next());
231		}
232
233		/**
234		* @param callable $predicate
235		*
236		* @return string
237		*/
238	29	protected function readWhile(callable $predicate) {
239	29	$str = "";
240	29	while (!$this->input->eof() && call_user_func($predicate, $this->input->peek())) {
241	18	$str .= $this->input->next();
242	18	}
243	29	return $str;
244		}
245
246		/**
247		* @param string $char
248		*
249		* @return bool
250		*/
251	29	protected function isWhitespace($char) {
252	29	return strpos(" \t\n\r", $char) !== false;
253		}
254
255		/**
256		* @param string $char
257		*
258		* @return bool
259		*/
260	22	protected function isDigit($char) {
261	22	return is_numeric($char);
262		}
263
264		/**
265		* @return bool
266		*/
267	24	protected function isDoubleBracketString() {
268	24	return $this->input->peek() == '[' && !$this->input->eof(1) && $this->input->peek(1) == '[';
269		}
270
271		/**
272		* @return bool
273		*/
274	29	protected function isComment() {
275	29	return $this->input->peek() == '-' && !$this->input->eof(1) && $this->input->peek(1) == '-';
276		}
277
278		/**
279		* @param string $char
280		*
281		* @return bool
282		*/
283	18	protected function isStartIdentifierCharacter($char) {
284	18	return preg_match('/[a-zA-Z_]/', $char) === 1;
285		}
286
287		/**
288		* @param string $char
289		*
290		* @return bool
291		*/
292	14	protected function isIdentifierCharacter($char) {
293	14	return preg_match('/[a-zA-Z0-9_]/', $char) === 1;
294		}
295
296		/**
297		* @param string $char
298		*
299		* @return bool
300		*/
301	13	protected function isPunctuation($char) {
302	13	return strpos(",{}=[]", $char) !== false;
303		}
304
305		/**
306		* @param string $text
307		*
308		* @return bool
309		*/
310	14	protected function isKeyword($text) {
311	14	return in_array($text, Lua::$luaKeywords);
312		}
313		}

koesie10 / LuaSerializer

Push — master ( a70f7d...66870e )

TokenStream B

Complexity

Size/Duplication

Coupling/Cohesion

Test Coverage

Importance

23 Methods

How to fix Complexity

Complex Class

Duplication Side-by-Side

Filter issues like