Everlution\Navigation\Builder\NavigationBuilder

Complexity

Total Complexity

19

Size/Duplication

Total Lines	129
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	5

Importance

Changes

0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
A	getBreadcrumbs()	0	15	2
A	isAncestor()	0	7	1
A	getCurrent()	0	8	2
A	getRoot()	0	4	1
B	build()	0	17	5
A	getParent()	0	4	1
A	getRootItem()	0	10	2
A	addItemsFromStack()	0	8	2
A	addItem()	0	11	2

<?php

declare(strict_types=1);

namespace Everlution\Navigation\Builder;

use Everlution\Navigation\ContainerInterface;
use Everlution\Navigation\Item\ItemInterface;
use Everlution\Navigation\Item\NestableInterface;

/**
 * Class NavigationBuilder.
 *
 * @author Ivan Barlog <ivan.barlog@everlution.sk>
 */
class NavigationBuilder
{
    /** @var ContainerInterface[] */
    private $container;
    /** @var RootNode */
    private $root;
    /** @var ItemInterface[] */
    private $stack = [];
    /** @var ItemInterface[] */
    private $used = [];
    /** @var ItemInterface */
    private $current;

    public function __construct(ContainerInterface $container, MatcherInterface $matcher)
    {
        $this->container = $container;

It seems like $container of type object<Everlution\Navigation\ContainerInterface> is incompatible with the declared type array<integer,object<Everlution\Navigation\ContainerInterface>> of property $container.

        $this->build($matcher);
    }

    /**
     * @return ItemInterface[]
     *
     * @throws NoCurrentItemFoundException
     */
    public function getBreadcrumbs(): array
    {
        if (empty($this->stack)) {
            $this->getRootItem($this->getCurrent());
            $this->stack = array_reverse($this->stack);
            $this->stack = array_map(
                function (ItemInterface $item) {
                    return $this->used[get_class($item)];
                },
                $this->stack
            );
        }

        return $this->stack;
    }

    /**
     * @param ItemInterface $item
     *
     * @return bool
     *
     * @throws NoCurrentItemFoundException
     */
    public function isAncestor(ItemInterface $item): bool
    {
        $ancestors = $this->getBreadcrumbs();
        array_pop($ancestors);

        return in_array($item, $ancestors);
    }

    /**
     * @return ItemInterface
     *
     * @throws NoCurrentItemFoundException
     */
    public function getCurrent(): ItemInterface
    {
        if (!$this->current) {
            throw new NoCurrentItemFoundException();
        }

        return $this->current;
    }

    public function getRoot(): RootNode
    {
        return $this->root;
    }

    private function build(MatcherInterface $matcher)
    {
        $this->root = new RootNode();
        foreach ($this->container->getItems() as $item) {

The method getItems cannot be called on $this->container (of type array<integer,object<Everlution\Navigation\ContainerInterface>>).

            if (!$this->current && $matcher->isCurrent($item)) {
                $this->current = $item;
            }

            if ($item instanceof NestableInterface) {
                $this->getRootItem($item);

$item is of type object<Everlution\Navigation\Item\NestableInterface>, but the function expects a object<Everlution\Navigation\Item\ItemInterface>.

                $this->addItemsFromStack();
                continue;
            }

            $this->addItem($this->root, $item);
        }
    }

    private function getParent(NestableInterface $item): ItemInterface
    {
        return $this->container->get($item->getParent());

The method get cannot be called on $this->container (of type array<integer,object<Everlution\Navigation\ContainerInterface>>).

    }

    private function getRootItem(ItemInterface $item): ?ItemInterface
    {
        $this->stack[] = $item;

        if (!$item instanceof NestableInterface) {
            return null;
        }

        return $this->getRootItem($this->getParent($item));
    }

    private function addItemsFromStack(): void
    {
        $root = $this->root;
        while ($item = array_pop($this->stack)) {
            $this->addItem($root, $item);
            $root = $root->get(get_class($item));
        }
    }

    private function addItem(RootNode $root, ItemInterface $item): void
    {
        $name = get_class($item);
        if (array_key_exists($name, $this->used)) {
            return;
        }

        $parentNode = new ParentNode($item);
        $this->used[$name] = $parentNode;
        $root->addChild($parentNode);
    }
}