ray-di / Ray.Di

src/di/AbstractModule.php

<?php

declare(strict_types=1);

namespace Ray\Di;

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

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

use Stringable;

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

/**
 * @psalm-import-type BindableInterface from Types
 * @psalm-import-type PointcutList from Types
 * @psalm-import-type InterceptorClassList from Types
 */
abstract class AbstractModule implements Stringable
{
    /** @var Matcher */
    protected $matcher;

    /** @var ?AbstractModule */
    protected $lastModule;
    private ?Container $container = null;

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

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

    /**
     * Return module bindings as JSON string
     */
    public function toJson(): string
    {
        return (new ModuleJson())($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 === null) {
            $this->activate();
        }

        assert($this->container instanceof Container);

        return $this->container;
    }

    /**
     * Bind interceptor
     *
     * @param InterceptorClassList $interceptors

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

     */
    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 InterceptorClassList $interceptors
     */
    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
     */
    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);
        }
    }

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

    /**
     * Bind interface
     *
     * @param BindableInterface $interface

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

     */
    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();
    }
}