ray-di / Ray.Di

src/di/Container.php

<?php

declare(strict_types=1);

namespace Ray\Di;

use BadMethodCallException;
use Ray\Aop\Compiler;
use Ray\Aop\CompilerInterface;
use Ray\Aop\Pointcut;
use Ray\Di\Exception\Unbound;
use Ray\Di\Exception\Untargeted;
use Ray\Di\MultiBinding\MultiBindings;
use ReflectionClass;

use function array_merge;
use function class_exists;
use function explode;
use function ksort;

/**
 * @psalm-import-type DependencyContainer from Types
 * @psalm-import-type PointcutList from Types
 * @psalm-import-type DependencyIndex from Types
 * @psalm-import-type MethodArguments from Types
 * @psalm-import-type InjectableValue from Types
 */
final class Container implements InjectorInterface
{
    /** @var MultiBindings */
    public $multiBindings;

    /** @var DependencyContainer */

The type Ray\Di\DependencyContainer was not found. Maybe you did not declare it correctly or list all dependencies?

    private $container = [];

    /** @var array<int, Pointcut> */
    private $pointcuts = [];

    public function __construct()
    {
        $this->multiBindings = new MultiBindings();
    }

    /**
     * @return list<string>

The type Ray\Di\list was not found. Maybe you did not declare it correctly or list all dependencies?

     */
    public function __sleep()
    {
        return ['container', 'pointcuts', 'multiBindings'];

The expression return array('container', 'pointcuts', 'multiBindings') returns the type array<integer,string> which is incompatible with the documented return type Ray\Di\list.

    }

    /**
     * Add binding to a container
     */
    public function add(Bind $bind): void
    {
        $dependency = $bind->getBound();
        $dependency->register($this->container, $bind);

$this->container of type Ray\Di\DependencyContainer is incompatible with the type array expected by parameter $container of Ray\Di\DependencyInterface::register().

    }

    /**
     * Add Pointcut to container
     */
    public function addPointcut(Pointcut $pointcut): void
    {
        $this->pointcuts[] = $pointcut;
    }

    /**
     * {@inheritDoc}
     *
     * @param ''|class-string<T> $interface

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

     * @param string             $name
     *
     * @return ($interface is '' ? mixed : T)

The doc comment ($interface at position 1 could not be parsed: Unknown type name '$interface' at position 1 in ($interface.

     *
     * @template T of object
     */
    public function getInstance($interface, $name = Name::ANY)
    {
        /** @psalm-suppress MixedReturnStatement */
        return $this->getDependency($interface . '-' . $name);
    }

    /**
     * Return dependency injected instance
     *
     * @param MethodArguments $params

The type Ray\Di\MethodArguments was not found. Maybe you did not declare it correctly or list all dependencies?

     *
     * @return mixed
     *
     * @throws Unbound
     */
    public function getInstanceWithArgs(string $interface, array $params)
    {
        $index = $interface . '-';
        if (! isset($this->container[$index])) {
            throw $this->unbound($index);
        }

        $dependency = $this->container[$index];
        if (! $dependency instanceof Dependency) {
            throw new BadMethodCallException($interface);
        }

        return $dependency->injectWithArgs($this, $params);
    }

    /**
     * Return dependency injected instance
     *
     * @param DependencyIndex $index

The type Ray\Di\DependencyIndex was not found. Maybe you did not declare it correctly or list all dependencies?

     *
     * @return mixed
     *
     * @throws Unbound
     */
    public function getDependency(string $index)
    {
        if (! isset($this->container[$index])) {
            throw $this->unbound($index);
        }

        return $this->container[$index]->inject($this);
    }

    /**
     * Rename existing dependency interface + name
     */
    public function move(string $sourceInterface, string $sourceName, string $targetInterface, string $targetName): void
    {
        $sourceIndex = $sourceInterface . '-' . $sourceName;
        if (! isset($this->container[$sourceIndex])) {
            throw $this->unbound($sourceIndex);
        }

        $targetIndex = $targetInterface . '-' . $targetName;
        $this->container[$targetIndex] = $this->container[$sourceIndex];
        unset($this->container[$sourceIndex]);
    }

    /**
     * Return Unbound exception
     *
     * @param DependencyIndex $index {interface}-{bind name}
     *
     * @return Exception\Unbound|Exception\Untargeted
     */
    public function unbound(string $index)
    {
        [$class, $name] = explode('-', $index);
        if (class_exists($class) && ! (new ReflectionClass($class))->isAbstract()) {
            return new Untargeted($class);
        }

        return new Unbound("{$class}-{$name}");
    }

    /**
     * Return container
     *
     * @return array<non-empty-string, DependencyInterface>

The doc comment array<non-empty-string, DependencyInterface> at position 2 could not be parsed: Unknown type name 'non-empty-string' at position 2 in array<non-empty-string, DependencyInterface>.

     * @psalm-return DependencyContainer
     */
    public function getContainer(): array
    {
        return $this->container;

The expression return $this->container returns the type Ray\Di\DependencyContainer which is incompatible with the type-hinted return array.

    }

    /**
     * Return pointcuts
     *
     * @return array<int, Pointcut>
     * @psalm-return PointcutList
     */
    public function getPointcuts(): array
    {
        return $this->pointcuts;
    }

    /**
     * Merge container
     */
    public function merge(self $container): void
    {
        $this->multiBindings->merge($container->multiBindings);
        $this->container += $container->getContainer();
        $this->pointcuts = array_merge($this->pointcuts, $container->getPointcuts());
    }

    /**
     * Weave aspects to all dependency in container
     */
    public function weaveAspects(CompilerInterface $compiler): void
    {
        if (empty($this->pointcuts)) {
            return;
        }

        foreach ($this->container as $dependency) {
            if ($dependency instanceof Dependency) {
                $dependency->weaveAspects($compiler, $this->pointcuts);
            }
        }
    }

    /**
     * Weave aspect to single dependency
     */
    public function weaveAspect(Compiler $compiler, Dependency $dependency): self
    {
        $dependency->weaveAspects($compiler, $this->pointcuts);

        return $this;
    }

    /**
     * @param callable(DependencyInterface, string): DependencyInterface $f
     */
    public function map(callable $f): void
    {
        foreach ($this->container as $key => &$index) {
            $index = $f($index, $key);
        }
    }

    public function sort(): void
    {
        ksort($this->container);

$this->container of type Ray\Di\DependencyContainer is incompatible with the type array expected by parameter $array of ksort().

    }
}