Spatie\Activitylog\Traits\DetectsChanges

Complexity

Total Complexity

30

Size/Duplication

Total Lines	138
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	4

Test Coverage

Coverage

97.06%

Importance

Changes

0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	bootDetectsChanges()	0	13	2
B	attributesToBeLogged()	0	26	9
A	shouldLogOnlyDirty()	0	8	2
A	shouldLogUnguarded()	0	16	4
B	attributeValuesToBeLogged()	0	33	7
A	logChanges()	0	19	4
A	getRelatedModelAttributeValue()	0	12	2

<?php

namespace Spatie\Activitylog\Traits;

use Illuminate\Support\Str;
use Illuminate\Database\Eloquent\Model;
use Spatie\Activitylog\Exceptions\CouldNotLogChanges;

trait DetectsChanges
{
    protected $oldAttributes = [];

    protected static function bootDetectsChanges()
    {
        if (static::eventsToBeRecorded()->contains('updated')) {
            static::updating(function (Model $model) {

                //temporary hold the original attributes on the model
                //as we'll need these in the updating event
                $oldValues = $model->replicate()->setRawAttributes($model->getOriginal());

                $model->oldAttributes = static::logChanges($oldValues);
            });
        }
    }

    public function attributesToBeLogged(): array
    {
        $attributes = [];

        if (isset(static::$logFillable) && static::$logFillable) {
            $attributes = array_merge($attributes, $this->getFillable());

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

        }

        if ($this->shouldLogUnguarded()) {
            $attributes = array_merge($attributes, array_diff(array_keys($this->getAttributes()), $this->getGuarded()));

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

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

        }

        if (isset(static::$logAttributes) && is_array(static::$logAttributes)) {
            $attributes = array_merge($attributes, array_diff(static::$logAttributes, ['*']));

            if (in_array('*', static::$logAttributes)) {
                $attributes = array_merge($attributes, array_keys($this->getAttributes()));

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

            }
        }

        if (isset(static::$logAttributesToIgnore) && is_array(static::$logAttributesToIgnore)) {
            $attributes = array_diff($attributes, static::$logAttributesToIgnore);
        }

        return $attributes;
    }

    public function shouldLogOnlyDirty(): bool
    {
        if (! isset(static::$logOnlyDirty)) {
            return false;
        }

        return static::$logOnlyDirty;
    }

    public function shouldLogUnguarded(): bool
    {
        if (! isset(static::$logUnguarded)) {
            return false;
        }

        if (! static::$logUnguarded) {
            return false;
        }

        if (in_array('*', $this->getGuarded())) {

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

            return false;
        }

        return true;
    }

    public function attributeValuesToBeLogged(string $processingEvent): array
    {
        if (! count($this->attributesToBeLogged())) {
            return [];
        }

        $properties['attributes'] = static::logChanges(

$properties was never initialized. Although not strictly required by PHP, it is generally a good practice to add $properties = array(); before regardless.

            $this->exists

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

                ? $this->fresh() ?? $this

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

                : $this
        );

        if (static::eventsToBeRecorded()->contains('updated') && $processingEvent == 'updated') {
            $nullProperties = array_fill_keys(array_keys($properties['attributes']), null);

            $properties['old'] = array_merge($nullProperties, $this->oldAttributes);
        }

        if ($this->shouldLogOnlyDirty() && isset($properties['old'])) {
            $properties['attributes'] = array_udiff_assoc(
                $properties['attributes'],
                $properties['old'],
                function ($new, $old) {
                    return $new <=> $old;
                }
            );
            $properties['old'] = collect($properties['old'])
                ->only(array_keys($properties['attributes']))
                ->all();
        }

        return $properties;
    }

    public static function logChanges(Model $model): array
    {
        $changes = [];
        $attributes = $model->attributesToBeLogged();

        foreach ($attributes as $attribute) {
            if (Str::contains($attribute, '.')) {
                $changes += self::getRelatedModelAttributeValue($model, $attribute);
            } elseif (in_array($attribute, $model->getDates())) {
                $changes[$attribute] = $model->serializeDate(

The method serializeDate() cannot be called from this context as it is declared protected in class Illuminate\Database\Eloquent\Concerns\HasAttributes.

                    $model->asDateTime($model->getAttribute($attribute))

The method asDateTime() cannot be called from this context as it is declared protected in class Illuminate\Database\Eloquent\Concerns\HasAttributes.

                );
            } else {
                $changes[$attribute] = $model->getAttribute($attribute);
            }
        }

        return $changes;
    }

    protected static function getRelatedModelAttributeValue(Model $model, string $attribute): array
    {
        if (substr_count($attribute, '.') > 1) {
            throw CouldNotLogChanges::invalidAttribute($attribute);
        }

        [$relatedModelName, $relatedAttribute] = explode('.', $attribute);

The variable $relatedModelName does not exist. Did you forget to declare it?

The variable $relatedAttribute does not exist. Did you mean $attribute?

        $relatedModel = $model->$relatedModelName ?? $model->$relatedModelName();

        return ["{$relatedModelName}.{$relatedAttribute}" => $relatedModel->$relatedAttribute ?? null];

The variable $relatedAttribute does not exist. Did you mean $attribute?

    }
}