Railt\Compiler\Grammar\PP2\Analyzer

Complexity

Total Complexity

14

Size/Duplication

Total Lines	138
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	4

Test Coverage

Coverage

0%

Importance

Changes

0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	6	1
A	add()	0	4	1
A	isCompleted()	0	4	1
A	getResult()	0	7	1
A	parse()	0	6	2
A	store()	0	4	1
A	getMapping()	0	4	1
A	build()	0	4	1
A	fetchId()	0	8	2
A	group()	0	8	3

<?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\Iterator\LookaheadIterator;
use Railt\Compiler\Reader\ProvideTokens;
use Railt\Parser\Rule\Production;
use Railt\Parser\Rule\Symbol;
use Railt\Parser\Rule\Terminal;

/**
 * Class Analyzer
 */
class Analyzer
{
    /**
     * A list of parsed rules
     *
     * @var array|Symbol[]|Terminal[]|Production[]
     */
    private $parsed = [];

    /**
     * A list of kept rule names.
     *
     * @var array
     */
    private $keep;

    /**
     * @var Mapping
     */
    private $mapping;

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

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

    /**
     * Analyzer constructor.
     * @param array $keep
     * @param ProvideTokens $tokens
     */
    public function __construct(array $keep, ProvideTokens $tokens)
    {
        $this->keep = $keep;
        $this->mapping = new Mapping();
        $this->tokens = $tokens;
    }

    /**
     * @param string $rule
     * @param iterable $tokens
     */
    public function add(string $rule, iterable $tokens): void
    {
        $this->ruleTokens[$rule] = $tokens;
    }

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

    /**
     * @return array
     * @throws \InvalidArgumentException
     */
    public function getResult(): array
    {
        $this->parsed = [];
        $this->parse();

        return $this->parsed;
    }

    /**
     * @throws \InvalidArgumentException
     */
    private function parse(): void
    {
        foreach ($this->ruleTokens as $rule => $tokens) {
            $this->store($this->build($rule, $tokens));
        }
    }

    /**
     * @param Symbol $symbol
     */
    public function store(Symbol $symbol): void
    {
        $this->parsed[] = $symbol;
    }

    /**
     * @return Mapping
     */
    public function getMapping(): Mapping
    {
        return $this->mapping;
    }

    /**
     * @param string $rule
     * @param array $tokens
     * @return Production
     * @throws \InvalidArgumentException
     */
    public function build(string $rule, array $tokens): Production
    {
        return $this->group(new LookaheadIterator($tokens), $rule)->reduce();

$tokens is of type array, but the function expects a object<Railt\Compiler\Iterator\iterable>.

    }

    /**
     * @param string $rule
     * @return int
     * @throws \InvalidArgumentException
     */
    public function fetchId(string $rule): int
    {
        if ($this->mapping->has($rule)) {
            return $this->mapping->id($rule);
        }

        return $this->build($rule, $this->ruleTokens[$rule])->getId();
    }

    /**
     * @param LookaheadIterator $iterator
     * @param string|null $rule
     * @return Group
     */
    public function group(LookaheadIterator $iterator, string $rule = null): Group
    {
        if ($rule && ! \in_array($rule, $this->keep, true)) {

The expression $rule 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.

            $rule = null;
        }

        return new Group($iterator, $this, $rule);
    }
}