Zewa\DIContainer::resolve()

Complexity

Conditions	13
Paths	19

Size

Total Lines	88
Code Lines	34

Duplication

Lines	15
Ratio	17.05 %

Importance

Changes

0

<?php
    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) {
            // 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;
    }
}