Backpack\CRUD\app\Library\Components\AttributeCollection

Complexity

Total Complexity

32

Size/Duplication

Total Lines	149
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

16 Methods

Rating	Name	Duplication	Size	Complexity
A	getItems()	0	3	1
A	validate()	0	10	2
A	__construct()	0	20	4
A	updateItem()	0	4	1
A	deleteItem()	0	4	1
A	addAttribute()	0	5	2
A	getAttributeValue()	0	3	2
A	getCollectionRepository()	0	3	1
A	toArray()	0	5	1
A	setCollectionManager()	0	5	1
A	replaceAttributes()	0	3	1
B	setAttributeDefaults()	0	21	7
A	setValidationRules()	0	12	4
A	addCollectionOfAttributes()	0	3	1
A	hasAttribute()	0	3	1
A	buildAttributes()	0	8	2

<?php

namespace Backpack\CRUD\app\Library\Components;

use Backpack\CRUD\app\Library\Components\Attributes\BackpackAttribute;
use Backpack\CRUD\app\Library\Components\Interfaces\AttributeInterface;
use Backpack\CRUD\app\Library\Components\Interfaces\SmartComponentInterface;
use Illuminate\Support\Collection;
use Illuminate\Support\Facades\Validator;

class AttributeCollection
{
    protected Collection $items;

    public function __construct(array|string|Collection $attributes,
                                private CollectionRepository $collectionRepository,
                                ValidationRules|array $rules = [],
                                array $defaults = []
                            ) {
        $attributes = is_string($attributes) ? collect(['name' => $attributes]) : collect($attributes);

The condition is_string($attributes) is always false.

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

        $rules = is_array($rules) ? new ValidationRules($rules) : $rules;

The condition is_array($rules) is always true.

        $defaults = collect($defaults)->mapWithKeys(function ($default, $attribute) {
            if (is_a($default, AttributeInterface::class, true)) {
                return [$default::getAttributeName() => $default];
            }

            return [$attribute => $default];
        })->toArray();

        $this->items = $this->buildAttributes($attributes, $rules, $defaults);

        assert($this->hasAttribute('name'), 'Component name cant be empty.');
        assert(is_string($this->getAttributeValue('name')), 'Component name must be a valid string.');
    }

    private function buildAttributes(Collection $attributes, ValidationRules $rules, array $defaults): Collection
    {
        return $attributes->mapWithKeys(function ($attribute, $key) use ($rules, $defaults) {
            if (! is_a($attribute, AttributeInterface::class, true)) {
                return [$key => new BackpackAttribute($key, $attribute, $defaults[$key] ?? null, $rules->for($key))];
            }

            return [$attribute::getAttributeName() => $attribute];
        });
    }

    public function setCollectionManager(CollectionRepository $collection)
    {
        $this->collectionRepository = $collection;

        return $collection;
    }

    public function hasAttribute($attribute)
    {
        return $this->items->has($attribute);
    }

    public function getAttributeValue($attribute, $default = null)
    {
        return $this->items->has($attribute) ? $this->items->get($attribute, $default)->value() : $default;
    }

    public function getCollectionRepository()
    {
        return $this->collectionRepository;
    }

    public function replaceAttributes(AttributeCollection $attributes)
    {
        $this->attributes = $attributes->toArray();

The property attributes does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly.

    }

    public function setValidationRules(array $rules)
    {
        $rules = new ValidationRules($rules);

        $this->items->each(function ($item, $key) use ($rules) {
            if (! is_string($key) && is_a($item, AttributeInterface::class, true)) {
                $key = $item::getAttributeName();
            }
            if (is_string($rules->for($key) ?? [])) {
                dd($key, $rules);
            }
            $item->setRules($rules->for($key) ?? []);
        });
    }

    public function validate($attributes = null, $rules = null)
    {
        $attributes = $attributes ?? $this->toArray();

        $rules = $rules ?? $this->rules;

The property rules does not exist on Backpack\CRUD\app\Library\Components\AttributeCollection. Did you maybe forget to declare it?

        $validator = Validator::make($attributes, $rules)->stopOnFirstFailure();

        if ($validator->fails()) {
            throw new \Exception($validator->errors()->first());
        }
    }

    public function getItems()
    {
        return $this->items;
    }

    public function addAttribute($attribute, $value)
    {
        $item = $this->hasAttribute($attribute) ? $this->items->get($attribute)->setValue($value) : new BackpackAttribute($attribute, $value);
        $item->validate($value);
        $this->updateItem($item);
    }

    public function addCollectionOfAttributes(SmartComponentInterface $item)
    {
        $this->collectionRepository->addItem($item->getAttribute('name'), $item->getAttributesArray());
    }

    private function updateItem(AttributeInterface|BackpackAttribute $item)
    {
        $this->items[$item->attribute] = $item;

The property attribute does not seem to exist on Backpack\CRUD\app\Library\Components\Attributes\BackpackAttribute.

        $this->collectionRepository->setItemAttributes($this->getAttributeValue('name'), $this->toArray());
    }

    public function deleteItem(string $name)
    {
        $this->items->forget($name);
        $this->collectionRepository->removeItem($name);
    }

    public function toArray()
    {
        return $this->items->mapWithKeys(function ($item, $key) {
            return [$key => $item->value()];
        })->toArray();
    }

    public function setAttributeDefaults(array $defaults)
    {
        foreach ($defaults as $key => $default) {
            if (! is_string($key) && is_a($default, AttributeInterface::class, true)) {
                $key = $default::getAttributeName();
            }

            if (! $this->items->has($key)) {
                if (is_a($default, AttributeInterface::class, true)) {
                    $this->items[$key] = $default::make($key, $default::getDefault($this), $default, []);

                    continue;
                }

                if ($default instanceof \Closure) {
                    $this->items[$key] = new BackpackAttribute($key, $default($this), $default, []);

                    continue;
                }

                $this->items[$key] = new BackpackAttribute($key, $default, $default, []);
            }
        }
    }
}