KyleMassacre\Menus\MenuBuilder

Complexity

Total Complexity

65

Size/Duplication

Total Lines	657
Duplicated Lines	0 %

Test Coverage

Coverage

28.99%

Importance

Changes

0

39 Methods

Rating	Name	Duplication	Size	Complexity
A	add()	0	7	1
A	route()	0	21	2
A	toCollection()	0	3	1
A	setView()	0	5	1
A	formatUrl()	0	5	3
A	addBadge()	0	9	1
A	findBy()	0	5	1
A	render()	0	17	5
A	resolve()	0	17	6
A	setStyles()	0	3	1
A	getPresenter()	0	3	1
A	getOrderedItems()	0	9	3
A	__construct()	0	4	1
A	setPresenterFromStyle()	0	3	1
A	destroy()	0	5	1
A	resolveItems()	0	9	3
A	whereTitle()	0	9	2
A	addDivider()	0	5	1
A	setViewFactory()	0	5	1
A	header()	0	3	1
A	setPrefixUrl()	0	5	1
A	enableOrdering()	0	5	1
A	url()	0	19	2
A	addHeader()	0	9	1
A	toArray()	0	3	1
A	dropdown()	0	20	2
A	disableOrdering()	0	5	1
A	renderView()	0	4	2
A	getStyle()	0	5	1
A	hasStyle()	0	3	1
A	style()	0	7	2
A	setBindings()	0	5	1
A	getName()	0	3	1
A	count()	0	3	1
A	getItems()	0	3	1
A	divider()	0	3	1
A	setPresenter()	0	3	1
A	getStyles()	0	3	2
A	renderMenu()	0	24	5

<?php

namespace KyleMassacre\Menus;

use Countable;
use Illuminate\Contracts\Config\Repository;
use Illuminate\Support\Arr;
use Illuminate\View\Factory as ViewFactory;
use KyleMassacre\Menus\Traits\CanHide;

class MenuBuilder implements Countable
{
    use CanHide;
    /**
     * Menu name.
     *
     * @var string
     */
    protected $menu;

    /**
     * Array menu items.
     *
     * @var array
     */
    protected $items = [];

    /**
     * Default presenter class.
     *
     * @var string
     */
    protected $presenter = Presenters\Bootstrap\NavbarPresenter::class;

    /**
     * Style name for each presenter.
     *
     * @var array
     */
    protected $styles = [];

    /**
     * Prefix URL.
     *
     * @var string|null
     */
    protected $prefixUrl;

    /**
     * The name of view presenter.
     *
     * @var string
     */
    protected $view;

    /**
     * The laravel view factory instance.
     *
     * @var \Illuminate\View\Factory
     */
    protected $views;

    /**
     * Determine whether the ordering feature is enabled or not.
     *
     * @var boolean
     */
    protected $ordering = false;

    /**
     * Resolved item binding map.
     *
     * @var array
     */
    protected $bindings = [];
    /**
     * @var Repository
     */
    private $config;

    /**
     * Constructor.
     *
     * @param string $menu
     * @param Repository $config
     */
    public function __construct($menu, Repository $config)
    {
        $this->menu = $menu;
        $this->config = $config;
    }

    /**
     * Get menu name.
     *
     * @return string
     */
    public function getName()
    {
        return $this->menu;
    }

    /**
     * Find menu item by given its title.
     *
     * @param  string        $title
     * @param  callable|null $callback
     * @return mixed
     */
    public function whereTitle($title, callable $callback = null)
    {
        $item = $this->findBy('title', $title);

        if (is_callable($callback)) {
            return call_user_func($callback, $item);

It seems like $callback can also be of type null; however, parameter $callback of call_user_func() does only seem to accept callable, maybe add an additional type check?

        }

        return $item;
    }

    /**
     * Find menu item by given key and value.
     *
     * @param  string $key
     * @param  string $value
     * @return \KyleMassacre\Menus\MenuItem
     */
    public function findBy($key, $value)
    {
        return collect($this->items)->filter(function ($item) use ($key, $value) {

$this->items of type array is incompatible with the type Illuminate\Contracts\Support\Arrayable expected by parameter $value of collect().

            return $item->{$key} == $value;
        })->first();
    }

    /**
     * Set view factory instance.
     *
     * @param ViewFactory $views
     *
     * @return $this
     */
    public function setViewFactory(ViewFactory $views)
    {
        $this->views = $views;

        return $this;
    }

    /**
     * Set view.
     *
     * @param string $view
     *
     * @return $this
     */
    public function setView($view)
    {
        $this->view = $view;

        return $this;
    }

    /**
     * Set Prefix URL.
     *
     * @param string $prefixUrl
     *
     * @return $this
     */
    public function setPrefixUrl($prefixUrl)
    {
        $this->prefixUrl = $prefixUrl;

        return $this;
    }

    /**
     * Set styles.
     *
     * @param array $styles
     */
    public function setStyles(array $styles)
    {
        $this->styles = $styles;
    }

    /**
     * Set new presenter class.
     *
     * @param string $presenter
     */
    public function setPresenter($presenter)
    {
        $this->presenter = $presenter;
    }

    /**
     * Get presenter instance.
     *
     * @return \KyleMassacre\Menus\Presenters\PresenterInterface
     */
    public function getPresenter()
    {
        return new $this->presenter();
    }

    /**
     * Set new presenter class by given style name.
     *
     * @param string $name
     *
     * @return self
     */
    public function style($name)
    {
        if ($this->hasStyle($name)) {
            $this->setPresenter($this->getStyle($name));
        }

        return $this;
    }

    /**
     * Determine if the given name in the presenter style.
     *
     * @param $name
     *
     * @return bool
     */
    public function hasStyle($name)
    {
        return array_key_exists($name, $this->getStyles());
    }

    /**
     * Get style aliases.
     *
     * @return mixed
     */
    public function getStyles()
    {
        return $this->styles ?: $this->config->get('menus.styles');
    }

    /**
     * Get the presenter class name by given alias name.
     *
     * @param $name
     *
     * @return mixed
     */
    public function getStyle($name)
    {
        $style = $this->getStyles();

        return $style[$name];
    }

    /**
     * Set new presenter class from given alias name.
     *
     * @param $name
     */
    public function setPresenterFromStyle($name)
    {
        $this->setPresenter($this->getStyle($name));
    }

    /**
     * Set the resolved item bindings
     *
     * @param array $bindings
     * @return $this
     */
    public function setBindings(array $bindings)
    {
        $this->bindings = $bindings;

        return $this;
    }

    /**
     * Resolves a key from the bindings array.
     *
     * @param  string|array $key
     * @return mixed
     */
    public function resolve($key)
    {
        if (is_array($key)) {
            foreach ($key as $k => $v) {
                $key[$k] = $this->resolve($v);
            }
        } elseif (is_string($key)) {

The condition is_string($key) is always true.

            $matches = array();
            preg_match_all('/{[\s]*?([^\s]+)[\s]*?}/i', $key, $matches, PREG_SET_ORDER);
            foreach ($matches as $match) {
                if (array_key_exists($match[1], $this->bindings)) {
                    $key = preg_replace('/' . $match[0] . '/', $this->bindings[$match[1]], $key, 1);
                }
            }
        }

        return $key;
    }

    /**
     * Resolves an array of menu items properties.
     *
     * @param  array  &$items
     * @return void
     */
    protected function resolveItems(array &$items)
    {
        $resolver = function ($property) {
            return $this->resolve($property) ?: $property;
        };

        $totalItems = count($items);
        for ($i = 0; $i < $totalItems; $i++) {
            $items[$i]->fill(array_map($resolver, $items[$i]->getProperties()));
        }
    }

    /**
     * Add new child menu.
     *
     * @param array $attributes
     *
     * @return \KyleMassacre\Menus\MenuItem
     */
    public function add(array $attributes = array())
    {
        $item = MenuItem::make($attributes);

        $this->items[] = $item;

        return $item;
    }

    /**
     * Create new menu with dropdown.
     *
     * @param $title
     * @param callable $callback
     * @param array    $attributes
     *
     * @return $this
     */
    public function dropdown($title, \Closure $callback, $order = null, array $attributes = array())
    {
        $properties = compact('title', 'order', 'attributes');

        if (func_num_args() == 3) {
            $arguments = func_get_args();

            $title = Arr::get($arguments, 0);
            $attributes = Arr::get($arguments, 2);

            $properties = compact('title', 'attributes');
        }

        $item = MenuItem::make($properties);

        call_user_func($callback, $item);

        $this->items[] = $item;

        return $item;

The expression return $item returns the type KyleMassacre\Menus\MenuItem which is incompatible with the documented return type KyleMassacre\Menus\MenuBuilder.

    }

    /**
     * Register new menu item using registered route.
     *
     * @param $route
     * @param $title
     * @param array $parameters
     * @param array $attributes
     *
     * @return static
     */
    public function route($route, $title, $parameters = array(), $order = null, $attributes = array())
    {
        if (func_num_args() == 4) {
            $arguments = func_get_args();

            return $this->add([

The expression return $this->add(array('route' => array(Illuminate\Support\Arr::get($arguments, 0), Illuminate\Support\Arr::get($arguments, 2)), 'title' => Illuminate\Support\Arr::get($arguments, 1), 'attributes' => Illuminate\Support\Arr::get($arguments, 3))) returns the type KyleMassacre\Menus\MenuItem which is incompatible with the documented return type KyleMassacre\Menus\MenuBuilder.

                'route' => [Arr::get($arguments, 0), Arr::get($arguments, 2)],
                'title' => Arr::get($arguments, 1),
                'attributes' => Arr::get($arguments, 3),
            ]);
        }

        $route = array($route, $parameters);

        $item = MenuItem::make(
            compact('route', 'title', 'parameters', 'attributes', 'order')
        );

        $this->items[] = $item;

        return $item;

The expression return $item returns the type KyleMassacre\Menus\MenuItem which is incompatible with the documented return type KyleMassacre\Menus\MenuBuilder.

    }

    /**
     * Format URL.
     *
     * @param string $url
     *
     * @return string
     */
    protected function formatUrl($url)
    {
        $uri = !is_null($this->prefixUrl) ? $this->prefixUrl . $url : $url;

        return $uri == '/' ? '/' : ltrim(rtrim($uri, '/'), '/');
    }

    /**
     * Register new menu item using url.
     *
     * @param $url
     * @param $title
     * @param array $attributes
     *
     * @return static
     */
    public function url($url, $title, $order = 0, $attributes = array())
    {
        if (func_num_args() == 3) {
            $arguments = func_get_args();

            return $this->add([

The expression return $this->add(array('url' => $this->formatUrl(Illuminate\Support\Arr::get($arguments, 0)), 'title' => Illuminate\Support\Arr::get($arguments, 1), 'attributes' => Illuminate\Support\Arr::get($arguments, 2))) returns the type KyleMassacre\Menus\MenuItem which is incompatible with the documented return type KyleMassacre\Menus\MenuBuilder.

                'url' => $this->formatUrl(Arr::get($arguments, 0)),
                'title' => Arr::get($arguments, 1),
                'attributes' => Arr::get($arguments, 2),
            ]);
        }

        $url = $this->formatUrl($url);

        $item = MenuItem::make(compact('url', 'title', 'order', 'attributes'));

        $this->items[] = $item;

        return $item;

The expression return $item returns the type KyleMassacre\Menus\MenuItem which is incompatible with the documented return type KyleMassacre\Menus\MenuBuilder.

    }

    /**
     * Add new divider item.
     *
     * @param int $order
     * @return \KyleMassacre\Menus\MenuItem
     */
    public function addDivider($order = null)
    {
        $this->items[] = new MenuItem(array('name' => 'divider', 'order' => $order));

        return $this;

The expression return $this returns the type KyleMassacre\Menus\MenuBuilder which is incompatible with the documented return type KyleMassacre\Menus\MenuItem.

    }

    public function addBadge(string $type, $text)
    {
        $properties = array(
            'type' => $type,
            'text' => $text,
            'name' => 'badge',
        );

        return $this->add($properties);
    }

    /**
     * Add new header item.
     *
     * @return \KyleMassacre\Menus\MenuItem
     */
    public function addHeader($title, $order = null)
    {
        $this->items[] = new MenuItem(array(
            'name' => 'header',
            'title' => $title,
            'order' => $order,
        ));

        return $this;

The expression return $this returns the type KyleMassacre\Menus\MenuBuilder which is incompatible with the documented return type KyleMassacre\Menus\MenuItem.

    }

    /**
     * Alias for "addHeader" method.
     *
     * @param string $title
     *
     * @return $this
     */
    public function header($title)
    {
        return $this->addHeader($title);

The expression return $this->addHeader($title) returns the type KyleMassacre\Menus\MenuItem which is incompatible with the documented return type KyleMassacre\Menus\MenuBuilder.

    }

    /**
     * Alias for "addDivider" method.
     *
     * @return $this
     */
    public function divider()
    {
        return $this->addDivider();

The expression return $this->addDivider() returns the type KyleMassacre\Menus\MenuItem which is incompatible with the documented return type KyleMassacre\Menus\MenuBuilder.

    }

    /**
     * Get items count.
     *
     * @return int
     */
    public function count()
    {
        return count($this->items);
    }

    /**
     * Empty the current menu items.
     */
    public function destroy()
    {
        $this->items = array();

        return $this;
    }

    /**
     * Render the menu to HTML tag.
     *
     * @param string $presenter
     *
     * @return string
     */
    public function render($presenter = null)
    {
        $this->resolveItems($this->items);

        if (!is_null($this->view)) {

The condition is_null($this->view) is always false.

            return $this->renderView($presenter);
        }

        if ($this->hasStyle($presenter)) {
            $this->setPresenterFromStyle($presenter);
        }

        if (!is_null($presenter) && !$this->hasStyle($presenter)) {
            $this->setPresenter($presenter);
        }

        return $this->renderMenu();
    }

    /**
     * Render menu via view presenter.
     *
     * @return \Illuminate\View\View
     */
    public function renderView($presenter = null)
    {
        return $this->views->make($presenter ?: $this->view, [
            'items' => $this->getOrderedItems(),
        ]);
    }

    /**
     * Get original items.
     *
     * @return array
     */
    public function getItems()
    {
        return $this->items;
    }

    /**
     * Get menu items as laravel collection instance.
     *
     * @return \Illuminate\Support\Collection
     */
    public function toCollection()
    {
        return collect($this->items);

$this->items of type array is incompatible with the type Illuminate\Contracts\Support\Arrayable expected by parameter $value of collect().

    }

    /**
     * Get menu items as array.
     *
     * @return array
     */
    public function toArray()
    {
        return $this->toCollection()->toArray();
    }

    /**
     * Enable menu ordering.
     *
     * @return self
     */
    public function enableOrdering()
    {
        $this->ordering = true;

        return $this;
    }

    /**
     * Disable menu ordering.
     *
     * @return self
     */
    public function disableOrdering()
    {
        $this->ordering = false;

        return $this;
    }

    /**
     * Get menu items and order it by 'order' key.
     *
     * @return array
     */
    public function getOrderedItems()
    {
        if (config('menus.ordering') || $this->ordering) {
            return $this->toCollection()->sortBy(function ($item) {
                return $item->order;
            })->all();
        }

        return $this->items;
    }

    /**
     * Render the menu.
     *
     * @return string
     */
    protected function renderMenu()
    {
        $presenter = $this->getPresenter();
        $menu = $presenter->getOpenTagWrapper();

        $items = array_filter($this->getOrderedItems(), function ($item) {
            return !$item->hidden();
        });

        foreach ($items as $item) {
            if ($item->hasSubMenu()) {
                $menu .= $presenter->getMenuWithDropDownWrapper($item);
            } elseif ($item->isHeader()) {
                $menu .= $presenter->getHeaderWrapper($item);
            } elseif ($item->isDivider()) {
                $menu .= $presenter->getDividerWrapper();
            } else {
                $menu .= $presenter->getMenuWithoutDropdownWrapper($item);
            }
        }

        $menu .= $presenter->getCloseTagWrapper();

        return $menu;
    }
}