SmartWeb\ModuleTesting\Util\BacksUpItems

Complexity

Total Complexity

10

Size/Duplication

Total Lines	84
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

Importance

Changes

0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	__get()	0	8	2
A	__set()	0	4	1
A	inject()	0	14	4
A	backupItems()	0	4	1
A	restoreItems()	0	5	1
A	getCopier()	0	4	1

<?php


namespace SmartWeb\ModuleTesting\Util;

use DeepCopy\DeepCopy;
use Illuminate\Support\Arr;
use Illuminate\Support\Collection;
use InvalidArgumentException;
use SmartWeb\ModuleTesting\Support\Concerns\MutatesAttributes;
use Traversable;


if (!function_exists('is_iterable')) {
    /**
     * true if a value is iterable and will be accepted by the iterable pseudo-type, false for other values.
     *
     * @param mixed $value
     *
     * @return bool
     *
     * @see  \is_iterable()
     * @link https://wiki.php.net/rfc/iterable
     */
    function is_iterable($value)
    {
        return (is_array($value) or ($value instanceof Traversable));

Using logical operators such as or instead of || is generally not recommended.

    }
}


/**
 * Trait BacksUpItems
 *
 * @package SmartWeb\Testing\Util
 */
trait BacksUpItems
{
    
    use MutatesAttributes;
    
    /**
     * @var Collection
     */
    protected $items;
    
    /**
     * @var Collection
     */
    private $itemsBackup;
    
    /**
     * @var DeepCopy
     */
    private $copier;
    
    /**
     * @ignore
     *
     * @param $name
     *
     * @return mixed
     */
    final public function __get($name)
    {
        if ($this->hasGetMutator($name)) {
            return $this->getMutatedAttribute($name);
        }
        
        return $this->items[$name];
    }
    
    /**
     * @ignore
     *
     * @param $name
     * @param $value
     */
    final public function __set($name, $value)
    {
        $this->items[$name] = $value;
    }
    
    /**
     * @param mixed[] ...$items
     */
    final protected function inject(...$items)
    {
        $this->items = new Collection();
        
        foreach ($items as $item) {
            if (is_iterable($item) && Arr::isAssoc($item)) {
                $this->items = $this->items->merge($item);
            } else {
                throw new InvalidArgumentException("\$items must be an associative array.");
            }
        }
        
        $this->itemsBackup = $this->items ?? new Collection();
    }
    
    final protected function backupItems()
    {
        $this->itemsBackup = $this->getCopier()->copy($this->items ?? new Collection());
    }
    
    final protected function restoreItems()
    {
        $this->items = $this->getCopier()->copy($this->itemsBackup);
        $this->itemsBackup = null;
    }
    
    /**
     * @return DeepCopy
     */
    private function getCopier() : DeepCopy
    {
        return ($this->copier = $this->copier ?? new DeepCopy(true))->skipUncloneable();
    }
}