ByTIC\Models\SmartProperties\Definitions\Definition

Complexity

Total Complexity

36

Size/Duplication

Total Lines	265
Duplicated Lines	0 %

Importance

Changes

0

20 Methods

Rating	Name	Duplication	Size	Complexity
A	getValues()	0	15	3
A	getItem()	0	14	3
A	hasItem()	0	5	2
A	getPropertyClass()	0	6	2
A	getItems()	0	7	2
A	getDefaultValueFromManager()	0	8	2
A	getField()	0	3	1
A	setDefaultValue()	0	3	1
A	addItem()	0	6	2
A	initItems()	0	7	2
A	setManager()	0	3	1
A	initDefaultValue()	0	10	3
A	newProperty()	0	9	1
A	initLabel()	0	4	1
A	getManager()	0	3	1
A	getLabel()	0	7	2
A	setLabel()	0	3	1
A	getDefaultValue()	0	7	2
A	setField()	0	3	1
A	getPropertyItemsRootNamespace()	0	14	3

<?php

namespace ByTIC\Models\SmartProperties\Definitions;

use ByTIC\Models\SmartProperties\Properties\AbstractProperty\Generic;
use ByTIC\Models\SmartProperties\Properties\AbstractProperty\Generic as Property;
use ByTIC\Models\SmartProperties\RecordsTraits\HasSmartProperties\RecordsTrait;
use Exception;
use Nip\Records\RecordManager;

/**
 * Class Definition
 * @package ByTIC\Models\SmartProperties\Definitions
 */
class Definition implements \Serializable
{
    use Traits\HasName;
    use Traits\HasPlaces;
    use Traits\Serializable;

    /**
     * @var RecordManager|RecordsTrait
     */
    protected $manager;


    /**
     * @var string
     */
    protected $label = null;

    /**
     * @var string
     */
    protected $field;

    protected $items = null;
    protected $itemsAliases = [];

    protected $defaultValue = null;

    /**
     * @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() . ']
                [' . 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
    {
        if ($this->items == null) {
            $this->initItems();
        }

        return $this->items;
    }

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

    /**
     * @return string|null
     */
    public function getField(): ?string
    {
        return $this->field;
    }

    /**
     * @param mixed $field
     */
    public function setField($field)
    {
        $this->field = $field;
    }

    /**
     * @return RecordManager
     */
    public function getManager()
    {
        return $this->manager;

The expression return $this->manager also could return the type ByTIC\Models\SmartProperties\RecordsTraits\HasSmartProperties\RecordsTrait which is incompatible with the documented return type Nip\Records\RecordManager.

    }

    /**
     * @param RecordManager|RecordsTrait $manager
     */
    public function setManager($manager)
    {
        $this->manager = $manager;
    }

    /**
     * @return string
     */
    public function getLabel(): ?string
    {
        if ($this->label === null) {
            $this->initLabel();
        }

        return $this->label;
    }

    /**
     * @param string $label
     */
    public function setLabel(string $label)
    {
        $this->label = $label;
    }

    protected function initLabel()
    {
        $name = inflector()->pluralize($this->getName());
        $this->setLabel($name);
    }

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

It seems like $type can also be of type string; however, parameter $type of ByTIC\Models\SmartProperties\Definitions\Definition::getPropertyClass() does only seem to accept null, maybe add an additional type check?

        $object = new $className();
        /** @var Property $object */
        $object->setManager($this->getManager());
        $object->setField($this->getField());
        $object->setNamespace($this->getPropertyItemsRootNamespace());
        return $object;
    }

    /**
     * @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);
    }

    /**
     * @return string
     */
    public function getDefaultValue(): ?string
    {
        if ($this->defaultValue === null) {
            $this->initDefaultValue();
        }

        return $this->defaultValue;
    }

    /**
     * @param null $defaultValue

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

     */
    public function setDefaultValue($defaultValue)
    {
        $this->defaultValue = $defaultValue;
    }

    /**
     * @param Generic $object
     */
    protected function addItem(Property $object)
    {
        $this->items[$object->getName()] = $object;
        $aliases = $object->getAliases();
        foreach ($aliases as $alias) {
            $this->itemsAliases[$alias] = $object->getName();
        }
    }

    protected function initDefaultValue()
    {
        $managerDefaultValue = $this->getDefaultValueFromManager();
        if ($managerDefaultValue && $this->hasItem($managerDefaultValue)) {
            $defaultValue = $managerDefaultValue;
        } else {
            $keys = array_keys($this->getItems());

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

            $defaultValue = reset($keys);
        }
        $this->setDefaultValue($defaultValue);

It seems like $defaultValue can also be of type string and true; however, parameter $defaultValue of ByTIC\Models\SmartProperties\Definitions\Definition::setDefaultValue() does only seem to accept null, maybe add an additional type check?

    }

    /**
     * @return bool|string
     */
    protected function getDefaultValueFromManager()
    {
        $method = 'getDefault' . $this->getName();
        if (method_exists($this->getManager(), $method)) {
            return $this->getManager()->{$method}();
        }

        return false;
    }

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

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

    /**
     * @return string
     */
    protected function getPropertyItemsRootNamespace(): string
    {
        $manager = $this->getManager();
        $method = 'get' . $this->getName() . 'ItemsRootNamespace';
        if (method_exists($manager, $method)) {
            return $manager->{$method}();
        }

        $method = 'get' . $this->getName() . 'Namespace';
        if (method_exists($manager, $method)) {
            return $manager->{$method}();
        }

        return $manager->getModelNamespace() . $this->getLabel() . '\\';
    }

    /**
     * @param $name
     *
     * @return array
     */
    public function getValues($name): array
    {
        $return = [];
        $items = $this->getItems();

        foreach ($items as $type) {
            $method = 'get' . ucfirst($name);
            if (method_exists($type, $method)) {
                $return[] = $type->$method();
            } else {
                $return[] = $type->{$name};
            }
        }

        return $return;
    }
}