Anfischer\Cloner\CloneService

Complexity

Total Complexity

9

Size/Duplication

Total Lines	100
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes	2
Bugs	0	Features	0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	clone()	0	5	1
A	mapOriginalToClonedKey()	0	5	1
A	getFreshInstance()	0	27	3
A	getItemOrCollection()	0	3	2
A	cloneRecursive()	0	14	1
A	getKeyMap()	0	3	1

<?php

namespace Anfischer\Cloner;

use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\Relations\Pivot;
use Illuminate\Support\Arr;
use Illuminate\Support\Collection;

class CloneService implements CloneServiceInterface
{
    protected $originalKeyToClonedKeyMap = [];

    /**
     * Clones a model and its relationships
     *
     * @param Model $model
     * @return Model
     */
    public function clone(Model $model) : Model
    {
        return $this->cloneRecursive(
            $this->getFreshInstance($model)
        )->first();
    }

    /**
     * Recursively clones a model and its relationships
     *
     * @param $model
     * @return mixed
     */
    private function cloneRecursive($model)
    {
        Collection::wrap($model)->each(function ($item) {
            Collection::wrap($item->getRelations())->each(function ($method, $relation) use ($item) {
                $collection = $this->getFreshInstance($this->cloneRecursive($method), $item);

                $item->setRelation(
                    $relation,
                    $this->getItemOrCollection($collection)
                );
            });
        });

        return $model;
    }

    /**
     * Gets the first item of the collection if the collection
     * only contains one item, otherwise it returns the collection
     *
     * @param Collection $collection
     * @return Collection|mixed
     */
    private function getItemOrCollection(Collection $collection)
    {
        return $collection->count() > 1 ? $collection : $collection->first();
    }

    /**
     * Gets a fresh cloned instance of the model
     * which is stripped of the original models unique attributes
     *
     * @param object $model
     * @param object $parent
     * @return Collection
     */
    private function getFreshInstance($model, $parent = null) : Collection
    {
        return Collection::wrap($model)->map(function ($original) use ($parent) {
            return tap(new $original, function ($instance) use ($original, $parent) {
                // Ensure we can get hold of the new ID relative to the original
                $instance->saved(function () use ($original, $instance) {
                    $this->mapOriginalToClonedKey($original, $instance);
                });

                $filter = [
                    $original->getForeignKey(),
                    $original->getKeyName(),
                    $original->getCreatedAtColumn(),
                    $original->getUpdatedAtColumn(),
                ];

                if ($parent && ! is_a($instance, Pivot::class)) {
                    array_push($filter, $parent->getForeignKey());
                }

                $attributes = Arr::except(
                    $original->getAttributes(),
                    $filter
                );

                $instance->setRawAttributes($attributes);
                $instance->setRelations($original->getRelations());
            });
        });
    }

    public function getKeyMap(): array
    {
        return $this->originalKeyToClonedKeyMap;
    }

    public function mapOriginalToClonedKey(Model $original, Model $cloned): void
    {
        $this->originalKeyToClonedKeyMap[get_class($original)][
            $original->getKey()
        ] = $cloned->getKey();
    }
}