ntentan\panie\Container

Complexity

Total Complexity

20

Size/Duplication

Total Lines	84
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	2

Importance

Changes

0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	3	1
A	getResolvedClassName()	0	9	4
A	bind()	0	3	1
A	singleton()	0	4	1
A	getSingletonInstance()	0	6	2
A	resolve()	0	14	4
C	getInstance()	0	27	7

<?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 = ['class' => $class];
        }     
        return $bound;
    }

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

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

    public function getInstance($className, $constructorArguments = []) {
        
        $reflection = new \ReflectionClass($className);
        if ($reflection->isAbstract()) {
            throw new exceptions\ResolutionException(
            "Abstract class {$reflection->getName()} cannot be instantiated. "
            . "Please provide a binding to an implementation."
            );
        }
        $constructor = $reflection->getConstructor();
        $instanceParameters = [];

        if ($constructor != null) {
            $parameters = $constructor->getParameters();
            foreach ($parameters as $parameter) {
                $class = $parameter->getClass();
                if (isset($constructorArguments[$parameter->getName()])) {
                    $instanceParameters[] = $constructorArguments[$parameter->getName()];
                } else if($class == self::class){
                    $instanceParameters[] = $this;
                } else {                    
                    $instanceParameters[] = $class ? $this->resolve($class->getName()) : null;
                }
            }
        }
        return $reflection->newInstanceArgs($instanceParameters);
    }

}