Ray\Di\AbstractModule

Complexity

Total Complexity

19

Size/Duplication

Total Lines	152
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

11 Methods

Rating	Name	Duplication	Size	Complexity
A	override()	0	4	1
A	bindPriorityInterceptor()	0	6	2
A	__construct()	0	12	2
A	__toString()	0	3	1
A	bind()	0	3	1
A	install()	0	3	1
A	getContainer()	0	8	2
A	bindInterceptor()	0	13	3
A	activate()	0	5	1
A	rename()	0	5	3
A	rebind()	0	4	2

<?php

declare(strict_types=1);

namespace Ray\Di;

use Ray\Aop\AbstractMatcher;
use Ray\Aop\Matcher;
use Ray\Aop\MethodInterceptor;
use Ray\Aop\Pointcut;
use Ray\Aop\PriorityPointcut;

use function assert;
use function class_exists;
use function interface_exists;

abstract class AbstractModule
{
    /** @var Matcher */
    protected $matcher;

    /** @var ?AbstractModule */
    protected $lastModule;

    /** @var ?Container */
    private $container;

    /** @var Rebind >*/
    private $rebind;

    public function __construct(
        ?self $module = null
    ) {
        $this->rebind = new Rebind();
        $this->lastModule = $module;
        $this->activate();
        assert($this->container instanceof Container);
        if ($module instanceof self) {
            $this->container->merge($module->getContainer());
        }

        $this->rebind->commit($this->container);
    }

    public function __toString(): string
    {
        return (new ModuleString())($this->getContainer(), $this->getContainer()->getPointcuts());
    }

    /**
     * Install module
     */
    public function install(self $module): void
    {
        $this->getContainer()->merge($module->getContainer());
    }

    /**
     * Override module
     */
    public function override(self $module): void
    {
        $module->getContainer()->merge($this->getContainer());
        $this->container = $module->getContainer();
    }

    /**
     * Return activated container
     */
    public function getContainer(): Container
    {
        if (! $this->container instanceof Container) {
            $this->activate();
            assert($this->container instanceof Container);
        }

        return $this->container;
    }

    /**
     * Bind interceptor
     *
     * @param array<class-string<MethodInterceptor>> $interceptors

The doc comment array<class-string<MethodInterceptor>> at position 2 could not be parsed: Unknown type name 'class-string' at position 2 in array<class-string<MethodInterceptor>>.

     */
    public function bindInterceptor(AbstractMatcher $classMatcher, AbstractMatcher $methodMatcher, array $interceptors): void
    {
        $pointcut = new Pointcut($classMatcher, $methodMatcher, $interceptors);
        $this->getContainer()->addPointcut($pointcut);
        foreach ($interceptors as $interceptor) {
            if (class_exists($interceptor)) {
                (new Bind($this->getContainer(), $interceptor))->to($interceptor)->in(Scope::SINGLETON);

                return;
            }

            assert(interface_exists($interceptor));
            (new Bind($this->getContainer(), $interceptor))->in(Scope::SINGLETON);
        }
    }

    /**
     * Bind interceptor early
     *
     * @param array<class-string<MethodInterceptor>> $interceptors

The doc comment array<class-string<MethodInterceptor>> at position 2 could not be parsed: Unknown type name 'class-string' at position 2 in array<class-string<MethodInterceptor>>.

     */
    public function bindPriorityInterceptor(AbstractMatcher $classMatcher, AbstractMatcher $methodMatcher, array $interceptors): void
    {
        $pointcut = new PriorityPointcut($classMatcher, $methodMatcher, $interceptors);
        $this->getContainer()->addPointcut($pointcut);
        foreach ($interceptors as $interceptor) {
            (new Bind($this->getContainer(), $interceptor))->to($interceptor)->in(Scope::SINGLETON);
        }
    }

    /**
     * Rename binding name
     *
     * @param string $interface       Interface
     * @param string $newName         New binding name
     * @param string $sourceName      Original binding name
     * @param string $targetInterface Original interface
     *
     * @deprecated Use rebind() instead
     */
    public function rename(string $interface, string $newName, string $sourceName = Name::ANY, string $targetInterface = ''): void
    {
        $targetInterface = $targetInterface ?: $interface;
        if ($this->lastModule instanceof self) {
            $this->lastModule->getContainer()->move($interface, $sourceName, $targetInterface, $newName);
        }
    }

    /**
     * Re-bind an existing binding
     */
    public function rebind(string $fromInterface, string $toName, string $fromName = '', string $toInterface = ''): void
    {
        $toInterface = $toInterface ?: $fromInterface;
        $this->rebind->bind($fromInterface, $toName, $fromName, $toInterface);
    }

    /**
     * Configure binding
     *
     * @return void
     *
     * @noinspection ReturnTypeCanBeDeclaredInspection
     */
    abstract protected function configure();

    /**
     * Bind interface
     *
     * @phpstan-param class-string|string $interface
     */
    protected function bind(string $interface = ''): Bind
    {
        return new Bind($this->getContainer(), $interface);
    }

    /**
     * Activate bindings
     */
    private function activate(): void
    {
        $this->container = new Container();
        $this->matcher = new Matcher();
        $this->configure();
    }
}