Di::add() - Code Metrics - Inspection of "Major refactoring" - softberg/quantum-php-core - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Pull Request — master (#182)

by Arman
created 2024-12-17 13:59 UTC
Di::add() A

↳ Parent: Di
Complexity

Conditions	3
Paths	2
Size

Total Lines	4
Code Lines	2
Duplication

Lines	0
Ratio	0 %
Importance

Changes
Metric	Value
cc	3
eloc	2
nc	2
nop	1
dl	0
loc	4
rs	10
c	0
b	0
f	0
<?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.9.5
 */

namespace Quantum\Di;

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

/**
 * 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()
    {
        if (empty(self::$dependencies)) {
            self::$dependencies = self::coreDependencies();

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

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

        $params = [];

        foreach ($reflection->getParameters() as $param) {
            $params[] = self::resolveParameter($param, $additional);
        }

        return $params;
    }

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

    /**
     * Gets the dependency from the container
     * @param string $dependency
     * @return mixed
     * @throws 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::$container[$dependency] = self::instantiate($dependency);
        }

        return self::$container[$dependency];

    }

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

        $constructor = $class->getConstructor();

        $params = [];

        if ($constructor) {
            foreach ($constructor->getParameters() as $param) {
                $params[] = self::resolveParameter($param);
            }
        }

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

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

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

        if ($type && self::instantiable($type)) {
            return self::get($type);
        }

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

        if (count($additional)) {
            return array_shift($additional);
        }

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

    }

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

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

        return (array)require_once $userDependencies;
    }

    /**
     * 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\Libraries\Storage\FileSystem::class,
        ];
    }

}

softberg / quantum-php-core

Pull Request — master (#182)

Di::add() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
