ByTIC\Models\SmartProperties\Definitions\Definition\HasProperties

Complexity

Total Complexity

15

Size/Duplication

Total Lines	97
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	getItems()	0	9	2
A	hasItem()	0	5	2
A	initItems()	0	7	2
A	newProperty()	0	4	2
A	getPropertyClass()	0	6	2
A	addItem()	0	7	2
A	getItem()	0	14	3

<?php

namespace ByTIC\Models\SmartProperties\Definitions\Definition;

use ByTIC\Models\SmartProperties\Properties\AbstractProperty\Generic;
use ByTIC\Models\SmartProperties\Properties\AbstractProperty\Generic as Property;
use ByTIC\Models\SmartProperties\Properties\PropertiesFactory;
use Exception;

/**
 * Trait HasProperties
 * @package ByTIC\Models\SmartProperties\Definitions\Definition
 */
trait HasProperties
{
    protected $items = null;
    protected $itemsAliases = [];

    /**
     * @param $name
     *
     * @return Property
     * @throws Exception
     */
    public function getItem($name): Property
    {
        $items = $this->getItems();
        if (!$this->hasItem($name)) {
            throw new Exception(
                'Bad Item [' . $name . '] for smart property 
                [' . $this->getManager()->getController() . '::' . $this->getName() . ']

It seems like getName() must be provided by classes using this trait. How about adding it as abstract method to this trait?

It seems like getManager() must be provided by classes using this trait. How about adding it as abstract method to this trait?

                [' . implode(',', array_keys($items)) . ']'

It seems like $items can also be of type null; however, parameter $array of array_keys() does only seem to accept array, maybe add an additional type check?

            );
        }
        if (isset($this->itemsAliases[$name])) {
            $name = $this->itemsAliases[$name];
        }
        return $items[$name];
    }

    /**
     * @return null|Property[]
     */
    public function getItems(): ?array
    {
        $this->checkBuild();

It seems like checkBuild() must be provided by classes using this trait. How about adding it as abstract method to this trait?

        if ($this->items == null) {
            $this->initItems();
        }

        return $this->items;
    }

    public function initItems()
    {
        $names = $this->getPlaces();

It seems like getPlaces() must be provided by classes using this trait. How about adding it as abstract method to this trait?

        $this->items = [];
        foreach ($names as $name) {
            $object = $this->newProperty($name);
            $this->addItem($object);
        }
    }

    /**
     * @param string $type
     *
     * @return Property
     */
    public function newProperty($type = null): Property
    {
        $type = $type ?: $this->getDefaultValue();

It seems like getDefaultValue() must be provided by classes using this trait. How about adding it as abstract method to this trait?

        return PropertiesFactory::forDefinition($this, $type);

The call to ByTIC\Models\SmartProperties\Properties\PropertiesFactory::forDefinition() has too few arguments starting with baseNamespace.

    }

    /**
     * @param null $type

Are you sure the doc-type for parameter $type is correct as it would always require null to be passed?

     *
     * @return string
     */
    public function getPropertyClass($type = null): string
    {
        $type = $type ?: $this->getDefaultValue();

$type is of type null, thus it always evaluated to false.

        $type = str_replace(DIRECTORY_SEPARATOR, '\\', $type);

        return $this->getPropertyItemsRootNamespace() . inflector()->classify($type);

It seems like getPropertyItemsRootNamespace() must be provided by classes using this trait. How about adding it as abstract method to this trait?

    }

    /**
     * @param Generic $object
     */
    public function addItem(Property $object)
    {
        $this->items[$object->getName()] = $object;
        $this->addPlace($object->getName());

It seems like addPlace() must be provided by classes using this trait. How about adding it as abstract method to this trait?

        $aliases = $object->getAliases();
        foreach ($aliases as $alias) {
            $this->itemsAliases[$alias] = $object->getName();
        }
    }

    /**
     * @param $name
     * @return bool
     */
    public function hasItem($name): bool
    {
        $items = $this->getItems();

        return isset($items[$name]) || isset($this->itemsAliases[$name]);
    }


}