RuleParser::parse() - Code Metrics - Inspection of "solved TODOs regarding WithName." - lechimp-p/dicto.php - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( cc2765...340ff8 )

by Richard

created 2016-08-01 18:27 UTC

RuleParser::parse() A

↳ Parent: RuleParser

Complexity

Conditions	1
Paths	1

Size

Total Lines	6
Code Lines	5

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	5
CRAP Score	1

Importance

Changes	2
Bugs	0	Features	1

Metric	Value
dl	0
loc	6
ccs	5
cts	5
cp	1
rs	9.4285
c	2
b	0
f	1
cc	1
eloc	5
nc	1
nop	1
crap	1

<?php
/******************************************************************************
 * An implementation of dicto (scg.unibe.ch/dicto) in and for PHP.
 *
 * Copyright (c) 2016 Richard Klees <[email protected]>
 * 
 * This software is licensed under The MIT License. You should have received
 * a copy of the license along with the code.
 */

namespace Lechimp\Dicto\Definition;

use Lechimp\Dicto\Rules\ArgumentParser;
use Lechimp\Dicto\Rules\Ruleset;
use Lechimp\Dicto\Variables as V;
use Lechimp\Dicto\Rules as R;

/**
 * Parser for Rulesets.
 */
class RuleParser extends Parser implements ArgumentParser {
    const ASSIGNMENT_RE = "(\w+)\s*=\s*";
    const STRING_RE = "[\"]((([\\\\][\"])|[^\"])+)[\"]";
    const RULE_MODE_RE = "must|can(not)?";

    /**
     * @var Variable[]
     */
    protected $predefined_variables;

    public function __construct() {
        parent::__construct();
        $this->predefined_variables = array

            ( new V\Classes()
            , new V\Functions()
            , new V\Globals()
            , new V\Files()
            , new V\Methods()
            // TODO: Add some language constructs here...
            );

        $known_schemas = array
            ( new R\ContainText()
            , new R\DependOn()
            , new R\Invoke()
            );

        // Assignment 
        $this->symbol(self::ASSIGNMENT_RE);

        // Any
        $this->operator("{")
            ->null_denotation_is(function(array &$matches) {

                $arr = array();
                while(true) {
                    $arr[] = $this->variable(0);
                    if ($this->is_current_token_operator("}")) {
                        $this->advance_operator("}");
                        return new V\Any($arr);
                    }
                    $this->advance_operator(",");
                }
            });
        $this->operator("}");
        $this->operator(",");

        // Except
        $this->symbol("except", 10)
            ->left_denotation_is(function($left, array &$matches) {

                if (!($left instanceof V\Variable)) {
                    throw new ParserException
                        ("Expected a variable at the left of except.");
                }
                $right = $this->variable(10);
                return new V\Except($left, $right);
            });

        // WithName
        $this->symbol("with name:", 20)
            ->left_denotation_is(function($left, array &$matches) {

                if (!($left instanceof V\Variable)) {
                    throw new ParserException
                        ("Expected a variable at the left of \"with name:\".");
                }
                $right = $this->string(20);
                return new V\WithName($right, $left);
            });

        // Strings
        $this->symbol(self::STRING_RE);

        // Rules
        $this->symbol("only");
        $this->symbol(self::RULE_MODE_RE, 0)
            ->null_denotation_is(function (array &$matches) {
                if ($matches[0] == "can") {
                    return R\Rule::MODE_ONLY_CAN;
                }
                if ($matches[0] == "must") {
                    return R\Rule::MODE_MUST;
                }
                if ($matches[0] == "cannot") {
                    return R\Rule::MODE_CANNOT;
                }
                throw new \LogicException("Unexpected \"".$matches[0]."\".");
            });
        $this->add_schemas($known_schemas);

        // Names
        $this->literal("\w+", function (array &$matches) {
                return $this->get_variable($matches[0]);
            });

        $this->symbol("\n");
    }

    // IMPLEMENTATION OF Parser

    /**
     * @return  Ruleset
     */
    public function parse($source) {
        $this->variables = array();

        $this->rules = array();
class MyClass { }

$x = new MyClass();
$x->foo = true;
        $this->add_predefined_variables();
        return parent::parse($source);
    }

    /**
     * Parses the top level statements in the rules file.
     *
     * @return  Ruleset 
     */
    protected function root() {
        while (true) {
            // drop empty lines
            while ($this->is_current_token_matched_by("\n")) {
                $this->advance("\n");
            }
            if ($this->is_end_of_file_reached()) {
                break;
            }

            // A top level statments is either..
            // ..an assignment to a variable.
            if ($this->is_current_token_matched_by(self::ASSIGNMENT_RE)) {
                $this->variable_assignment();
            }
            // ..or a rule declaration
            else {
                $this->rule_declaration();
            }

            if ($this->is_end_of_file_reached()) {
                break;
            }
            $this->advance("\n");
        }
        $this->purge_predefined_variables();
        return new Ruleset($this->variables, $this->rules);

    }

    // EXPRESSION TYPES

    /**
     * Fetch a rule mode from the stream.
     *
     * @return mixed
     */
    protected function rule_mode() {
        $this->is_current_token_matched_by(self::RULE_MODE_RE);
        $t = $this->current_symbol();
        $m = $this->current_match();
        $this->fetch_next_token();
        $mode = $t->null_denotation($m);
        return $mode;
    }

    /**
     * Fetch a string from the stream.
     *
     * @return  string
     */
    protected function string($right_binding_power = 0) {

        if (!$this->is_current_token_matched_by(self::STRING_RE)) {
            throw new ParserException("Expected string.");
        }
        $m = $this->current_match();
        $this->fetch_next_token();
        return  str_replace("\\\"", "\"",
                    str_replace("\\n", "\n",
                        $m[1]));
    }

    /**
     * Fetch a variable from the stream.
     *
     * @return  V\Variable
     */
    protected function variable($right_binding_power = 0) {
        $t = $this->current_symbol();
        $m = $this->current_match();
        $this->fetch_next_token();
        $left = $t->null_denotation($m);

        while ($right_binding_power < $this->token[0]->binding_power()) {
            $t = $this->current_symbol();
            $m = $this->current_match();
            $this->fetch_next_token();
            $left = $t->left_denotation($left, $m);
        }

        if (!($left instanceof V\Variable)) {
            throw new ParserException("Expected variable.");
        }

        return $left;
    }

    /**
     * Fetch a rule schema and its arguments from the stream.
     *
     * @return  array   (R\Schema, array)
     */
    protected function rule_schema($right_binding_power = 0) {

        $t = $this->current_symbol();
        $m = $this->current_match();
        $this->fetch_next_token();
        $schema = $t->null_denotation($m);
        if (!($schema instanceof R\Schema)) {
            throw new ParserException("Expected name of a rule schema.");
        }
        return $schema;
    }

    // TOP LEVEL STATEMENTS

    /**
     * Process a variable assignment.
     *
     * @return  null
     */
    protected function variable_assignment() {
        $m = $this->current_match(); 
        $this->fetch_next_token();
        $def = $this->variable();
        $this->add_variable($m[1], $def);
    }

    /**
     * Process a rule declaration.
     *
     * @return  null
     */
    protected function rule_declaration() {
        if ($this->is_current_token_matched_by("only")) {
            $this->advance("only");
        }
        $var = $this->variable();
        $mode = $this->rule_mode();
        $schema = $this->rule_schema();
        $this->is_start_of_rule_arguments = true;
        $arguments = $schema->fetch_arguments($this);
        assert('is_array($arguments)');
        $this->rules[] = new R\Rule($mode, $var, $schema, $arguments);
    }


    // HANDLING OF VARIABLES

    /**
     * Add a variable to the variables currently known.
     *
     * @param   string      $name
     * @param   V\Variable  $def
     * @return null
     */
    protected function add_variable($name, V\Variable $def) {
        assert('is_string($name)');
        if (array_key_exists($name, $this->variables)) {

            throw new ParserException("Variable '$name' already defined.");
        }
        assert('$def instanceof Lechimp\\Dicto\\Variables\\Variable');
        $this->variables[$name] = $def->withName($name);

    }

    /**
     * Get a predefined variable.
     *
     * @param   string  $name
     * @return  V\Variable
     */
    protected function get_variable($name) {
        if (!array_key_exists($name, $this->variables)) {

            throw new ParserException("Unknown variable '$name'.");
        }
        return $this->variables[$name];

    }

    /**
     * Add all predefined variables to the current set of variables.
     *
     * @return null
     */
    protected function add_predefined_variables() {
        foreach ($this->predefined_variables as $predefined_var) {
            $this->add_variable($predefined_var->name(), $predefined_var);
        }
    }

    /**
     * Purge all predefined variables from the current set of variables.
     *
     * @return null
     */
    protected function purge_predefined_variables() {
        foreach ($this->predefined_variables as $predefined_var) {
            unset($this->variables[$predefined_var->name()]);
        }
    }

    // HANDLING OF SCHEMAS

    /**
     * Add a list of schemas to the parser.
     *
     * @param   Schema[]
     * @return  null
     */
    protected function add_schemas(array &$schemas) {
        foreach ($schemas as $schema) {
            $this->add_schema($schema);
        }
    }

    /**
     * Add a schema to the parser.
     *
     * @param   R/Schema
     * @return  null
     */
    protected function add_schema(R\Schema $schema) {
        $this->symbol($schema->name())
            ->null_denotation_is(function(array &$_) use ($schema) {

                return $schema;
            });
    }

    // IMPLEMENTATION OF ArgumentParser

    /**
     * @var bool
     */
    protected $is_start_of_rule_arguments = false;

    protected function maybe_fetch_argument_delimiter() {
        if (!$this->is_start_of_rule_arguments) {
            $this->advance_operator(",");
            $this->is_start_of_rule_arguments = false;
        }
    }

    /**
     * @inheritdoc
     */
    public function fetch_string() {
        $this->maybe_fetch_argument_delimiter();
        return $this->string();
    }

    /**
     * @inheritdoc
     */
    public function fetch_variable() {
        $this->maybe_fetch_argument_delimiter();
        return $this->variable();
    }
}


1		<?php
2		/******************************************************************************
3		* An implementation of dicto (scg.unibe.ch/dicto) in and for PHP.
4		*
5		* Copyright (c) 2016 Richard Klees <[email protected]>
6		*
7		* This software is licensed under The MIT License. You should have received
8		* a copy of the license along with the code.
9		*/
10
11		namespace Lechimp\Dicto\Definition;
12
13		use Lechimp\Dicto\Rules\ArgumentParser;
14		use Lechimp\Dicto\Rules\Ruleset;
15		use Lechimp\Dicto\Variables as V;
16		use Lechimp\Dicto\Rules as R;
17
18		/**
19		* Parser for Rulesets.
20		*/
21		class RuleParser extends Parser implements ArgumentParser {
22		const ASSIGNMENT_RE = "(\w+)\s=\s";
23		const STRING_RE = "[\"]((([\\\\][\"])\|[^\"])+)[\"]";
24		const RULE_MODE_RE = "must\|can(not)?";
25
26		/**
27		* @var Variable[]
28		*/
29		protected $predefined_variables;
30
31	25	public function __construct() {
32	25	parent::__construct();
33	25	$this->predefined_variables = array
		0 ignored issues – show Documentation Bug introduced 2016-08-01 18:35 UTC by Report Bug Copy Issue Report It seems like `array(new \Lechimp\Dicto...to\Variables\Methods())` of type `array<integer,object<Lec...\Variables\\Methods>"}>` is incompatible with the declared type `array<integer,object<Lec...o\Definition\Variable>>` of property `$predefined_variables`. Our type inference engine has found an assignment to a property that is incompatible with the declared type of that property. Either this assignment is in error or the assigned type should be added to the documentation/type hint for that property.. Loading history...
34	25	( new V\Classes()
35	25	, new V\Functions()
36	25	, new V\Globals()
37	25	, new V\Files()
38	25	, new V\Methods()
39		// TODO: Add some language constructs here...
40	25	);
41
42		$known_schemas = array
43	25	( new R\ContainText()
44	25	, new R\DependOn()
45	25	, new R\Invoke()
46	25	);
47
48		// Assignment
49	25	$this->symbol(self::ASSIGNMENT_RE);
50
51		// Any
52	25	$this->operator("{")
53		->null_denotation_is(function(array &$matches) {
		0 ignored issues – show Unused Code introduced 2016-08-01 18:35 UTC by Report Bug Copy Issue Report The parameter `$matches` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history...
54	7	$arr = array();
55	7	while(true) {
56	7	$arr[] = $this->variable(0);
57	7	if ($this->is_current_token_operator("}")) {
58	7	$this->advance_operator("}");
59	7	return new V\Any($arr);
60		}
61	7	$this->advance_operator(",");
62	7	}
63	25	});
64	25	$this->operator("}");
65	25	$this->operator(",");
66
67		// Except
68	25	$this->symbol("except", 10)
69		->left_denotation_is(function($left, array &$matches) {
		0 ignored issues – show Unused Code introduced 2016-08-01 18:35 UTC by Report Bug Copy Issue Report The parameter `$matches` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history...
70	7	if (!($left instanceof V\Variable)) {
71		throw new ParserException
72		("Expected a variable at the left of except.");
73		}
74	7	$right = $this->variable(10);
75	7	return new V\Except($left, $right);
76	25	});
77
78		// WithName
79	25	$this->symbol("with name:", 20)
80		->left_denotation_is(function($left, array &$matches) {
		0 ignored issues – show Unused Code introduced 2016-08-01 18:35 UTC by Report Bug Copy Issue Report The parameter `$matches` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history...
81	7	if (!($left instanceof V\Variable)) {
82		throw new ParserException
83		("Expected a variable at the left of \"with name:\".");
84		}
85	7	$right = $this->string(20);
86	7	return new V\WithName($right, $left);
87	25	});
88
89		// Strings
90	25	$this->symbol(self::STRING_RE);
91
92		// Rules
93	25	$this->symbol("only");
94	25	$this->symbol(self::RULE_MODE_RE, 0)
95		->null_denotation_is(function (array &$matches) {
96	11	if ($matches[0] == "can") {
97	1	return R\Rule::MODE_ONLY_CAN;
98		}
99	10	if ($matches[0] == "must") {
100	7	return R\Rule::MODE_MUST;
101		}
102	3	if ($matches[0] == "cannot") {
103	3	return R\Rule::MODE_CANNOT;
104		}
105		throw new \LogicException("Unexpected \"".$matches[0]."\".");
106	25	});
107	25	$this->add_schemas($known_schemas);
108
109		// Names
110		$this->literal("\w+", function (array &$matches) {
111	20	return $this->get_variable($matches[0]);
112	25	});
113
114	25	$this->symbol("\n");
115	25	}
116
117		// IMPLEMENTATION OF Parser
118
119		/**
120		* @return Ruleset
121		*/
122	25	public function parse($source) {
123	25	$this->variables = array();
		0 ignored issues – show Bug introduced 2016-08-01 18:35 UTC by Report Bug Copy Issue Report The property `variables` does not seem to exist. Did you mean `predefined_variables`? An attempt at access to an undefined property has been detected. This may either be a typographical error or the property has been renamed but there are still references to its old name. If you really want to allow access to undefined properties, you can define magic methods to allow access. See the php core documentation on Overloading. Loading history...
124	25	$this->rules = array();
		0 ignored issues – show Bug introduced 2016-08-01 18:35 UTC by Report Bug Copy Issue Report The property `rules` does not exist. Did you maybe forget to declare it? In PHP it is possible to write to properties without declaring them. For example, the following is perfectly valid PHP code: class MyClass { } $x = new MyClass(); $x->foo = true; Generally, it is a good practice to explictly declare properties to avoid accidental typos and provide IDE auto-completion: class MyClass { public $foo; } $x = new MyClass(); $x->foo = true; Loading history...
125	25	$this->add_predefined_variables();
126	25	return parent::parse($source);
127		}
128
129		/**
130		* Parses the top level statements in the rules file.
131		*
132		* @return Ruleset
133		*/
134	16	protected function root() {
135	16	while (true) {
136		// drop empty lines
137	16	while ($this->is_current_token_matched_by("\n")) {
138	5	$this->advance("\n");
139	5	}
140	16	if ($this->is_end_of_file_reached()) {
141	6	break;
142		}
143
144		// A top level statments is either..
145		// ..an assignment to a variable.
146	15	if ($this->is_current_token_matched_by(self::ASSIGNMENT_RE)) {
147	8	$this->variable_assignment();
148	8	}
149		// ..or a rule declaration
150		else {
151	11	$this->rule_declaration();
152		}
153
154	15	if ($this->is_end_of_file_reached()) {
155	10	break;
156		}
157	6	$this->advance("\n");
158	6	}
159	16	$this->purge_predefined_variables();
160	16	return new Ruleset($this->variables, $this->rules);
		0 ignored issues – show Bug introduced 2016-08-01 18:35 UTC by Report Bug Copy Issue Report The property `variables` does not seem to exist. Did you mean `predefined_variables`? An attempt at access to an undefined property has been detected. This may either be a typographical error or the property has been renamed but there are still references to its old name. If you really want to allow access to undefined properties, you can define magic methods to allow access. See the php core documentation on Overloading. Loading history...
161		}
162
163		// EXPRESSION TYPES
164
165		/**
166		* Fetch a rule mode from the stream.
167		*
168		* @return mixed
169		*/
170	11	protected function rule_mode() {
171	11	$this->is_current_token_matched_by(self::RULE_MODE_RE);
172	11	$t = $this->current_symbol();
173	11	$m = $this->current_match();
174	11	$this->fetch_next_token();
175	11	$mode = $t->null_denotation($m);
176	11	return $mode;
177		}
178
179		/**
180		* Fetch a string from the stream.
181		*
182		* @return string
183		*/
184	15	protected function string($right_binding_power = 0) {
		0 ignored issues – show Unused Code introduced 2016-08-01 18:35 UTC by Report Bug Copy Issue Report The parameter `$right_binding_power` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history...
185	15	if (!$this->is_current_token_matched_by(self::STRING_RE)) {
186		throw new ParserException("Expected string.");
187		}
188	15	$m = $this->current_match();
189	15	$this->fetch_next_token();
190	15	return str_replace("\\\"", "\"",
191	15	str_replace("\\n", "\n",
192	15	$m[1]));
193		}
194
195		/**
196		* Fetch a variable from the stream.
197		*
198		* @return V\Variable
199		*/
200	20	protected function variable($right_binding_power = 0) {
201	20	$t = $this->current_symbol();
202	20	$m = $this->current_match();
203	20	$this->fetch_next_token();
204	20	$left = $t->null_denotation($m);
205
206	20	while ($right_binding_power < $this->token[0]->binding_power()) {
207	10	$t = $this->current_symbol();
208	10	$m = $this->current_match();
209	10	$this->fetch_next_token();
210	10	$left = $t->left_denotation($left, $m);
211	10	}
212
213	20	if (!($left instanceof V\Variable)) {
214		throw new ParserException("Expected variable.");
215		}
216
217	20	return $left;
218		}
219
220		/**
221		* Fetch a rule schema and its arguments from the stream.
222		*
223		* @return array (R\Schema, array)
224		*/
225	11	protected function rule_schema($right_binding_power = 0) {
		0 ignored issues – show Unused Code introduced 2016-08-01 18:35 UTC by Report Bug Copy Issue Report The parameter `$right_binding_power` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history...
226	11	$t = $this->current_symbol();
227	11	$m = $this->current_match();
228	11	$this->fetch_next_token();
229	11	$schema = $t->null_denotation($m);
230	11	if (!($schema instanceof R\Schema)) {
231		throw new ParserException("Expected name of a rule schema.");
232		}
233	11	return $schema;
234		}
235
236		// TOP LEVEL STATEMENTS
237
238		/**
239		* Process a variable assignment.
240		*
241		* @return null
242		*/
243	8	protected function variable_assignment() {
244	8	$m = $this->current_match();
245	8	$this->fetch_next_token();
246	8	$def = $this->variable();
247	8	$this->add_variable($m[1], $def);
248	8	}
249
250		/**
251		* Process a rule declaration.
252		*
253		* @return null
254		*/
255	11	protected function rule_declaration() {
256	11	if ($this->is_current_token_matched_by("only")) {
257	1	$this->advance("only");
258	1	}
259	11	$var = $this->variable();
260	11	$mode = $this->rule_mode();
261	11	$schema = $this->rule_schema();
262	11	$this->is_start_of_rule_arguments = true;
263	11	$arguments = $schema->fetch_arguments($this);
264	11	assert('is_array($arguments)');
265	11	$this->rules[] = new R\Rule($mode, $var, $schema, $arguments);
266	11	}
267
268
269		// HANDLING OF VARIABLES
270
271		/**
272		* Add a variable to the variables currently known.
273		*
274		* @param string $name
275		* @param V\Variable $def
276		* @return null
277		*/
278	25	protected function add_variable($name, V\Variable $def) {
279	25	assert('is_string($name)');
280	25	if (array_key_exists($name, $this->variables)) {
		0 ignored issues – show Bug introduced 2016-08-01 18:35 UTC by Report Bug Copy Issue Report The property `variables` does not seem to exist. Did you mean `predefined_variables`? An attempt at access to an undefined property has been detected. This may either be a typographical error or the property has been renamed but there are still references to its old name. If you really want to allow access to undefined properties, you can define magic methods to allow access. See the php core documentation on Overloading. Loading history...
281		throw new ParserException("Variable '$name' already defined.");
282		}
283	25	assert('$def instanceof Lechimp\\Dicto\\Variables\\Variable');
284	25	$this->variables[$name] = $def->withName($name);
		0 ignored issues – show Bug introduced 2016-08-01 18:35 UTC by Report Bug Copy Issue Report The property `variables` does not seem to exist. Did you mean `predefined_variables`? An attempt at access to an undefined property has been detected. This may either be a typographical error or the property has been renamed but there are still references to its old name. If you really want to allow access to undefined properties, you can define magic methods to allow access. See the php core documentation on Overloading. Loading history...
285	25	}
286
287		/**
288		* Get a predefined variable.
289		*
290		* @param string $name
291		* @return V\Variable
292		*/
293	20	protected function get_variable($name) {
294	20	if (!array_key_exists($name, $this->variables)) {
		0 ignored issues – show Bug introduced 2016-08-01 18:35 UTC by Report Bug Copy Issue Report The property `variables` does not seem to exist. Did you mean `predefined_variables`? An attempt at access to an undefined property has been detected. This may either be a typographical error or the property has been renamed but there are still references to its old name. If you really want to allow access to undefined properties, you can define magic methods to allow access. See the php core documentation on Overloading. Loading history...
295		throw new ParserException("Unknown variable '$name'.");
296		}
297	20	return $this->variables[$name];
		0 ignored issues – show Bug introduced 2016-08-01 18:35 UTC by Report Bug Copy Issue Report The property `variables` does not seem to exist. Did you mean `predefined_variables`? An attempt at access to an undefined property has been detected. This may either be a typographical error or the property has been renamed but there are still references to its old name. If you really want to allow access to undefined properties, you can define magic methods to allow access. See the php core documentation on Overloading. Loading history...
298		}
299
300		/**
301		* Add all predefined variables to the current set of variables.
302		*
303		* @return null
304		*/
305	25	protected function add_predefined_variables() {
306	25	foreach ($this->predefined_variables as $predefined_var) {
307	25	$this->add_variable($predefined_var->name(), $predefined_var);
308	25	}
309	25	}
310
311		/**
312		* Purge all predefined variables from the current set of variables.
313		*
314		* @return null
315		*/
316	16	protected function purge_predefined_variables() {
317	16	foreach ($this->predefined_variables as $predefined_var) {
318	16	unset($this->variables[$predefined_var->name()]);
319	16	}
320	16	}
321
322		// HANDLING OF SCHEMAS
323
324		/**
325		* Add a list of schemas to the parser.
326		*
327		* @param Schema[]
328		* @return null
329		*/
330	25	protected function add_schemas(array &$schemas) {
331	25	foreach ($schemas as $schema) {
332	25	$this->add_schema($schema);
333	25	}
334	25	}
335
336		/**
337		* Add a schema to the parser.
338		*
339		* @param R/Schema
340		* @return null
341		*/
342	25	protected function add_schema(R\Schema $schema) {
343	25	$this->symbol($schema->name())
344	25	->null_denotation_is(function(array &$_) use ($schema) {
		0 ignored issues – show Unused Code introduced 2016-08-01 18:35 UTC by Report Bug Copy Issue Report The parameter `$_` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history...
345	11	return $schema;
346	25	});
347	25	}
348
349		// IMPLEMENTATION OF ArgumentParser
350
351		/**
352		* @var bool
353		*/
354		protected $is_start_of_rule_arguments = false;
355
356	11	protected function maybe_fetch_argument_delimiter() {
357	11	if (!$this->is_start_of_rule_arguments) {
358		$this->advance_operator(",");
359		$this->is_start_of_rule_arguments = false;
360		}
361	11	}
362
363		/**
364		* @inheritdoc
365		*/
366	5	public function fetch_string() {
367	5	$this->maybe_fetch_argument_delimiter();
368	5	return $this->string();
369		}
370
371		/**
372		* @inheritdoc
373		*/
374	6	public function fetch_variable() {
375	6	$this->maybe_fetch_argument_delimiter();
376	6	return $this->variable();
377		}
378		}
379

lechimp-p / dicto.php

Push — master ( cc2765...340ff8 )

RuleParser::parse() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like