LaravelFlare\Flare\Admin\ModelAdmin\AttributeCollection

Complexity

Total Complexity

18

Size/Duplication

Total Lines	120
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	1

Importance

Changes	1
Bugs	0	Features	0

4 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	8	1
A	formatFields()	0	13	2
A	add()	0	8	3
C	formatInnerField()	0	36	12

<?php

namespace LaravelFlare\Flare\Admin\ModelAdmin;

use Illuminate\Support\Collection;
use LaravelFlare\Fields\FieldManager;
use LaravelFlare\Fields\Types\BaseField;

class AttributeCollection extends Collection
{
    /**
     * The items contained in the collection.
     *
     * @var array
     */
    protected $items = [];

    /**
     * Field Manager Instance
     * 
     * @var \LaravelFlare\Fields\FieldManager
     */
    protected $fields;

    /**
     * ModelAdmin which contains this Attribute Collection.
     * 
     * @var \LaravelFlare\Flare\Admin\Models\ModelAdmin
     */
    protected $modelManager;

    /**
     * Create a new collection.
     *
     * @param  mixed  $items
     * 
     * @return void

Adding a @return annotation to constructors is generally not recommended as a constructor does not have a meaningful return value.

     */
    public function __construct($items = [], $modelManager = null)
    {
        $this->fields = \App::make(FieldManager::class);
        $this->items = $items;

It seems like $items of type * is incompatible with the declared type array of property $items.

        $this->modelManager = $modelManager;

        $this->formatFields();
    }

    /**
     * Attempt to reformat the current attribute items array
     * into the most usable format (an Attribute Collection).
     * 
     * @return void
     */
    public function formatFields()
    {
        $items = $this->items;
        $formattedItems = [];

        foreach ($items as $name => $inner) {
            $formattedItems[$name] = $this->formatInnerField($name, $inner);
        }

        $this->items = $formattedItems;

        return $this;
    }

    /**
     * Allows adding fields to the Attribute Collection 
     * 
     * @param array $items
     */
    public function add($items = [])
    {
        if (!is_array($items) || func_num_args() > 1) {
            $items = func_get_args();
        }

        $this->push($this->formatInnerField(null, $items));
    }

    /**
     * Format an Inner Field which can either be in the format
     * of an Array, an instance of BaseAttribute or even an
     * AttributeCollection object (which contains more!).
     *
     * @param  mixed $name
     * @param  mixed  $inner 
     * 
     * @return mixed
     */
    protected function formatInnerField($name = null, $inner = [])
    {
        if ($inner instanceof BaseField) {
            return $inner;
        }

        if ($inner instanceof AttributeCollection) {
            $formattedItems = [];

            foreach ($inner->toArray() as $name => $inner) {
                $formattedItems[$name] = $this->formatInnerField($inner);
            }

            return $formattedItems;
        }

        if (is_scalar($inner) && $this->attributeManager->attributeTypeExists($inner)) {
            return $this->attributeManager->createAttribute($inner, $name, [], $this->modelManager);

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

        }

        if (is_array($inner) && array_key_exists('type', $inner) && is_scalar($inner['type']) && $this->attributeManager->attributeTypeExists($inner['type'])) {
            $type = $inner['type'];
            array_forget($inner, 'type');
            return $this->attributeManager->createAttribute($type, $name, $inner, $this->modelManager);
        }

        if (is_array($inner)) {
            $formattedItems = [];

            foreach ($inner as $name => $inner) {
                $formattedItems[$name] = $this->formatInnerField($inner);
            }

            return $formattedItems;
        }
    }
}