michael-rubel / laravel-loop-functions

src/Traits/LoopFunctions.php

<?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;
    }
}