ByTIC\Models\SmartProperties\Definitions\DefinitionRegistry

Complexity

Total Complexity

13

Size/Duplication

Total Lines	112
Duplicated Lines	0 %

Importance

Changes

0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	checkDefinitionToBuild()	0	8	2
A	definitionName()	0	6	2
A	getAll()	0	9	2
A	managerName()	0	6	2
A	get()	0	12	2
A	set()	0	6	1
A	has()	0	9	2

<?php

namespace ByTIC\Models\SmartProperties\Definitions;

use ByTIC\Models\SmartProperties\Exceptions\InvalidArgumentException;
use Nip\Utility\Traits\SingletonTrait;

/**
 * Class DefinitionRegistry
 * @package ByTIC\Models\SmartProperties\Definitions
 */
class DefinitionRegistry
{
    use SingletonTrait;

    /**
     * @var Definition[]
     */
    protected $builders = [];

    /**
     * @var []

The doc comment [] at position 0 could not be parsed: Unknown type name '[' at position 0 in [].

     */
    protected $definitionsBuilt = [];

    /**
     * @var Definition[]
     */
    protected $definitions = [];

    public function has($manager, string $definitionName): bool
    {
        $managerName = $this->managerName($manager);

        if (!isset($this->definitions[$managerName][$definitionName])) {
            return false;
        }

        return true;
    }

    /**
     * @param $manager
     * @param string $definitionName
     * @return mixed
     */
    public function get($manager, string $definitionName)
    {
        $managerName = $this->managerName($manager);

        if (!isset($this->definitions[$managerName][$definitionName])) {
            throw new InvalidArgumentException(sprintf(
                'Unable to find a definition "%s" for class "%s".',
                $definitionName, $managerName
            ));
        }

        return $this->definitions[$managerName][$definitionName];
    }

    /**
     * @param $manager
     * @return mixed
     */
    public function getAll($manager)
    {
        $managerName = $this->managerName($manager);

        if (!isset($this->definitions[$managerName])) {
            return [];
        }

        return $this->definitions[$managerName];
    }

    /**
     * @param object $manager
     * @param $definition
     */
    public function set(object $manager, $definition)
    {
        $managerName = $this->managerName($manager);
        $definitionName = $this->definitionName($definition);

        $this->definitions[$managerName][$definitionName] = $definition;
    }

    /**
     * @param object $manager
     * @param \Closure $callback
     */
    public function checkDefinitionToBuild(object $manager, \Closure $callback)
    {
        $managerName = $this->managerName($manager);
        if (isset($this->definitionsBuilt[$managerName])) {
            return;
        }
        $callback();
        $this->definitionsBuilt[$managerName] = true;
    }

    /**
     * @param object|string $manager
     * @return string
     */
    protected function managerName($manager): string
    {
        if (is_object($manager)) {
            return get_class($manager);
        }
        return (string)$manager;
    }

    /**
     * @param object|string $definition
     * @return string
     */
    protected function definitionName($definition): string
    {
        if ($definition instanceof Definition) {
            return $definition->getName();

The expression return $definition->getName() could return the type null which is incompatible with the type-hinted return string. Consider adding an additional type-check to rule them out.

        }
        return (string)$definition;
    }
}