Quantum\Di\Di

Complexity

Total Complexity

38

Size/Duplication

Total Lines	272
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

15 Methods

Rating	Name	Duplication	Size	Complexity
A	resolve()	0	19	3
A	create()	0	7	2
A	checkCircularDependency()	0	5	2
A	coreDependencies()	0	6	1
A	instantiate()	0	9	2
A	get()	0	7	2
A	reset()	0	5	1
A	register()	0	17	6
A	instantiable()	0	3	2
A	isRegistered()	0	3	1
A	userDependencies()	0	9	2
A	registerDependencies()	0	5	3
A	resolveParameters()	0	9	2
A	autowire()	0	7	2
B	resolveParameter()	0	19	7

<?php

/**
 * Quantum PHP Framework
 *
 * An open source software development framework for PHP
 *
 * @package Quantum
 * @author Arman Ag. <arman.ag@softberg.org>
 * @copyright Copyright (c) 2018 Softberg LLC (https://softberg.org)
 * @link http://quantum.softberg.org/
 * @since 2.9.8
 */

namespace Quantum\Di;

use Quantum\Di\Exceptions\DiException;
use ReflectionException;
use ReflectionParameter;
use ReflectionFunction;
use ReflectionMethod;
use Quantum\App\App;
use ReflectionClass;

/**
 * Di Class
 * @package Quantum/Di
 */
class Di
{

    /**
     * @var array
     */
    private static $dependencies = [];

    /**
     * @var array
     */
    private static $container = [];

    /**
     * @var array
     */
    private static $resolving = [];

    /**
     * Loads dependency definitions
     */
    public static function registerDependencies()
    {
        foreach (self::coreDependencies() + self::userDependencies() as $abstract => $concrete) {
            if (!self::isRegistered($abstract)) {
                self::register($concrete, $abstract);
            }
        }
    }

    /**
     * Registers new dependency
     * @param string $concrete
     * @param string|null $abstract
     * @throws DiException
     */
    public static function register(string $concrete, ?string $abstract = null)
    {
        $key = $abstract ?? $concrete;

        if (isset(self::$dependencies[$key])) {
            throw DiException::dependencyAlreadyRegistered($key);
        }

        if (!class_exists($concrete)) {
            throw DiException::dependencyNotInstantiable($concrete);
        }

        if ($abstract !== null && !class_exists($abstract) && !interface_exists($abstract)) {
            throw DiException::invalidAbstractDependency($abstract);
        }

        self::$dependencies[$key] = $concrete;
    }

    /**
     * Checks if a dependency registered
     * @param string $abstract
     * @return bool
     */
    public static function isRegistered(string $abstract): bool
    {
        return isset(self::$dependencies[$abstract]);
    }

    /**
     * Retrieves a shared instance of the given dependency.
     * @param string $dependency
     * @param array $args
     * @return mixed
     * @throws DiException
     * @throws ReflectionException
     */
    public static function get(string $dependency, array $args = [])
    {
        if (!self::isRegistered($dependency)) {
            throw DiException::dependencyNotRegistered($dependency);
        }

        return self::resolve($dependency, $args, true);
    }

    /**
     * Creates new instance of the given dependency.
     * @param string $dependency
     * @param array $args
     * @return mixed
     * @throws DiException
     * @throws ReflectionException
     */
    public static function create(string $dependency, array $args = [])
    {
        if (!self::isRegistered($dependency)) {
            self::register($dependency);
        }

        return self::resolve($dependency, $args, false);
    }

    /**
     * Automatically resolves and injects parameters for a callable.
     * @param callable $entry
     * @param array $args
     * @return array
     * @throws DiException
     * @throws ReflectionException
     */
    public static function autowire(callable $entry, array $args = []): array
    {
        $reflection = is_closure($entry)
            ? new ReflectionFunction($entry)
            : new ReflectionMethod(...$entry);

$entry is expanded, but the parameter $objectOrMethod of ReflectionMethod::__construct() does not expect variable arguments.

        return self::resolveParameters($reflection->getParameters(), $args);
    }

    /**
     * @return void
     */
    public static function reset(): void
    {
        self::$dependencies = [];
        self::$container = [];
        self::$resolving = [];
    }

    /**
     * Resolves the dependency
     * @param string $abstract
     * @param array $args
     * @param bool $singleton
     * @return mixed
     * @throws DiException
     * @throws ReflectionException
     */
    private static function resolve(string $abstract, array $args = [], bool $singleton = true)
    {
        self::checkCircularDependency($abstract);

        self::$resolving[$abstract] = true;

        try {
            $concrete = self::$dependencies[$abstract];

            if ($singleton) {
                if (!isset(self::$container[$abstract])) {
                    self::$container[$abstract] = self::instantiate($concrete, $args);
                }
                return self::$container[$abstract];
            }

            return self::instantiate($concrete, $args);
        } finally {
            unset(self::$resolving[$abstract]);
        }
    }

    /**
     * Instantiates the dependency
     * @param string $concrete
     * @param array $args
     * @return mixed
     * @throws DiException
     * @throws ReflectionException
     */
    private static function instantiate(string $concrete, array $args = [])
    {
        $class = new ReflectionClass($concrete);

        $constructor = $class->getConstructor();

        $params = $constructor ? self::resolveParameters($constructor->getParameters(), $args) : [];

        return new $concrete(...$params);
    }

    /**
     * Resolves all parameters
     * @param array $parameters
     * @param array $args
     * @return array
     * @throws DiException
     * @throws ReflectionException
     */
    private static function resolveParameters(array $parameters, array &$args = []): array
    {
        $resolved = [];

        foreach ($parameters as $param) {
            $resolved[] = self::resolveParameter($param, $args);
        }

        return $resolved;
    }

    /**
     * Resolves the parameter
     * @param ReflectionParameter $param
     * @param array|null $args
     * @return array|mixed|null
     * @throws DiException
     * @throws ReflectionException
     */
    private static function resolveParameter(ReflectionParameter $param, ?array &$args = [])
    {
        $type = $param->getType() ? $param->getType()->getName() : null;

The method getName() does not exist on ReflectionType. It seems like you code against a sub-type of ReflectionType such as ReflectionNamedType.

        $concrete = self::$dependencies[$type] ?? $type;

        if ($concrete && self::instantiable($concrete)) {
            return self::create($concrete);
        }

        if ($type === 'array') {
            return $args;
        }

        if (!empty($args)) {
            return array_shift($args);
        }

        return $param->isDefaultValueAvailable() ? $param->getDefaultValue() : null;
    }

    /**
     * Checks if the class is instantiable
     * @param string $class
     * @return bool
     */
    protected static function instantiable(string $class): bool
    {
        return class_exists($class) && (new ReflectionClass($class))->isInstantiable();
    }

    /**
     * @param string $abstract
     * @return void
     * @throws DiException
     */
    private static function checkCircularDependency(string $abstract): void
    {
        if (isset(self::$resolving[$abstract])) {
            $chain = implode(' -> ', array_keys(self::$resolving)) . ' -> ' . $abstract;
            throw DiException::circularDependency($chain);
        }
    }

    /**
     * Loads user defined dependencies
     * @return array
     */
    private static function userDependencies(): array
    {
        $userDependencies = App::getBaseDir() . DS . 'shared' . DS . 'config' . DS . 'dependencies.php';

        if (!file_exists($userDependencies)) {
            return [];
        }

        return (array)require_once $userDependencies;
    }

    /**
     * Loads the core dependencies
     * @return array
     */
    private static function coreDependencies(): array
    {
        return [
            \Quantum\Loader\Loader::class => \Quantum\Loader\Loader::class,
            \Quantum\Http\Request::class => \Quantum\Http\Request::class,
            \Quantum\Http\Response::class => \Quantum\Http\Response::class,
        ];
    }
}