Spatie\EloquentSortable\SortableTrait

Complexity

Total Complexity

26

Size/Duplication

Total Lines	245
Duplicated Lines	12.24 %

Coupling/Cohesion

Components	1
Dependencies	2

Importance

Changes	7
Bugs	1	Features	1

15 Methods

Rating	Name	Duplication	Size	Complexity
A	bootSortableTrait()	0	8	3
A	setHighestOrderNumber()	0	6	1
A	getHighestOrderNumber()	0	4	1
A	scopeOrdered()	0	4	1
A	scopeAbove()	0	4	1
A	scopeBelow()	0	4	1
A	setNewOrder()	0	17	4
A	determineOrderColumnName()	0	11	3
A	shouldSortWhenCreating()	0	4	1
A	moveOrderDown()	15	15	2
A	moveOrderUp()	15	15	2
A	swapOrderWithModel()	0	14	1
A	swapOrder()	0	4	1
A	moveToStart()	0	19	2
A	moveToEnd()	0	21	2

<?php

namespace Spatie\EloquentSortable;

use ArrayAccess;
use Illuminate\Database\Eloquent\Builder;
use Illuminate\Database\Eloquent\SoftDeletingScope;
use InvalidArgumentException;

trait SortableTrait
{
    public static function bootSortableTrait()
    {
        static::creating(function ($model) {

The method creating() does not exist on Spatie\EloquentSortable\SortableTrait. Did you maybe mean shouldSortWhenCreating()?

            if ($model instanceof Sortable && $model->shouldSortWhenCreating()) {
                $model->setHighestOrderNumber();
            }
        });
    }

    /**
     * Modify the order column value.
     */
    public function setHighestOrderNumber()
    {
        $orderColumnName = $this->determineOrderColumnName();

        $this->$orderColumnName = $this->getHighestOrderNumber() + 1;
    }

    /**
     * Determine the order value for the new record.
     */
    public function getHighestOrderNumber(): int
    {
        return (int) static::max($this->determineOrderColumnName());
    }

    /**
     * Let's be nice and provide an ordered scope.
     *
     * @param \Illuminate\Database\Eloquent\Builder $query
     * @param string $direction
     *
     * @return \Illuminate\Database\Query\Builder
     */
    public function scopeOrdered(Builder $query, string $direction = 'asc')
    {
        return $query->orderBy($this->determineOrderColumnName(), $direction);
    }

    /**
     * Query records which are ordered above the given position.
     *
     * @param \Illuminate\Database\Eloquent\Builder $query
     * @param int $position
     *
     * @return \Illuminate\Database\Query\Builder
     */
    public function scopeAbove(Builder $query, int $position)
    {
        return $query->where($this->determineOrderColumnName(), '<', $position);
    }

    /**
     * Query records which are ordered below the given position.
     *
     * @param \Illuminate\Database\Eloquent\Builder $query
     * @param int $position
     *
     * @return \Illuminate\Database\Query\Builder
     */
    public function scopeBelow(Builder $query, int $position)
    {
        return $query->where($this->determineOrderColumnName(), '>', $position);
    }

    /**
     * This function reorders the records: the record with the first id in the array
     * will get order 1, the record with the second it will get order 2, ...
     *
     * A starting order number can be optionally supplied (defaults to 1).
     *
     * @param array|\ArrayAccess $ids
     * @param int $startOrder
     */
    public static function setNewOrder($ids, int $startOrder = 1)
    {
        if (! is_array($ids) && ! $ids instanceof ArrayAccess) {
            throw new InvalidArgumentException('You must pass an array or ArrayAccess object to setNewOrder');
        }

        $model = new static;

        $orderColumnName = $model->determineOrderColumnName();
        $primaryKeyColumn = $model->getKeyName();

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

        foreach ($ids as $id) {
            static::withoutGlobalScope(SoftDeletingScope::class)
                ->where($primaryKeyColumn, $id)
                ->update([$orderColumnName => $startOrder++]);
        }
    }

    /*
     * Determine the column name of the order column.
     */
    protected function determineOrderColumnName(): string
    {
        if (
            isset($this->sortable['order_column_name']) &&
            ! empty($this->sortable['order_column_name'])
        ) {
            return $this->sortable['order_column_name'];
        }

        return 'order_column';
    }

    /**
     * Determine if the order column should be set when saving a new model instance.
     */
    public function shouldSortWhenCreating(): bool
    {
        return $this->sortable['sort_when_creating'] ?? true;
    }

    /**
     * Swaps the order of this model with the model 'below' this model.
     *
     * @return $this
     */
    public function moveOrderDown()

This method seems to be duplicated in your project.

    {
        $orderColumnName = $this->determineOrderColumnName();

        $swapWithModel = static::limit(1)
            ->ordered()
            ->below($this->$orderColumnName)
            ->first();

        if (! $swapWithModel) {
            return $this;
        }

        return $this->swapOrderWithModel($swapWithModel);
    }

    /**
     * Swaps the order of this model with the model 'above' this model.
     *
     * @return $this
     */
    public function moveOrderUp()

This method seems to be duplicated in your project.

    {
        $orderColumnName = $this->determineOrderColumnName();

        $swapWithModel = static::limit(1)
            ->ordered('desc')
            ->above($this->$orderColumnName)
            ->first();

        if (! $swapWithModel) {
            return $this;
        }

        return $this->swapOrderWithModel($swapWithModel);
    }

    /**
     * Swap the order of this model with the order of another model.
     *
     * @param \Spatie\EloquentSortable\Sortable $otherModel
     *
     * @return $this
     */
    public function swapOrderWithModel(Sortable $otherModel)
    {
        $orderColumnName = $this->determineOrderColumnName();

        $oldOrderOfOtherModel = $otherModel->$orderColumnName;

        $otherModel->$orderColumnName = $this->$orderColumnName;
        $otherModel->save();

        $this->$orderColumnName = $oldOrderOfOtherModel;
        $this->save();

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

        return $this;
    }

    /**
     * Swap the order of two models.
     *
     * @param \Spatie\EloquentSortable\Sortable $model
     * @param \Spatie\EloquentSortable\Sortable $otherModel
     */
    public static function swapOrder(Sortable $model, Sortable $otherModel)
    {
        $model->swapOrderWithModel($otherModel);
    }

    /**
     * Moves this model to the first position.
     *
     * @return $this
     */
    public function moveToStart()
    {
        $firstModel = static::limit(1)
            ->ordered()
            ->first();

        if ($firstModel->id === $this->id) {

The property id does not exist. Did you maybe forget to declare it?

            return $this;
        }

        $orderColumnName = $this->determineOrderColumnName();

        $this->$orderColumnName = $firstModel->$orderColumnName;
        $this->save();

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

        static::where($this->getKeyName(), '!=', $this->id)->increment($orderColumnName);

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

        return $this;
    }

    /**
     * Moves this model to the last position.
     *
     * @return $this
     */
    public function moveToEnd()
    {
        $maxOrder = $this->getHighestOrderNumber();

        $orderColumnName = $this->determineOrderColumnName();

        if ($this->$orderColumnName === $maxOrder) {
            return $this;
        }

        $oldOrder = $this->$orderColumnName;

        $this->$orderColumnName = $maxOrder;
        $this->save();

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

        static::where($this->getKeyName(), '!=', $this->id)

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

            ->below($oldOrder)
            ->decrement($orderColumnName);

        return $this;
    }
}