AlgoWeb\ODataMetadata\Edm\Validation\Internal\InterfaceValidator\VisitorOfISchemaElement

Complexity

Total Complexity

6

Size/Duplication

Total Lines	64
Duplicated Lines	0 %

Importance

Changes	2
Bugs	1	Features	0

3 Methods

Rating	Name	Duplication	Size	Complexity
A	VisitT()	0	47	4
A	forType()	0	3	1
A	__construct()	0	6	1

<?php

declare(strict_types=1);


namespace AlgoWeb\ODataMetadata\Edm\Validation\Internal\InterfaceValidator;

use AlgoWeb\ODataMetadata\Edm\Validation\Internal\InterfaceValidator;
use AlgoWeb\ODataMetadata\Enums\SchemaElementKind;
use AlgoWeb\ODataMetadata\Interfaces\IEntityContainer;
use AlgoWeb\ODataMetadata\Interfaces\IFunction;
use AlgoWeb\ODataMetadata\Interfaces\ISchemaElement;
use AlgoWeb\ODataMetadata\Interfaces\ISchemaType;
use AlgoWeb\ODataMetadata\Interfaces\IValueTerm;

final class VisitorOfISchemaElement extends VisitorOfT
{
    protected $lookup = [];

    public function __construct()
    {
        $this->lookup[SchemaElementKind::TypeDefinition()->getKey()] = ISchemaType::class;
        $this->lookup[SchemaElementKind::Function()->getKey()] = IFunction::class;
        $this->lookup[SchemaElementKind::ValueTerm()->getKey()] = IValueTerm::class;
        $this->lookup[SchemaElementKind::EntityContainer()->getKey()] = IEntityContainer::class;
    }

    protected function VisitT($item, array &$followup, array &$references): iterable
    {
        assert($item instanceof ISchemaElement);
        $errors = [];

        if (null === $item->getNamespace()) {
            InterfaceValidator::CollectErrors(
                InterfaceValidator::CreatePropertyMustNotBeNullError(
                    $item,
                    'Namespace'
                ),
                $errors
            );
        }

        $kind = $item->getSchemaElementKind();
        $key = $kind->getKey();

        if (array_key_exists($key, $this->lookup)) {
            InterfaceValidator::CollectErrors(
                InterfaceValidator::CheckForInterfaceKindValueMismatchError(
                    $item,
                    $item->getSchemaElementKind(),
                    'SchemaElementKind',
                    $this->lookup[$key]
                ),
                $errors
            );
        } else {
            switch ($kind) {
                case SchemaElementKind::None():
                    break;

                default:
                    InterfaceValidator::CollectErrors(
                        InterfaceValidator::CreateEnumPropertyOutOfRangeError(
                            $item,
                            $item->getSchemaElementKind(),
                            'SchemaElementKind'
                        ),
                        $errors
                    );
                    break;
            }
        }

        return $errors ?? [];

The expression return $errors ?? array() also could return the type array which is incompatible with the return type mandated by AlgoWeb\ODataMetadata\Edm\Validation\Internal\InterfaceValidator\VisitorOfT::VisitT() of iterable|null.

    }

    public function forType(): string
    {
        return ISchemaElement::class;
    }
}