Definition::hasItem() - Code Metrics - Inspection of "Merge pull request #3 from bytic/analysis-BM0nmm" - bytic/models-smart-properties - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Push — master ( bcadde...416dc9 )

by Gabriel
created 2020-10-13 08:31 UTC
Definition::hasItem() A

↳ Parent: Definition
Complexity

Conditions	1
Paths	1
Size

Total Lines	5
Code Lines	2
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	3
CRAP Score	1
Importance

Changes
Metric	Value
eloc	2
c	0
b	0
f	0
dl	0
loc	5
rs	10
ccs	3
cts	3
cp	1
cc	1
nc	1
nop	1
crap	1
<?php

namespace ByTIC\Models\SmartProperties\Properties\Definitions;

use ByTIC\Common\Records\Traits\HasSmartProperties\RecordsTrait;
filter:
    dependency_paths: ["lib/*"]
use ByTIC\Models\SmartProperties\Properties\AbstractProperty\Generic as Property;
use Exception;
use Nip\Records\RecordManager;
use RecursiveDirectoryIterator;
use RecursiveIteratorIterator;

/**
 * Class Definition
 * @package ByTIC\Models\SmartProperties\Properties\Definitions
 */
class Definition
{
    use Traits\HasItemsDirectoryTrait;

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

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

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

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

    protected $items = null;

    protected $defaultValue = null;

    /**
     * @param $name
     *
     * @return Property
     * @throws Exception
     */
    public function getItem($name)
    {
        $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)) . ']'
            );
        }

        return $items[$name];
    }

    /**
     * @return null|Property[]
     */
    public function getItems()
    {
        if ($this->items == null) {
            $this->initItems();
        }

        return $this->items;
    }

    public function initItems()
    {
        $names       = $this->getItemsNames();
        $this->items = [];
        foreach ($names as $name) {
            if (! $this->isAbstractItemName($name)) {
                $object                          = $this->newStatus($name);
                $this->items[$object->getName()] = $object;
            }
        }
    }

    /**
     * @return array
     */
    public function getItemsNames()
    {
        $names = $this->getItemsNamesFromManager();

        return $names ? $names : $this->getItemsNamesFromFiles();

    }

    /**
     * @return array|boolean
     */
    protected function getItemsNamesFromManager()
    {
        $methodName = 'get' . $this->getName() . 'Names';
        if (method_exists($this->getManager(), $methodName)) {
            return $this->getManager()->$methodName();
        }

        return false;
    }

    /**
     * @return mixed
     */
    public function getName()
    {
        if ($this->name === null) {
            $this->initName();
        }

        return $this->name;
    }

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

    protected function initName()
    {
        $name = inflector()->classify($this->getField());
        $this->setName($name);
    }

    /**
     * @return mixed
     */
    public function getField()
    {
        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 array
     */
    protected function getItemsNamesFromFiles()
    {
        $directory = $this->getItemsDirectory();
        $files = new RecursiveIteratorIterator(new RecursiveDirectoryIterator($directory));
        $names = [];
        foreach ($files as $file) {
            if ($file->isDir()) {
                continue;
            }
            $name = str_replace($directory, '', $file->getPathname());
            $name = str_replace('.php', '', $name);
            $names[] = trim($name, DIRECTORY_SEPARATOR . '\\');
        }

        return array_unique($names);
    }


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

        return $this->label;
    }

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

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

    /**
     * @param string $name
     *
     * @return bool
     */
    public function isAbstractItemName($name)
    {
        if (in_array($name, ['Abstract', 'Generic'])) {
            return true;
        }
        if (strpos($name, 'Abstract') === 0) {
            return true;
        }
        if (strpos($name, '\Abstract') !== false) {
            return true;
        }
        if (strpos($name, DIRECTORY_SEPARATOR . 'Abstract') !== false) {
            return true;
        }

        return false;
    }

    /**
     * @param string $type
     *
     * @return Property
     */
    public function newStatus($type = null)
    {
        $className = $this->getItemClass($type);
        $className = $this->getItemClass(/** @scrutinizer ignore-type */ $type);
        $object    = new $className();
        /** @var Property $object */
        $object->setManager($this->getManager());
        $object->setField($this->getField());

        return $object;
    }

    /**
     * @param null $type

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

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

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

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

        return $this->defaultValue;
    }

    /**
     * @param null $defaultValue

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

    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)
    {
        $items = $this->getItems();

        return isset($items[$name]);
    }

    /**
     * @return string
     */
    protected function getPropertyItemsRootNamespace()
    {
        $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)
    {
        $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 ( bcadde...416dc9 )

Definition::hasItem() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like
