Railt\Compiler\Grammar\PP2\RuleResolver

Complexity

Total Complexity

15

Size/Duplication

Total Lines	122
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	4

Test Coverage

Coverage

0%

Importance

Changes

0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	resolve()	0	14	3
A	next()	0	14	3
A	resolveCurrent()	0	16	4
A	analyze()	0	12	2
A	all()	0	8	2

<?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\Grammar\PP2;

use Railt\Compiler\Exception\GrammarException;
use Railt\Compiler\Reader\BaseRules;
use Railt\Io\Exception\ExternalFileException;
use Railt\Io\Readable;
use Railt\Lexer\TokenInterface;
use Railt\Parser\Rule\Symbol;

/**
 * Class RuleResolver
 */
class RuleResolver extends BaseRules implements ResolverInterface
{
    /**
     * @var array
     */
    private $ruleTokens = [];

    /**
     * @var string|null
     */
    private $current;

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

    /**
     * @var TokenResolver
     */
    private $tokens;

    /**
     * RuleResolver constructor.
     * @param TokenResolver $tokens
     */
    public function __construct(TokenResolver $tokens)
    {
        $this->tokens = $tokens;
    }

    /**
     * @param Readable $readable
     * @param TokenInterface $token
     * @throws \Railt\Io\Exception\ExternalFileException
     */
    public function resolve(Readable $readable, TokenInterface $token): void
    {
        if ($this->next($readable, $token)) {
            return;
        }

        if (! \array_key_exists($this->current, $this->ruleTokens)) {
            $this->ruleTokens[$this->current] = [];
        }

        $this->ruleTokens[$this->current][] = $token;

        $this->addFile($this->current, $readable);
    }

    /**
     * @param Readable $readable
     * @param TokenInterface $token
     * @return bool
     * @throws \Railt\Io\Exception\ExternalFileException
     */
    private function next(Readable $readable, TokenInterface $token): bool
    {
        if ($token->name() === 'T_NODE_DEFINITION') {
            $this->resolveCurrent($readable, $token);
            return true;
        }

        if ($this->current === null) {
            $error = \sprintf('Unprocessed production %s', $token->value(0));
            throw (new GrammarException($error))->throwsIn($readable, $token->offset());
        }

        return false;
    }

    /**
     * @param Readable $readable
     * @param TokenInterface $token
     * @throws \Railt\Io\Exception\ExternalFileException
     */
    private function resolveCurrent(Readable $readable, TokenInterface $token): void
    {
        $this->current = \trim($token->value(1), '#');

        if ($token->value(1)[0] === '#') {
            $this->keep[] = $this->current;
        }

        if ($token->value(2)) {
            try {
                $this->addDelegate($this->current, $token->value(2));
            } catch (ExternalFileException $e) {
                throw $e->throwsIn($readable, $token->offset());
            }
        }
    }

    /**
     * @return array|Symbol[]
     */
    private function analyze(): array
    {
        $analyzer = new Analyzer(parent::all(), $this->keep);

It seems like you call parent on a different method (all() instead of analyze()). Are you sure this is correct? If so, you might want to change this to $this->all().

        foreach ($this->ruleTokens as $rule => $tokens) {
            $analyzer->add($rule, $tokens);
        }

        $this->ruleTokens = [];

        return $analyzer->getResult();
    }

    /**
     * @return array
     */
    public function all(): array
    {
       foreach ($this->analyze() as $symbol) {
           $this->add($symbol);
       }

        return parent::all();
    }
}