App\Support\Model\HasAttributes

Complexity

Total Complexity

8

Size/Duplication

Total Lines	67
Duplicated Lines	0 %

Test Coverage

Coverage

0%

Importance

Changes	1
Bugs	0	Features	0

3 Methods

Rating	Name	Duplication	Size	Complexity
A	isRelationValueDirty()	0	16	4
A	isCollectionValid()	0	12	3
A	getCollectionValue()	0	5	1

<?php

namespace App\Support\Model;

use DomainException;
use Illuminate\Database\Eloquent\Collection;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\Relations\Relation;
use InvalidArgumentException;

/**
 * @property int $id
 * @property \Illuminate\Support\Carbon $created_at
 * @property \Illuminate\Support\Carbon $updated_at
 */
trait HasAttributes
{
    /**
     * Determine if the model relation value has been modified.
     *
     * @param  array|string|null  $relations
     * @return bool
     *
     * @throws \InvalidArgumentException
     */
    public function isRelationValueDirty($relations = null): bool
    {
        $attributes = array_map(function ($name) {
            $relation = $this->$name();

            if (!$relation instanceof Relation || !method_exists($relation, 'getForeignKeyName')) {
                throw new InvalidArgumentException(sprintf(
                    'The given relation name %s on model class %s must return a relationship instance and has getForeignKeyName() method.',
                    $name, static::class
                ));
            }

            return $relation->getForeignKeyName();
        }, is_array($relations) ? $relations : func_get_args());

        return $this->isDirty($attributes);

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

    }

    /**
     * Determine whether the given model collection is valid with the given class name.
     *
     * @param  \Illuminate\Database\Eloquent\Collection<\Illuminate\Database\Eloquent\Model>  $models
     * @param  string  $className
     * @param  bool  $throwExceptionWhenNotValid
     * @return bool
     *
     * @throws \DomainException
     */
    protected function isCollectionValid(Collection $models, string $className, bool $throwExceptionWhenNotValid = true): bool
    {
        return $models->every(function (Model $model) use ($className, $throwExceptionWhenNotValid) {
            $isValid = $model instanceof $className;

            if (!$isValid && $throwExceptionWhenNotValid) {
                throw new DomainException(sprintf(
                    'Invalid %s model type, %s given', $className, get_class($model)
                ));
            }

            return $isValid;
        });
    }

    /**
     * Return collection value from specified model relation.
     *
     * @param  string  $key
     * @param  string  $className
     * @return \Illuminate\Database\Eloquent\Collection<\Illuminate\Database\Eloquent\Model>
     *
     * @throws \DomainException
     */
    public function getCollectionValue(string $key, string $className): Collection
    {
        $this->isCollectionValid($models = $this->getRelationValue($key), $className);

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

        return $models;
    }
}