Zewa\DIContainer

Complexity

Total Complexity

16

Size/Duplication

Total Lines	116
Duplicated Lines	32.76 %

Coupling/Cohesion

Components	1
Dependencies	0

Test Coverage

Coverage

0%

Importance

Changes

0

3 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
A	isDependencyLoaded()	0	8	2
D	resolve()	38	87	13

<?php

namespace Zewa;

class DIContainer
{
    //So.. I'm storing dependencies so they can be retrived for later collection
    //without re-instantiating.. we should make this optional some way?

    /**
     * @var array $dependencies
     * @var Config $dependencies['Config']
     */
    private $dependencies = [];
    private $callbacks = [];

    public function __construct(Config $config)
    {
        $this->dependencies['\Zewa\DIContainer'] = $this;
        $this->dependencies['\Zewa\Config'] = $config;
    }

    private function isDependencyLoaded(string $class) : bool
    {
        if (isset($this->dependencies[$class])) {
            return true;
        }

        return false;
    }

    //@TODO change class & service resolution ?
    public function resolve($class, $share = false)
    {
        if ($this->isDependencyLoaded($class)) {
            return $this->dependencies[$class];
        } elseif (!empty($this->callbacks[$class])) {
            $share = $this->callbacks[$class]['share'] === true || $share === true ? true : false;
            //pass an instance of $this to the factory for dependency injection on cached classes
            $dependency = $this->callbacks[$class]['factory']($this);
            if ($share === true) {
                $this->dependencies[$class] = $dependency;
            }

            return $dependency;
        }

        // Reflect on the $class
        $reflectionClass = new \ReflectionClass($class);

        // Fetch the constructor (instance of ReflectionMethod)
        $constructor = $reflectionClass->getConstructor();

        // If there is no constructor, there is no
        // dependencies, which means that our job is done.
        if (! $constructor) {

This code seems to be duplicated across your project.

            $dependency = new $class;
            if ($share === true) {
                $this->dependencies[$class] = $dependency;
            }

            return $dependency;
        }

        // Fetch the arguments from the constructor
        // (collection of ReflectionParameter instances)
        $params = $constructor->getParameters();

        // If there is a constructor, but no dependencies,
        // our job is done.
        if (count($params) === 0) {

This code seems to be duplicated across your project.

            $dependency = new $class;
            if ($share === true) {
                $this->dependencies[$class] = $dependency;
            }
            return $dependency;
        }

        // This is were we store the dependencies
        $newInstanceParams = [];

        // Loop over the constructor arguments
        foreach ($params as $param) {

This code seems to be duplicated across your project.

            // Here we should perform a bunch of checks, such as:
            // isArray(), isCallable(), isDefaultValueAvailable()

58% of this comment could be valid code. Did you maybe forget this after debugging?

            // isOptional() etc.

            // For now, we just check to see if the argument is
            // a class, so we can instantiate it,
            // otherwise we just pass null.
            if (is_null($param->getClass())) {
                $newInstanceParams[] = null;
                continue;
            }

            // This is where 'the magic happens'. We resolve each
            // of the dependencies, by recursively calling the
            // resolve() method.
            // At one point, we will reach the bottom of the
            // nested dependencies we need in order to instantiate
            // the class.
            $newInstanceParams[] = $this->resolve(
                "\\" . $param->getClass()->getName()
            );
        }

        // Return the reflected class, instantiated with all its
        // dependencies (this happens once for all the
        // nested dependencies).
        $dependency = $reflectionClass->newInstanceArgs(
            $newInstanceParams
        );

        if ($share === true) {
            $this->dependencies[$class] = $dependency;
        }

        return $dependency;
    }
}