ConditionParser::get() - Code Metrics - Inspection of "[BUGFIX] Instantiate form validator with `ObjectMa..." - romm/formz - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — typo3-v8-compatibility ( ae4db2...381377 )

by Romain

created 2017-02-13 10:01 UTC

ConditionParser::get() A

↳ Parent: ConditionParser

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Importance

Changes

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

<?php
/*
 * 2017 Romain CANON <[email protected]>
 *
 * This file is part of the TYPO3 Formz project.
 * It is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License, either
 * version 3 of the License, or any later version.
 *
 * For the full copyright and license information, see:
 * http://www.gnu.org/licenses/gpl-3.0.html
 */

namespace Romm\Formz\Condition\Parser;

use Romm\Formz\Condition\Parser\Node\BooleanNode;
use Romm\Formz\Condition\Parser\Node\ConditionNode;
use Romm\Formz\Condition\Parser\Node\NodeInterface;
use Romm\Formz\Condition\Parser\Node\NullNode;
use Romm\Formz\Configuration\Form\Condition\Activation\ActivationInterface;
use Romm\Formz\Configuration\Form\Condition\Activation\EmptyActivation;
use Romm\Formz\Service\Traits\FacadeInstanceTrait;
use TYPO3\CMS\Core\SingletonInterface;
use TYPO3\CMS\Core\Utility\GeneralUtility;
use TYPO3\CMS\Extbase\Error\Error;
use TYPO3\CMS\Extbase\Error\Result;

/**
 * A parser capable of parsing a validation condition string from a field
 * configuration, by creating a tree containing nodes which represents the
 * logical operations.
 *
 * Calling the function `parse()` will return an instance of `ConditionTree`
 * which will contain the full nodes tree, as well as a result instance.
 *
 * Parsing errors are handled, and stored in the tree result instance. When a
 * condition has been parsed, it is highly recommended to check if the result
 * contains errors before using the tree.
 *
 * Below is a list of what is currently supported by the parser:
 *  - Logical AND: defined by `&&`, it is no more than a logical "and" operator.
 *  - Logical OR: defined by `||`, same as above.
 *  - Operation groups: you can group several operation between parenthesis:
 *    `(...)`.
 *  - Condition names: represented by the items names in the `Activation`
 *    instance, there real meaning is a boolean result.
 */
class ConditionParser implements SingletonInterface
{
    use FacadeInstanceTrait;

    const LOGICAL_AND = '&&';
    const LOGICAL_OR = '||';

    /**
     * @var Result
     */
    private $result;

    /**
     * @var ActivationInterface
     */
    private $condition;

    /**
     * @var ConditionParserScope
     */
    private $scope;

    /**
     * See class documentation.
     *
     * @param ActivationInterface $condition
     * @return ConditionTree
     */
    public function parse(ActivationInterface $condition)
    {
        $this->resetParser($condition);

        $rootNode = ($condition instanceof EmptyActivation)
            ? NullNode::get()
            : $this->getNodeRecursive();

        return GeneralUtility::makeInstance(ConditionTree::class, $rootNode, $this->result);
    }

    /**
     * @param ActivationInterface $condition
     */
    private function resetParser(ActivationInterface $condition)
    {
        $this->condition = $condition;
        $this->result = GeneralUtility::makeInstance(Result::class);

        $this->scope = $this->getNewScope();
        $this->scope->setExpression($this->splitConditionExpression($condition->getCondition()));
    }

    /**
     * Recursive function to convert an array of condition data to a nodes tree.
     *
     * @return NodeInterface|null
     */
    private function getNodeRecursive()
    {
        while (false === empty($this->scope->getExpression())) {
            if ($this->result->hasErrors()) {
                break;
            }

            $currentExpression = $this->scope->getExpression();
            $this->processToken($currentExpression[0]);
            $this->processLogicalAndNode();
        }

        $this->processLastLogicalOperatorNode();

        $node = $this->scope->getNode();
        unset($this->scope);

        return $node;
    }

    /**
     * Will process a given token, which should be in the list of know tokens.
     *
     * @param string $token
     * @return $this
     */
    private function processToken($token)
    {
        switch ($token) {
            case ')':
                $this->processTokenClosingParenthesis();
                break;
            case '(':
                $this->processTokenOpeningParenthesis();
                break;
            case self::LOGICAL_OR:
            case self::LOGICAL_AND:
                $this->processTokenLogicalOperator($token);
                break;
            default:
                $this->processTokenCondition($token);
                break;
        }

        return $this;
    }

    /**
     * Will process the opening parenthesis token `(`.
     *
     * A new scope will be created, containing the whole tokens list, which are
     * located between the opening parenthesis and the closing one. The scope
     * will be processed in a new scope, then the result is stored and the
     * process can keep up.
     */
    private function processTokenOpeningParenthesis()
    {
        $groupNode = $this->getGroupNode($this->scope->getExpression());

        $scopeSave = $this->scope;
        $expression = array_slice($scopeSave->getExpression(), count($groupNode) + 2);
        $scopeSave->setExpression($expression);

        $this->scope = $this->getNewScope();
        $this->scope->setExpression($groupNode);

        $node = $this->getNodeRecursive();

        $this->scope = $scopeSave;
        $this->scope->setNode($node);
/** @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);
    }
}
    }

    /**
     * Will process the closing parenthesis token `)`.
     *
     * This function should not be called, because the closing parenthesis
     * should always be handled by the opening parenthesis token handler.
     */
    private function processTokenClosingParenthesis()
    {
        $this->addError('Parenthesis closes invalid group.', 1457969163);
    }

    /**
     * Will process the logical operator tokens `&&` and `||`.
     *
     * Depending on the type of the operator, the process will change.
     *
     * @param string $operator
     */
    private function processTokenLogicalOperator($operator)
    {
        if (null === $this->scope->getNode()) {
            $this->addError('Logical operator must be preceded by a valid operation.', 1457544986);
        } else {
            if (self::LOGICAL_OR === $operator) {
                if (null !== $this->scope->getLastOrNode()) {
                    /*
                     * If a `or` node was already registered, we create a new
                     * boolean node to join the two nodes.
                     */
                    $node = $this->getNode(
                        BooleanNode::class,
                        [$this->scope->getLastOrNode(), $this->scope->getNode(), $operator]
                    );
                    $this->scope->setNode($node);
                }

                $this->scope->setLastOrNode($this->scope->getNode());
            } else {
                $this->scope
                    ->setCurrentLeftNode($this->scope->getNode())
                    ->deleteNode();
            }

            $this->scope
                ->setCurrentOperator($operator)
                ->shiftExpression();
        }
    }

    /**
     * Will process the condition token.
     *
     * The condition must exist in the list of items of the condition.
     *
     * @param string $condition
     */
    private function processTokenCondition($condition)
    {
        if (false === $this->condition->hasItem($condition)) {
            $this->addError('The condition "' . $condition . '" does not exist.', 1457628378);
        } else {
            $node = $this->getNode(
                ConditionNode::class,
                [
                    $condition,
                    $this->condition->getItem($condition)
                ]
            );
            $this->scope
                ->setNode($node)
                ->shiftExpression();
        }
    }

    /**
     * Will check if a "logical and" node should be created, depending on which
     * tokens were processed before.
     *
     * @return $this
     */
    private function processLogicalAndNode()
    {
        if (null !== $this->scope->getCurrentLeftNode()
            && null !== $this->scope->getNode()
            && null !== $this->scope->getCurrentOperator()
        ) {
            $node = $this->getNode(
                BooleanNode::class,
                [$this->scope->getCurrentLeftNode(), $this->scope->getNode(), $this->scope->getCurrentOperator()]
            );
            $this->scope
                ->setNode($node)
                ->deleteCurrentLeftNode()
                ->deleteCurrentOperator();
        }

        return $this;
    }

    /**
     * Will check if a last logical operator node is remaining.
     *
     * @return $this
     */
    private function processLastLogicalOperatorNode()
    {
        if (null !== $this->scope->getCurrentLeftNode()) {
            $this->addError('Logical operator must be followed by a valid operation.', 1457545071);
        } elseif (null !== $this->scope->getLastOrNode()) {
            $node = $this->getNode(
                BooleanNode::class,
                [$this->scope->getLastOrNode(), $this->scope->getNode(), self::LOGICAL_OR]
            );
            $this->scope->setNode($node);
        }

        return $this;
    }

    /**
     * @param string $nodeClassName
     * @param array  $arguments
     * @return NodeInterface
     */
    private function getNode($nodeClassName, array $arguments)
    {
        return call_user_func_array(
            [GeneralUtility::class, 'makeInstance'],
            array_merge([$nodeClassName], $arguments)
        );
    }

    /**
     * Will fetch a group of operations in a given array: the first item must be
     * a parenthesis. If its closing parenthesis is found, then the inner part
     * of the group is returned. Example:
     *
     * Input: (cond1 && (cond2 || cond3)) && cond4
     * Output: cond1 && (cond2 || cond3)
     *
     * @param array $expression
     * @return array
     */
    private function getGroupNode(array $expression)
    {
        $index = $this->getGroupNodeClosingIndex($expression);
        $finalSplitCondition = [];

        if (-1 === $index) {
            $this->addError('Parenthesis not correctly closed.', 1457544856);
        } else {
            for ($i = 1; $i < $index; $i++) {
                $finalSplitCondition[] = $expression[$i];
            }
        }

        return $finalSplitCondition;
    }

    /**
     * Returns the index of the closing parenthesis that matches the opening
     * parenthesis at index 0 of the given expression.
     *
     * @param array $expression
     * @return int
     */
    private function getGroupNodeClosingIndex(array $expression)
    {
        $parenthesis = 1;
        $index = 0;

        while ($parenthesis > 0) {
            $index++;
            if ($index > count($expression)) {
                $index = -1;
                break;
            }

            if ('(' === $expression[$index]) {
                $parenthesis++;
            } elseif (')' === $expression[$index]) {
                $parenthesis--;
            }
        }

        return $index;
    }

    /**
     * Will split a condition expression string in an exploded array where each
     * entry represents an operation.
     *
     * @param string $condition
     * @return array
     */
    private function splitConditionExpression($condition)
    {
        preg_match_all('/(\w+|\(|\)|\&\&|\|\|)/', trim($condition), $result);

        return $result[0];
    }

    /**
     * @return ConditionParserScope
     */
    private function getNewScope()
    {
        return new ConditionParserScope;
    }

    /**
     * @param string $message
     * @param int    $code
     */
    private function addError($message, $code)
    {
        $error = new Error($message, $code);
        $this->result->addError($error);
    }
}


1			<?php
2			/*
3			* 2017 Romain CANON <[email protected]>
4			*
5			* This file is part of the TYPO3 Formz project.
6			* It is free software; you can redistribute it and/or modify it
7			* under the terms of the GNU General Public License, either
8			* version 3 of the License, or any later version.
9			*
10			* For the full copyright and license information, see:
11			* http://www.gnu.org/licenses/gpl-3.0.html
12			*/
13
14			namespace Romm\Formz\Condition\Parser;
15
16			use Romm\Formz\Condition\Parser\Node\BooleanNode;
17			use Romm\Formz\Condition\Parser\Node\ConditionNode;
18			use Romm\Formz\Condition\Parser\Node\NodeInterface;
19			use Romm\Formz\Condition\Parser\Node\NullNode;
20			use Romm\Formz\Configuration\Form\Condition\Activation\ActivationInterface;
21			use Romm\Formz\Configuration\Form\Condition\Activation\EmptyActivation;
22			use Romm\Formz\Service\Traits\FacadeInstanceTrait;
23			use TYPO3\CMS\Core\SingletonInterface;
24			use TYPO3\CMS\Core\Utility\GeneralUtility;
25			use TYPO3\CMS\Extbase\Error\Error;
26			use TYPO3\CMS\Extbase\Error\Result;
27
28			/**
29			* A parser capable of parsing a validation condition string from a field
30			* configuration, by creating a tree containing nodes which represents the
31			* logical operations.
32			*
33			* Calling the function `parse()` will return an instance of `ConditionTree`
34			* which will contain the full nodes tree, as well as a result instance.
35			*
36			* Parsing errors are handled, and stored in the tree result instance. When a
37			* condition has been parsed, it is highly recommended to check if the result
38			* contains errors before using the tree.
39			*
40			* Below is a list of what is currently supported by the parser:
41			* - Logical AND: defined by `&&`, it is no more than a logical "and" operator.
42			* - Logical OR: defined by `\|\|`, same as above.
43			* - Operation groups: you can group several operation between parenthesis:
44			* `(...)`.
45			* - Condition names: represented by the items names in the `Activation`
46			* instance, there real meaning is a boolean result.
47			*/
48			class ConditionParser implements SingletonInterface
49			{
50			use FacadeInstanceTrait;
51
52			const LOGICAL_AND = '&&';
53			const LOGICAL_OR = '\|\|';
54
55			/**
56			* @var Result
57			*/
58			private $result;
59
60			/**
61			* @var ActivationInterface
62			*/
63			private $condition;
64
65			/**
66			* @var ConditionParserScope
67			*/
68			private $scope;
69
70			/**
71			* See class documentation.
72			*
73			* @param ActivationInterface $condition
74			* @return ConditionTree
75			*/
76			public function parse(ActivationInterface $condition)
77			{
78			$this->resetParser($condition);
79
80			$rootNode = ($condition instanceof EmptyActivation)
81			? NullNode::get()
82			: $this->getNodeRecursive();
83
84			return GeneralUtility::makeInstance(ConditionTree::class, $rootNode, $this->result);
85			}
86
87			/**
88			* @param ActivationInterface $condition
89			*/
90			private function resetParser(ActivationInterface $condition)
91			{
92			$this->condition = $condition;
93			$this->result = GeneralUtility::makeInstance(Result::class);
94
95			$this->scope = $this->getNewScope();
96			$this->scope->setExpression($this->splitConditionExpression($condition->getCondition()));
97			}
98
99			/**
100			* Recursive function to convert an array of condition data to a nodes tree.
101			*
102			* @return NodeInterface\|null
103			*/
104			private function getNodeRecursive()
105			{
106			while (false === empty($this->scope->getExpression())) {
107			if ($this->result->hasErrors()) {
108			break;
109			}
110
111			$currentExpression = $this->scope->getExpression();
112			$this->processToken($currentExpression[0]);
113			$this->processLogicalAndNode();
114			}
115
116			$this->processLastLogicalOperatorNode();
117
118			$node = $this->scope->getNode();
119			unset($this->scope);
120
121			return $node;
122			}
123
124			/**
125			* Will process a given token, which should be in the list of know tokens.
126			*
127			* @param string $token
128			* @return $this
129			*/
130			private function processToken($token)
131			{
132			switch ($token) {
133			case ')':
134			$this->processTokenClosingParenthesis();
135			break;
136			case '(':
137			$this->processTokenOpeningParenthesis();
138			break;
139			case self::LOGICAL_OR:
140			case self::LOGICAL_AND:
141			$this->processTokenLogicalOperator($token);
142			break;
143			default:
144			$this->processTokenCondition($token);
145			break;
146			}
147
148			return $this;
149			}
150
151			/**
152			* Will process the opening parenthesis token `(`.
153			*
154			* A new scope will be created, containing the whole tokens list, which are
155			* located between the opening parenthesis and the closing one. The scope
156			* will be processed in a new scope, then the result is stored and the
157			* process can keep up.
158			*/
159			private function processTokenOpeningParenthesis()
160			{
161			$groupNode = $this->getGroupNode($this->scope->getExpression());
162
163			$scopeSave = $this->scope;
164			$expression = array_slice($scopeSave->getExpression(), count($groupNode) + 2);
165			$scopeSave->setExpression($expression);
166
167			$this->scope = $this->getNewScope();
168			$this->scope->setExpression($groupNode);
169
170			$node = $this->getNodeRecursive();
171
172			$this->scope = $scopeSave;
173			$this->scope->setNode($node);
			0 ignored issues – show Bug introduced 2017-01-25 09:33 UTC by Report Bug Copy Issue Report It seems like `$node` defined by `$this->getNodeRecursive()` on line `170` can be `null`; however, `Romm\Formz\Condition\Par...nParserScope::setNode()` 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...
174			}
175
176			/**
177			* Will process the closing parenthesis token `)`.
178			*
179			* This function should not be called, because the closing parenthesis
180			* should always be handled by the opening parenthesis token handler.
181			*/
182			private function processTokenClosingParenthesis()
183			{
184			$this->addError('Parenthesis closes invalid group.', 1457969163);
185			}
186
187			/**
188			* Will process the logical operator tokens `&&` and `\|\|`.
189			*
190			* Depending on the type of the operator, the process will change.
191			*
192			* @param string $operator
193			*/
194			private function processTokenLogicalOperator($operator)
195			{
196			if (null === $this->scope->getNode()) {
197			$this->addError('Logical operator must be preceded by a valid operation.', 1457544986);
198			} else {
199			if (self::LOGICAL_OR === $operator) {
200			if (null !== $this->scope->getLastOrNode()) {
201			/*
202			* If a `or` node was already registered, we create a new
203			* boolean node to join the two nodes.
204			*/
205			$node = $this->getNode(
206			BooleanNode::class,
207			[$this->scope->getLastOrNode(), $this->scope->getNode(), $operator]
208			);
209			$this->scope->setNode($node);
210			}
211
212			$this->scope->setLastOrNode($this->scope->getNode());
213			} else {
214			$this->scope
215			->setCurrentLeftNode($this->scope->getNode())
216			->deleteNode();
217			}
218
219			$this->scope
220			->setCurrentOperator($operator)
221			->shiftExpression();
222			}
223			}
224
225			/**
226			* Will process the condition token.
227			*
228			* The condition must exist in the list of items of the condition.
229			*
230			* @param string $condition
231			*/
232			private function processTokenCondition($condition)
233			{
234			if (false === $this->condition->hasItem($condition)) {
235			$this->addError('The condition "' . $condition . '" does not exist.', 1457628378);
236			} else {
237			$node = $this->getNode(
238			ConditionNode::class,
239			[
240			$condition,
241			$this->condition->getItem($condition)
242			]
243			);
244			$this->scope
245			->setNode($node)
246			->shiftExpression();
247			}
248			}
249
250			/**
251			* Will check if a "logical and" node should be created, depending on which
252			* tokens were processed before.
253			*
254			* @return $this
255			*/
256			private function processLogicalAndNode()
257			{
258			if (null !== $this->scope->getCurrentLeftNode()
259			&& null !== $this->scope->getNode()
260			&& null !== $this->scope->getCurrentOperator()
261			) {
262			$node = $this->getNode(
263			BooleanNode::class,
264			[$this->scope->getCurrentLeftNode(), $this->scope->getNode(), $this->scope->getCurrentOperator()]
265			);
266			$this->scope
267			->setNode($node)
268			->deleteCurrentLeftNode()
269			->deleteCurrentOperator();
270			}
271
272			return $this;
273			}
274
275			/**
276			* Will check if a last logical operator node is remaining.
277			*
278			* @return $this
279			*/
280			private function processLastLogicalOperatorNode()
281			{
282			if (null !== $this->scope->getCurrentLeftNode()) {
283			$this->addError('Logical operator must be followed by a valid operation.', 1457545071);
284			} elseif (null !== $this->scope->getLastOrNode()) {
285			$node = $this->getNode(
286			BooleanNode::class,
287			[$this->scope->getLastOrNode(), $this->scope->getNode(), self::LOGICAL_OR]
288			);
289			$this->scope->setNode($node);
290			}
291
292			return $this;
293			}
294
295			/**
296			* @param string $nodeClassName
297			* @param array $arguments
298			* @return NodeInterface
299			*/
300			private function getNode($nodeClassName, array $arguments)
301			{
302			return call_user_func_array(
303			[GeneralUtility::class, 'makeInstance'],
304			array_merge([$nodeClassName], $arguments)
305			);
306			}
307
308			/**
309			* Will fetch a group of operations in a given array: the first item must be
310			* a parenthesis. If its closing parenthesis is found, then the inner part
311			* of the group is returned. Example:
312			*
313			* Input: (cond1 && (cond2 \|\| cond3)) && cond4
314			* Output: cond1 && (cond2 \|\| cond3)
315			*
316			* @param array $expression
317			* @return array
318			*/
319			private function getGroupNode(array $expression)
320			{
321			$index = $this->getGroupNodeClosingIndex($expression);
322			$finalSplitCondition = [];
323
324			if (-1 === $index) {
325			$this->addError('Parenthesis not correctly closed.', 1457544856);
326			} else {
327			for ($i = 1; $i < $index; $i++) {
328			$finalSplitCondition[] = $expression[$i];
329			}
330			}
331
332			return $finalSplitCondition;
333			}
334
335			/**
336			* Returns the index of the closing parenthesis that matches the opening
337			* parenthesis at index 0 of the given expression.
338			*
339			* @param array $expression
340			* @return int
341			*/
342			private function getGroupNodeClosingIndex(array $expression)
343			{
344			$parenthesis = 1;
345			$index = 0;
346
347			while ($parenthesis > 0) {
348			$index++;
349			if ($index > count($expression)) {
350			$index = -1;
351			break;
352			}
353
354			if ('(' === $expression[$index]) {
355			$parenthesis++;
356			} elseif (')' === $expression[$index]) {
357			$parenthesis--;
358			}
359			}
360
361			return $index;
362			}
363
364			/**
365			* Will split a condition expression string in an exploded array where each
366			* entry represents an operation.
367			*
368			* @param string $condition
369			* @return array
370			*/
371			private function splitConditionExpression($condition)
372			{
373			preg_match_all('/(\w+\|\(\|\)\|\&\&\|\\|\\|)/', trim($condition), $result);
374
375			return $result[0];
376			}
377
378			/**
379			* @return ConditionParserScope
380			*/
381			private function getNewScope()
382			{
383			return new ConditionParserScope;
384			}
385
386			/**
387			* @param string $message
388			* @param int $code
389			*/
390			private function addError($message, $code)
391			{
392			$error = new Error($message, $code);
393			$this->result->addError($error);
394			}
395			}
396

romm / formz

Push — typo3-v8-compatibility ( ae4db2...381377 )

ConditionParser::get() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like