Mutable::moveBefore() - Code Metrics - Inspection of "Use null coalesce operator in favour of deprecated..." - adminarchitect/core - Measure and Improve Code Quality continuously with Scrutinizer

Completed
Push — master ( 01d429...8f4868 )

by Terzi
created 2018-09-15 08:50 UTC
Mutable::moveBefore() A

↳ Parent: Mutable
Complexity

Conditions	3
Paths	3
Size

Total Lines	12
Code Lines	6
Duplication

Lines	0
Ratio	0 %
Importance

Changes
Metric	Value
eloc	6
dl	0
loc	12
rs	10
c	0
b	0
f	0
cc	3
nc	3
nop	2
<?php

namespace Terranet\Administrator\Collection;

use Closure;
use Illuminate\Support\Collection as BaseCollection;
use Terranet\Administrator\Exception;
use Terranet\Administrator\Field\Text;

class Mutable extends BaseCollection
{
    /**
     * Push an item onto the end of the collection.
     *
     * @param  mixed $element
     * @param null|Closure $callback
     *
     * @return $this
     */
    public function push($element, Closure $callback = null): self
    {
        $element = $this->createElement($element);

        if ($callback) {
            $callback($element);
        }

        parent::push($element);

        return $this;
    }

    /**
     * Insert an element into collection at specified position.
     *
     * @param $element
     * @param $position
     * @param null|Closure $callback
     *
     * @return $this
     */
    public function insert($element, $position, Closure $callback = null): self
    {
        $element = $this->createElement($element);

        if ($callback) {
            $callback($element);
        }

        if (is_string($position)) {
            $this->push($element);

            return $this->move($element->id(), $position);
        }

        if ($position >= $this->count()) {
            return $this->push($element);
        }

        if (0 === $position) {
            return $this->prepend($element);
        }

        $items = [];
        foreach ($this->all() as $index => $value) {
            if ($index === $position) {
                array_push($items, $element);
            }

            array_push($items, $value);
        }
        $this->items = $items;

        return $this;
    }

    /**
     * Get all items except for those with the specified keys.
     *
     * @param  mixed|string|array $keys
     * @return static
     */
    public function except($keys)
    {
        if ($keys instanceof self) {
            $keys = $keys->all();
        } elseif (!is_array($keys)) {
            $keys = func_get_args();
        }

        $items = $this->filter(function ($element) use ($keys) {
            return !in_array($element->id(), $keys, true);
        })->all();

        $this->items = array_values($items);

        return $this;
    }

    /**
     * Retrieve only visible items.
     *
     * @param string $page
     *
     * @return Mutable
     */
    public function visibleOnPage(string $page)
    {
        return $this->filter(function ($item) use ($page) {
            return ($item instanceof Group) || $item->isVisibleOnPage($page);
        });
    }

    /**
     * Update elements behaviour.
     *
     * @param string $id
     * @param Closure $callback
     *
     * @return $this
     */
    public function update(string $id, Closure $callback): self
    {
        if (str_contains($id, ',')) {
            collect(explode(',', $id))
                ->map('trim')
                ->each(function ($element) use ($callback) {
                    $this->update($element, $callback);
                });

            return $this;
        }

        $element = $this->find($id);

        if ($element && $callback) {
            $newElement = $callback($element);
            if ($newElement !== $element) {
                $position = $this->position($id);
                $this->except($id);
                $this->insert($newElement, $position);
            }
        }

        return $this;
    }

    /**
     * Update many elements at once.
     *
     * @param $ids
     *
     * @return $this
     */
    public function updateMany(array $ids = []): self
    {
        foreach ($ids as $id => $callback) {
            $this->update($id, $callback);
        }

        return $this;
    }

    /**
     * Move element.
     *
     * @param $id
     * @param int|mixed|string $position
     *
     * @throws Exception
     *
     * @return static
     *
     * @example: move('user_id', 4);
     * @example: move('user_id', 'before:name");
     * @example: move('user_id', 'after:id");
     */
    public function move(string $id, $position): self
    {
        if (is_numeric($position)) {
            return $this->toPosition($id, $position);
        }

        if (starts_with($position, 'before:')) {
            return $this->moveBefore($id, substr($position, 7));
        }

        if (starts_with($position, 'after:')) {
            return $this->moveAfter($id, substr($position, 6));
        }

        throw new Exception("Unknown moving direction: {$position}");
    }

    /**
     * Move element before another one.
     *
     * @param string $id
     * @param $target
     *
     * @return $this
     */
    public function moveBefore(string $id, $target)
    {
        if ($element = $this->find($id)) {
            $this->except($id);
            $targetPosition = $this->position($target);

            if ($targetPosition >= 0) {
                $this->insert($element, $targetPosition)->all();
            }
        }

        return $this;
    }

    /**
     * Move element after another one.
     *
     * @param string $id
     * @param $target
     *
     * @return $this
     */
    public function moveAfter(string $id, $target): self
    {
        if ($element = $this->find($id)) {
            $this->except($id);

            $targetPosition = $this->position($target);

            if ($targetPosition >= 0) {
                $this->insert($element, $targetPosition + 1)->all();
            }
        }

        return $this;
    }

    /**
     * Add a new elements group.
     *
     * @param string $id
     * @param Closure $callback
     *
     * @return $this
     */
    public function group(string $id, Closure $callback): self
    {
        $group = new Group($id);

        $callback($group);

        $this->push($group);

        return $this;
    }

    /**
     * Join existing elements to a group.
     *
     * @param $elements
     * @param $groupId
     * @param null $position

     *
     * @return $this
     */
    public function join($elements, $groupId, $position = null): self
    {
        $group = new Group($groupId);

        $this->filter(function ($element) use ($elements) {
            return in_array($element->id(), $elements, true);
        })->each(function ($element) use ($group) {
            $group->push($element);
            $this->items = $this->except($element->id())->all();
        });

        if ($position) {
            $this->insert($group, $position);
        } else {
            $this->push($group);
        }

        return $this;
    }

    /**
     * Build a collection.
     *
     * @param $decorator
     *
     * @return static
     */
    public function build($decorator)
    {
        return $this->map(function ($element) use ($decorator) {
            if ($element instanceof Group) {
                $element->map(function ($e) use ($decorator) {
                    return $decorator->make($e);
                });

                return $element;
            }

            return $decorator->make($element);
        });
    }

    /**
     * Find an element.
     *
     * @param string $id
     *
     * @return mixed
     */
    public function find(string $id)
    {
        $element = $this->first(function ($element) use ($id) {
            return $element && $element->id() === $id;
        });

        if (!$element) {
            $this->notFound($id);
        }

        return $element;
    }

    /**
     * Find an element position.
     *
     * @param string $id
     *
     * @return null|int|string
     */
    public function position(string $id): int
    {
        $i = 0;
        foreach ($this->all() as $item) {
            if ($item->id() === $id) {
                return $i;
            }

            ++$i;
        }

        return $this->notFound($id);
    }

    /**
     * Make elements sortable.
     *
     * @param mixed string|array $keys
     * @param \Closure $callback
     * @example: sortable(['title'])
     * @example: sortable(['title' => function($query) {  }])
     */
    public function sortable($keys, \Closure $callback = null)
    {
        if (is_array($keys)) {
            foreach ($keys as $id => $callback) {
                if (is_string($id)) {
                    $this->sortable($id, $callback);
                } else {
                    $this->sortable($callback);
                }
            }

            return $this;
        }

        app('scaffold.module')->addSortable(
        app('scaffold.module')->/** @scrutinizer ignore-call */ addSortable(
            $keys,
            $callback
        );

        return $this;
    }

    /**
     * Remove column from Sortable collection.
     *
     * @return self
     */
    public function disableSorting($keys): self
    {
        if (!is_array($keys)) {
            $keys = func_get_args();
        }

        foreach ($keys as $key) {
            app('scaffold.module')->removeSortable($key);
            app('scaffold.module')->/** @scrutinizer ignore-call */ removeSortable($key);
        }

        return $this;
    }

    /**
     * Move an element to a position.
     *
     * @param string $id
     * @param $position
     *
     * @return static
     */
    protected function toPosition(string $id, $position): self
    {
        $element = $this->find($id);

        return $this
            ->except($id)
            ->insert($element, $position);
    }

    /**
     * @param $id
     *
     * @throws Exception
     */
    protected function notFound($id)
    {
        throw new Exception(sprintf('Element [%s] does not exist.', $id));
    }

    /**
     * Create element object from string.
     *
     * @param $element
     *
     * @return mixed
     */
    protected function createElement($element)
    {
        if (is_string($element)) {
            $element = Text::make($element, $element);
        }

        return $element;
    }
}

adminarchitect / core

Push — master ( 01d429...8f4868 )

Mutable::moveBefore() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
