KyleMassacre\Menus\MenuItem

Complexity

Total Complexity

72

Size/Duplication

Total Lines	534
Duplicated Lines	0 %

Test Coverage

Coverage

47.65%

Importance

Changes

0

36 Methods

Rating	Name	Duplication	Size	Complexity
A	getIcon()	0	10	4
A	getProperties()	0	3	1
A	hasChilds()	0	3	1
A	hasActiveOnChild()	0	7	3
B	getActiveStateFromChildren()	0	20	9
A	hasSubMenu()	0	3	1
A	getAttributes()	0	18	5
A	isDivider()	0	3	1
A	isHeader()	0	3	1
A	getActiveStateFromChilds()	0	3	1
A	is()	0	3	1
A	getRequest()	0	3	1
A	hasRoute()	0	3	1
A	inactive()	0	16	5
A	getChildren()	0	7	2
A	route()	0	15	2
A	child()	0	5	1
A	getActiveStateFromRoute()	0	3	1
A	getBadge()	0	8	2
A	getChilds()	0	3	1
A	addBadge()	0	11	1
A	getActiveStateFromUrl()	0	3	1
A	addDivider()	0	7	1
A	getUrl()	0	11	3
A	addHeader()	0	10	1
A	getActiveAttribute()	0	3	1
B	isActive()	0	24	7
A	dropdown()	0	20	2
A	fill()	0	5	3
A	hasBadge()	0	3	1
A	url()	0	13	2
A	divider()	0	3	1
A	__construct()	0	4	1
A	order()	0	5	1
A	getInactiveAttribute()	0	3	1
A	header()	0	3	1

<?php

namespace KyleMassacre\Menus;

use Illuminate\Support\Arr;
use Illuminate\Support\Facades\Request;
use KyleMassacre\Menus\Contracts\MenuItemContract;
use KyleMassacre\Menus\Traits\CanHide;
use Spatie\Html\Facades\Html as HTML;

/**
 * @property string url
 * @property string route
 * @property string title
 * @property string name
 * @property string icon
 * @property int parent
 * @property array attributes
 * @property bool active
 * @property int order
 * @property array badge
 */
class MenuItem extends MenuItemContract
{
    use CanHide;

    /**
     * Constructor.
     *
     * @param array $properties
     */
    public function __construct(array $properties = array())
    {
        $this->properties = $properties;
        $this->fill($properties);
    }

    /**
     * Fill the attributes.
     *
     * @param array $attributes
     */
    public function fill(array $attributes): void
    {
        foreach ($attributes as $key => $value) {
            if (in_array($key, $this->fillable)) {
                $this->{$key} = $value;
            }
        }
    }

    /**
     * Create new menu child item using array.
     *
     * @param array $attributes
     *
     * @return self
     */
    public function child(array $attributes): self
    {
        $this->childs[] = static::make($attributes);

        return $this;
    }

    /**
     * Register new child menu with dropdown.
     *
     * @param $title
     * @param \Closure $callback
     * @param int $order
     * @param array $attributes
     * @return $this
     */
    public function dropdown(string $title, \Closure $callback, int $order = 0, array $attributes = array()): static
    {
        $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');
        }

        $child = static::make($properties);

        call_user_func($callback, $child);

        $this->childs[] = $child;

        return $child;
    }

    /**
     * Create new menu item and set the action to route.
     *
     * @param $route
     * @param $title
     * @param array $parameters
     * @param array $attributes
     *
     * @return MenuItemContract
     */
    public function route($route, $title, array $parameters = array(), $order = 0, array $attributes = array()): static
    {
        if (func_num_args() === 4) {
            $arguments = func_get_args();

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

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

        return $this->add(compact('route', 'title', 'order', 'attributes'));
    }

    /**
     * Create new menu item  and set the action to url.
     *
     * @param $url
     * @param $title
     * @param array $attributes
     *
     * @return static
     */
    public function url($url, $title, $order = 0, array $attributes = array()): static
    {
        if (func_num_args() === 3) {
            $arguments = func_get_args();

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

        return $this->add(compact('url', 'title', 'order', 'attributes'));
    }

    /**
     * Add new divider.
     *
     * @param int $order
     *
     * @return self
     */
    public function addDivider($order = null): static
    {
        $item = static::make(array('name' => 'divider', 'order' => $order));

        $this->childs[] = $item;

        return $item;
    }

    /**
     * Alias method instead "addDivider".
     *
     * @param int $order
     *
     * @return MenuItem
     */
    public function divider($order = null): static
    {
        return $this->addDivider($order);
    }

    /**
     * Add dropdown header.
     *
     * @param $title
     *
     * @return $this
     */
    public function addHeader($title): static
    {
        $item = static::make(array(
            'name' => 'header',
            'title' => $title,
        ));

        $this->childs[] = $item;

        return $item;
    }

    /**
     * Same with "addHeader" method.
     *
     * @param $title
     *
     * @return $this
     */
    public function header($title): static
    {
        return $this->addHeader($title);
    }

    public function addBadge(string $type, $text): static
    {
        $properties = array(
            'type' => $type,
            'text' => $text,
            'name' => 'badge',
        );
        $item = static::make($properties);
        $this->badge = $properties;

        return $item;
    }

    /**
     * @deprecated See `getChildren`
     * @return array
     */
    public function getChilds(): array
    {
        return $this->getChildren();
    }

    /**
     * Get childs.
     *
     * @return array
     */
    public function getChildren(): array
    {
        if (config('menus.ordering')) {
            return collect($this->childs)->sortBy('order')->all();

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

        }

        return $this->childs;
    }

    /**
     * Get url.
     *
     * @return string
     */
    public function getUrl(): string
    {
        if ($this->route !== null) {
            return route($this->route[0], $this->route[1]);
        }

        if (empty($this->url)) {
            return url('/#');
        }

        return url($this->url);
    }

    /**
     * Get request url.
     *
     * @return string
     */
    public function getRequest(): string
    {
        return ltrim(str_replace(url('/'), '', $this->getUrl()), '/');
    }

    /**
     * @return string
     */
    public function getBadge(): string
    {
        if ($this->hasBadge()) {
            extract($this->badge);

            return '<span class="' . $type . '">' . $text . '</span>';
        }
        return '';
    }

    /**
     * Get icon.
     *
     * @param string|null $default
     *
     * @return string|null
     */
    public function getIcon(string $default = null): ?string
    {
        if ($this->icon !== null && $this->icon !== '') {
            return '<i class="' . $this->icon . '"></i>';
        }
        if ($default === null) {
            return $default;
        }

        return '<i class="' . $default . '"></i>';
    }

    /**
     * Get properties.
     *
     * @return array
     */
    public function getProperties(): array
    {
        return $this->properties;
    }

    /**
     * Get HTML attribute data.
     *
     * @return string
     */
    public function getAttributes(): string
    {
        $attributes = $this->attributes ?: [];

        Arr::forget($attributes, ['active', 'icon']);

        $attributeString = collect($attributes)
            ->map(function ($value, $key) {
                if (is_bool($value)) {
                    return $value ? $key : '';
                }

                return $key . '="' . e($value) . '"';
            })
            ->filter()
            ->implode(' ');

        return $attributeString ? ' ' . $attributeString : '';
    }

    /**
     * Check is the current item divider.
     *
     * @return bool
     */
    public function isDivider(): bool
    {
        return $this->is('divider');
    }

    /**
     * Check is the current item divider.
     *
     * @return bool
     */
    public function isHeader(): bool
    {
        return $this->is('header');
    }

    /**
     * Check is the current item divider.
     *
     * @param $name
     *
     * @return bool
     */
    public function is($name): bool
    {
        return $this->name == $name;
    }

    /**
     * Check is the current item has sub menu .
     *
     * @return bool
     */
    public function hasSubMenu(): bool
    {
        return !empty($this->childs);
    }

    /**
     * @deprecated Same with hasSubMenu.
     *
     * @return bool
     */
    public function hasChilds(): bool
    {
        return $this->hasSubMenu();
    }

    /**
     * Check the active state for current menu.
     *
     * @return mixed
     */
    public function hasActiveOnChild(): mixed
    {
        if ($this->inactive()) {
            return false;
        }

        return $this->hasSubMenu() && $this->getActiveStateFromChildren();
    }

    public function getActiveStateFromChildren(): bool
    {
        foreach ($this->getChildren() as $child) {
            if ($child->inactive()) {
                continue;
            }
            if ($child->hasChilds()) {
                if ($child->getActiveStateFromChilds()) {
                    return true;
                }
            } elseif ($child->isActive()) {
                return true;
            } elseif ($child->hasRoute() && $child->getActiveStateFromRoute()) {
                return true;
            } elseif ($child->getActiveStateFromUrl()) {
                return true;
            }
        }

        return false;
    }

    /**
     * @deprecated See `getActiveStateFromChildren()`
     * Get active state from child menu items.
     *
     * @return bool
     */
    public function getActiveStateFromChilds(): bool
    {
        return $this->getActiveStateFromChildren();
    }

    /**
     * Get inactive state.
     *
     * @return bool
     */
    public function inactive(): bool
    {
        $inactive = $this->getInactiveAttribute();

        if ($inactive === '1' || $inactive === '0') {
            return (bool)$inactive;
        }
        if (is_bool($inactive)) {

The condition is_bool($inactive) is always false.

            return $inactive;
        }

        if ($inactive instanceof \Closure) {

$inactive is never a sub-type of Closure.

            return call_user_func($inactive);
        }

        return false;
    }

    /**
     * Get active attribute.
     *
     * @return string
     */
    public function getActiveAttribute(): string
    {
        return Arr::get($this->attributes, 'active', '');
    }

    /**
     * Get inactive attribute.
     *
     * @return string
     */
    public function getInactiveAttribute(): string
    {
        return Arr::get($this->attributes, 'inactive', '');
    }

    /**
     * Get active state for current item.
     *
     * @return mixed
     */
    public function isActive(): mixed
    {
        if ($this->inactive()) {
            return false;
        }

        $active = $this->getActiveAttribute();

        if ($active === '1' || $active === '0') {
            return (bool)$active;
        }
        if (is_bool($active)) {

The condition is_bool($active) is always false.

            return $active;
        }

        if ($active instanceof \Closure) {

$active is never a sub-type of Closure.

            return call_user_func($active);
        }

        if ($this->hasRoute()) {
            return $this->getActiveStateFromRoute();
        }

        return $this->getActiveStateFromUrl();
    }

    /**
     * Determine the current item using route.
     *
     * @return bool
     */
    protected function hasRoute(): bool
    {
        return !empty($this->route);
    }

    /**
     * Get active status using route.
     *
     * @return bool
     */
    protected function getActiveStateFromRoute(): bool
    {
        return Request::is(str_replace(url('/') . '/', '', $this->getUrl()));
    }

    /**
     * Get active status using request url.
     *
     * @return bool
     */
    protected function getActiveStateFromUrl(): bool
    {
        return Request::is($this->url);
    }

    /**
     * Set order value.
     *
     * @param  int $order
     * @return self
     */
    public function order(int $order): self
    {
        $this->order = $order;

        return $this;
    }

    public function hasBadge(): bool
    {
        return !empty($this->badge);
    }
}