Parser::delimited() - Code Metrics - koesie10/LuaSerializer - Measure and Improve Code Quality continuously with Scrutinizer

Parser::delimited() B
last analyzed 2016-10-20 19:27 UTC

↳ Parent: Parser

Complexity

Conditions	5
Paths	4

Size

Total Lines	21
Code Lines	16

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	17
CRAP Score	5

Importance

Changes

Metric	Value
dl	0
loc	21
c	0
b	0
f	0
ccs	17
cts	17
cp	1
rs	8.7624
nc	4
cc	5
eloc	16
nop	4
crap	5

<?php

namespace Vlaswinkel\Lua;

use Vlaswinkel\Lua\AST\ASTNode;
use Vlaswinkel\Lua\AST\NilASTNode;
use Vlaswinkel\Lua\AST\NumberASTNode;
use Vlaswinkel\Lua\AST\StringASTNode;
use Vlaswinkel\Lua\AST\TableASTNode;
use Vlaswinkel\Lua\AST\TableEntryASTNode;

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

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

    /**
     * @return ASTNode
     *
     * @throws ParseException
     */
    public function parse() {
        $result = $this->parseInternal();

        if (!$this->input->eof()) {
            if ($result instanceof StringASTNode && $this->isPunctuation('=')) {
                $this->skipPunctuation('=');
                $value = $this->parseInternal();

                return new TableASTNode([new TableEntryASTNode($value, $result)]);
/** @return stdClass|null */
function mayReturnNull() { }

function doesNotAcceptNull(stdClass $x) { }

// With potential error.
function withoutCheck() {
    $x = mayReturnNull();
    doesNotAcceptNull($x); // Potential error here.
}

// Safe - Alternative 1
function withCheck1() {
    $x = mayReturnNull();
    if ( ! $x instanceof stdClass) {
        throw new \LogicException('$x must be defined.');
    }
    doesNotAcceptNull($x);
}

// Safe - Alternative 2
function withCheck2() {
    $x = mayReturnNull();
    if ($x instanceof stdClass) {
        doesNotAcceptNull($x);
    }
}
            }
            
            $this->input->error('Parser has finished parsing, but end of file was not reached. Next character is ' . $this->input->peek()->getValue());
        }

        return $result;
    }

    /**
     * @return ASTNode
     *
     * @throws ParseException
     */
    protected function parseInternal() {
        if ($this->isPunctuation('{')) {
            return $this->parseTable();
        }
        if ($this->isPunctuation('[')) {
            return $this->parseTableKey();
        }
        $token = $this->input->next();
        if ($token->getType() == Token::TYPE_NUMBER) {
            return new NumberASTNode($token->getValue());
        }
        if ($token->getType() == Token::TYPE_STRING || $token->getType() == Token::TYPE_IDENTIFIER) {
            return new StringASTNode($token->getValue());
        }
        if ($token->getType() == Token::TYPE_KEYWORD) {
            if ($token->getValue() === 'nil') {
                return new NilASTNode();
            } else {
                $this->input->error('Unexpected keyword: ' . $token->getValue());
            }
        }
        $this->unexpected();
    }

    /**
     * @return TableASTNode
     */
    protected function parseTable() {
        return new TableASTNode(
            $this->delimited(
                '{',
                '}',
                ',',
                [$this, 'parseTableEntry']
            )
        );
    }

    /**
     * @return TableEntryASTNode
     */
    protected function parseTableEntry() {
        $token = $this->parseInternal();
        if ($this->isPunctuation('=')) {
            $this->skipPunctuation('=');
            $value = $this->parseInternal();
            return new TableEntryASTNode(
                $value,
/** @return stdClass|null */
function mayReturnNull() { }

function doesNotAcceptNull(stdClass $x) { }

// With potential error.
function withoutCheck() {
    $x = mayReturnNull();
    doesNotAcceptNull($x); // Potential error here.
}

// Safe - Alternative 1
function withCheck1() {
    $x = mayReturnNull();
    if ( ! $x instanceof stdClass) {
        throw new \LogicException('$x must be defined.');
    }
    doesNotAcceptNull($x);
}

// Safe - Alternative 2
function withCheck2() {
    $x = mayReturnNull();
    if ($x instanceof stdClass) {
        doesNotAcceptNull($x);
    }
}
                $token
            );
        }
        return new TableEntryASTNode($token);
/** @return stdClass|null */
function mayReturnNull() { }

function doesNotAcceptNull(stdClass $x) { }

// With potential error.
function withoutCheck() {
    $x = mayReturnNull();
    doesNotAcceptNull($x); // Potential error here.
}

// Safe - Alternative 1
function withCheck1() {
    $x = mayReturnNull();
    if ( ! $x instanceof stdClass) {
        throw new \LogicException('$x must be defined.');
    }
    doesNotAcceptNull($x);
}

// Safe - Alternative 2
function withCheck2() {
    $x = mayReturnNull();
    if ($x instanceof stdClass) {
        doesNotAcceptNull($x);
    }
}
    }

    /**
     * @return ASTNode

     */
    protected function parseTableKey() {
        $this->skipPunctuation('[');
        $token = $this->parseInternal();
        $this->skipPunctuation(']');
        return $token;
    }

    /**
     * @param string   $start
     * @param string   $stop
     * @param string   $separator
     * @param callable $parser
     *
     * @return array
     */
    protected function delimited($start, $stop, $separator, callable $parser) {
        $a     = [];
        $first = true;
        $this->skipPunctuation($start);
        while (!$this->input->eof()) {
            if ($this->isPunctuation($stop)) {
                break;
            }
            if ($first) {
                $first = false;
            } else {
                $this->skipPunctuation($separator);
            }
            if ($this->isPunctuation($stop)) {
                break;
            }
            $a[] = $parser();
        }
        $this->skipPunctuation($stop);
        return $a;
    }

    /**
     * @param string|null $char
     *
     * @return bool
     */
    protected function isPunctuation($char = null) {
        $token = $this->input->peek();
        return $token && $token->getType() == Token::TYPE_PUNCTUATION && ($char === null || $token->getValue(
            ) == $char);
    }

    /**
     * @param string|null $char
     *
     * @throws ParseException
     */
    protected function skipPunctuation($char = null) {
        if ($this->isPunctuation($char)) {
            $this->input->next();
        } else {
            $this->input->error('Expecting punctuation: "' . $char . '"');
        }
    }

    /**
     * @throws ParseException
     */
    protected function unexpected() {
        $this->input->error('Unexpected token: ' . json_encode($this->input->peek()));
    }
}

1		<?php
2
3		namespace Vlaswinkel\Lua;
4
5		use Vlaswinkel\Lua\AST\ASTNode;
6		use Vlaswinkel\Lua\AST\NilASTNode;
7		use Vlaswinkel\Lua\AST\NumberASTNode;
8		use Vlaswinkel\Lua\AST\StringASTNode;
9		use Vlaswinkel\Lua\AST\TableASTNode;
10		use Vlaswinkel\Lua\AST\TableEntryASTNode;
11
12		/**
13		* Class Parser
14		*
15		* @see http://lisperator.net/pltut/parser/the-parser
16		*
17		* @author Koen Vlaswinkel <[email protected]>
18		* @package Vlaswinkel\Lua
19		*/
20		class Parser {
21		/**
22		* @var TokenStream
23		*/
24		private $input;
25
26		/**
27		* Parser constructor.
28		*
29		* @param TokenStream $input
30		*/
31	24	public function __construct(TokenStream $input) {
32	24	$this->input = $input;
33	24	}
34
35		/**
36		* @return ASTNode
37		*
38		* @throws ParseException
39		*/
40	24	public function parse() {
41	24	$result = $this->parseInternal();
42
43	22	if (!$this->input->eof()) {
44	2	if ($result instanceof StringASTNode && $this->isPunctuation('=')) {
45	2	$this->skipPunctuation('=');
46	2	$value = $this->parseInternal();
47
48	2	return new TableASTNode([new TableEntryASTNode($value, $result)]);
		0 ignored issues – show Bug introduced 2016-08-20 09:17 UTC by Report Bug Copy Issue Report It seems like `$value` defined by `$this->parseInternal()` on line `46` can be `null`; however, `Vlaswinkel\Lua\AST\Table...yASTNode::__construct()` does not accept `null`, maybe add an additional type check? Unless you are absolutely sure that the expression can never be null because of other conditions, we strongly recommend to add an additional type check to your code: /** @return stdClass\|null */ function mayReturnNull() { } function doesNotAcceptNull(stdClass $x) { } // With potential error. function withoutCheck() { $x = mayReturnNull(); doesNotAcceptNull($x); // Potential error here. } // Safe - Alternative 1 function withCheck1() { $x = mayReturnNull(); if ( ! $x instanceof stdClass) { throw new \LogicException('$x must be defined.'); } doesNotAcceptNull($x); } // Safe - Alternative 2 function withCheck2() { $x = mayReturnNull(); if ($x instanceof stdClass) { doesNotAcceptNull($x); } } Loading history...
49		}
50
51		$this->input->error('Parser has finished parsing, but end of file was not reached. Next character is ' . $this->input->peek()->getValue());
52		}
53
54	20	return $result;
55		}
56
57		/**
58		* @return ASTNode
59		*
60		* @throws ParseException
61		*/
62	24	protected function parseInternal() {
63	24	if ($this->isPunctuation('{')) {
64	13	return $this->parseTable();
65		}
66	23	if ($this->isPunctuation('[')) {
67	4	return $this->parseTableKey();
68		}
69	23	$token = $this->input->next();
70	23	if ($token->getType() == Token::TYPE_NUMBER) {
71	8	return new NumberASTNode($token->getValue());
72		}
73	21	if ($token->getType() == Token::TYPE_STRING \|\| $token->getType() == Token::TYPE_IDENTIFIER) {
74	18	return new StringASTNode($token->getValue());
75		}
76	5	if ($token->getType() == Token::TYPE_KEYWORD) {
77	5	if ($token->getValue() === 'nil') {
78	4	return new NilASTNode();
79		} else {
80	1	$this->input->error('Unexpected keyword: ' . $token->getValue());
81		}
82		}
83		$this->unexpected();
84		}
85
86		/**
87		* @return TableASTNode
88		*/
89	13	protected function parseTable() {
90	13	return new TableASTNode(
91	13	$this->delimited(
92	13	'{',
93	13	'}',
94	13	',',
95	13	[$this, 'parseTableEntry']
96	13	)
97	12	);
98		}
99
100		/**
101		* @return TableEntryASTNode
102		*/
103	12	protected function parseTableEntry() {
104	12	$token = $this->parseInternal();
105	12	if ($this->isPunctuation('=')) {
106	11	$this->skipPunctuation('=');
107	11	$value = $this->parseInternal();
108	11	return new TableEntryASTNode(
109	11	$value,
		0 ignored issues – show Bug introduced 2016-08-20 09:17 UTC by Report Bug Copy Issue Report It seems like `$value` defined by `$this->parseInternal()` on line `107` can be `null`; however, `Vlaswinkel\Lua\AST\Table...yASTNode::__construct()` does not accept `null`, maybe add an additional type check? Unless you are absolutely sure that the expression can never be null because of other conditions, we strongly recommend to add an additional type check to your code: /** @return stdClass\|null */ function mayReturnNull() { } function doesNotAcceptNull(stdClass $x) { } // With potential error. function withoutCheck() { $x = mayReturnNull(); doesNotAcceptNull($x); // Potential error here. } // Safe - Alternative 1 function withCheck1() { $x = mayReturnNull(); if ( ! $x instanceof stdClass) { throw new \LogicException('$x must be defined.'); } doesNotAcceptNull($x); } // Safe - Alternative 2 function withCheck2() { $x = mayReturnNull(); if ($x instanceof stdClass) { doesNotAcceptNull($x); } } Loading history...
110		$token
111	11	);
112		}
113	5	return new TableEntryASTNode($token);
		0 ignored issues – show Bug introduced 2016-08-20 09:17 UTC by Report Bug Copy Issue Report It seems like `$token` defined by `$this->parseInternal()` on line `104` can be `null`; however, `Vlaswinkel\Lua\AST\Table...yASTNode::__construct()` does not accept `null`, maybe add an additional type check? Unless you are absolutely sure that the expression can never be null because of other conditions, we strongly recommend to add an additional type check to your code: /** @return stdClass\|null */ function mayReturnNull() { } function doesNotAcceptNull(stdClass $x) { } // With potential error. function withoutCheck() { $x = mayReturnNull(); doesNotAcceptNull($x); // Potential error here. } // Safe - Alternative 1 function withCheck1() { $x = mayReturnNull(); if ( ! $x instanceof stdClass) { throw new \LogicException('$x must be defined.'); } doesNotAcceptNull($x); } // Safe - Alternative 2 function withCheck2() { $x = mayReturnNull(); if ($x instanceof stdClass) { doesNotAcceptNull($x); } } Loading history...
114		}
115
116		/**
117		* @return ASTNode
		0 ignored issues – show Documentation introduced 2016-08-20 09:17 UTC by Report Bug Copy Issue Report Should the return type not be `ASTNode\|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...
118		*/
119	4	protected function parseTableKey() {
120	4	$this->skipPunctuation('[');
121	4	$token = $this->parseInternal();
122	4	$this->skipPunctuation(']');
123	4	return $token;
124		}
125
126		/**
127		* @param string $start
128		* @param string $stop
129		* @param string $separator
130		* @param callable $parser
131		*
132		* @return array
133		*/
134	13	protected function delimited($start, $stop, $separator, callable $parser) {
135	13	$a = [];
136	13	$first = true;
137	13	$this->skipPunctuation($start);
138	13	while (!$this->input->eof()) {
139	13	if ($this->isPunctuation($stop)) {
140	12	break;
141		}
142	12	if ($first) {
143	12	$first = false;
144	12	} else {
145	5	$this->skipPunctuation($separator);
146		}
147	12	if ($this->isPunctuation($stop)) {
148	2	break;
149		}
150	12	$a[] = $parser();
151	12	}
152	12	$this->skipPunctuation($stop);
153	12	return $a;
154		}
155
156		/**
157		* @param string\|null $char
158		*
159		* @return bool
160		*/
161	24	protected function isPunctuation($char = null) {
162	24	$token = $this->input->peek();
163	24	return $token && $token->getType() == Token::TYPE_PUNCTUATION && ($char === null \|\| $token->getValue(
164	24	) == $char);
165		}
166
167		/**
168		* @param string\|null $char
169		*
170		* @throws ParseException
171		*/
172	14	protected function skipPunctuation($char = null) {
173	14	if ($this->isPunctuation($char)) {
174	14	$this->input->next();
175	14	} else {
176	1	$this->input->error('Expecting punctuation: "' . $char . '"');
177		}
178	14	}
179
180		/**
181		* @throws ParseException
182		*/
183		protected function unexpected() {
184		$this->input->error('Unexpected token: ' . json_encode($this->input->peek()));
185		}
186		}

koesie10 / LuaSerializer

Parser::delimited() B last analyzed 2016-10-20 19:27 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

Parser::delimited() B
last analyzed 2016-10-20 19:27 UTC