Railt\SDL\Compiler

Complexity

Total Complexity

7

Size/Duplication

Total Lines	111
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	4

Test Coverage

Coverage

90.91%

Importance

Changes

0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	7	1
A	typeLoader()	0	6	1
A	compile()	0	8	1
A	runCompiler()	0	4	1
A	run()	0	7	1
A	document()	0	4	1
A	preload()	0	6	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;

use Railt\Io\File;
use Railt\Io\Readable;
use Railt\Reflection\Contracts\Definition;
use Railt\Reflection\Contracts\Document as DocumentInterface;
use Railt\Reflection\Contracts\Reflection as ReflectionInterface;
use Railt\Reflection\Dictionary\CallbackDictionary;
use Railt\Reflection\Document;
use Railt\Reflection\Reflection;
use Railt\SDL\Compiler\Backend;
use Railt\SDL\Compiler\Frontend;
use Railt\SDL\Compiler\Process;
use Railt\SDL\Exception\InternalErrorException;
use Railt\SDL\Exception\SyntaxException;
use Railt\SDL\Exception\TypeException;

/**
 * Class Compiler
 */
class Compiler implements CompilerInterface
{
    /**
     * @var ReflectionInterface
     */
    private $reflection;

    /**
     * @var Frontend
     */
    private $frontend;

    /**
     * @var Backend
     */
    private $backend;

    /**
     * @var Process
     */
    private $process;

    /**
     * Compiler constructor.
     */
    public function __construct()
    {
        $this->process = new Process();
        $this->frontend = new Frontend();
        $this->backend = new Backend($this->process);
        $this->reflection = new Reflection(new CallbackDictionary($this->typeLoader()));

It seems like new \Railt\Reflection\Reflection(new \Railt\Reflection\Dictionary\CallbackDictionary($this->typeLoader())) of type object<Railt\Reflection\Reflection> is incompatible with the declared type object<Railt\Reflection\Contracts\Reflection> of property $reflection.

    }

    /**
     * @return \Closure
     */
    private function typeLoader(): \Closure
    {
        return function (string $type, Definition $from = null) {

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

            $this->compile(File::fromPathname($type . '.graphqls'));

It seems like \Railt\Io\File::fromPathname($type . '.graphqls') targeting Railt\Io\File::fromPathname() can also be of type object<Railt\Io\File>; however, Railt\SDL\Compiler::compile() does only seem to accept object<Railt\Io\Readable>, maybe add an additional type check?

        };
    }

    /**
     * @param Readable $schema
     * @return DocumentInterface
     * @throws InternalErrorException
     * @throws SyntaxException
     * @throws TypeException
     */
    public function compile(Readable $schema): DocumentInterface
    {
        $document = $this->runCompiler($schema);

        $this->process->run();

        return $document;
    }

    /**
     * @param Readable $schema
     * @return DocumentInterface
     * @throws InternalErrorException
     * @throws SyntaxException
     * @throws TypeException
     */
    private function runCompiler(Readable $schema): DocumentInterface
    {
        return $this->run(clone $this->reflection, $schema);
    }

    /**
     * @param ReflectionInterface $reflection
     * @param Readable $schema
     * @return DocumentInterface
     * @throws InternalErrorException
     * @throws SyntaxException
     * @throws TypeException
     */
    private function run(ReflectionInterface $reflection, Readable $schema): DocumentInterface
    {
        return $this->backend->each(
            $this->backend->context($this->document($reflection, $schema)),
            $this->frontend->exec($schema)
        );
    }

    /**
     * @param ReflectionInterface $reflection
     * @param Readable $schema
     * @return DocumentInterface
     */
    private function document(ReflectionInterface $reflection, Readable $schema): DocumentInterface
    {
        return new Document($reflection, $schema);
    }

    /**
     * @param Readable $schema
     * @return ReflectionInterface
     * @throws InternalErrorException
     * @throws SyntaxException
     * @throws TypeException
     */
    public function preload(Readable $schema): ReflectionInterface
    {
        $this->run($this->reflection, $schema);

        return $this->reflection;
    }
}