Railt\SDL\Frontend\Builder

Complexity

Total Complexity

16

Size/Duplication

Total Lines	145
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	5

Importance

Changes

0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
A	bootDefaults()	0	5	1
A	bootDefaultBuilders()	0	6	2
A	bootDefaultInterceptors()	0	6	2
A	build()	0	11	2
A	reduce()	0	10	2
A	run()	0	17	4
A	get()	0	11	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\SDL\Frontend;

use Railt\Io\Readable;
use Railt\Parser\Ast\NodeInterface;
use Railt\Parser\Ast\RuleInterface;
use Railt\SDL\Exception\InternalException;
use Railt\SDL\Frontend\Builder\BuilderInterface;
use Railt\SDL\Frontend\Interceptor\InterceptorInterface;
use Railt\SDL\Frontend\Interceptor\RuleInterceptor;

/**
 * Class Builder
 */
class Builder
{
    /**
     * @var string[]|BuilderInterface[]
     */
    private const DEFAULT_BUILDER_DEFINITIONS = [

    ];

    /**
     * string[]|InterceptorInterface[]
     */
    private const DEFAULT_INTERCEPTORS = [
        RuleInterceptor::class,
    ];

    /**
     * @var array|BuilderInterface[]
     */
    private $builders = [];

    /**
     * @var SymbolTable
     */
    private $table;

    /**
     * @var array|InterceptorInterface[]
     */
    private $interceptors = [];

    /**
     * Builder constructor.
     */
    public function __construct()
    {
        $this->table = new SymbolTable();
        $this->bootDefaults();
    }

    /**
     * @return void
     */
    private function bootDefaults(): void
    {
        $this->bootDefaultBuilders();
        $this->bootDefaultInterceptors();
    }

    /**
     * @return void
     */
    private function bootDefaultBuilders(): void
    {
        foreach (self::DEFAULT_BUILDER_DEFINITIONS as $rule => $builder) {
            $this->builders[$rule] = new $builder($this, $this->table);
        }
    }

    /**
     * @return void
     */
    private function bootDefaultInterceptors(): void
    {
        foreach (self::DEFAULT_INTERCEPTORS as $interceptor) {
            $this->interceptors[] = new $interceptor($this, $this->table);
        }
    }

    /**
     * @param Readable $file
     * @param RuleInterface $ast
     * @return ValueObject
     * @throws \Railt\Io\Exception\ExternalFileException
     */
    public function build(Readable $file, RuleInterface $ast): ValueObject
    {
        $document = new ValueObject();
        $document->definitions = [];

The property definitions does not exist on object<Railt\SDL\Frontend\ValueObject>. Since you implemented __set, maybe consider adding a @property annotation.

        foreach ($ast->getChildren() as $child) {
            $document->definitions[] = $this->reduce($file, $child);

The property definitions does not exist on object<Railt\SDL\Frontend\ValueObject>. Since you implemented __get, maybe consider adding a @property annotation.

        }

        return $document;
    }

    /**
     * @param Readable $file
     * @param RuleInterface $ast
     * @return mixed
     * @throws \Railt\Io\Exception\ExternalFileException
     */
    public function reduce(Readable $file, RuleInterface $ast)
    {
        $process = $this->get($file, $ast)->reduce($ast);

        if ($process instanceof \Generator) {
            return $this->run($file, $process);
        }

        return $process;
    }

    /**
     * @param Readable $file
     * @param \Generator $process
     * @return mixed
     */
    private function run(Readable $file, \Generator $process)
    {
        while ($process->valid()) {
            $value = $process->current();

            foreach ($this->interceptors as $interceptor) {
                if ($interceptor->match($value)) {
                    $value = $interceptor->apply($file, $value);
                    break;
                }
            }

            $process->send($value);
        }

        return $process->getReturn();
    }

    /**
     * @param Readable $file
     * @param RuleInterface $ast
     * @return BuilderInterface
     * @throws \Railt\Io\Exception\ExternalFileException
     */
    private function get(Readable $file, RuleInterface $ast): BuilderInterface
    {
        $builder = $this->builders[$ast->getName()] ?? null;

        if ($builder === null) {
            $error = 'Unrecognized AST rule %s';
            throw (new InternalException(\sprintf($error, $ast->getName())))->throwsIn($file, $ast->getOffset());
        }

        return $builder;
    }
}