Serafim\Properties\Bootstrap

Complexity

Total Complexity

16

Size/Duplication

Total Lines	150
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	3

Importance

Changes

0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	getInstance()	0	4	1
A	setInstance()	0	4	1
A	__construct()	0	5	1
A	getInvocationPosition()	0	6	1
A	setCacheDriver()	0	4	1
A	getAttribute()	0	16	4
A	hasAttribute()	0	4	1
A	getClassInheritance()	0	15	2
A	getAttributeOrBuild()	0	12	3
A	getCacheKey()	0	4	1

<?php
/**
 * This file is part of Properties package.
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */
declare(strict_types=1);

namespace Serafim\Properties;

use Psr\SimpleCache\CacheInterface;
use Serafim\Properties\Attribute\AttributeInterface;

/**
 * Class Bootstrap
 */
final class Bootstrap
{
    /**
     * @var Bootstrap
     */
    private static $instance;

    /**
     * @var CacheInterface
     */
    private $cache;

    /**
     * @var Builder
     */
    private $builder;

    /**
     * @var array|string[]
     */
    private $inheritance = [];

    /**
     * @return Bootstrap
     */
    public static function getInstance(): self
    {
        return self::$instance ?? self::setInstance(new self());
    }

    /**
     * @param self|Bootstrap $instance
     * @return Bootstrap
     */
    public static function setInstance(?self $instance): self
    {
        return self::$instance = $instance;
    }

    /**
     * Bootstrap constructor.
     */
    private function __construct()
    {
        $this->cache = new ArrayCache();
        $this->builder = new Builder();
    }

    /**
     * @return array
     */
    public function getInvocationPosition(): array
    {
        $trace = \debug_backtrace(\DEBUG_BACKTRACE_IGNORE_ARGS)[2] ?? [];

        return [$trace['file'] ?? __FILE__, $trace['line'] ?? __LINE__];
    }

    /**
     * @param null|CacheInterface $cache
     */
    public function setCacheDriver(?CacheInterface $cache): void
    {
        $this->cache = $cache ?? new ArrayCache();
    }

    /**
     * @param string $class
     * @param string $name
     * @return AttributeInterface|null
     * @throws \Psr\SimpleCache\InvalidArgumentException
     */
    public function getAttribute(string $class, string $name): ?AttributeInterface
    {
        foreach ($this->getClassInheritance($class) as $child) {
            $result = $this->getAttributeOrBuild($child, $name, function () use ($child) {

Are you sure the assignment to $result is correct as $this->getAttributeOrBuild($child, $name, function () use($child) { foreach ($this->builder->buildClass($child) as $attribute) { (yield $this->getCacheKey($child, $attribute->getName()) => $attribute); } }) (which targets Serafim\Properties\Bootstrap::getAttributeOrBuild()) seems to always return null.

                foreach ($this->builder->buildClass($child) as $attribute) {
                    yield $this->getCacheKey($child, $attribute->getName()) => $attribute;
                }
            });

            if ($result) {
                return $result;
            }
        }

        return null;
    }

    /**
     * @param string $class
     * @param string $name
     * @return bool
     * @throws \Psr\SimpleCache\InvalidArgumentException
     */
    public function hasAttribute(string $class, string $name): bool
    {
        return $this->getAttribute($class, $name) !== null;
    }

    /**
     * @param string $class
     * @return iterable|string[]
     */
    private function getClassInheritance(string $class): iterable
    {
        $inheritance = function() use ($class) {
            yield $class;
            yield from \array_keys(\class_parents($class));
            yield from \array_keys(\class_implements($class));
            yield from \array_keys(\class_uses($class));
        };

        if (! isset($this->inheritance[$class])) {
            $this->inheritance[$class] = \iterator_to_array($inheritance(), false);
        }

        return $this->inheritance[$class];
    }

    /**
     * @param string $class
     * @param string $name
     * @param \Closure $build
     * @return null|AttributeInterface
     * @throws \Psr\SimpleCache\InvalidArgumentException
     */
    private function getAttributeOrBuild(string $class, string $name, \Closure $build): ?AttributeInterface
    {
        $key = $this->getCacheKey($class, $name);

        if (! $this->cache->has($key)) {
            foreach ($build() as $inner => $attribute) {
                $this->cache->set($inner, $attribute);
            }
        }

        return $this->cache->get($key);
    }

    /**
     * @param string $class
     * @param string $name
     * @return string
     */
    private function getCacheKey(string $class, string $name): string
    {
        return \hash('md4', \implode(':', [$class, $name]));
    }
}