Railt\SDL\Compiler\Definition\TypeDefinitionDelegate

Complexity

Total Complexity

7

Size/Duplication

Total Lines	75
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	7

Test Coverage

Coverage

0%

Importance

Changes

0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	boot()	0	12	1
A	register()	0	9	1
A	verifyDuplication()	0	10	2
A	addDescription()	0	9	2
A	parseString()	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\Compiler\Definition;

use Railt\Parser\Ast\RuleInterface;
use Railt\Parser\Environment;
use Railt\Reflection\AbstractTypeDefinition;
use Railt\Reflection\Contracts\Definition\TypeDefinition;
use Railt\Reflection\Contracts\Dictionary;
use Railt\Reflection\Document;
use Railt\SDL\Compiler\Pipeline;
use Railt\SDL\Compiler\Value\StringValue;
use Railt\SDL\Exception\TypeConflictException;

/**
 * Class TypeDefinitionDelegate
 */
abstract class TypeDefinitionDelegate extends DefinitionDelegate
{
    /**
     * @param Environment $env
     */
    public function boot(Environment $env): void
    {
        parent::boot($env);

        $this->transaction($this->definition, function () {
            $this->register();
        });

        $this->future(Pipeline::PRIORITY_DEFINITION, function () {
            $this->addDescription($this->definition, $this);
        });
    }

    /**
     * @throws \Railt\Io\Exception\ExternalFileException
     * @throws \Railt\Reflection\Exception\TypeNotFoundException
     */
    private function register(): void
    {
        /** @var Document $document */
        $document = $this->definition->getDocument();

        $this->verifyDuplication($this->definition, $document->getDictionary());

        $document->withDefinition($this->definition);
    }


    /**
     * @param TypeDefinition $type
     * @param Dictionary $dict
     * @throws \Railt\Io\Exception\ExternalFileException
     * @throws \Railt\Reflection\Exception\TypeNotFoundException
     */
    private function verifyDuplication(TypeDefinition $type, Dictionary $dict): void
    {
        if ($dict->has($type->getName())) {
            $prev  = $dict->get($type->getName(), $type);
            $error = 'Could not redeclare type %s by %s';
            $error = \sprintf($error, $prev, $type);

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

    /**
     * @param TypeDefinition|AbstractTypeDefinition $type
     * @param RuleInterface $rule
     */
    protected function addDescription(TypeDefinition $type, RuleInterface $rule): void
    {
        /** @var RuleInterface $description */
        $description = $rule->first('Description', 1);

        if ($description) {
            $type->withDescription($this->parseString($description));
        }
    }

    /**
     * @param RuleInterface $rule
     * @return string
     */
    private function parseString(RuleInterface $rule): string
    {
        $value = new StringValue($rule->getChild(0));

It seems like $rule->getChild(0) can be null; however, __construct() does not accept null, maybe add an additional type check?

        return $value->toScalar();
    }
}