Definition::getField() - Code Metrics - Inspection of "add name alias" - bytic/models-smart-properties - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Push — master ( c4a808...c45372 )

by Gabriel
created 2021-08-04 19:48 UTC
Definition::getField() A

↳ Parent: Definition
Complexity

Conditions	1
Paths	1
Size

Total Lines	3
Code Lines	1
Duplication

Lines	0
Ratio	0 %
Importance

Changes
Metric	Value
eloc	1
c	0
b	0
f	0
dl	0
loc	3
rs	10
cc	1
nc	1
nop	0
<?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)) . ']'
                [' . implode(',', array_keys(/** @scrutinizer ignore-type */ $items)) . ']'
            );
        }
        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;

    }

    /**
     * @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);
        $className = $this->getPropertyClass(/** @scrutinizer ignore-type */ $type);
        $object = new $className();
        /** @var Property $object */
        $object->setManager($this->getManager());
        $object->setField($this->getField());
        $object->setNamespace($this->getPropertyItemsRootNamespace());
        return $object;
    }

    /**
     * @param null $type

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

        $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

     */
    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());
            $keys = array_keys(/** @scrutinizer ignore-type */ $this->getItems());
            $defaultValue = reset($keys);
        }
        $this->setDefaultValue($defaultValue);
        $this->setDefaultValue(/** @scrutinizer ignore-type */ $defaultValue);
    }

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

bytic / models-smart-properties

Push — master ( c4a808...c45372 )

Definition::getField() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
