BaseNode::getCurrentNode() - Code Metrics - Inspection of "Big cleanup" - nicoSWD/php-rule-parser - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 066343...e5de66 )

by Nico

created 2017-10-21 15:09 UTC

BaseNode::getCurrentNode() A

↳ Parent: BaseNode

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	2
CRAP Score	1

Importance

Changes

Metric	Value
dl	0
loc	4
ccs	2
cts	2
cp	1
rs	10
c	0
b	0
f	0
cc	1
eloc	2
nc	1
nop	0
crap	1

<?php

declare(strict_types = 1);

/**
 * @license     http://opensource.org/licenses/mit-license.php MIT
 * @link        https://github.com/nicoSWD
 * @author      Nicolas Oelgart <[email protected]>
 */
namespace nicoSWD\Rules\AST\Nodes;

use nicoSWD\Rules\AST;
use nicoSWD\Rules\AST\TokenCollection;
use nicoSWD\Rules\Parser;
use nicoSWD\Rules\TokenType;
use nicoSWD\Rules\Core\CallableFunction;
use nicoSWD\Rules\Exceptions\ParserException;
use nicoSWD\Rules\Tokens;
use nicoSWD\Rules\Tokens\BaseToken;
use nicoSWD\Rules\Tokens\TokenComment;
use nicoSWD\Rules\Tokens\TokenMethod;
use nicoSWD\Rules\Tokens\TokenNewline;
use nicoSWD\Rules\Tokens\TokenSpace;

abstract class BaseNode
{
    /** @var AST */
    protected $ast;

    /** @var string */
    protected $methodName = '';

    /** @var int */
    protected $methodOffset = 0;

    public function __construct(AST $ast)
    {
        $this->ast = $ast;
    }

    abstract public function getNode(): BaseToken;

    /**
     * Looks ahead, but does not move the pointer.
     */
    protected function hasMethodCall(): bool
    {
        $stackClone = $this->ast->getStack()->getClone();

        while ($stackClone->valid()) {
            $stackClone->next();

            if (!$token = $stackClone->current()) {
                break;
            } elseif ($this->isIgnoredToken($token)) {
                continue;
            } elseif ($token instanceof TokenMethod) {
                $this->methodName = $token->getValue();
                $this->methodOffset = $token->getOffset();

                return true;
            } else {
                break;
            }
        }

        return false;
    }

    public function getMethod(BaseToken $token): CallableFunction
    {
        $methodName = $this->getMethodName();
        $methodClass = '\nicoSWD\Rules\Core\Methods\\' . ucfirst($methodName);

        if (!class_exists($methodClass)) {
            $current = $this->getCurrentNode();

            throw new ParserException(sprintf(
                'undefined is not a function at position %d on line %d',
                $current->getPosition(),
                $current->getLine()
            ));
        }

        /** @var CallableFunction $instance */
        $instance = new $methodClass($token);

        if ($instance->getName() !== $methodName) {
            throw new ParserException(
                'undefined is not a function'
            );
        }

        return $instance;
    }

    private function getMethodName(): string
    {
        do {
            $this->ast->next();
        } while ($this->getCurrentNode()->getOffset() < $this->methodOffset);

        return trim(ltrim(rtrim($this->methodName, "\r\n("), '.'));
    }

    public function getArrayItems(): TokenCollection
    {
        return $this->getCommaSeparatedValues(TokenType::SQUARE_BRACKETS);
    }

    public function getArguments(): TokenCollection
    {
        return $this->getCommaSeparatedValues(TokenType::PARENTHESES);
    }

    public function getCurrentNode()
    {
        return $this->ast->getStack()->current();
    }

    public function getParser(): Parser
    {
        return $this->ast->parser;
    }

    private function getCommaSeparatedValues(int $stopAt): TokenCollection
    {
        $commaExpected = false;
        $items = new TokenCollection();

        do {
            $this->ast->next();

            if (!$current = $this->ast->current()) {
                throw new ParserException('Unexpected end of string');
            }

            if ($current->getType() === TokenType::VALUE) {
                if ($commaExpected) {
                    throw ParserException::unexpectedToken($current);
                }

                $commaExpected = true;
                $items->attach($current);
            } elseif ($current instanceof Tokens\TokenComma) {
                if (!$commaExpected) {
                    throw ParserException::unexpectedToken($current);
                }

                $commaExpected = false;
            } elseif ($current->getType() === $stopAt) {
                break;
            } elseif (!$this->isIgnoredToken($current)) {
                throw ParserException::unexpectedToken($current);
            }
        } while ($this->ast->valid());

        if (!$commaExpected && $items->count() > 0) {
            throw new ParserException(sprintf(
                'Unexpected "," at position %d on line %d',
                $current->getPosition(),
                $current->getLine()
            ));
        }

        $items->rewind();

        return $items;
    }

    private function isIgnoredToken(BaseToken $token): bool
    {
        return (
            $token instanceof TokenSpace ||
            $token instanceof TokenNewline ||
            $token instanceof TokenComment
        );
    }
}


1		<?php
2
3		declare(strict_types = 1);
4
5		/**
6		* @license http://opensource.org/licenses/mit-license.php MIT
7		* @link https://github.com/nicoSWD
8		* @author Nicolas Oelgart <[email protected]>
9		*/
10		namespace nicoSWD\Rules\AST\Nodes;
11
12		use nicoSWD\Rules\AST;
13		use nicoSWD\Rules\AST\TokenCollection;
14		use nicoSWD\Rules\Parser;
15		use nicoSWD\Rules\TokenType;
16		use nicoSWD\Rules\Core\CallableFunction;
17		use nicoSWD\Rules\Exceptions\ParserException;
18		use nicoSWD\Rules\Tokens;
19		use nicoSWD\Rules\Tokens\BaseToken;
20		use nicoSWD\Rules\Tokens\TokenComment;
21		use nicoSWD\Rules\Tokens\TokenMethod;
22		use nicoSWD\Rules\Tokens\TokenNewline;
23		use nicoSWD\Rules\Tokens\TokenSpace;
24
25		abstract class BaseNode
26		{
27		/** @var AST */
28		protected $ast;
29
30		/** @var string */
31		protected $methodName = '';
32
33		/** @var int */
34		protected $methodOffset = 0;
35
36	204	public function __construct(AST $ast)
37		{
38	204	$this->ast = $ast;
39	204	}
40
41		abstract public function getNode(): BaseToken;
42
43		/**
44		* Looks ahead, but does not move the pointer.
45		*/
46	192	protected function hasMethodCall(): bool
47		{
48	192	$stackClone = $this->ast->getStack()->getClone();
49
50	192	while ($stackClone->valid()) {
51	192	$stackClone->next();
52
53	192	if (!$token = $stackClone->current()) {
54	98	break;
55	190	} elseif ($this->isIgnoredToken($token)) {
56	128	continue;
57	190	} elseif ($token instanceof TokenMethod) {
58	108	$this->methodName = $token->getValue();
59	108	$this->methodOffset = $token->getOffset();
60
61	108	return true;
62		} else {
63	170	break;
64		}
65		}
66
67	172	return false;
68		}
69
70	108	public function getMethod(BaseToken $token): CallableFunction
71		{
72	108	$methodName = $this->getMethodName();
73	108	$methodClass = '\nicoSWD\Rules\Core\Methods\\' . ucfirst($methodName);
74
75	108	if (!class_exists($methodClass)) {
76	2	$current = $this->getCurrentNode();
77
78	2	throw new ParserException(sprintf(
79	2	'undefined is not a function at position %d on line %d',
80	2	$current->getPosition(),
81	2	$current->getLine()
82		));
83		}
84
85		/** @var CallableFunction $instance */
86	106	$instance = new $methodClass($token);
87
88	106	if ($instance->getName() !== $methodName) {
89	2	throw new ParserException(
90	2	'undefined is not a function'
91		);
92		}
93
94	104	return $instance;
95		}
96
97	108	private function getMethodName(): string
98		{
99		do {
100	108	$this->ast->next();
101	108	} while ($this->getCurrentNode()->getOffset() < $this->methodOffset);
102
103	108	return trim(ltrim(rtrim($this->methodName, "\r\n("), '.'));
104		}
105
106	52	public function getArrayItems(): TokenCollection
107		{
108	52	return $this->getCommaSeparatedValues(TokenType::SQUARE_BRACKETS);
109		}
110
111	126	public function getArguments(): TokenCollection
112		{
113	126	return $this->getCommaSeparatedValues(TokenType::PARENTHESES);
114		}
115
116	178	public function getCurrentNode()
117		{
118	178	return $this->ast->getStack()->current();
119		}
120
121	28	public function getParser(): Parser
122		{
123	28	return $this->ast->parser;
124		}
125
126	148	private function getCommaSeparatedValues(int $stopAt): TokenCollection
127		{
128	148	$commaExpected = false;
129	148	$items = new TokenCollection();
130
131		do {
132	148	$this->ast->next();
133
134	148	if (!$current = $this->ast->current()) {
135	4	throw new ParserException('Unexpected end of string');
136		}
137
138	148	if ($current->getType() === TokenType::VALUE) {
139	124	if ($commaExpected) {
140	4	throw ParserException::unexpectedToken($current);
141		}
142
143	124	$commaExpected = true;
144	124	$items->attach($current);
145	148	} elseif ($current instanceof Tokens\TokenComma) {
146	60	if (!$commaExpected) {
147	4	throw ParserException::unexpectedToken($current);
148		}
149
150	60	$commaExpected = false;
151	148	} elseif ($current->getType() === $stopAt) {
152	132	break;
153	64	} elseif (!$this->isIgnoredToken($current)) {
154	4	throw ParserException::unexpectedToken($current);
155		}
156	124	} while ($this->ast->valid());
157
158	132	if (!$commaExpected && $items->count() > 0) {
159	6	throw new ParserException(sprintf(
160	6	'Unexpected "," at position %d on line %d',
161	6	$current->getPosition(),
162	6	$current->getLine()
163		));
164		}
165
166	126	$items->rewind();
167
168	126	return $items;
169		}
170
171	190	private function isIgnoredToken(BaseToken $token): bool
172		{
173		return (
174	190	$token instanceof TokenSpace \|\|
175	190	$token instanceof TokenNewline \|\|
176	190	$token instanceof TokenComment
177		);
178		}
179		}
180

nicoSWD / php-rule-parser

Push — master ( 066343...e5de66 )

BaseNode::getCurrentNode() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like