Kunstmaan\AdminBundle\Helper\Menu\MenuBuilder

Complexity

Total Complexity

22

Size/Duplication

Total Lines	176
Duplicated Lines	5.11 %

Coupling/Cohesion

Components	1
Dependencies	2

Test Coverage

Coverage

100%

Importance

Changes

0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	addAdaptMenu()	0	5	1
A	getCurrent()	0	24	5
A	getBreadCrumb()	0	11	2
A	getLowestTopChild()	0	12	3
A	getTopChildren()	0	13	3
A	getChildren()	0	14	3
A	getAdaptors()	0	8	2
A	sortAdaptors()	9	9	2

<?php

namespace Kunstmaan\AdminBundle\Helper\Menu;

use Symfony\Component\DependencyInjection\ContainerInterface;
use Symfony\Component\HttpFoundation\Request;

/**
 * The MenuBuilder will build the top menu and the side menu of the admin interface
 */
class MenuBuilder
{
    /**
     * @var MenuAdaptorInterface[]
     */
    private $adaptors = array();

    /**
     * @var MenuAdaptorInterface[]
     */
    private $sorted = array();

    /**
     * @var TopMenuItem[]
     */
    private $topMenuItems = null;

    /**
     * @var ContainerInterface
     */
    private $container;

    /**
     * @var MenuItem|null
     */
    private $currentCache = null;

    /**
     * Constructor
     *
     * @param ContainerInterface $container The container
     */
    public function __construct(ContainerInterface $container)
    {
        $this->container = $container;
    }

    /**
     * Add menu adaptor
     *
     * @param MenuAdaptorInterface $adaptor
     */
    public function addAdaptMenu(MenuAdaptorInterface $adaptor, $priority = 0)
    {
        $this->adaptors[$priority][] = $adaptor;
        unset($this->sorted);
    }

    /**
     * Get current menu item
     *
     * @return MenuItem|null
     */
    public function getCurrent()
    {
        if ($this->currentCache !== null) {
            return $this->currentCache;
        }
        /* @var $active MenuItem */
        $active = null;
        do {
            /* @var MenuItem[] $children */
            $children = $this->getChildren($active);
            $foundActiveChild = false;
            foreach ($children as $child) {
                if ($child->getActive()) {
                    $foundActiveChild = true;
                    $active = $child;

                    break;
                }
            }
        } while ($foundActiveChild);
        $this->currentCache = $active;

        return $active;
    }

    /**
     * Get breadcrumb path for current menu item
     *
     * @return MenuItem[]
     */
    public function getBreadCrumb()
    {
        $result = array();
        $current = $this->getCurrent();
        while (!is_null($current)) {
            array_unshift($result, $current);
            $current = $current->getParent();
        }

        return $result;
    }

    /**
     * Get top parent menu of current menu item
     *
     * @return TopMenuItem|null
     */
    public function getLowestTopChild()
    {
        $current = $this->getCurrent();
        while (!is_null($current)) {
            if ($current instanceof TopMenuItem) {
                return $current;
            }
            $current = $current->getParent();
        }

        return null;
    }

    /**
     * Get all top menu items
     *
     * @return MenuItem[]
     */
    public function getTopChildren()
    {
        if (is_null($this->topMenuItems)) {
            /* @var $request Request */
            $request = $this->container->get('request_stack')->getCurrentRequest();
            $this->topMenuItems = array();
            foreach ($this->getAdaptors() as $menuAdaptor) {

The expression $this->getAdaptors() of type null|array<integer,object<Kunstmaan\AdminBundle\Helper\Menu\MenuAdaptorInterface>> is not guaranteed to be traversable. How about adding an additional type check?

                $menuAdaptor->adaptChildren($this, $this->topMenuItems, null, $request);
            }
        }

        return $this->topMenuItems;
    }

    /**
     * Get immediate children of the specified menu item
     *
     * @param MenuItem $parent

Should the type for parameter $parent not be null|MenuItem?

     *
     * @return MenuItem[]
     */
    public function getChildren(MenuItem $parent = null)
    {
        if ($parent === null) {
            return $this->getTopChildren();
        }
        /* @var $request Request */
        $request = $this->container->get('request_stack')->getCurrentRequest();
        $result = array();
        foreach ($this->getAdaptors() as $menuAdaptor) {

The expression $this->getAdaptors() of type null|array<integer,object<Kunstmaan\AdminBundle\Helper\Menu\MenuAdaptorInterface>> is not guaranteed to be traversable. How about adding an additional type check?

            $menuAdaptor->adaptChildren($this, $result, $parent, $request);
        }

        return $result;
    }

    private function getAdaptors()
    {
        if (!isset($this->sorted)) {
            $this->sortAdaptors();
        }

        return $this->sorted;
    }

    /**
     * Sorts the internal list of adaptors by priority.
     */
    private function sortAdaptors()

This method seems to be duplicated in your project.

    {
        $this->sorted = array();

        if (isset($this->adaptors)) {
            krsort($this->adaptors);
            $this->sorted = call_user_func_array('array_merge', $this->adaptors);

It seems like call_user_func_array('array_merge', $this->adaptors) of type * is incompatible with the declared type array<integer,object<Kunstmaan\AdminBundle\Helper\Menu\MenuAdaptorInterface>> of property $sorted.

        }
    }
}