Railt\SDL\Compiler\Builder

Complexity

Total Complexity

11

Size/Duplication

Total Lines	104
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	7

Test Coverage

Coverage

66.67%

Importance

Changes

0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
A	run()	0	25	5
A	build()	0	4	1
A	buildDefinition()	0	19	3
A	setLogger()	0	7	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\SDL\Compiler;

use Psr\Log\LoggerAwareInterface;
use Psr\Log\LoggerAwareTrait;
use Psr\Log\LoggerInterface;
use Railt\Io\Readable;
use Railt\Parser\Ast\RuleInterface;
use Railt\Reflection\Contracts\Definition as DefinitionInterface;
use Railt\Reflection\Contracts\Reflection;
use Railt\Reflection\Document;
use Railt\SDL\Ast\ProvidesDefinition;
use Railt\SDL\Compiler\Process\Emittable;
use Railt\SDL\Compiler\Process\Pipeline;
use Railt\SDL\Exception\CompilerException;
use Railt\SDL\Exception\InternalException;

/**
 * Class Factory
 */
class Builder implements LoggerAwareInterface
{
    use LoggerAwareTrait;

    /**
     * @var SystemManager
     */
    private $systems;

    /**
     * @var Pipeline
     */
    private $pipeline;

    /**
     * Process constructor.
     */
    public function __construct()
    {
        $this->pipeline = new Pipeline();
        $this->systems = new SystemManager($this, $this->pipeline);
    }

    /**
     * @param Reflection $root
     * @param Readable $file
     * @param RuleInterface $ast
     * @return Document
     */
    public function run(Reflection $root, Readable $file, RuleInterface $ast): Document
    {
        $document = new Document($root, $file);

$root of type object<Railt\Reflection\Contracts\Reflection> is not a sub-type of object<Railt\Reflection\Reflection>. It seems like you assume a concrete implementation of the interface Railt\Reflection\Contracts\Reflection to be always present.

        if ($this->logger) {
            $this->logger->debug(\sprintf('Create document %s', $document));
        }

        $this->systems->resolve($document, $ast);

        /** @var Emittable $deferred */
        foreach ($this->pipeline as $deferred) {
            $handler = $deferred->emit();

            while ($handler->valid()) {
                $handler->next();
            }
        }

        if ($this->logger) {
            $this->logger->debug(\sprintf('Complete document %s', $document));
        }

        return $document;
    }

    /**
     * @param RuleInterface $rule
     * @param DefinitionInterface $parent
     * @return DefinitionInterface
     */
    public function build(RuleInterface $rule, DefinitionInterface $parent): DefinitionInterface
    {
        return $this->buildDefinition($rule, $parent);
    }

    /**
     * @param ProvidesDefinition|RuleInterface $rule
     * @param DefinitionInterface $parent
     * @return DefinitionInterface
     * @throws CompilerException
     */
    private function buildDefinition(RuleInterface $rule, DefinitionInterface $parent): DefinitionInterface
    {
        if (! $rule instanceof ProvidesDefinition) {
            $error = \vsprintf('%s AST should implement %s interface', [
                $rule->getName(), ProvidesDefinition::class]);

            throw new InternalException($error);
        }

        $definition = $rule->resolve($parent);

        if ($this->logger) {
            $this->logger->debug(\sprintf('Create type definition %s from %s', $definition, $parent));
        }

        $this->systems->resolve($definition, $rule);

        return $definition;
    }

    /**
     * Sets a logger instance on the object.
     * @param LoggerInterface $logger
     * @return void
     */
    public function setLogger(LoggerInterface $logger): void
    {
        $this->logger = $logger;

        $this->pipeline->setLogger($logger);
        $this->systems->setLogger($logger);
    }
}