Spatie\Menu\Laravel\Menu

Complexity

Total Complexity

20

Size/Duplication

Total Lines	252
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	5

Importance

Changes

0

19 Methods

Rating	Name	Duplication	Size	Complexity
A	setActiveFromRequest()	0	4	1
A	url()	0	4	1
A	action()	0	4	1
A	route()	0	4	1
A	view()	0	4	1
A	urlIf()	0	4	1
A	actionIf()	0	4	1
A	routeIf()	0	4	1
A	viewIf()	0	4	1
A	addIfCan()	0	7	2
A	linkIfCan()	0	4	1
A	htmlIfCan()	0	4	1
A	submenuIfCan()	0	9	1
A	parseSubmenuIfCanArgs()	0	4	1
A	urlIfCan()	0	4	1
A	actionIfCan()	0	4	1
A	routeIfCan()	0	4	1
A	viewIfCan()	0	4	1
A	toHtml()	0	4	1

<?php

namespace Spatie\Menu\Laravel;

use Illuminate\Contracts\Support\Htmlable;
use Illuminate\Support\Traits\Macroable;
use Illuminate\Contracts\Auth\Access\Gate;
use Spatie\Menu\Item;
use Spatie\Menu\Menu as BaseMenu;

class Menu extends BaseMenu implements Htmlable
{
    use Macroable;

    /**
     * Set all relevant children active based on the current request's URL.
     *
     * /, /about, /contact => request to /about will set the about link active.
     *
     * /en, /en/about, /en/contact => request to /en won't set /en active if the
     *                                request root is set to /en.
     *
     * @param string $requestRoot If the link's URL is an exact match with the
     *                            request root, the link won't be set active.
     *                            This behavior is to avoid having home links
     *                            active on every request.
     *
     * @return $this
     */
    public function setActiveFromRequest(string $requestRoot = '/')
    {
        return $this->setActive(app('request')->url(), $requestRoot);
    }

    /**
     * @param string $path
     * @param string $text
     * @param array $parameters
     * @param bool|null $secure
     *
     * @return $this
     */
    public function url(string $path, string $text, array $parameters = [], $secure = null)
    {
        return $this->add(Link::toUrl($path, $text, $parameters, $secure));
    }

    /**
     * @param string $action
     * @param string $text
     * @param array $parameters
     * @param bool $absolute
     *
     * @return $this
     */
    public function action(string $action, string $text, array $parameters = [], bool $absolute = true)
    {
        return $this->add(Link::toAction($action, $text, $parameters, $absolute));
    }

    /**
     * @param string $name
     * @param string $text
     * @param array $parameters
     * @param bool $absolute
     * @param \Illuminate\Routing\Route|null $route
     *
     * @return $this
     */
    public function route(string $name, string $text, array $parameters = [], bool $absolute = true, $route = null)
    {
        return $this->add(Link::toRoute($name, $text, $parameters, $absolute, $route));
    }

    /**
     * @param string $name
     * @param array $data
     *
     * @return $this
     */
    public function view(string $name, array $data = [])
    {
        return $this->add(View::create($name, $data));
    }

    /**
     * @param bool $condition
     * @param string $path
     * @param string $text
     * @param array $parameters
     * @param bool|null $secure
     *
     * @return $this
     */
    public function urlIf($condition, string $path, string $text, array $parameters = [], $secure = null)
    {
        return $this->addIf($condition, Link::toUrl($path, $text, $parameters, $secure));
    }

    /**
     * @param bool $condition
     * @param string $action
     * @param string $text
     * @param array $parameters
     * @param bool $absolute
     *
     * @return $this
     */
    public function actionIf($condition, string $action, string $text, array $parameters = [], bool $absolute = true)
    {
        return $this->addIf($condition, Link::toAction($action, $text, $parameters, $absolute));
    }

    /**
     * @param bool $condition
     * @param string $name
     * @param string $text
     * @param array $parameters
     * @param bool $absolute
     * @param \Illuminate\Routing\Route|null $route
     *
     * @return $this
     */
    public function routeIf($condition, string $name, string $text, array $parameters = [], bool $absolute = true, $route = null)
    {
        return $this->addIf($condition, Link::toRoute($name, $text, $parameters, $absolute, $route));
    }

    /**
     * @param $condition
     * @param string $name
     * @param array $data
     *
     * @return $this
     */
    public function viewIf($condition, string $name, array $data)
    {
        return $this->addIf($condition, View::create($name, $data));
    }

    /**
     * @param string|array $authorization
     * @param \Spatie\Menu\Item $item
     *
     * @return $this
     */
    public function addIfCan($authorization, Item $item)
    {
        $ablityArguments = is_array($authorization) ? $authorization : [$authorization];
        $ability = array_shift($ablityArguments);

        return $this->addIf(app(Gate::class)->allows($ability, $ablityArguments), $item);
    }

    /**
     * @param string|array $authorization
     * @param string $url
     * @param string $text
     *
     * @return $this
     */
    public function linkIfCan($authorization, string $url, string $text)
    {
        return $this->addIfCan($authorization, Link::to($url, $text));
    }

    /**
     * @param string|array $authorization
     * @param string $html
     *
     * @return \Spatie\Menu\Laravel\Menu
     */
    public function htmlIfCan($authorization, string $html)
    {
        return $this->addIfCan($authorization, Html::raw($html));
    }

    /**
     * @param string|array $authorization
     * @param callable|\Spatie\Menu\Menu|\Spatie\Menu\Item $header
     * @param callable|\Spatie\Menu\Menu|null $menu
     *
     * @return $this
     */
    public function submenuIfCan($authorization, $header, $menu = null)

The parameter $authorization is not used and could be removed.

The parameter $header is not used and could be removed.

The parameter $menu is not used and could be removed.

    {
        list($authorization, $header, $menu) = $this->parseSubmenuIfCanArgs(...func_get_args());

        $menu = $this->createSubmenuMenu($menu);
        $header = $this->createSubmenuHeader($header);

        return $this->addIfCan($authorization, $menu->prependIf($header, $header));

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

    }

    protected function parseSubmenuIfCanArgs($authorization, ...$args): array
    {
        return array_merge([$authorization], $this->parseSubmenuArgs($args));
    }

    /**
     * @param string|array $authorization
     * @param string $path
     * @param string $text
     * @param array $parameters
     * @param bool|null $secure
     *
     * @return $this
     */
    public function urlIfCan($authorization, string $path, string $text, array $parameters = [], $secure = null)
    {
        return $this->addIfCan($authorization, Link::toUrl($path, $text, $parameters, $secure));
    }

    /**
     * @param string|array $authorization
     * @param string $action
     * @param string $text
     * @param array $parameters
     * @param bool $absolute
     *
     * @return $this
     */
    public function actionIfCan($authorization, string $action, string $text, array $parameters = [], bool $absolute = true)
    {
        return $this->addIfCan($authorization, Link::toAction($action, $text, $parameters, $absolute));
    }

    /**
     * @param string|array $authorization
     * @param string $name
     * @param string $text
     * @param array $parameters
     * @param bool $absolute
     * @param \Illuminate\Routing\Route|null $route
     *
     * @return $this
     */
    public function routeIfCan($authorization, string $name, string $text, array $parameters = [], bool $absolute = true, $route = null)
    {
        return $this->addIfCan($authorization, Link::toRoute($name, $text, $parameters, $absolute, $route));
    }

    /**
     * @param $condition
     * @param string $name
     * @param array $data
     *
     * @return $this
     */
    public function viewIfCan($authorization, string $name, array $data)
    {
        return $this->addIfCan($authorization, View::create($name, $data));
    }

    /**
     * @return string
     */
    public function toHtml() : string
    {
        return $this->render();
    }
}