Overtrue\LaravelVersionable\Versionable

Complexity

Total Complexity

35

Size/Duplication

Total Lines	243
Duplicated Lines	0 %

Coupling/Cohesion

Components	3
Dependencies	1

Test Coverage

Coverage

73.75%

Importance

Changes

0

20 Methods

Rating	Name	Duplication	Size	Complexity
A	bootVersionable()	0	14	2
A	createVersionForModel()	0	7	2
A	versions()	0	4	1
A	lastVersion()	0	4	1
A	getVersion()	0	4	1
A	revertToVersion()	0	4	1
A	removeOldVersions()	0	8	2
A	removeAllVersions()	0	4	1
A	shouldVersioning()	0	4	2
A	getVersionableAttributes()	0	21	4
A	setVersionable()	0	10	2
A	setDontVersionable()	0	10	2
A	getVersionable()	0	4	2
A	getDontVersionable()	0	4	2
A	getVersionStrategy()	0	4	2
A	setVersionStrategy()	0	10	2
A	getVersionModel()	0	4	1
A	getKeepVersionsCount()	0	4	1
A	versionableFromArray()	0	12	3
A	withoutVersion()	0	8	1

<?php

/*
 * This file is part of the overtrue/laravel-versionable.
 *
 * (c) overtrue <i@overtrue.me>
 *
 * This source file is subject to the MIT license that is bundled.
 */

namespace Overtrue\LaravelVersionable;

use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\Relations\MorphMany;
use Illuminate\Database\Eloquent\Relations\MorphOne;

trait Versionable
{
    static protected $versioning = true;

    // You can add these properties to you versionable model
    //protected $versionable = [];
    //protected $dontVersionable = ['*'];

    public static function bootVersionable()
    {
        static::saved(function (Model $model) {
            self::createVersionForModel($model);
        });

        static::deleted(function (Model $model) {
            if ($model->forceDeleting) {
                $model->removeAllVersions();
            } else {
                self::createVersionForModel($model);
            }
        });
    }

    private static function createVersionForModel(Model $model): void
    {
        if ($model->shouldVersioning()) {
            Version::createForModel($model);
            $model->removeOldVersions($model->getKeepVersionsCount());
        }
    }

    /**
     * @return \Illuminate\Database\Eloquent\Relations\MorphMany
     */
    public function versions(): MorphMany
    {
        return $this->morphMany(\config('versionable.version_model'), 'versionable')->latest('id');

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

    }

    /**
     * @return \Illuminate\Database\Eloquent\Relations\MorphOne
     */
    public function lastVersion(): MorphOne
    {
        return $this->morphOne(\config('versionable.version_model'), 'versionable')->latest('id');

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

    }

    /**
     * @param int $id
     *
     * @return \Illuminate\Database\Eloquent\Model|null
     */
    public function getVersion($id)
    {
        return $this->versions()->find($id);
    }

    /**
     * @param int $id
     *
     * @return mixed
     */
    public function revertToVersion($id)
    {
        return $this->versions()->findOrFail($id)->revert();
    }

    /**
     * @param int $keep
     */
    public function removeOldVersions(int $keep): void
    {
        if ($keep <= 0) {
            return;
        }

        $this->versions()->skip($keep)->take($keep)->get()->each->delete();
    }

    public function removeAllVersions()
    {
        $this->versions->each->delete();

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

    }

    /**
     * @return bool
     */
    public function shouldVersioning(): bool
    {
        return self::$versioning && !empty($this->getVersionableAttributes());
    }

    /**
     * @return array
     */
    public function getVersionableAttributes(): array
    {
        $changes = $this->getDirty();

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

        if (empty($changes)) {
            return [];
        }

        switch ($this->getVersionStrategy()) {
            case VersionStrategy::DIFF:
                $contents = $changes;
                break;
            case VersionStrategy::SNAPSHOT:
                $contents = $this->attributesToArray();

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

                break;
            default:
                $contents = $changes;
        }

        return $this->versionableFromArray($contents);
    }

    /**
     * @param array $attributes
     *
     * @return $this
     *
     * @throws \Exception
     */
    public function setVersionable(array $attributes)
    {
        if (!\property_exists($this, 'versionable')) {
            throw new \Exception('Property $versionable not exist.');
        }

        $this->versionable = $attributes;

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

        return $this;
    }

    /**
     * @param array $attributes
     *
     * @return $this
     *
     * @throws \Exception
     */
    public function setDontVersionable(array $attributes)
    {
        if (!\property_exists($this, 'dontVersionable')) {
            throw new \Exception('Property $dontVersionable not exist.');
        }

        $this->dontVersionable = $attributes;

The property dontVersionable does not seem to exist. Did you mean versionable?

        return $this;
    }

    /**
     * @return array
     */
    public function getVersionable(): array
    {
        return \property_exists($this, 'versionable') ? $this->versionable : [];
    }

    /**
     * @return array
     */
    public function getDontVersionable(): array
    {
        return \property_exists($this, 'dontVersionable') ? $this->dontVersionable : [];

The property dontVersionable does not seem to exist. Did you mean versionable?

    }

    /**
     * @return string
     */
    public function getVersionStrategy()
    {
        return \property_exists($this, 'versionStrategy') ? $this->versionStrategy : VersionStrategy::DIFF;

The property versionStrategy does not seem to exist. Did you mean versions?

    }

    /**
     * @param string $strategy
     *
     * @return $this
     *
     * @throws \Exception
     */
    public function setVersionStrategy(string $strategy)
    {
        if (!\property_exists($this, 'versionStrategy')) {
            throw new \Exception('Property $versionStrategy not exist.');
        }

        $this->versionStrategy = $strategy;

The property versionStrategy does not seem to exist. Did you mean versions?

        return $this;
    }

    /**
     * @return string
     */
    public function getVersionModel(): string
    {
        return config('versionable.version_model');
    }

    /**
     * @return string
     */
    public function getKeepVersionsCount(): string
    {
        return config('versionable.keep_versions', 0);
    }

    /**
     * Get the versionable attributes of a given array.
     *
     * @param array $attributes
     *
     * @return array
     */
    public function versionableFromArray(array $attributes): array
    {
        if (count($this->getVersionable()) > 0) {
            return \array_intersect_key($attributes, array_flip($this->getVersionable()));
        }

        if (count($this->getDontVersionable()) > 0) {
            return \array_diff_key($attributes, array_flip($this->getDontVersionable()));
        }

        return $attributes;
    }

    /**
     * @param callable $callback
     */
    public static function withoutVersion(callable $callback)
    {
        self::$versioning = false;

        \call_user_func($callback);

        self::$versioning = true;
    }
}