Conia\Chuck\Registry

Complexity

Total Complexity

60

Size/Duplication

Total Lines	330
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes

0

22 Methods

Rating	Name	Duplication	Size	Complexity
A	hasTagged()	0	3	1
A	taggedEntry()	0	3	1
A	add()	0	10	2
B	resolveEntry()	0	53	11
A	resolveParam()	0	25	5
A	fromArgsArray()	0	4	1
A	has()	0	3	2
A	tag()	0	3	1
A	addTagged()	0	6	1
A	getTagged()	0	9	2
A	get()	0	18	5
A	getWithParamName()	0	11	2
A	normalizeParameterName()	0	9	3
A	fromArgsClosure()	0	7	1
A	autowire()	0	11	2
A	resolveArgs()	0	12	3
A	entry()	0	5	1
A	__construct()	0	14	2
A	reifyAndReturn()	0	7	2
A	getParamInfo()	0	14	4
A	addAnyway()	0	10	1
B	new()	0	26	7

<?php

declare(strict_types=1);

namespace Conia\Chuck;

use Closure;
use Conia\Chuck\Exception\ContainerException;
use Conia\Chuck\Exception\NotFoundException;
use Psr\Container\ContainerInterface;
use ReflectionClass;
use ReflectionFunction;
use ReflectionFunctionAbstract;
use ReflectionMethod;
use ReflectionNamedType;
use ReflectionParameter;
use Throwable;

/**
 * @psalm-type EntryArray = array<never, never>|array<string, RegistryEntry>
 */
class Registry implements ContainerInterface
{
    /** @var EntryArray */

The type Conia\Chuck\EntryArray was not found. Maybe you did not declare it correctly or list all dependencies?

    protected array $entries = [];

    /** @var array<never, never>|array<string, EntryArray> */
    protected array $taggedEntries = [];
    protected readonly ?ContainerInterface $container;

    public function __construct(
        ?ContainerInterface $container = null,
        protected readonly bool $autowire = true
    ) {
        $this->container = $container;

The property container is declared read-only in Conia\Chuck\Registry.

        if ($container) {
            $this->addAnyway(ContainerInterface::class, $container);
            $this->addAnyway($container::class, $container);
        } else {
            $this->addAnyway(ContainerInterface::class, $this);
        }

        $this->addAnyway(Registry::class, $this);
    }

    public function has(string $id): bool
    {
        return isset($this->entries[$id]) || $this->container?->has($id);
    }

    public function entry(string $id, string $paramName = ''): mixed
    {
        $paramName = $this->normalizeParameterName($paramName);

        return $this->entries[$id . $paramName];
    }

    public function get(string $id): mixed
    {
        $entry = $this->entries[$id] ?? null;

        if ($entry) {
            return $this->resolveEntry($entry);
        }

        if ($this->container?->has($id)) {
            return $this->container->get($id);

The method get() does not exist on null.

        }

        // Autowiring: $id does not exists as an entry in the registry
        if ($this->autowire && class_exists($id)) {
            return $this->autowire($id);
        }

        throw new NotFoundException('Unresolvable id: ' . $id);
    }

    /**
     * @param non-empty-string $id

The doc comment non-empty-string at position 0 could not be parsed: Unknown type name 'non-empty-string' at position 0 in non-empty-string.

     */
    public function add(
        string $id,
        mixed $value = null,
        string $paramName = '',
    ): RegistryEntry {
        if ($this->container) {
            throw new ContainerException('Third party container implementation in use');
        }

        return $this->addAnyway($id, $value, $paramName);
    }

    /**
     * @param non-empty-string $id

The doc comment non-empty-string at position 0 could not be parsed: Unknown type name 'non-empty-string' at position 0 in non-empty-string.

     */
    public function addAnyway(
        string $id,
        mixed $value = null,
        string $paramName = '',
    ): RegistryEntry {
        $paramName = $this->normalizeParameterName($paramName);
        $entry = new RegistryEntry($id, $value ?? $id);
        $this->entries[$id . $paramName] = $entry;

        return $entry;
    }

    public function tag(string $tag): RegistryTag
    {
        return new RegistryTag($tag, $this);
    }

    public function hasTagged(string $tag, string $id): bool
    {
        return isset($this->taggedEntries[$tag][$id]);
    }

    public function taggedEntry(string $tag, string $id): RegistryEntry
    {
        return $this->taggedEntries[$tag][$id];
    }

    public function getTagged(string $tag, string $id): mixed
    {
        $entry = $this->taggedEntries[$tag][$id] ?? null;

        if ($entry) {
            return $this->resolveEntry($entry);
        }

        throw new NotFoundException('Unresolvable tagged id: ' . $tag . '::' . $id);
    }

    /**
     * @param non-empty-string $id

The doc comment non-empty-string at position 0 could not be parsed: Unknown type name 'non-empty-string' at position 0 in non-empty-string.

     */
    public function addTagged(string $tag, string $id, mixed $value = null): RegistryEntry
    {
        $entry = new RegistryEntry($id, $value ?? $id);
        $this->taggedEntries[$tag][$id] = $entry;

        return $entry;
    }

    public function new(string $id, mixed ...$args): object
    {
        $entry = $this->entries[$id] ?? null;

        if ($entry) {
            /** @var mixed */
            $value = $entry->definition();

            if (is_string($value)) {
                if (interface_exists($value)) {
                    return $this->new($value, ...$args);
                }

                if (class_exists($value)) {
                    /** @psalm-suppress MixedMethodCall */
                    return new $value(...$args);
                }
            }
        }

        if ($this->autowire && class_exists($id)) {
            /** @psalm-suppress MixedMethodCall */
            return new $id(...$args);
        }

        throw new NotFoundException('Cannot instantiate ' . $id);
    }

    public function getWithParamName(string $id, string $paramName): mixed
    {
        $paramName = $this->normalizeParameterName($paramName);

        // See if there's a entry with a bound parameter name:
        // e. g. '\Namespace\MyClass$myParameter'
        // If $paramName is emtpy an existing unbound entry should
        // be found on first try.
        return isset($this->entries[$id . $paramName]) ?
            $this->resolveEntry($this->entries[$id . $paramName]) :
            $this->get($id);
    }

    public function resolveParam(ReflectionParameter $param): mixed
    {
        $type = $param->getType();

        if ($type instanceof ReflectionNamedType) {
            try {
                return $this->getWithParamName($type->getName(), '$' . ltrim($param->getName(), '?'));
            } catch (NotFoundException $e) {
                if ($param->isDefaultValueAvailable()) {
                    return $param->getDefaultValue();
                }

                throw $e;
            }
        } else {
            if ($type) {
                throw new ContainerException(
                    "Autowiring does not support union or intersection types. Source: \n" .
                        $this->getParamInfo($param)
                );
            }

            throw new ContainerException(
                "Autowired entities need to have typed constructor parameters. Source: \n" .
                    $this->getParamInfo($param)
            );
        }
    }

    public function getParamInfo(ReflectionParameter $param): string
    {
        $type = $param->getType();
        $rf = $param->getDeclaringFunction();
        $rc = null;

        if ($rf instanceof ReflectionMethod) {
            $rc = $rf->getDeclaringClass();
        }

        return ($rc ? $rc->getName() . '::' : '') .
            ($rf->getName() . '(..., ') .
            ($type ? (string)$type . ' ' : '') .
            '$' . $param->getName() . ', ...)';
    }

    protected function resolveEntry(RegistryEntry $entry): mixed
    {
        if ($entry->shouldReturnAsIs()) {
            return $entry->definition();
        }

        /** @var mixed - the current value, instantiated or definition */
        $value = $entry->get();

        if (is_string($value)) {
            if (class_exists($value)) {
                $args = $entry->getArgs();

                if (isset($args)) {
                    // Don't autowire if $args are given
                    if ($args instanceof Closure) {
                        return $this->reifyAndReturn($entry, $this->fromArgsClosure($value, $args));
                    }

                    return $this->reifyAndReturn($entry, $this->fromArgsArray($value, $args));
                }

                return $this->reifyAndReturn($entry, $this->autowire($value));
            }

            if (isset($this->entries[$value])) {
                return $this->get($value);
            }
        }

        if ($value instanceof Closure) {
            // Get the instance from the registered closure
            $rf = new ReflectionFunction($value);
            $args = $entry->getArgs();

            if (is_null($args)) {
                $args = $this->resolveArgs($rf);
            } elseif ($args instanceof Closure) {
                /** @var array<string, mixed> */
                $args = $args();
            }

            /** @var mixed */
            $result = $value(...$args);

            return $this->reifyAndReturn($entry, $result);
        }

        if (is_object($value)) {
            return $value;
        }

        throw new NotFoundException('Unresolvable id: ' . print_r($value, true));

Are you sure print_r($value, true) of type string|true can be used in concatenation?

    }

    protected function reifyAndReturn(RegistryEntry $entry, mixed $value): mixed
    {
        if ($entry->shouldReify()) {
            $entry->set($value);
        }

        return $value;
    }

    /** @param class-string $class */

The doc comment class-string at position 0 could not be parsed: Unknown type name 'class-string' at position 0 in class-string.

    protected function autowire(string $class): object
    {
        $rc = new ReflectionClass($class);
        $constructor = $rc->getConstructor();
        $args = $this->resolveArgs($constructor);

        try {
            return $rc->newInstance(...$args);
        } catch (Throwable $e) {
            throw new ContainerException(
                'Autowiring unresolvable: ' . $class . ' Details: ' . $e->getMessage()
            );
        }
    }

    protected function resolveArgs(?ReflectionFunctionAbstract $rf): array
    {
        $args = [];

        if ($rf) {
            foreach ($rf->getParameters() as $param) {
                /** @var list<mixed> */
                $args[] = $this->resolveParam($param);
            }
        }

        return $args;
    }

    /** @param class-string $class */

The doc comment class-string at position 0 could not be parsed: Unknown type name 'class-string' at position 0 in class-string.

    protected function fromArgsArray(string $class, array $args): object
    {
        /** @psalm-suppress MixedMethodCall */
        return new $class(...$args);
    }

    /** @param class-string $class */

The doc comment class-string at position 0 could not be parsed: Unknown type name 'class-string' at position 0 in class-string.

    protected function fromArgsClosure(string $class, Closure $callback): object
    {
        $rf = new ReflectionFunction($callback);
        $args = $this->resolveArgs($rf);

        /** @psalm-suppress MixedMethodCall */
        return new $class(...$callback(...$args));
    }

    protected function normalizeParameterName(string $paramName): string
    {
        if (empty($paramName)) {
            return $paramName;
        }

        $paramName = trim($paramName);

        return str_starts_with($paramName, '$') ? $paramName : '$' . $paramName;
    }
}