Railt\Compiler\Reader\Resolver\RulesBuilder

Complexity

Total Complexity

21

Size/Duplication

Total Lines	211
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	6

Test Coverage

Coverage

0%

Importance

Changes

0

12 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	6	1
B	build()	0	26	4
A	isCompleted()	0	4	1
A	add()	0	7	1
A	root()	0	4	2
A	getId()	0	12	3
A	isKept()	0	4	1
A	reduce()	0	16	3
A	reduceToken()	0	10	1
A	reduceConcat()	0	4	1
A	complete()	0	17	2
A	current()	0	4	1

<?php
/**
 * This file is part of Railt package.
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */
declare(strict_types=1);

namespace Railt\Compiler\Reader\Resolver;

use Railt\Compiler\Iterator\SlicedIterator;
use Railt\Compiler\Lexer;
use Railt\Compiler\Reader\Resolver\Builder\Builder;
use Railt\Compiler\Reader\Resolver\Builder\ConcatenationBuilder;
use Railt\Compiler\Reader\Resolver\Builder\TokenBuilder;
use Railt\Io\Readable;
use Railt\Lexer\TokenInterface;

/**
 * Class RulesBuilder
 */
class RulesBuilder
{
    /**
     * @var array
     */
    private $rules;

    /**
     * @var RuleResolver
     */
    private $resolver;

    /**
     * @var array
     */
    private $parsed = [];

    /**
     * @var \SplStack
     */
    private $stack;

    /**
     * @var Readable|null
     */
    private $file;

    /**
     * @var array
     */
    private $mappings = [];

    /**
     * @var int
     */
    private $lastRuleId = 0;

    /**
     * @var string
     */
    private $text = '';

    /**
     * RulesBuilder constructor.
     * @param RuleResolver $resolver
     */
    public function __construct(RuleResolver $resolver)
    {
        $this->resolver = $resolver;
        $this->rules    = $resolver->getRules();
        $this->stack    = new \SplStack();
    }

    /**
     * @return array
     */
    public function build(): array
    {
        foreach ($this->rules as $rule => $tokens) {
            if ($this->isCompleted($rule)) {
                continue;
            }


            $this->file = $this->resolver->getFiles()[$rule];

            $iterator = new SlicedIterator($tokens);

            $this->stack->push($current = $this->root($rule));

            while ($iterator->valid()) {
                $this->text .= $iterator->current()->value() . ' ';

                $this->reduce($iterator->current(), $iterator);
                $iterator->next();
            }

            $this->complete();
        }

        return $this->parsed;
    }

    /**
     * @param string $rule
     * @return bool
     */
    private function isCompleted(string $rule): bool
    {
        return \array_key_exists($rule, $this->parsed);
    }

    /**
     * @param Builder $builder
     * @return RulesBuilder
     */
    private function add(Builder $builder): RulesBuilder
    {
        $this->current()->jump($builder->getId());
        $this->stack->push($builder);

        return $this;
    }

    /**
     * @param string $rule
     * @return ConcatenationBuilder
     */
    private function root(string $rule): ConcatenationBuilder
    {
        return new ConcatenationBuilder($this->getId($rule), $this->isKept($rule) ? $rule : null);
    }

    /**
     * @param string $rule
     * @return int
     */
    private function getId(string $rule = null): int
    {
        if ($rule === null) {
            return $this->lastRuleId++;
        }

        if (\array_key_exists($rule, $this->mappings)) {
            return $this->mappings[$rule];
        }

        return $this->mappings[$rule] = $this->lastRuleId++;
    }

    /**
     * @param string $rule
     * @return bool
     */
    private function isKept(string $rule): bool
    {
        return \in_array($rule, $this->resolver->getKeep(), true);
    }

    /**
     * @param TokenInterface $token
     * @param SlicedIterator $tokens
     * @return int
     */
    private function reduce(TokenInterface $token, SlicedIterator $tokens): int

The parameter $tokens is not used and could be removed.

    {
        switch ($token->name()) {
            case Lexer::T_KEPT:
                return $this->reduceToken($token, true);

            case Lexer::T_SKIPPED:
                return $this->reduceToken($token, false);

            //default:
            //    $error = \sprintf('Unexpected token %s', $token);

54% of this comment could be valid code. Did you maybe forget this after debugging?

            //    throw (new GrammarException($error))->throwsIn($this->file, $token->offset());

70% of this comment could be valid code. Did you maybe forget this after debugging?

        }

        return 0;
    }

    /**
     * @param TokenInterface $token
     * @param bool $keep
     * @return int
     */
    private function reduceToken(TokenInterface $token, bool $keep): int
    {
        $key = $token->value(1) . ':' . $token->name();

        $builder = new TokenBuilder($this->getId($key), $token->value(1), $keep);

        $this->add($builder)->complete();

        return $builder->getId();
    }

    private function reduceConcat(SlicedIterator $iterator)

This method is not used, and could be removed.

    {
        dd($iterator);
    }

    /**
     * @return RulesBuilder
     */
    private function complete(): RulesBuilder
    {
        /** @var Builder $rule */
        $rule = $this->stack->pop();
        $instance = $rule->build();

        if ($rule->getName()) {

The expression $rule->getName() of type null|string is loosely compared to true; this is ambiguous if the string can be empty. You might want to explicitly use !== null instead.

            $this->parsed[$rule->getName()] = $instance;
        } else {
            $this->parsed[] = $instance;
        }

        $instance->{'--grammar--'} = $this->text;
        $this->text = '';

        return $this;
    }

    /**
     * @return Builder
     */
    private function current(): Builder
    {
        return $this->stack->top();
    }
}