Di::userDependencies() - Code Metrics - Inspection of "Di and autowiring related changes" - softberg/quantum-php-core - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#54)

by Arman

created 2021-12-26 20:37 UTC

Di::userDependencies() A

↳ Parent: Di

Complexity

Conditions	2
Paths	2

Size

Total Lines	11
Code Lines	5

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	2
eloc	5
c	1
b	0
f	0
nc	2
nop	0
dl	0
loc	11
rs	10

<?php

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

namespace Quantum\Di;

use Quantum\Libraries\Storage\FileSystem;
use Quantum\Exceptions\DiException;
use ReflectionFunction;
use ReflectionClass;
use ReflectionMethod;

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

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

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

    /**
     * Loads dependency definitions
     */
    public static function loadDefinitions()
    {
        self::$dependencies = self::coreDependencies();

        $userDependencies = self::userDependencies();

        foreach ($userDependencies as $dependency) {
            self::add($dependency);
        }
    }

    /**
     * Creates and injects dependencies.
     * @param callable $entry
     * @param array $additional
     * @return array
     * @throws \Quantum\Exceptions\DiException
     * @throws \ReflectionException
     */
    public static function autowire(callable $entry, array $additional = []): array
    {
        if (is_closure($entry)) {
            $reflection = new ReflectionFunction($entry);
        } else {
            $reflection = new ReflectionMethod(...$entry);
            $reflection = new ReflectionMethod(/** @scrutinizer ignore-type */ ...$entry);
        }

        $params = [];

        foreach ($reflection->getParameters() as $param) {
            $type = $param->getType();

            if(!self::instantiable($type)) {
                if($type && $type->getName() == 'array') {
                if($type && $type->/** @scrutinizer ignore-call */ getName() == 'array') {
                    array_push($params, $additional);
                } else {
                    array_push($params, current($additional));
                    next($additional);
                }
                continue;
            }

            array_push($params, self::get($type->getName()));
        }

        return $params;
    }

    /**
     * Adds new dependency
     * @param string $dependency
     */
    public static function add(string $dependency)
    {
        if (!in_array($dependency, self::$dependencies) && class_exists($dependency)) {
            array_push(self::$dependencies, $dependency);
        }
    }

    /**
     * Gets the dependency from the container
     * @param string $dependency
     * @return mixed
     * @throws \Quantum\Exceptions\DiException
     * @throws \ReflectionException
     */
    public static function get(string $dependency)
    {
        if (!in_array($dependency, self::$dependencies)) {
            throw DiException::dependencyNotDefined($dependency);
        }

        if (!isset(self::$container[$dependency])) {
            self::instantiate($dependency);
        }

        return self::$container[$dependency];
    }

    /**
     * Instantiates the dependency
     * @param string $dependency
     * @throws \Quantum\Exceptions\DiException|\ReflectionException
     */
    protected static function instantiate(string $dependency)
    {
        $class = new ReflectionClass($dependency);

        $constructor = $class->getConstructor();

        $params = [];

        if ($constructor) {
            foreach ($constructor->getParameters() as $param) {
                $type = $param->getType()->getName();

                if (!$type || !self::instantiable($type)) {
                    continue;
                }

                $params[] = self::get($type);
            }
        }

        self::$container[$dependency] = new $dependency(...$params);
    }

    /**
     * Checks if the class is instantiable
     * @param mixed $type
     * @return bool
     */
    protected static function instantiable($type): bool
    {
        return $type != 'Closure' && !is_callable($type) && class_exists($type);
    }

    /**
     * Loads user defined dependencies
     * @return array
     */
    private static function userDependencies(): array
    {
        $fs = new FileSystem();

        $dependencies = base_dir() . DS . 'config' . DS . 'dependencies.php';

        if (!$fs->exists($dependencies)) {
            return [];
        }

        return require_once $dependencies;
    }

    /**
     * Gets the core dependencies
     * @return array
     */
    private static function coreDependencies(): array
    {
        return [
            \Quantum\Http\Request::class,
            \Quantum\Http\Response::class,
            \Quantum\Loader\Loader::class,
            \Quantum\Factory\ViewFactory::class,
            \Quantum\Factory\ModelFactory::class,
            \Quantum\Factory\ServiceFactory::class,
            \Quantum\Libraries\Mailer\Mailer::class,
            \Quantum\Libraries\Storage\FileSystem::class,
        ];
    }

}


softberg / quantum-php-core

Pull Request — master (#54)

Di::userDependencies() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like