Alpixel\Bundle\MenuBundle\Builder\MenuBuilder

Complexity

Total Complexity

21

Size/Duplication

Total Lines	153
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	5

Importance

Changes	6
Bugs	1	Features	2

8 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	6	1
A	isValidLocale()	0	8	3
A	setDefaultLocale()	0	13	2
A	isValidMachineNamme()	0	8	3
A	getKnpMenu()	0	4	1
A	setKnpMenu()	0	6	1
B	createKnpMenu()	0	25	6
A	getTree()	0	14	4

<?php

namespace Alpixel\Bundle\MenuBundle\Builder;

use Alpixel\Bundle\MenuBundle\Exception\LocaleException;
use Alpixel\Bundle\MenuBundle\Model\ItemInterface;
use Doctrine\ORM\EntityManager;
use Knp\Menu\FactoryInterface;
use Knp\Menu\MenuItem as KnpMenuItem;
use UnexpectedValueException;

class MenuBuilder
{
    protected $entityManager;
    protected $factory;
    protected $knpMenu;
    protected $defaultLocale;


    /**
     * MenuBuilder constructor.
     *
     * @param EntityManager $entityManager
     * @param FactoryInterface $factory
     */
    function __construct(EntityManager $entityManager, FactoryInterface $factory)

It is generally recommended to explicitly declare the visibility for methods.

    {
        $this->entityManager = $entityManager;
        $this->factory       = $factory;
        $this->knpMenu       = null;
    }

    /**
     * Check if locale is valid
     *
     * @param $locale
     * @return bool
     */
    protected static function isValidLocale($locale)
    {
        if (is_string($locale) && !empty($locale)) {
            return true;
        }

        return false;
    }

    /**
     * The parameter $locale must be defined in your
     * symfony configuration file under parameters.
     *
     * @param $locale String
     * @return $this
     */
    public function setDefaultLocale($locale)
    {
        if(self::isValidLocale($locale)) {
            $this->defaultLocale = $locale;

            return $this;
        }

        throw new LocaleException('
            The $locale parameter must be a non empty string or the locale is not defined
            under the Symfony parameters configuration.
        ');
    }

    /**
     * Check if the machineName is valid
     *
     * @param $machineName
     * @return bool
     */
    public static function isValidMachineNamme($machineName)
    {
        if (is_string($machineName) && !empty($machineName)) {
            return true;
        }

        return false;
    }

    /**
     * Retrun null or a KnpMenuItem instance
     *
     * @return null|KnpMenuItem
     */
    public function getKnpMenu()
    {
        return $this->knpMenu;
    }

    /**
     * Set the KnpMenuItem instance
     *
     * @param KnpMenuItem $knpMenu
     * @return $this
     */
    public function setKnpMenu(KnpMenuItem $knpMenu)
    {
        $this->knpMenu = $knpMenu;

        return $this;
    }

    /**
     * Create KnpMenuItem
     *
     * @param  string $machineName The name of menu
     * @param  string $locale      Language code (Recommanded ISO-639)
     *
     * @return KnpMenuItem         Get formatted menu
     */
    public function createKnpMenu($machineName, $locale = null)
    {
        if (!self::isValidMachineNamme($machineName)) {
            throw new UnexpectedValueException('The parameter $machineName must be a non empty string');
        }

        if ($locale === null) {
            $locale = $this->defaultLocale;
        } else if (!self::isValidLocale($locale)) {
            throw new LocaleException();
        }

        $repository = $this->entityManager->getRepository('AlpixelMenuBundle:Menu');
        $menu       = $repository->findOneMenuByMachineNameAndLocale($machineName, $locale);
        $items      = $menu->getItems()->toArray();

        $this->setKnpMenu($this->factory->createItem('root'));

$this->factory->createItem('root') of type object<Knp\Menu\ItemInterface> is not a sub-type of object<Knp\Menu\MenuItem>. It seems like you assume a concrete implementation of the interface Knp\Menu\ItemInterface to be always present.

        foreach ($items as $item) {
            if($item->getParent() === null) {
                $this->getTree($this->knpMenu, $item);

It seems like $this->knpMenu can be null; however, getTree() does not accept null, maybe add an additional type check?

            }
        }

        return $this->getKnpMenu();
    }

    /**
     * Create tree un KnpMenuItem
     *
     * @param  KnpMenuItem      $knpMenu
     * @param  ItemInterface    $item
     * @param  KnpMenuItem|null $parent
     *
     * @return KnpMenuItem      A formatted KnpMenu
     */
    protected function getTree(KnpMenuItem $knpMenu, ItemInterface $item, KnpMenuItem $parent = null)
    {
        $menuItem = ($parent === null) ? $knpMenu->addChild($item) : $parent->addChild($item);

        if ($uri = $item->getUri() !== null) {
            $menuItem->setUri($uri);

$uri is of type boolean, but the function expects a string.

        }

        foreach ($item->getChidlren() as $child) {
            $this->getTree($knpMenu, $child, $menuItem);

$menuItem is of type object<Knp\Menu\ItemInterface>, but the function expects a null|object<Knp\Menu\MenuItem>.

        }

        return $menuItem;
    }
}