SaveActions - Code Metrics - Inspection of "Merge branch 'master' into v4dot1" - Laravel-Backpack/CRUD - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — v4dot1 ( bece96 )

by Cristian

created 2020-03-05 17:38 UTC

SaveActions C

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	413
Duplicated Lines	1.45 %

Coupling/Cohesion

Components	2
Dependencies	3

Importance

Changes

Metric	Value
dl	6
loc	413
rs	5.5199
c	0
b	0
f	0
wmc	56
lcom	2
cbo	3

19 Methods

Rating	Name	Duplication	Size	Complexity
A	getSaveActionDefaultForCurrentOperation()	0	4	1
A	getFallBackSaveAction()	0	15	3
A	getSaveActionByOrder()	0	6	1
A	addSaveActions()	0	11	3
A	addSaveAction()	0	20	5
A	orderSaveAction()	0	19	6
A	replaceSaveActions()	0	11	2
A	setSaveActions()	0	4	1
A	removeSaveActions()	0	6	2
A	removeSaveAction()	0	8	2
A	removeAllSaveActions()	0	4	1
A	orderSaveActions()	0	10	3
A	getOrderedSaveActions()	0	10	1
A	getVisibleSaveActions()	0	14	3
A	getCurrentSaveAction()	0	16	2
A	getSaveAction()	0	21	3
A	setSaveAction()	0	16	4
B	performSaveAction()	6	36	8
B	setupDefaultSaveActions()	0	49	5

How to fix Duplicated Code Complexity

Duplicated Code

Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.

Common duplication problems, and corresponding solutions are:

If you have the same expression in different places: Extract expression to a method
If you have the same method in different sub-classes: Extract method, and pull up field to the parent class
If you have the same code in unrelated classes: Consider extracting the code to a new class, and injecting that class

Complex Class

Tip: Before tackling complexity, make sure that you eliminate any duplication first. This often can reduce the size of classes significantly.

Complex classes like SaveActions often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.

Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.

While breaking up the class, it is a good idea to analyze how other classes use SaveActions, and based on these observations, apply Extract Interface, too.

<?php

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

use Illuminate\Support\Arr;

trait SaveActions
{
    /**
     * Get the developer's preference on what save action is the default one
     * for the current operation.
     *
     * @return string
     */
    public function getSaveActionDefaultForCurrentOperation()
    {
        return config('backpack.crud.operations.'.$this->getCurrentOperation().'.defaultSaveAction', 'save_and_back');
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}
    }

    /**
     * Get the save action with full fallback until default.
     *
     * @return string
     */
    public function getFallBackSaveAction()
    {
        //we get the higher order in save actions array. It will return something only when explicit by developer
        $higherAction = $this->getSaveActionByOrder(1);

        if (empty($higherAction)) {
            if ($this->hasOperationSetting('defaultSaveAction')) {
                return $this->getOperationSetting('defaultSaveAction');
            }

            return $this->getSaveActionDefaultForCurrentOperation();
        }

        return key($higherAction);
    }

    /**
     * Gets the save action that has the desired order.
     *
     * @param int $order
     * @return array
     */
    public function getSaveActionByOrder($order)
    {
        return array_filter($this->getOperationSetting('save_actions'), function ($arr) use ($order) {
            return $arr['order'] == $order;
        });
    }

    /**
     * Allow the developer to register multiple save actions.
     *
     * @param array $saveActions
     * @return void
     */
    public function addSaveActions($saveActions)
    {
        // count vs count recursive will be diferent when counting single dimension vs multiple dimension arrays.
        // count([1,2]) = 2, count([1,[2,3]]) = 2 with recursive it's 3. so if counts are different we have a
        // multi dimensional array
        if (count($saveActions) != count($saveActions, COUNT_RECURSIVE)) {
            foreach ($saveActions as $saveAction) {
                $this->addSaveAction($saveAction);
            }
        }
    }

    /**
     * Allow developers to register save action into CRUD.
     *
     * @param array $saveAction
     * @return void
     */
    public function addSaveAction(array $saveAction)
    {
        $orderCounter = $this->getOperationSetting('save_actions') !== null ? (count($this->getOperationSetting('save_actions')) + 1) : 1;
        //check for some mandatory fields
        $saveAction['name'] ?? abort(500, 'Please define save action name.');
        $saveAction['redirect'] = $saveAction['redirect'] ?? function ($crud, $request, $itemId) {
            return $request->has('http_referrer') ? $request->get('http_referrer') : $crud->route;
        };
        $saveAction['visible'] = $saveAction['visible'] ?? true;
        $saveAction['button_text'] = $saveAction['button_text'] ?? $saveAction['name'];
        $saveAction['order'] = isset($saveAction['order']) ? $this->orderSaveAction($saveAction['name'], $saveAction['order']) : $orderCounter;

        $actions = $this->getOperationSetting('save_actions') ?? [];

        if (! in_array($saveAction['name'], $actions)) {
            $actions[$saveAction['name']] = $saveAction;
        }

        $this->setOperationSetting('save_actions', $actions);
    }

    /**
     * Replaces setting order or forces some default.
     *
     * @param string $saveAction
     * @param int $wantedOrder
     * @return int
     */
    public function orderSaveAction(string $saveAction, int $wantedOrder)
    {
        $actions = $this->getOperationSetting('save_actions') ?? [];
        if (! empty($actions)) {
            $replaceOrder = isset($actions[$saveAction]) ? $actions[$saveAction]['order'] : count($actions) + 1;

            foreach ($actions as $key => $sv) {
                if ($wantedOrder == $sv['order']) {
                    $actions[$key]['order'] = $replaceOrder;
                }
                if ($key == $saveAction) {
                    $actions[$key]['order'] = $wantedOrder;
                }
            }
            $this->setOperationSetting('save_actions', $actions);
        }

        return $wantedOrder;
    }

    /**
     * Replace the current save actions with the ones provided.
     *
     * @param array $saveActions
     * @return void
     */
    public function replaceSaveActions($saveActions)
    {
        //we reset all save actions
        $this->setOperationSetting('save_actions', []);
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}

        if (count($saveActions) != count($saveActions, COUNT_RECURSIVE)) {
            $this->addSaveActions($saveActions);
        } else {
            $this->addSaveAction($saveActions);
        }
    }

    /**
     * Alias function of replaceSaveActions() for CRUD consistency.
     *
     * @param array $saveActions
     * @return void
     */
    public function setSaveActions($saveActions)
    {
        return $this->replaceSaveActions($saveActions);
    }

    /**
     * Allow the developer to remove multiple save actions from settings.
     *
     * @param array $saveActions
     * @return void
     */
    public function removeSaveActions(array $saveActions)
    {
        foreach ($saveActions as $sv) {
            $this->removeSaveAction($sv);
        }
    }

    /**
     * Allow the developer to remove a save action from settings.
     *
     * @param string $saveAction
     * @return void
     */
    public function removeSaveAction(string $saveAction)
    {
        $actions = $this->getOperationSetting('save_actions') ?? [];
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}
        if (isset($actions[$saveAction])) {
            $actions[$saveAction] = null;
        }
        $this->setOperationSetting('save_actions', array_filter($actions));
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}
    }

    /**
     * Allow the developer to unset all save actions.
     *
     * @param string $saveAction
/**
 * @param array $germany
 * @param array $island
 * @param array $italy
 */
function finale($germany, $island) {
    return "2:1";
}
     * @return void
     */
    public function removeAllSaveActions()
    {
        $this->setOperationSettings('save_actions', []);
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}
    }

    /**
     * Allows the developer to set save actions order. It could be ['action1','action2'] or ['action1' => 1, 'action2' => 2].
     *
     * @param array $saveActions
     * @return void
     */
    public function orderSaveActions(array $saveActions)
    {
        foreach ($saveActions as $sv => $order) {
            if (! is_int($order)) {
                $this->orderSaveAction($order, $sv + 1);
            } else {
                $this->orderSaveAction($sv, $order);
            }
        }
    }

    /**
     * Return the ordered save actions to use in the crud panel.
     *
     * @return void

     */
    public function getOrderedSaveActions()
    {
        $actions = $this->getOperationSetting('save_actions') ?? [];
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}

        uasort($actions, function ($a, $b) {
            return $a['order'] <=> $b['order'];
        });

        return $actions;
    }

    /**
     * Returns the save actions that passed the visible callback.
     *
     * @return void

     */
    public function getVisibleSaveActions()
    {
        $actions = $this->getOrderedSaveActions();
        foreach ($actions as $actionName => $action) {
            $visible = $action['visible'];
            if (is_callable($visible)) {
                $actions[$actionName]['visible'] = $visible($this);
            }
        }

        return array_filter($actions, function ($action) {
            return $action['visible'] == true;
        }, ARRAY_FILTER_USE_BOTH);
    }

    /**
     * Gets the current save action for this crud.
     *
     * @param array $saveOptions
     * @return array
     */
    public function getCurrentSaveAction($saveOptions)
    {

        //get save action from session if exists, or get the developer defined order
        $saveAction = session($this->getCurrentOperation().'.saveAction', $this->getFallBackSaveAction());
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}
        if (isset($saveOptions[$saveAction])) {
            $currentAction = $saveOptions[$saveAction];
        } else {
            $currentAction = Arr::first($saveOptions);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        }

        return [
            'value' => $currentAction['name'],
            'label' => $currentAction['button_text'],
        ];
    }

    /**
     * Here we check for save action visibility and prepare the actions array for display.
     *
     * @return array

     */
    public function getSaveAction()
    {
        //get only the save actions that pass visibility callback
        $saveOptions = $this->getVisibleSaveActions();

        //get the current action
        $saveCurrent = $this->getCurrentSaveAction($saveOptions);

        //get the dropdown options
        $dropdownOptions = [];
        foreach ($saveOptions as $key => $option) {
            if ($option['name'] != $saveCurrent['value']) {
                $dropdownOptions[$option['name']] = $option['button_text'];
            }
        }

        return [
            'active'  => $saveCurrent,
            'options' => $dropdownOptions,
        ];
    }

    /**
     * Change the session variable that remembers what to do after the "Save" action.
     *
     * @param string|null $forceSaveAction
     *
     * @return void
     */
    public function setSaveAction($forceSaveAction = null)
    {
        $saveAction = $forceSaveAction ?:
            \Request::input('save_action', $this->getFallBackSaveAction());

        $showBubble = $this->getOperationSetting('showSaveActionChange') ?? config('backpack.crud.operations.'.$this->getCurrentOperation().'.showSaveActionChange') ?? true;
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}

        if (
            $showBubble &&
            session($this->getCurrentOperation().'.saveAction', 'save_and_back') !== $saveAction
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}
        ) {
            \Alert::info(trans('backpack::crud.save_action_changed_notification'))->flash();
        }

        session([$this->getCurrentOperation().'.saveAction' => $saveAction]);
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}
    }

    /**
     * Redirect to the correct URL, depending on which save action has been selected.
     *
     * @param string $itemId

     *
     * @return \Illuminate\Http\Response

     */
    public function performSaveAction($itemId = null)
    {
        $request = \Request::instance();
        $saveAction = $request->input('save_action', $this->getFallBackSaveAction());
        $itemId = $itemId ?: $request->input('id');
        $actions = $this->getOperationSetting('save_actions');
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}

        if (isset($actions[$saveAction])) {
            if (is_callable($actions[$saveAction]['redirect'])) {

                $redirectUrl = $actions[$saveAction]['redirect']($this, $request, $itemId);
            }

            //allow the save action to define default http_referrer (url for the save_and_back button)
            if (isset($actions[$saveAction]['referrer_url'])) {
                if (is_callable($actions[$saveAction]['referrer_url'])) {

                    $referrer_url = $actions[$saveAction]['referrer_url']($this, $request, $itemId);
                }
            }
        }

        // if the request is AJAX, return a JSON response
        if ($this->request->ajax()) {
class MyClass { }

$x = new MyClass();
$x->foo = true;
            return [
                'success'      => true,
                'data'         => $this->entry,
class MyClass { }

$x = new MyClass();
$x->foo = true;
                'redirect_url' => $redirectUrl,
function myFunction($a) {
    switch ($a) {
        case 'foo':
            $x = 1;
            break;

        case 'bar':
            $x = 2;
            break;
    }

    // $x is potentially undefined here.
    echo $x;
}
                'referrer_url' => $referrer_url,
function myFunction($a) {
    switch ($a) {
        case 'foo':
            $x = 1;
            break;

        case 'bar':
            $x = 2;
            break;
    }

    // $x is potentially undefined here.
    echo $x;
}
            ];
        }

        if (isset($referrer_url)) {
            session()->flash('referrer_url_override', $referrer_url);
        }

        return \Redirect::to($redirectUrl);
    }

    /**
     * This functions register Backpack default save actions into CRUD.
     *
     * @return array

     */
    public function setupDefaultSaveActions()
    {
        $defaultSaveActions = [
            [
                'name' => 'save_and_back',
                'visible' => function ($crud) {
                    return $crud->hasAccess('list');
                },
                'redirect' => function ($crud, $request, $itemId = null) {

                    return $request->has('http_referrer') ? $request->get('http_referrer') : $crud->route;
                },
                'button_text' => trans('backpack::crud.save_action_save_and_back'),
            ],
            [
                'name' => 'save_and_edit',
                'visible' => function ($crud) {
                    return $crud->hasAccess('update');
                },
                'redirect' => function ($crud, $request, $itemId = null) {
                    $itemId = $itemId ?: $request->input('id');
                    $redirectUrl = $crud->route.'/'.$itemId.'/edit';
                    if ($request->has('locale')) {
                        $redirectUrl .= '?locale='.$request->input('locale');
                    }
                    if ($request->has('current_tab')) {
                        $redirectUrl = $redirectUrl.'#'.$request->get('current_tab');
                    }

                    return $redirectUrl;
                },
                'referrer_url' => function ($crud, $request, $itemId) {
                    return url($crud->route.'/'.$itemId.'/edit');
                },
                'button_text' => trans('backpack::crud.save_action_save_and_edit'),
            ],
            [
                'name' => 'save_and_new',
                'visible' => function ($crud) {
                    return $crud->hasAccess('create');
                },
                'redirect' => function ($crud, $request, $itemId = null) {

                    return $this->route.'/create';
class MyClass { }

$x = new MyClass();
$x->foo = true;
                },
                'button_text' => trans('backpack::crud.save_action_save_and_new'),
            ],
        ];

        $this->addSaveActions($defaultSaveActions);
    }
}


Scrutinizer GitHub App not installed

Push — v4dot1 ( bece96 )

SaveActions C

Complexity

Size/Duplication

Coupling/Cohesion

Importance

19 Methods

How to fix Duplicated Code Complexity

Duplicated Code

Complex Class

Available Fixes

Available Fixes

Laravel-Backpack / CRUD

Scrutinizer GitHub App not installed

Push — v4dot1 ( bece96 )

SaveActions C

Complexity

Size/Duplication

Coupling/Cohesion

Importance

19 Methods

How to fix Duplicated Code Complexity

Duplicated Code

Complex Class

Available Fixes

Available Fixes

Duplication Side-by-Side

Filter issues like