ntentan\panie\Container

Complexity

Total Complexity

25

Size/Duplication

Total Lines	104
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	2

Test Coverage

Coverage

83.64%

Importance

Changes

0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	getResolvedClassName()	0	10	4
A	bind()	0	4	1
A	has()	0	4	1
A	setup()	0	4	1
A	resolve()	0	15	4
B	getConstructorArguments()	0	17	6
A	getSingletonInstance()	0	7	2
B	getInstance()	0	19	5

<?php

namespace ntentan\panie;

/**
 * Description of Container
 *
 * @author ekow
 */
class Container
{

    private $bindings;
    private $singletons = [];

    public function __construct()
    {
        $this->bindings = new Bindings();
    }

    /**
     * 
     * @param string|\ReflectionClass $class
     * @return \ReflectionClass
     */
    public function getResolvedClassName($class)
    {
        $bound = null;
        if ($this->bindings->has($class)) {
            $bound = $this->bindings->get($class);
        } else if (is_string($class) && class_exists($class)) {
            $bound = ['binding' => $class];
        }
        return $bound;
    }

    public function bind($type)
    {
        return $this->bindings->setActiveKey($type);
    }

    public function has($type)
    {
        return $this->bindings->has($type);
    }

    public function setup($bindings, $replace = true)
    {
        $this->bindings->merge($bindings, $replace);
    }

    public function resolve($type, $constructorArguments = [])
    {
        if ($type === null) {
            throw new exceptions\ResolutionException("Cannot resolve an empty type");
        }
        $resolvedClass = $this->getResolvedClassName($type);
        if ($resolvedClass['binding'] === null) {
            throw new exceptions\ResolutionException("Could not resolve dependency $type");
        }
        if ($resolvedClass['singleton'] ?? false) {
            return $this->getSingletonInstance($type, $resolvedClass['binding'], $constructorArguments);
        } else {
            return $this->getInstance($resolvedClass['binding'], $constructorArguments);
        }
    }

    private function getConstructorArguments($constructor, $constructorArguments)
    {
        $argumentValues = [];
        $parameters = $constructor->getParameters();
        foreach ($parameters as $parameter) {
            $class = $parameter->getClass();
            $className = $class ? $class->getName() : null;
            if (isset($constructorArguments[$parameter->getName()])) {
                $argumentValues[] = $constructorArguments[$parameter->getName()];
            } else if ($className == self::class) {
                $argumentValues[] = $this;
            } else {
                $argumentValues[] = $className ? $this->resolve($className) : null;
            }
        }
        return $argumentValues;
    }

    private function getSingletonInstance($type, $class, $constructorArguments)
    {
        if (!isset($this->singletons[$type])) {
            $this->singletons[$type] = $this->getInstance($class, $constructorArguments);
        }
        return $this->singletons[$type];
    }

    public function getInstance($className, $constructorArguments = [])
    {
        if (is_callable($className)) {
            return $className($this);
        }
        if (is_object($className)) {
            return $className;
        }
        $reflection = new \ReflectionClass($className);
        if ($reflection->isAbstract()) {
            throw new exceptions\ResolutionException(
            "Abstract class {$reflection->getName()} cannot be instantiated. "

Consider using $reflection->name. There is an issue with getName() and APC-enabled PHP versions.

            . "Please provide a binding to an implementation."
            );
        }
        $constructor = $reflection->getConstructor();
        $instance = $reflection->newInstanceArgs($constructor ? $this->getConstructorArguments($constructor, $constructorArguments) : []);
        return $instance;
    }
}