Backpack\CRUD\app\Library\CrudPanel\Traits\Buttons

Complexity

Total Complexity

49

Size/Duplication

Total Lines	341
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

20 Methods

Rating	Name	Duplication	Size	Complexity
A	buttons()	0	3	1
A	modifyButton()	0	18	4
A	addButtonFromModelFunction()	0	3	1
A	removeButtons()	0	5	3
A	addButton()	0	7	2
A	removeButtonFromStack()	0	4	2
A	getButtonKey()	0	7	4
A	getButtonsForStack()	0	3	1
A	button()	0	3	1
A	addCrudButton()	0	3	1
A	buttonsStartWith()	0	28	5
A	removeAllButtonsFromStack()	0	4	1
A	removeButton()	0	4	3
A	addButtonFromView()	0	5	1
A	firstButtonWhere()	0	3	1
A	buttonsEndWith()	0	29	5
A	removeAllButtons()	0	3	1
B	orderButtons()	0	38	7
A	hasButtonWhere()	0	3	1
A	moveButton()	0	30	4

<?php

namespace Backpack\CRUD\app\Library\CrudPanel\Traits;

use Backpack\CRUD\app\Library\CrudPanel\CrudButton;
use Illuminate\Support\Collection;

trait Buttons
{
    // ------------
    // BUTTONS
    // ------------

    /**
     * Order the CRUD buttons. If certain button names are missing from the given order array
     * they will be pushed to the end of the button collection.
     *
     * @param  string  $stack  Stack where the buttons belongs. Options: top, line, bottom.
     * @param  array  $order  Ordered names of the buttons. ['update', 'delete', 'show']
     * @param  bool  $abortIfNotExist  If true, an exception will be thrown if a button name is not found.
     */
    public function orderButtons(string $stack, array $order, bool $abortIfNotExist = true): void
    {
        $newButtons = collect([]);

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

        $otherButtons = collect([]);

        // we get the buttons that belong to the specified stack
        $stackButtons = $this->buttons()->reject(function ($item) use ($stack, $otherButtons) {
            if ($item->stack != $stack) {
                // if the button does not belong to this stack we just add it for merging later
                $otherButtons->push($item);

                return true;
            }

            return false;
        });

        // we parse the ordered buttons
        collect($order)->each(function ($btnKey) use ($abortIfNotExist, $newButtons, $stackButtons) {

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

            if (!$button = $stackButtons->where('name', $btnKey)->first()) {
                if ($abortIfNotExist) {
                    abort(500, 'Button name [«' . $btnKey . '»] not found.', ['developer-error-exception']);
                }
            }
            $newButtons->push($button);
        });

        // if the ordered buttons are less than the total number of buttons in the stack
        // we add the remaining buttons to the end of the ordered ones
        if (count($newButtons) < count($stackButtons)) {
            foreach ($stackButtons as $button) {
                if (! $newButtons->where('name', $button->name)->first()) {
                    $newButtons->push($button);
                }
            }
        }

        $this->setOperationSetting('buttons', $newButtons->merge($otherButtons));

It seems like setOperationSetting() must be provided by classes using this trait. How about adding it as abstract method to this trait?

    }

    /**
     * Add a button to the CRUD table view.
     *
     * @param  string  $stack  Where should the button be visible? Options: top, line, bottom.
     * @param  string  $name  The name of the button. Unique.
     * @param  string  $type  Type of button: view or model_function.
     * @param  string  $content  The HTML for the button.
     * @param  bool|string  $position  Position on the stack: beginning or end. If false, the position will be
     *                                 'beginning' for the line stack or 'end' otherwise.
     * @param  bool  $replaceExisting  True if a button with the same name on the given stack should be replaced.
     * @return \Backpack\CRUD\app\Library\CrudPanel\CrudButton The new CRUD button.
     */
    public function addButton($stack, $name, $type, $content, $position = false, $replaceExisting = true)
    {
        if ($replaceExisting) {
            $this->removeButton($name, $stack);
        }

        return new CrudButton($name, $stack, $type, $content, $position);
    }

    public function addCrudButton(CrudButton $crudButton)
    {
        $this->setOperationSetting('buttons', $this->buttons()->push($crudButton));
    }

    public function addButtonFromModelFunction($stack, $name, $model_function_name, $position = false)
    {
        $this->addButton($stack, $name, 'model_function', $model_function_name, $position);
    }

    public function addButtonFromView($stack, $name, $view, $position = false)
    {
        $view = 'crud::buttons.'.$view;

        $this->addButton($stack, $name, 'view', $view, $position);
    }

    /**
     * @return Collection
     */
    public function buttons()
    {
        return $this->getOperationSetting('buttons') ?? collect();

It seems like getOperationSetting() must be provided by classes using this trait. How about adding it as abstract method to this trait?

    }

    /**
     * Modify the attributes of a button.
     *
     * @param  string  $name  The button name.
     * @param  array  $modifications  The attributes and their new values.
     * @return CrudButton The button that has suffered the changes, for daisychaining methods.
     */
    public function modifyButton($name, $modifications = null)
    {
        /**
         * @var CrudButton|null
         */
        $button = $this->buttons()->firstWhere('name', $name);

        if (! $button) {
            abort(500, 'CRUD Button "'.$name.'" not found. Please ensure the button exists before you modify it.', ['developer-error-exception']);
        }

        if (is_array($modifications)) {
            foreach ($modifications as $key => $value) {
                $button->{$key} = $value;
            }
        }

        return $button;
    }

    /**
     * Remove a button from the CRUD panel.
     *
     * @param  string  $name  Button name.
     * @param  string  $stack  Optional stack name.
     */
    public function removeButton($name, $stack = null)
    {
        $this->setOperationSetting('buttons', $this->buttons()->reject(function ($button) use ($name, $stack) {
            return $stack == null ? $button->name == $name : ($button->stack == $stack) && ($button->name == $name);

It seems like you are loosely comparing $stack of type null|string against null; this is ambiguous if the string can be empty. Consider using a strict comparison === instead.

        }));
    }

    /**
     * @param  array  $names  Button names
     * @param  string|null  $stack  Optional stack name.
     */
    public function removeButtons($names, $stack = null)
    {
        if (! empty($names)) {
            foreach ($names as $name) {
                $this->removeButton($name, $stack);
            }
        }
    }

    public function removeAllButtons()
    {
        $this->setOperationSetting('buttons', collect());
    }

    public function removeAllButtonsFromStack($stack)
    {
        $this->setOperationSetting('buttons', $this->buttons()->reject(function ($button) use ($stack) {
            return $button->stack == $stack;
        }));
    }

    public function removeButtonFromStack($name, $stack)
    {
        $this->setOperationSetting('buttons', $this->buttons()->reject(function ($button) use ($name, $stack) {
            return $button->name == $name && $button->stack == $stack;
        }));
    }

    /**
     * Move the most recently added button before or after the given target button. Default is before.
     *
     * @param  string|array  $target  The target button name or array.
     * @param  string|array  $where  Move 'before' or 'after' the target.
     * @param  string|array  $destination  The destination button name or array.
     */
    public function moveButton($target, $where, $destination)
    {
        $targetButton = $this->firstButtonWhere('name', $target);

It seems like $target can also be of type array; however, parameter $value of Backpack\CRUD\app\Library\CrudPanel\Traits\Buttons::firstButtonWhere() does only seem to accept string, maybe add an additional type check?

        $destinationButton = $this->firstButtonWhere('name', $destination);
        $destinationKey = $this->getButtonKey($destination);
        $newDestinationKey = ($where == 'before' ? $destinationKey : $destinationKey + 1);

        $newButtons = $this->buttons()->filter(function ($value, $key) use ($target) {

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

            return $value->name != $target;
        });

        if (! $targetButton) {
            return;
        }

        if (! $destinationButton) {
            return;
        }

        $firstSlice = $newButtons->slice(0, $newDestinationKey);

It seems like $newDestinationKey can also be of type string; however, parameter $length of Illuminate\Support\Collection::slice() does only seem to accept integer|null, maybe add an additional type check?

        $lastSlice = $newButtons->slice($newDestinationKey, null);

It seems like $newDestinationKey can also be of type string; however, parameter $offset of Illuminate\Support\Collection::slice() does only seem to accept integer, maybe add an additional type check?

        $newButtons = $firstSlice->push($targetButton);

$targetButton of type true is incompatible with the type Illuminate\Support\TValue expected by parameter $values of Illuminate\Support\Collection::push().

        $lastSlice->each(function ($item, $key) use ($newButtons) {

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

            $newButtons->push($item);
        });

        $this->setOperationSetting('buttons', $newButtons);
    }

    /**
     * Check if a button exists, by any given attribute.
     *
     * @param  string  $attribute  Attribute name on that button definition array.
     * @param  string  $value  Value of that attribute on that button definition array.
     * @return bool
     */
    public function hasButtonWhere($attribute, $value)
    {
        return $this->buttons()->contains($attribute, $value);
    }

    /**
     * Get the first button where a given attribute has the given value.
     *
     * @param  string  $attribute  Attribute name on that button definition array.
     * @param  string  $value  Value of that attribute on that button definition array.
     * @return bool
     */
    public function firstButtonWhere($attribute, $value)
    {
        return $this->buttons()->firstWhere($attribute, $value);

The expression return $this->buttons()->firstWhere($attribute, $value) also could return the type Illuminate\Support\Traits\TValue which is incompatible with the documented return type boolean.

    }

    /**
     * Get button key from its name.
     *
     * @param  string  $buttonName  Button name.
     * @return string
     */
    public function getButtonKey($name)
    {
        $array = $this->buttons()->toArray();

        foreach ($array as $key => $value) {
            if ((is_object($value) ? $value->name : $value['name']) === $name) {
                return $key;
            }
        }
    }

    /**
     * Return the buttons for a given stack.
     */
    public function getButtonsForStack(string $stack): Collection
    {
        return $this->buttons()->where('stack', $stack);
    }

    /**
     * Add a new button to the current CRUD operation.
     */
    public function button(string|array $nameOrAttributes): CrudButton
    {
        return new CrudButton($nameOrAttributes);
    }

    /**
     *  Reorganize a collection by putting certain elements at the beginning
     *
     * @param string       $stack
     * @param array|string $startButtons
     * @param bool         $abortIfNotExist
     */
    public function buttonsStartWith(string $stack, array|string $startButtons, bool $abortIfNotExist = true): void
    {
        $startButtons = is_array($startButtons)

The condition is_array($startButtons) is always true.

            ? $startButtons
            : [$startButtons];

        $stackButtons = $this->buttons()
            ->where('stack', $stack)
            ->pluck('name')
            ->toArray();

        $startItems = [];

        foreach ($startButtons as $btnKey) {
            if (!in_array($btnKey, $stackButtons)) {
                if($abortIfNotExist) {
                    abort(500, 'Button name [«' . $btnKey . '»] not found.', ['developer-error-exception']);
                }
            }
            else {
                $startItems[] = $btnKey;
            }
        }

        $remainingItems = array_diff($stackButtons, $startItems);
        $orderedButtons = [...$startItems, ...$remainingItems];

        $this->orderButtons($stack, $orderedButtons);
    }

    /**
     * Réorganise une collection en mettant certains éléments à la fin
     *
     * @param string       $stack
     * @param array|string $endButtons
     * @param bool         $abortIfNotExist
     */
    public
    function buttonsEndWith(string $stack, array|string $endButtons, bool $abortIfNotExist = true): void
    {
        $endButtons = is_array($endButtons)

The condition is_array($endButtons) is always true.

            ? $endButtons
            : [$endButtons];

        $stackButtons = $this->buttons()
            ->where('stack', $stack)
            ->pluck('name')
            ->toArray();

        $endItems = [];

        foreach ($endButtons as $btnKey) {
            if (!in_array($btnKey, $stackButtons)) {
                if($abortIfNotExist) {
                    abort(500, 'Button name [«' . $btnKey . '»] not found.', ['developer-error-exception']);
                }
            }
            else {
                $endItems[] = $btnKey;
            }
        }

        $remainingItems = array_diff($stackButtons, $endItems);
        $orderedButtons = [...$remainingItems, ...$endItems];

        $this->orderButtons($stack, $orderedButtons);
    }

}