TrackOriginalTrait::getDirty() - Code Metrics - Inspection of "update syncOriginal" - bytic/data-objects - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — main ( 7e0081...d3da7f )

by Gabriel

created 2020-10-16 17:50 UTC

TrackOriginalTrait::getDirty() A

↳ Parent: TrackOriginalTrait

Complexity

Conditions	5
Paths	12

Size

Total Lines	12
Code Lines	7

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	30

Importance

Changes	1
Bugs	0	Features	1

Metric	Value
cc	5
eloc	7
c	1
b	0
f	1
nc	12
nop	1
dl	0
loc	12
rs	9.6111
ccs	0
cts	5
cp	0
crap	30

<?php

namespace ByTIC\DataObjects\Behaviors\TrackOriginal;

use InvalidArgumentException;
use Nip\Utility\Arr;

/**
 * Trait TrackOriginalTrait
 * @package ByTIC\DataObjects\Behaviors\TrackOriginal
 */
trait TrackOriginalTrait
{
    use \ByTIC\DataObjects\Legacy\Behaviors\OldDBDataTrait;

    /**
     * The Object original state.
     *
     * @var array
     */
    protected $original = [];

    /**
     * @param $data
     */
    public function fillOriginal($data)
    {
        foreach ($data as $key => $value) {
            $this->original[$key] = $value;
        }
    }

    public function getOriginalData(): array
    {
        return $this->original;
    }

    /**
     * Returns the value of an original field by name
     *
     * @param string $field the name of the field for which original value is retrieved.
     * @param null $default

     * @return mixed
     */
    public function getOriginal(string $field, $default = null)
    {
        if (!strlen($field)) {
            throw new InvalidArgumentException('Cannot get an empty field');
        }

        if (array_key_exists($field, $this->original)) {
            return $this->original[$field];
        }

        return $this->get($field, $default);
        return $this->/** @scrutinizer ignore-call */ get($field, $default);
    }

    /**
     * Get the model's raw original attribute values.
     *
     * @param string|null $key
     * @param mixed $default
     * @return mixed|array
     */
    public function getRawOriginal($key = null, $default = null)
    {
        return Arr::get($this->original, $key, $default);
    }

    /**
     * Sync the original attributes with the current.
     *
     * @return $this
     */
    public function syncOriginal(): self
    {
        $keys = array_merge(array_keys($this->original), array_keys($this->getAttributes()));
        $keys = array_merge(array_keys($this->original), array_keys($this->/** @scrutinizer ignore-call */ getAttributes()));
        $keys =  array_unique(array_filter($keys));
        $data = [];
        foreach ($keys as $key) {
            $data[$key] = $this->getPropertyRaw($key);
            $data[$key] = $this->getPropertyRaw($key);
        }
        $this->original = $data;
        return $this;
    }

    /**
     * Determine if the model or any of the given attribute(s) have been modified.
     *
     * @param array|string|null $attributes
     * @return bool
     */
    public function isDirty($attributes = null)
    {
        return $this->hasChanges(
            $this->getDirty(),
            is_array($attributes) ? $attributes : func_get_args()
        );
    }

    /**
     * Determine if the model and all the given attribute(s) have remained the same.
     *
     * @param array|string|null $attributes
     * @return bool
     */
    public function isClean($attributes = null)
    {
        return !$this->isDirty(...func_get_args());
    }

    /**
     * Determine if the model or any of the given attribute(s) have been modified.
     *
     * @param array|string|null $attributes
     * @return bool
     */
    public function wasChanged($attributes = null)
    {
        return $this->hasChanges(
            $this->getChanges(),
                   getChanges(),
            is_array($attributes) ? $attributes : func_get_args()
        );
    }

    /**
     * Get the attributes that have been changed since last sync.
     *
     * @param null $fields

     * @return array
     */
    public function getDirty($fields = null): array
    {
        $dirty = [];
        $fields = is_array($fields) && count($fields) > 0 ? $fields : array_keys($this->getAttributes());

        foreach ($fields as $field) {
            $value = $this->getPropertyRaw($field);
            if (!$this->originalIsEquivalent($field, $value)) {
                $dirty[$field] = $value;
            }
        }

        return $dirty;
    }

    /**
     * Determine if any of the given attributes were changed.
     *
     * @param array $changes
     * @param array|string|null $attributes
     * @return bool
     */
    protected function hasChanges($changes, $attributes = null)
    {
        // If no specific attributes were provided, we will just see if the dirty array
        // already contains any attributes. If it does we will just return that this
        // count is greater than zero. Else, we need to check specific attributes.
        if (empty($attributes)) {
            return count($changes) > 0;
        }

        // Here we will spin through every attribute and see if this is in the array of
        // dirty attributes. If it is, we will return true and if we make it through
        // all of the attributes for the entire array we will return false at end.
        foreach (Arr::wrap($attributes) as $attribute) {
            if (array_key_exists($attribute, $changes)) {
                return true;
            }
        }

        return false;
    }

    /**
     * @param string $key
     * @param null $value

     * @return bool
     */
    protected function originalIsEquivalent(string $key, $value = null): bool
    {
        if (!array_key_exists($key, $this->original)) {
            return false;
        }
        $attribute = $value ?? $this->getPropertyRaw($key);
        $original = Arr::get($this->original, $key);

        if ($attribute === $original) {
            return true;
        }

        return is_numeric($attribute) && is_numeric($original)
            && strcmp((string)$attribute, (string)$original) === 0;
    }
}


bytic / data-objects

Push — main ( 7e0081...d3da7f )

TrackOriginalTrait::getDirty() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like