Koriym\AppStateDiagram\TaggedProfile

Complexity

Total Complexity

28

Size/Duplication

Total Lines	145
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	scanDescriptors()	0	23	4
A	scanLinks()	0	16	4
A	__construct()	0	6	1
A	getDescriptorId()	0	20	5
A	validDescriptor()	0	7	3
A	filteredDescriptor()	0	17	3
A	isFilteredOr()	0	13	4
A	isFilteredAnd()	0	13	4

<?php

declare(strict_types=1);

namespace Koriym\AppStateDiagram;

use Koriym\AppStateDiagram\Exception\InvalidDescriptorMissingIdOrHrefException;
use stdClass;

use function array_key_exists;
use function assert;
use function explode;
use function in_array;
use function is_string;
use function json_encode;
use function substr;

final class TaggedProfile extends AbstractProfile
{
    /** @var array<string, AbstractDescriptor> */
    private $tranceDescriptor;

    /**
     * @param list<string> $orTags

The type Koriym\AppStateDiagram\list was not found. Maybe you did not declare it correctly or list all dependencies?

     * @param list<string> $andTags
     */
    public function __construct(AbstractProfile $alpsFile, array $orTags, array $andTags)
    {
        $this->title = $alpsFile->title;
        $this->doc = $alpsFile->doc;
        $this->scanLinks($alpsFile, $andTags, $orTags);
        $this->scanDescriptors($alpsFile);
    }

    /**
     * @param list<string> $andTags
     * @param list<string> $orTags
     */
    private function scanLinks(AbstractProfile $alpsFile, array $andTags, array $orTags): void
    {
        $links = new Links();
        $transDescriptors = new Descriptors();
        foreach ($alpsFile->links as $link) {
            if (
                $this->isFilteredAnd($link->transDescriptor, $andTags)
                || $this->isFilteredOr($link->transDescriptor, $orTags)
            ) {
                $links->add($link);
                $transDescriptors->add($link->transDescriptor);
            }
        }

        $this->links = $links->links;
        $this->tranceDescriptor = $transDescriptors->descriptors;
    }

    private function scanDescriptors(AbstractProfile $alpsFile): void
    {
        $descriptors = new Descriptors();
        foreach ($this->links as $link) {
            $descriptors->add($link->transDescriptor);
            $from = $this->filteredDescriptor(
                $alpsFile->descriptors[$link->from],
                $alpsFile->descriptors
            );
            foreach ($from->descriptors as $descriptor) {
                $descriptors->add($descriptor);
            }

            $to = $this->filteredDescriptor(
                $alpsFile->descriptors[$link->to],
                $alpsFile->descriptors
            );
            foreach ($to->descriptors as $descriptor) {
                $descriptors->add($descriptor);
            }
        }

        $this->descriptors = $descriptors->descriptors;
    }

    /** @param list<string> $andTags */
    private function isFilteredAnd(AbstractDescriptor $descriptor, array $andTags): bool
    {
        if ($andTags === []) {
            return false;
        }

        foreach ($andTags as $tag) {
            if (! in_array($tag, $descriptor->tags, true)) {

$descriptor->tags of type Koriym\AppStateDiagram\list is incompatible with the type array expected by parameter $haystack of in_array().

                return false;
            }
        }

        return true;
    }

    /** @param list<string> $orTags */
    private function isFilteredOr(AbstractDescriptor $descriptor, array $orTags): bool
    {
        if ($orTags === []) {
            return false;
        }

        foreach ($orTags as $tag) {
            if (in_array($tag, $descriptor->tags, true)) {

$descriptor->tags of type Koriym\AppStateDiagram\list is incompatible with the type array expected by parameter $haystack of in_array().

                return true;
            }
        }

        return false;
    }

    private function getDescriptorId(stdClass $child): string
    {
        if (isset($child->id) && is_string($child->id)) {
            return $child->id;
        }

        $href = $child->href;
        if (! isset($href)) {
            throw new InvalidDescriptorMissingIdOrHrefException((string) json_encode($child)); // @codeCoverageIgnore
        }

        assert(is_string($href));

        $isInternal = $href[0] === '#';

        if ($isInternal) {
            return substr($href, 1);
        }

        return explode('#', $href)[1];
    }

    /** @param array<AbstractDescriptor> $allDescriptors */
    private function filteredDescriptor(AbstractDescriptor $edge, array $allDescriptors): Descriptors
    {
        $descriptors = new Descriptors();
        $filteredChildren = [];

        foreach ($edge->descriptor as $child) {
            $descriptor = $allDescriptors[$this->getDescriptorId($child)];
            if ($this->validDescriptor($descriptor)) {
                $filteredChildren[] = $child;
                $descriptors->add($descriptor);
            }
        }

        $edge->descriptor = $filteredChildren;

It seems like $filteredChildren of type array or array is incompatible with the declared type Koriym\AppStateDiagram\list of property $descriptor.

        $descriptors->add($edge);

        return $descriptors;
    }

    private function validDescriptor(AbstractDescriptor $descriptor): bool
    {
        if ($descriptor instanceof SemanticDescriptor) {
            return true;
        }

        return $descriptor instanceof TransDescriptor && array_key_exists($descriptor->id, $this->tranceDescriptor);
    }
}