Railt\SDL\Compiler\Definition\EnumDelegate

Complexity

Total Complexity

10

Size/Duplication

Total Lines	88
Duplicated Lines	6.82 %

Coupling/Cohesion

Components	1
Dependencies	6

Test Coverage

Coverage

0%

Importance

Changes

0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	create()	0	4	1
A	boot()	0	8	1
A	bootValues()	0	10	2
A	getEnumValues()	0	18	3
A	createEnumValue()	0	7	1
A	verifyDuplication()	6	9	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\Compiler\Definition;

use Railt\Parser\Ast\LeafInterface;
use Railt\Parser\Ast\NodeInterface;
use Railt\Parser\Ast\RuleInterface;
use Railt\Parser\Environment;
use Railt\Reflection\Contracts\Definition;
use Railt\Reflection\Contracts\Definition\TypeDefinition;
use Railt\Reflection\Contracts\Document as DocumentInterface;
use Railt\Reflection\Definition\Dependent\EnumValueDefinition;
use Railt\Reflection\Definition\EnumDefinition;
use Railt\Reflection\Document;
use Railt\SDL\Compiler\Pipeline;
use Railt\SDL\Exception\TypeConflictException;

/**
 * Class EnumDelegate
 */
class EnumDelegate extends TypeDefinitionDelegate
{
    /**
     * @param DocumentInterface|Document $document
     * @return Definition
     */
    protected function create(DocumentInterface $document): Definition
    {
        return new EnumDefinition($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.

    }

    /**
     * @param Environment $env
     */
    public function boot(Environment $env): void
    {
        parent::boot($env);

        $this->future(Pipeline::PRIORITY_DEFINITION, function() {
            $this->bootValues($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\EnumDefinition>.

        });
    }

    /**
     * @param EnumDefinition|TypeDefinition $enum
     */
    private function bootValues(EnumDefinition $enum): void
    {
        foreach ($this->getEnumValues($enum) as $value) {
            $this->transaction($value, function (EnumValueDefinition $value) use ($enum): void {
                $this->verifyDuplication($enum, $value);

                $enum->withValue($value);
            });
        }
    }

    /**
     * @param EnumDefinition $enum
     * @return iterable
     */
    private function getEnumValues(EnumDefinition $enum): iterable
    {
        /** @var RuleInterface $ast */
        foreach ($this->first('EnumValues', 1) as $ast) {

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

            $enumValue = $this->createEnumValue($enum, $ast->first('T_NAME', 1));

            $this->transaction($enumValue, function (EnumValueDefinition $def) use ($ast): void {
                //$this->withDescription($def, $ast);

80% of this comment could be valid code. Did you maybe forget this after debugging?

                /** @var RuleInterface $defValue */
                if ($defValue = $ast->first('Value', 1)) {
                    $def->withValue($this->value($defValue)->toScalar());
                }
            });

            yield $enumValue;
        }
    }

    /**
     * @param EnumDefinition $enum
     * @param LeafInterface|NodeInterface $name
     * @return EnumValueDefinition
     */
    private function createEnumValue(EnumDefinition $enum, LeafInterface $name): EnumValueDefinition
    {
        $def = new EnumValueDefinition($enum, $name->getValue());
        $def->withOffset($name->getOffset());

        return $def;
    }

    /**
     * @param EnumDefinition $enum
     * @param EnumValueDefinition $value
     * @throws \Railt\SDL\Exception\CompilerException
     */
    private function verifyDuplication(EnumDefinition $enum, EnumValueDefinition $value): void

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

    {
        if ($enum->hasValue($value->getName())) {

This code seems to be duplicated across your project.

            $error = 'Could not define %s, because %s already exists';
            $error = \sprintf($error, $value, $enum->getValue($value->getName()));

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