TokenStream - Code Metrics - Inspection of "Read double bracket strings with spaces correctly,..." - koesie10/LuaSerializer - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 8f1e95...1a0a87 )

by Koen

created 2016-08-07 07:48 UTC

TokenStream B

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	293
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

Test Coverage

Coverage

81.95%

Importance

Changes	2
Bugs	1	Features	0

Metric	Value
wmc	50
c	2
b	1
f	0
lcom	1
cbo	3
dl	0
loc	293
ccs	109
cts	133
cp	0.8195
rs	8.6206

22 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
D	readNext()	30	9
A	skipComment()	8	1
A	readDoubleQuotedString()	3	1
A	readSingleQuotedString()	3	1
B	readDoubleBracketString()	26	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	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 ($char == "--") {
            $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
                        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) == '[';
    }

    /**
     * @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	24	public function __construct(InputStream $input) {
26	24	$this->input = $input;
27	24	}
28
29		/**
30		* @return Token
31		*/
32	24	public function next() {
33	24	$token = $this->current;
34	24	$this->current = null;
35	24	if ($token) {
36	16	return $token;
37		}
38	8	return $this->readNext();
39		}
40
41		/**
42		* @return bool
43		*/
44	6	public function eof() {
45	6	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	16	public function peek() {
52	16	if ($this->current) {
53	16	return $this->current;
54		}
55	16	$this->current = $this->readNext();
56	16	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	24	protected function readNext() {
73	24	$this->readWhile([$this, 'isWhitespace']);
74	24	if ($this->input->eof()) {
75		return null;
76		}
77	24	$char = $this->input->peek();
78	24	if ($char == "--") {
79		$this->skipComment();
80		return $this->readNext();
81		}
82	24	if ($char == '"') {
83	9	return $this->readDoubleQuotedString();
84		}
85	20	if ($char == '\'') {
86	1	return $this->readSingleQuotedString();
87		}
88	19	if ($this->isDoubleBracketString()) {
89	2	return $this->readDoubleBracketString();
90		}
91	17	if ($this->isDigit($char)) {
92	6	return $this->readNumber();
93		}
94	13	if ($this->isStartIdentifierCharacter($char)) {
95	9	return $this->readIdentifier();
96		}
97	9	if ($this->isPunctuation($char)) {
98	8	return $this->readPunctuation();
99		}
100	1	$this->input->error('Cannot handle character: ' . $char . ' (ord: ' . ord($char) . ')');
101		}
102
103		protected function skipComment() {
104		$this->readWhile(
105		function ($char) {
106		return $char != "\n";
107		}
108		);
109		$this->input->next();
110		}
111
112		/**
113		* @return Token
114		*/
115	9	protected function readDoubleQuotedString() {
116	9	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	2	protected function readDoubleBracketString() {
130		// we cannot use readEscaped because it only supports a single char as $end
131	2	$escaped = false;
132	2	$str = "";
133		// skip both
134	2	$this->input->next();
135	2	$this->input->next();
136	2	while (!$this->input->eof()) {
137	2	$char = $this->input->next();
138	2	if ($escaped) {
139		$str .= $char;
140		$escaped = false;
141		} else {
142	2	if ($char == "\\") {
143		$escaped = true;
144		} else {
145	2	if ($char == ']' && $this->input->peek() == ']') { // we reached the end
146	2	break;
147		} else {
148	2	$str .= $char;
149		}
150		}
151		}
152	2	}
153	2	return new Token(Token::TYPE_STRING, $str);
154		}
155
156		/**
157		* @param string $end
158		*
159		* @return string
160		*/
161	10	protected function readEscaped($end) {
162	10	$escaped = false;
163	10	$str = "";
164	10	$this->input->next();
165	10	while (!$this->input->eof()) {
166	10	$char = $this->input->next();
167	10	if ($escaped) {
168		$str .= $char;
169		$escaped = false;
170		} else {
171	10	if ($char == "\\") {
172		$escaped = true;
173		} else {
174	10	if ($char == $end) {
175	10	break;
176		} else {
177	10	$str .= $char;
178		}
179		}
180		}
181	10	}
182	10	return $str;
183		}
184
185		/**
186		* @return Token
187		*/
188	6	protected function readNumber() {
189	6	$hasDot = false;
190	6	$number = $this->readWhile(
191		function ($char) use (&$hasDot) {
192	6	if ($char == '.') {
193	1	if ($hasDot) {
194		return false;
195		}
196	1	$hasDot = true;
197	1	return true;
198		}
199	6	return $this->isDigit($char);
200		}
201	6	);
202	6	return new Token(Token::TYPE_NUMBER, $hasDot ? floatval($number) : intval($number));
203		}
204
205		/**
206		* @return Token
207		*/
208	9	protected function readIdentifier() {
209	9	$first = false;
210	9	$identifier = $this->readWhile(
211	9	function ($char) use (&$first) {
212	9	if ($first) {
213		$first = false;
214		return $this->isStartIdentifierCharacter($char);
215		}
216	9	return $this->isIdentifierCharacter($char);
217		}
218	9	);
219	9	if ($this->isKeyword($identifier)) {
220	3	return new Token(Token::TYPE_KEYWORD, $identifier);
221		}
222	6	return new Token(Token::TYPE_IDENTIFIER, $identifier);
223		}
224
225		/**
226		* @return Token
227		*/
228	8	protected function readPunctuation() {
229	8	return new Token(Token::TYPE_PUNCTUATION, $this->input->next());
230		}
231
232		/**
233		* @param callable $predicate
234		*
235		* @return string
236		*/
237	24	protected function readWhile(callable $predicate) {
238	24	$str = "";
239	24	while (!$this->input->eof() && call_user_func($predicate, $this->input->peek())) {
240	13	$str .= $this->input->next();
241	13	}
242	24	return $str;
243		}
244
245		/**
246		* @param string $char
247		*
248		* @return bool
249		*/
250	24	protected function isWhitespace($char) {
251	24	return strpos(" \t\n\r", $char) !== false;
252		}
253
254		/**
255		* @param string $char
256		*
257		* @return bool
258		*/
259	17	protected function isDigit($char) {
260	17	return is_numeric($char);
261		}
262
263		/**
264		* @return bool
265		*/
266	19	protected function isDoubleBracketString() {
267	19	return $this->input->peek() == '[' && !$this->input->eof(1) && $this->input->peek(1) == '[';
268		}
269
270		/**
271		* @param string $char
272		*
273		* @return bool
274		*/
275	13	protected function isStartIdentifierCharacter($char) {
276	13	return preg_match('/[a-zA-Z_]/', $char) === 1;
277		}
278
279		/**
280		* @param string $char
281		*
282		* @return bool
283		*/
284	9	protected function isIdentifierCharacter($char) {
285	9	return preg_match('/[a-zA-Z0-9_]/', $char) === 1;
286		}
287
288		/**
289		* @param string $char
290		*
291		* @return bool
292		*/
293	9	protected function isPunctuation($char) {
294	9	return strpos(",{}=[]", $char) !== false;
295		}
296
297		/**
298		* @param string $text
299		*
300		* @return bool
301		*/
302	9	protected function isKeyword($text) {
303	9	return in_array($text, Lua::$luaKeywords);
304		}
305		}

koesie10 / LuaSerializer

Push — master ( 8f1e95...1a0a87 )

TokenStream B

Complexity

Size/Duplication

Coupling/Cohesion

Test Coverage

Importance

22 Methods

How to fix Complexity

Complex Class

Duplication Side-by-Side

Filter issues like