CalamandreiLorenzo\LaravelVersionable\Version

Complexity

Total Complexity

13

Size/Duplication

Total Lines	118
Duplicated Lines	6.78 %

Coupling/Cohesion

Components	1
Dependencies	6

Test Coverage

Coverage

84.09%

Importance

Changes

0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	10	2
A	boot()	0	13	2
A	user()	0	7	1
A	versionable()	0	4	1
A	createForModel()	5	21	2
A	revert()	0	4	1
A	diff()	3	16	4

<?php
/**
 * CalamandreiLorenzo\LaravelVersionable
 *
 * 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 CalamandreiLorenzo\LaravelVersionable;

use CalamandreiLorenzo\LaravelVersionable\Exceptions\NotVersionableModel;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\Relations\BelongsTo;
use Illuminate\Database\Eloquent\Relations\MorphTo;
use Illuminate\Database\Eloquent\SoftDeletes;
use Illuminate\Support\Arr;
use Illuminate\Support\Str;
use SebastianBergmann\Diff\Differ;
use function array_keys;
use function auth;
use function class_uses;
use function config;
use function in_array;

/**
 * Class Version.
 *
 * @property $id
 * @property Model $versionable
 * @property array $contents
 * @property int $version_number
 * @property $versionable_id
 * @property $versionable_type
 */
class Version extends Model
{
    use SoftDeletes;

    /**
     * @var string[] $casts
     */
    protected $casts = [
        'contents' => 'array',
    ];

    public function __construct(array $attributes = [])
    {
        if (
            config('versionable.key_type', VersionPrimaryKey::UUID)
            === VersionPrimaryKey::UUID
        ) {
            $this->keyType = "string";
        }
        parent::__construct($attributes);
    }

    /**
     * boot
     */
    protected static function boot(): void
    {
        parent::boot();

        self::creating(static function (Version $version) {
            if (
                config('versionable.key_type', VersionPrimaryKey::UUID)
                    === VersionPrimaryKey::UUID
            ) {
                $version->id = Str::uuid();
            }
        });
    }

    /**
     * @return BelongsTo
     */
    public function user(): BelongsTo
    {
        return $this->belongsTo(
            config('versionable.user_model'),
            config('versionable.user_foreign_key')
        );
    }

    /**
     * @return MorphTo
     */
    public function versionable(): MorphTo
    {
        return $this->morphTo('versionable');
    }

    /**
     * createForModel
     * @param Versionable|Model $model

Consider making the type for parameter $model a bit more specific; maybe use Model.

     * @return Version
     * @throws NotVersionableModel
     */
    public static function createForModel(Model $model): Version
    {
        if (!in_array(Versionable::class, class_uses($model), true)) {

This code seems to be duplicated across your project.

            throw new NotVersionableModel(
                "{$model} not use Versionable " . config('versionable.version_model')
            );
        }
        $versionClass = $model->getVersionModel();
        /** @var Version $version */
        $version = new $versionClass();
        $version->version_number = ((int) $versionClass::where('versionable_id', $model->getKey())
            ->where('versionable_type', $model->getMorphClass())
            ->max('version_number')) + 1;
        $version->versionable_id = $model->getKey();
        $version->versionable_type = $model->getMorphClass();
        $version->{config('versionable.user_foreign_key')} = auth()->id();

The method id does only exist in Illuminate\Contracts\Auth\Guard, but not in Illuminate\Contracts\Auth\Factory.

        $version->contents = $model->getVersionableAttributes();

        $version->save();
        return $version;
    }

    /**
     * @return bool
     */
    public function revert(): bool
    {
        return $this->versionable->fill($this->contents)->save();
    }

    /**
     * diff
     * @param Versionable|Model|null $model

Consider making the type for parameter $model a bit more specific; maybe use null|Model.

     *
     * @return string
     * @throws NotVersionableModel
     */
    public function diff(Model $model = null): string
    {
        $model || $model = $this->versionable;

Consider using a different name than the parameter $model. This often makes code more readable.

        if ($model instanceof self) {
            $source = $model->contents;
        } else {
            if (!in_array(Versionable::class, class_uses($model), true)) {

This code seems to be duplicated across your project.

                throw new NotVersionableModel("{$model} is not versionable");
            }

            $source = $model->versionableFromArray($this->versionable->toArray());

The method versionableFromArray cannot be called on $model (of type null).

        }

        return (new Differ())->diff(Arr::only($source, array_keys($this->contents)), $this->contents);
    }
}