Yiisoft\Yii\Bulma\Nav

Complexity

Total Complexity

37

Size/Duplication

Total Lines	280
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes	2
Bugs	0	Features	0

11 Methods

Rating	Name	Duplication	Size	Complexity
A	isItemActive()	0	11	5
B	isChildActive()	0	23	8
A	renderIcon()	0	10	2
A	activateParents()	0	5	1
A	renderDropdown()	0	15	2
A	deactivateItems()	0	5	1
B	renderItem()	0	65	11
A	currentPath()	0	5	1
A	run()	0	11	4
A	items()	0	5	1
A	withoutEncodeLabels()	0	5	1

<?php

declare(strict_types=1);

namespace Yiisoft\Yii\Bulma;

use InvalidArgumentException;
use JsonException;
use Yiisoft\Arrays\ArrayHelper;
use Yiisoft\Html\Html;

use function array_key_exists;
use function implode;
use function is_array;

final class Nav extends Widget
{
    private bool $activateItems = true;
    private bool $activateParents = false;
    private string $currentPath = '';
    private bool $encodeLabels = true;
    private array $items = [];

    /**
     * Disables active items according to their current path and returns a new instance.
     *
     * @return self
     *
     * {@see isItemActive}
     */
    public function deactivateItems(): self
    {
        $new = clone $this;
        $new->activateItems = false;
        return $new;
    }

    /**
     * Returns a new instance with the activated parent items.
     *
     * Activates parent menu items when one of the corresponding child menu items is active.
     *
     * @return self
     */
    public function activateParents(): self
    {
        $new = clone $this;
        $new->activateParents = true;
        return $new;
    }

    /**
     * Returns a new instance with the specified current path.
     *
     * @param string $value The current path.
     *
     * @return self
     */
    public function currentPath(string $value): self
    {
        $new = clone $this;
        $new->currentPath = $value;
        return $new;
    }

    /**
     * Disables encoding for labels and returns a new instance.
     *
     * @return self
     */
    public function withoutEncodeLabels(): self
    {
        $new = clone $this;
        $new->encodeLabels = false;
        return $new;
    }

    /**
     * Returns a new instance with the specified items.
     *
     * @param array $value List of items in the nav widget. Each array element represents a single menu item
     * which can be either a string or an array with the following structure:
     *
     * - label: string, required, the nav item label.
     * - url: optional, the item's URL. Defaults to "#".
     * - visible: bool, optional, whether this menu item is visible. Defaults to true.
     * - linkOptions: array, optional, the HTML attributes of the item's link.
     * - options: array, optional, the HTML attributes of the item container (LI).
     * - active: bool, optional, whether the item should be on active state or not.
     * - dropdownOptions: array, optional, the HTML options that will passed to the {@see Dropdown} widget.
     * - items: array|string, optional, the configuration array for creating a {@see Dropdown} widget, or a string
     *   representing the dropdown menu.
     * - encode: bool, optional, whether the label will be HTML-encoded. If set, supersedes the $encodeLabels option for
     *   only this item.
     *
     * If a menu item is a string, it will be rendered directly without HTML encoding.
     *
     * @return self
     */
    public function items(array $value): self
    {
        $new = clone $this;
        $new->items = $value;
        return $new;
    }

    protected function run(): string
    {
        $items = [];

        foreach ($this->items as $item) {
            if (!isset($item['visible']) || $item['visible']) {
                $items[] = $this->renderItem($item);
            }
        }

        return implode("\n", $items);
    }

    /**
     * Renders the given items as a dropdown.
     *
     * This method is called to create sub-menus.
     *
     * @param array $items the given items. Please refer to {@see Dropdown::items} for the array structure.
     * @param array $parentItem the parent item information. Please refer to {@see items} for the structure of this
     * array.
     *
     * @throws InvalidArgumentException
     *
     * @return string The rendering result.
     */
    private function renderDropdown(array $items, array $parentItem): string
    {
        $dropdown = Dropdown::widget()
            ->dividerClass('navbar-divider')

The method dividerClass() does not exist on Yiisoft\Widget\Widget. It seems like you code against a sub-type of Yiisoft\Widget\Widget such as Yiisoft\Yii\Bulma\Dropdown.

            ->itemClass('navbar-item')
            ->itemsClass('navbar-dropdown')
            ->withoutEncloseByContainer()
            ->items($items)
            ->itemsOptions(ArrayHelper::getValue($parentItem, 'dropdownOptions', []));

        if ($this->encodeLabels === false) {
            $dropdown = $dropdown->withoutEncodeLabels();
        }

        return $dropdown->render() . "\n";
    }

    /**
     * Checks to see if a child item is active optionally activating the parent.
     *
     * @param array $items
     * @param bool $active should the parent be active too
     *
     * @return array
     *
     * {@see items}
     */
    private function isChildActive(array $items, bool &$active): array
    {
        foreach ($items as $i => $child) {
            if ($this->isItemActive($child)) {
                ArrayHelper::setValue($items[$i], 'active', true);
                if ($this->activateParents) {
                    $active = $this->activateParents;
                }
            }

            if (is_array($child) && ($childItems = ArrayHelper::getValue($child, 'items')) && is_array($childItems)) {
                $activeParent = false;
                $items[$i]['items'] = $this->isChildActive($childItems, $activeParent);

                if ($activeParent) {
                    $items[$i]['options'] ??= ['class' => ''];
                    Html::addCssClass($items[$i]['options'], ['active' => 'is-active']);
                    $active = $activeParent;
                }
            }
        }

        return $items;
    }

    /**
     * Checks whether a menu item is active.
     *
     * This is done by checking if {@see currentPath} match that specified in the `url` option of the menu item. When
     * the `url` option of a menu item is specified in terms of an array, its first element is treated as the
     * currentPath for the item and the rest of the elements are the associated parameters. Only when its currentPath
     * and parameters match {@see currentPath}, respectively, will a menu item be considered active.
     *
     * @param array|object|string $item the menu item to be checked
     *
     * @return bool Whether the menu item is active
     */
    private function isItemActive($item): bool
    {
        if (isset($item['active'])) {
            return ArrayHelper::getValue($item, 'active');

It seems like $item can also be of type string; however, parameter $array of Yiisoft\Arrays\ArrayHelper::getValue() does only seem to accept array|object, maybe add an additional type check?

The expression return Yiisoft\Arrays\ArrayHelper::getValue($item, 'active') could return the type null which is incompatible with the type-hinted return boolean. Consider adding an additional type-check to rule them out.

        }

        return
            isset($item['url']) &&
            $this->currentPath !== '/' &&
            $item['url'] === $this->currentPath &&
            $this->activateItems;
    }

    private function renderIcon(string $label, string $icon, array $iconOptions): string
    {
        if ($icon !== '') {
            $label = Html::openTag('span', $iconOptions) .
                Html::tag('i', '', ['class' => $icon]) .
                Html::closeTag('span') .
                Html::tag('span', $label);
        }

        return $label;
    }

    /**
     * Renders a widget's item.
     *
     * @param array $item the item to render.
     *
     * @throws InvalidArgumentException|JsonException
     *
     * @return string The rendering result.
     */
    private function renderItem(array $item): string
    {
        if (!isset($item['label'])) {
            throw new InvalidArgumentException('The "label" option is required.');
        }

        $dropdown = false;
        $this->encodeLabels = $item['encode'] ?? $this->encodeLabels;

        if ($this->encodeLabels) {
            $label = Html::encode($item['label']);
        } else {
            $label = $item['label'];
        }

        $iconOptions = [];

        $icon = $item['icon'] ?? '';

        if (array_key_exists('iconOptions', $item) && is_array($item['iconOptions'])) {
            $iconOptions = $this->addOptions($iconOptions, 'icon');
        }

        $label = $this->renderIcon($label, $icon, $iconOptions);

        $options = ArrayHelper::getValue($item, 'options', []);
        $items = ArrayHelper::getValue($item, 'items');
        $url = ArrayHelper::getValue($item, 'url', '#');
        $linkOptions = ArrayHelper::getValue($item, 'linkOptions', []);
        $disabled = ArrayHelper::getValue($item, 'disabled', false);

        $active = $this->isItemActive($item);

        if (isset($items)) {
            $dropdown = true;

            Html::addCssClass($options, 'navbar-item has-dropdown is-hoverable');

            if (is_array($items)) {
                $items = $this->isChildActive($items, $active);
                $items = $this->renderDropdown($items, $item);
            }
        }

        Html::addCssClass($linkOptions, 'navbar-item');

        if ($disabled) {
            Html::addCssStyle($linkOptions, 'opacity:.65; pointer-events:none;');
        }

        if ($this->activateItems && $active) {
            Html::addCssClass($linkOptions, ['active' => 'is-active']);
        }

        if ($dropdown) {
            $dropdownOptions = ['class' => 'navbar-link'];

            return
                Html::openTag('div', $options) . "\n" .
                Html::a($label, $url, $dropdownOptions)->encode(false) . "\n" .
                $items .
                Html::closeTag('div');
        }

        return Html::a($label, $url, $linkOptions)->encode(false)->render();
    }
}