Railt\SDL\Compiler\Definition\DirectiveDelegate

Complexity

Total Complexity

11

Size/Duplication

Total Lines	78
Duplicated Lines	7.69 %

Coupling/Cohesion

Components	1
Dependencies	4

Test Coverage

Coverage

0%

Importance

Changes

0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	create()	0	4	1
A	register()	0	6	1
A	bootLocations()	0	11	2
A	verifyDuplication()	6	9	2
A	getLocations()	0	7	2
A	verifyLocation()	0	10	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\SDL\Compiler\Definition;

use Railt\Parser\Ast\LeafInterface;
use Railt\Reflection\Contracts\Definition;
use Railt\Reflection\Contracts\Definition\TypeDefinition;
use Railt\Reflection\Contracts\Document as DocumentInterface;
use Railt\Reflection\Definition\Dependent\DirectiveLocation;
use Railt\Reflection\Definition\DirectiveDefinition;
use Railt\Reflection\Document;
use Railt\SDL\Compiler\Pipeline;
use Railt\SDL\Exception\TypeConflictException;

/**
 * Class DirectiveDelegate
 */
class DirectiveDelegate extends TypeDefinitionDelegate
{
    /**
     * @param DocumentInterface|Document $document
     * @return Definition
     */
    protected function create(DocumentInterface $document): Definition
    {
        return new DirectiveDefinition($document, $this->getTypeName());

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

    }

    /**
     * @return void
     */
    protected function register(): void
    {
        $this->future(Pipeline::PRIORITY_DEFINITION, function() {
            $this->bootLocations($this->definition);

$this->definition is of type object<Railt\Reflection\Contracts\Definition\TypeDefinition>|object<Railt\Reflection\AbstractTypeDefinition>, but the function expects a object<Railt\Reflection\Definition\DirectiveDefinition>.

        });
    }

    /**
     * @param DirectiveDefinition|TypeDefinition $directive
     */
    private function bootLocations(DirectiveDefinition $directive): void
    {
        foreach ($this->getLocations($directive) as $offset => $location) {
            $this->transaction($location, function (DirectiveLocation $location) use ($directive): void {
                $this->verifyLocation($location);
                $this->verifyDuplication($directive, $location);

                $directive->withLocation($location);
            });
        }
    }

    /**
     * @param DirectiveDefinition $directive
     * @param DirectiveLocation $location
     * @throws \Railt\SDL\Exception\CompilerException
     */
    private function verifyDuplication(DirectiveDefinition $directive, DirectiveLocation $location): void

Consider using a different method name as you override a private method of the parent class.

    {
        if ($directive->hasLocation($location->getName())) {

This code seems to be duplicated across your project.

            $error = 'Could not determine the location %s, because %s already exists';
            $error = \sprintf($error, $location, $directive->getLocation($location->getName()));

            throw (new TypeConflictException($error))->using($this->getCallStack())->in($location);
        }
    }

    /**
     * @param DirectiveDefinition $definition
     * @return iterable|DirectiveLocation[]
     */
    private function getLocations(DirectiveDefinition $definition): iterable
    {
        /** @var LeafInterface $child */
        foreach ($this->first('DirectiveLocations', 1) as $child) {

The expression $this->first('DirectiveLocations', 1) of type null|object<Railt\Parser\Ast\NodeInterface> is not guaranteed to be traversable. How about adding an additional type check?

            yield (new DirectiveLocation($definition, $child->getValue()))->withOffset($child->getOffset());
        }
    }

    /**
     * @param DirectiveLocation $location
     * @throws \Railt\SDL\Exception\CompilerException
     */
    private function verifyLocation(DirectiveLocation $location): void
    {
        $isValid = $location->isExecutable() || $location->isPrivate();

        if (! $isValid) {
            $error = \sprintf('Invalid directive location %s', $location);

            throw $this->error(new TypeConflictException($error))->in($location);
        }
    }
}