Parser::parse() - Code Metrics - K-Phoen/rulerz - Measure and Improve Code Quality continuously with Scrutinizer

Parser::parse() A
last analyzed 2020-01-03 13:52 UTC

↳ Parent: Parser
Complexity

Conditions	2
Paths	2
Size

Total Lines
Duplication

Lines	0
Ratio	0 %
Importance

Changes
Metric	Value
cc	2
nc	2
nop	1
dl	0
loc	12
rs	9.8666
c	0
b	0
f	0
<?php

declare(strict_types=1);

namespace RulerZ\Parser;

use Hoa\Compiler;
use Hoa\File;
use Hoa\Ruler;
use Hoa\Visitor;

use RulerZ\Model;

/**
 * Parses a rule.
 *
 * A valid rule returns an AST:
 * ```
 * $parser = new Parser;
 * $ast = $parser->parse('foo = 42');
 * ```
 *
 * And an invalid one throw an exception:
 * ```should_throw
 * $parser = new Parser;
 * $parser->parse('foo = ');
 * ```
 */
class Parser implements Visitor\Visit
{
    /**
     * Parser.
     *
     * @var \Hoa\Compiler\Llk\Parser
     */
    private $parser;

    /**
     * Root.
     *
     * @var \RulerZ\Model\Rule object
     */
    private $root;

    /**
     * Next positional parameter index.
     *
     * @var int
     */
    private $nextParameterIndex = 0;

    /**
     * Parses the rule into an equivalent AST.
     *
     * @param string $rule The rule represented as a string.
     *
     * @return \RulerZ\Model\Rule
     */
    public function parse($rule)
    {
        if ($this->parser === null) {
            $this->parser = Compiler\Llk::load(
                new File\Read(__DIR__.'/../Grammar.pp')
            );
        }

        $this->nextParameterIndex = 0;

        return $this->visit($this->parser->parse($rule));
    }

    /**
     * Visit an element.
     *
     * @param   \Hoa\Visitor\Element  $element    Element to visit.
     * @param   mixed                 &$handle    Handle (reference).
     * @param   mixed                 $eldnah     Handle (not reference).
     *
     * @return  \RulerZ\Model\Rule
     *
     * @throws  \Hoa\Ruler\Exception\Interpreter
     */
    public function visit(Visitor\Element $element, &$handle = null, $eldnah = null)
    {
        /** @var \Hoa\Compiler\Llk\TreeNode $element */
        $id = $element->getId();
        $variable = false !== $eldnah;

        switch ($id) {
            case '#expression':
                $this->root = new Model\Rule();
                $this->root->expression = $element->getChild(0)->accept(
<?php

/**
 * @property int $x
 * @property int $y
 * @property string $text
 */
class MyLabel
{
    private $properties;

    private $allowedProperties = array('x', 'y', 'text');

    public function __get($name)
    {
        if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) {
            return $properties[$name];
        } else {
            return null;
        }
    }

    public function __set($name, $value)
    {
        if (in_array($name, $this->allowedProperties)) {
            $properties[$name] = $value;
        } else {
            throw new \LogicException("Property $name is not defined.");
        }
    }

}
                    $this,
                    $handle,
                    $eldnah
                );

                return $this->root;

            case '#operation':
                $children = $element->getChildren();
                $left = $children[0]->accept($this, $handle, $eldnah);
                $right = $children[2]->accept($this, $handle, $eldnah);
                $name = $children[1]->accept($this, $handle, false);

                return $this->root->_operator(
class Author {
    private $name;

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

    public function getName() {
        return $this->name;
    }
}

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}
                    $name,
                    [$left, $right],
                    false
                );

            case '#variable_access':
                $children = $element->getChildren();
                $name = $children[0]->accept($this, $handle, $eldnah);
                array_shift($children);

                foreach ($children as $child) {
                    $_child = $child->accept($this, $handle, $eldnah);

                    switch ($child->getId()) {
                        case '#attribute_access':
                            $name->attribute($_child);

                            break;
                    }
                }

                return $name;

            case '#attribute_access':
                return $element->getChild(0)->accept($this, $handle, false);

            case '#array_declaration':
                $out = [];

                foreach ($element->getChildren() as $child) {
                    $out[] = $child->accept($this, $handle, $eldnah);
                }

                return $out;
class Author {
    private $name;

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

    public function getName() {
        return $this->name;
    }
}

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}

            case '#function_call':
                $children = $element->getChildren();
                $name = $children[0]->accept($this, $handle, false);
                array_shift($children);

                $arguments = [];

                foreach ($children as $child) {
                    $arguments[] = $child->accept($this, $handle, $eldnah);
                }

                return $this->root->_operator(
class Author {
    private $name;

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

    public function getName() {
        return $this->name;
    }
}

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}
                    $name,
                    $arguments,
                    true
                );

            case '#and':
            case '#or':
            case '#xor':
                $name = substr($id, 1);
                $children = $element->getChildren();
                $left = $children[0]->accept($this, $handle, $eldnah);
                $right = $children[1]->accept($this, $handle, $eldnah);

                return $this->root->operation($name, [$left, $right]);
class Author {
    private $name;

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

    public function getName() {
        return $this->name;
    }
}

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}

            case '#not':
                return $this->root->operation(
class Author {
    private $name;

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

    public function getName() {
        return $this->name;
    }
}

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}
                    'not',
                    [$element->getChild(0)->accept($this, $handle, $eldnah)]
                );

            case 'token':
                $token = $element->getValueToken();
                $value = $element->getValueValue();

                switch ($token) {
                    case 'identifier':
                        return true === $variable ? $this->root->variable($value) : $value;
class Author {
    private $name;

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

    public function getName() {
        return $this->name;
    }
}

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}

                    case 'named_parameter':

                        return new Model\Parameter(substr($value, 1));
class Author {
    private $name;

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

    public function getName() {
        return $this->name;
    }
}

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}

                    case 'positional_parameter':
                        $index = $this->nextParameterIndex++;

                        return new Model\Parameter($index);
class Author {
    private $name;

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

    public function getName() {
        return $this->name;
    }
}

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}

                    case 'true':
                        return true;
class Author {
    private $name;

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

    public function getName() {
        return $this->name;
    }
}

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}

                    case 'false':
                        return false;
class Author {
    private $name;

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

    public function getName() {
        return $this->name;
    }
}

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}

                    case 'null':
                        return null;

                    case 'float':
                        return (float) $value;
class Author {
    private $name;

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

    public function getName() {
        return $this->name;
    }
}

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}

                    case 'integer':
                        return (int) $value;
class Author {
    private $name;

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

    public function getName() {
        return $this->name;
    }
}

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}

                    case 'string':
                        return str_replace(
class Author {
    private $name;

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

    public function getName() {
        return $this->name;
    }
}

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}
                            '\\'.$value[0],
                            $value[0],
                            substr($value, 1, -1)
                        );

                    default:
                        throw new Ruler\Exception\Interpreter('Token %s is unknown.', 0, $token);
                }

            default:
                throw new Ruler\Exception\Interpreter('Element %s is unknown.', 1, $id);
        }
    }
}

1			<?php
2
3			declare(strict_types=1);
4
5			namespace RulerZ\Parser;
6
7			use Hoa\Compiler;
8			use Hoa\File;
9			use Hoa\Ruler;
10			use Hoa\Visitor;
11
12			use RulerZ\Model;
13
14			/**
15			* Parses a rule.
16			*
17			* A valid rule returns an AST:
18			* ```
19			* $parser = new Parser;
20			* $ast = $parser->parse('foo = 42');
21			* ```
22			*
23			* And an invalid one throw an exception:
24			* ```should_throw
25			* $parser = new Parser;
26			* $parser->parse('foo = ');
27			* ```
28			*/
29			class Parser implements Visitor\Visit
30			{
31			/**
32			* Parser.
33			*
34			* @var \Hoa\Compiler\Llk\Parser
35			*/
36			private $parser;
37
38			/**
39			* Root.
40			*
K-Phoen / rulerz

Parser::parse() A last analyzed 2020-01-03 13:52 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

Parser::parse() A
last analyzed 2020-01-03 13:52 UTC
