MichaelRubel\LoopFunctions\Traits\LoopFunctions

Complexity

Total Complexity

9

Size/Duplication

Total Lines	122
Duplicated Lines	0 %

Test Coverage

Coverage

94.29%

Importance

Changes	12
Bugs	1	Features	1

6 Methods

Rating	Name	Duplication	Size	Complexity
A	propertiesFrom()	0	6	2
A	arrayToProperties()	0	9	2
A	attributesToProperties()	0	9	1
A	dumpProperties()	0	25	2
A	__get()	0	3	1
A	__set()	0	3	1

<?php

declare(strict_types=1);

namespace MichaelRubel\LoopFunctions\Traits;

use Illuminate\Database\Eloquent\Model;
use Illuminate\Support\Collection;

trait LoopFunctions
{
    use HelpsLoopFunctions;

    /**
     * Choose proper strategy to loop over the data.
     *
     * @param Model|\ArrayAccess|array|null $data
     * @param mixed|null                    $rescue
     *
     * @return void
     */
    public function propertiesFrom(Model|\ArrayAccess|array|null $data = null, mixed $rescue = null): void
    {
        if ($data) {
            match (true) {
                $data instanceof Model => $this->attributesToProperties($data, $rescue),

Are you sure the usage of $this->attributesToProperties($data, $rescue) targeting MichaelRubel\LoopFunctions\Traits\LoopFunctions::attributesToProperties() seems to always return null.

$data of type array is incompatible with the type Illuminate\Database\Eloquent\Model|null expected by parameter $model of MichaelRubel\LoopFunctions\Traits\LoopFunctions::attributesToProperties().

                default                => $this->arrayToProperties($data, $rescue),

Are you sure the usage of $this->arrayToProperties($data, $rescue) targeting MichaelRubel\LoopFunctions\Traits\LoopFunctions::arrayToProperties() seems to always return null.

            };
        }
    }

    /**
     * Maps your model attributes to local class properties.
     *
     * @param Model|null $model
     * @param mixed      $rescue
     *
     * @return void
     */
    public function attributesToProperties(?Model $model = null, mixed $rescue = null): void
    {
        collect($model?->getAttributes())

$model->getAttributes() of type array is incompatible with the type Illuminate\Contracts\Support\Arrayable expected by parameter $value of collect().

            ->except($this->ignoredPropertyNames())
            ->each(
                fn ($value, $property) => $this->assignValue(
                    $property,
                    $model->{$property},
                    $rescue
                )
            );
    }

    /**
     * Map array data to class properties.
     *
     * @param array|\ArrayAccess|null $data
     * @param mixed|null              $rescue
     *
     * @return void
     */
    public function arrayToProperties(array|\ArrayAccess|null $data, mixed $rescue = null): void
    {
        collect($data ?? [])

$data ?? array() of type array is incompatible with the type Illuminate\Contracts\Support\Arrayable expected by parameter $value of collect().

            ->except($this->ignoredPropertyNames())
            ->each(function ($value, $key) use ($rescue) {
                $this->assignValue($key, $value, $rescue);

                if ($this->canWalkRecursively($value)) {
                    $this->propertiesFrom($value, $rescue);
                }
            });
    }

    /**
     * Dump class properties as key-valued array.
     *
     * @param string|object|null $class
     * @param int|null           $filter
     * @param bool               $asCollection
     *
     * @return array|Collection
     * @throws \ReflectionException
     */
    public function dumpProperties(
        string|object|null $class = null,
        bool $asCollection = false,
        ?int $filter = null,
    ): array|Collection {
        $class = match (true) {
            is_string($class) => app($class),

It seems like $class can also be of type object; however, parameter $abstract of app() does only seem to accept null|string, maybe add an additional type check?

            is_object($class) => $class,
            default => $this,
        };

        $properties = (new \ReflectionClass($class))
            ->getProperties($filter);

        $collection = collect($properties)->mapWithKeys(

$properties of type ReflectionProperty[] is incompatible with the type Illuminate\Contracts\Support\Arrayable expected by parameter $value of collect().

            function (\ReflectionProperty $property) use ($class) {
                $property->setAccessible(true);

                return [$property->getName() => $property->getValue($class)];

It seems like $class can also be of type string; however, parameter $object of ReflectionProperty::getValue() does only seem to accept null|object, maybe add an additional type check?

            }
        );

        return ! $asCollection
            ? $collection->all()
            : $collection;
    }

    /**
     * Get the instance's property.
     *
     * @param string $name
     *
     * @return mixed
     */
    public function __get(string $name): mixed
    {
        return $this->{$name};
    }

    /**
     * Set the instance's property.
     *
     * @param string $name
     * @param mixed  $value
     */
    public function __set(string $name, mixed $value): void
    {
        $this->{$name} = $value;
    }
}