NavigationBuilder::isAncestor() - Code Metrics - Inspection of "version 2" - everlutionsk/navigation - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#5)

by Ivan

created 2018-01-05 21:12 UTC

NavigationBuilder::isAncestor() A

↳ Parent: NavigationBuilder

Complexity

Conditions	1
Paths	1

Size

Total Lines	7
Code Lines	4

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	7
c	0
b	0
f	0
rs	9.4285
cc	1
eloc	4
nc	1
nop	1

<?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 <[email protected]>
 */
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;

        $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) {

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

            if ($item instanceof NestableInterface) {
                $this->getRootItem($item);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
                $this->addItemsFromStack();
                continue;
            }

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

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

    }

    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);
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			namespace Everlution\Navigation\Builder;
6
7			use Everlution\Navigation\ContainerInterface;
8			use Everlution\Navigation\Item\ItemInterface;
9			use Everlution\Navigation\Item\NestableInterface;
10
11			/**
12			* Class NavigationBuilder.
13			*
14			* @author Ivan Barlog <[email protected]>
15			*/
16			class NavigationBuilder
17			{
18			/** @var ContainerInterface[] */
19			private $container;
20			/** @var RootNode */
21			private $root;
22			/** @var ItemInterface[] */
23			private $stack = [];
24			/** @var ItemInterface[] */
25			private $used = [];
26			/** @var ItemInterface */
27			private $current;
28
29			public function __construct(ContainerInterface $container, MatcherInterface $matcher)
30			{
31			$this->container = $container;
			0 ignored issues – show Documentation Bug introduced 2018-01-05 21:14 UTC by Report Bug Copy Issue Report It seems like `$container` of type `object<Everlution\Navigation\ContainerInterface>` is incompatible with the declared type `array<integer,object<Eve...on\ContainerInterface>>` of property `$container`. Our type inference engine has found an assignment to a property that is incompatible with the declared type of that property. Either this assignment is in error or the assigned type should be added to the documentation/type hint for that property.. Loading history...
32			$this->build($matcher);
33			}
34
35			/**
36			* @return ItemInterface[]
37			*
38			* @throws NoCurrentItemFoundException
39			*/
40			public function getBreadcrumbs(): array
41			{
42			if (empty($this->stack)) {
43			$this->getRootItem($this->getCurrent());
44			$this->stack = array_reverse($this->stack);
45			$this->stack = array_map(
46			function (ItemInterface $item) {
47			return $this->used[get_class($item)];
48			},
49			$this->stack
50			);
51			}
52
53			return $this->stack;
54			}
55
56			/**
57			* @param ItemInterface $item
58			*
59			* @return bool
60			*
61			* @throws NoCurrentItemFoundException
62			*/
63			public function isAncestor(ItemInterface $item): bool
64			{
65			$ancestors = $this->getBreadcrumbs();
66			array_pop($ancestors);
67
68			return in_array($item, $ancestors);
69			}
70
71			/**
72			* @return ItemInterface
73			*
74			* @throws NoCurrentItemFoundException
75			*/
76			public function getCurrent(): ItemInterface
77			{
78			if (!$this->current) {
79			throw new NoCurrentItemFoundException();
80			}
81
82			return $this->current;
83			}
84
85			public function getRoot(): RootNode
86			{
87			return $this->root;
88			}
89
90			private function build(MatcherInterface $matcher)
91			{
92			$this->root = new RootNode();
93			foreach ($this->container->getItems() as $item) {
			0 ignored issues – show Bug introduced 2018-01-05 21:14 UTC by Report Bug Copy Issue Report The method `getItems` cannot be called on `$this->container` (of type `array<integer,object<Eve...on\ContainerInterface>>`). Methods can only be called on objects. This check looks for methods being called on variables that have been inferred to never be objects. Loading history...
94			if (!$this->current && $matcher->isCurrent($item)) {
95			$this->current = $item;
96			}
97
98			if ($item instanceof NestableInterface) {
99			$this->getRootItem($item);
			0 ignored issues – show Documentation introduced 2018-01-05 21:14 UTC by Report Bug Copy Issue Report `$item` is of type `object<Everlution\Naviga...Item\NestableInterface>`, but the function expects a `object<Everlution\Navigation\Item\ItemInterface>`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
100			$this->addItemsFromStack();
101			continue;
102			}
103
104			$this->addItem($this->root, $item);
105			}
106			}
107
108			private function getParent(NestableInterface $item): ItemInterface
109			{
110			return $this->container->get($item->getParent());
			0 ignored issues – show Bug introduced 2018-01-05 21:14 UTC by Report Bug Copy Issue Report The method `get` cannot be called on `$this->container` (of type `array<integer,object<Eve...on\ContainerInterface>>`). Methods can only be called on objects. This check looks for methods being called on variables that have been inferred to never be objects. Loading history...
111			}
112
113			private function getRootItem(ItemInterface $item): ?ItemInterface
114			{
115			$this->stack[] = $item;
116
117			if (!$item instanceof NestableInterface) {
118			return null;
119			}
120
121			return $this->getRootItem($this->getParent($item));
122			}
123
124			private function addItemsFromStack(): void
125			{
126			$root = $this->root;
127			while ($item = array_pop($this->stack)) {
128			$this->addItem($root, $item);
129			$root = $root->get(get_class($item));
130			}
131			}
132
133			private function addItem(RootNode $root, ItemInterface $item): void
134			{
135			$name = get_class($item);
136			if (array_key_exists($name, $this->used)) {
137			return;
138			}
139
140			$parentNode = new ParentNode($item);
141			$this->used[$name] = $parentNode;
142			$root->addChild($parentNode);
143			}
144			}
145

everlutionsk / navigation

Pull Request — master (#5)

NavigationBuilder::isAncestor() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like