Ray\Di\AbstractModule

Complexity

Total Complexity

15

Size/Duplication

Total Lines	129
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	5

Test Coverage

Coverage

97.56%

Importance

Changes

0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	install()	0	4	1
	configure()	0	1	?
A	__construct()	0	9	2
A	override()	0	5	1
A	bindInterceptor()	0	8	2
A	bindPriorityInterceptor()	0	8	2
A	activate()	0	6	1
A	rename()	0	7	3
A	bind()	0	4	1
A	getContainer()	0	8	2

<?php

declare(strict_types=1);
/**
 * This file is part of the Ray.Di package.
 *
 * @license http://opensource.org/licenses/MIT MIT
 */
namespace Ray\Di;

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

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

    /**
     * @var AbstractModule|null
     */
    protected $lastModule;

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

    public function __construct(
        self $module = null
    ) {
        $this->lastModule = $module;

It seems like $module can also be of type object<self>. However, the property $lastModule is declared as type object<Ray\Di\AbstractModule>|null. Maybe add an additional type check?

        $this->activate();
        if ($module instanceof self) {
            $this->container->merge($module->getContainer());
        }
    }

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

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

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

        return $this->container;
    }

    /**
     * Bind interceptor
     *
     * @param AbstractMatcher $classMatcher
     * @param AbstractMatcher $methodMatcher
     * @param string[]        $interceptors
     */
    public function bindInterceptor(AbstractMatcher $classMatcher, AbstractMatcher $methodMatcher, array $interceptors)
    {
        $pointcut = new Pointcut($classMatcher, $methodMatcher, $interceptors);

$interceptors is of type array<integer,string>, but the function expects a array<integer,object<Ray\Aop\Interceptor>>.

        $this->container->addPointcut($pointcut);
        foreach ($interceptors as $interceptor) {
            (new Bind($this->container, $interceptor))->to($interceptor)->in(Scope::SINGLETON);
        }
    }

    /**
     * Bind interceptor early
     *
     * @param AbstractMatcher $classMatcher
     * @param AbstractMatcher $methodMatcher
     * @param array           $interceptors
     */
    public function bindPriorityInterceptor(AbstractMatcher $classMatcher, AbstractMatcher $methodMatcher, array $interceptors)
    {
        $pointcut = new PriorityPointcut($classMatcher, $methodMatcher, $interceptors);
        $this->container->addPointcut($pointcut);
        foreach ($interceptors as $interceptor) {
            (new Bind($this->container, $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 = '')
    {
        $targetInterface = $targetInterface ?: $interface;
        if ($this->lastModule instanceof self) {
            $this->lastModule->getContainer()->move($interface, $sourceName, $targetInterface, $newName);
        }
    }

    /**
     * Configure binding
     */
    abstract protected function configure();

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

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