Rudra\Container\Rudra

Complexity

Total Complexity

40

Size/Duplication

Total Lines	165
Duplicated Lines	0 %

Importance

Changes	7
Bugs	0	Features	2

16 Methods

Rating	Name	Duplication	Size	Complexity
A	run()	0	7	2
A	request()	0	3	1
A	mergeData()	0	3	1
A	set()	0	15	4
A	response()	0	3	1
A	config()	0	5	2
A	new()	0	12	3
A	has()	0	3	1
A	binding()	0	5	2
A	session()	0	3	1
A	iOc()	0	12	3
B	getParamsIoC()	0	32	9
A	cookie()	0	3	1
A	get()	0	11	5
A	services()	0	5	2
A	setObject()	0	3	2

<?php

declare(strict_types=1);

/**
 * @author    : Jagepard <jagepard@yandex.ru">
 * @license   https://mit-license.org/ MIT
 */

namespace Rudra\Container;

use Rudra\Container\Traits\{InstantiationsTrait};
use Rudra\Container\Interfaces\{RequestInterface, RudraInterface, ContainerInterface, ResponseInterface};

class Rudra implements RudraInterface, ContainerInterface
{
    use InstantiationsTrait;

    public static ?RudraInterface $rudra = null;
    private array $data = [];

    public function binding(array $contracts = []): ContainerInterface
    {
        if (!$this->has("binding")) $this->set(["binding", new Container($contracts)]);

        return $this->get("binding");
    }

    public function services(array $services = []): ContainerInterface
    {
        if (!$this->has("services")) $this->set(["services", new Container($services)]);

        return $this->get("services");
    }
    
    public function config(array $config = []): ContainerInterface
    {
        if (!$this->has("config")) $this->set(["config", new Container($config)]);

        return $this->get("config");
    }

    public function request(): RequestInterface
    {
        return $this->containerize(Request::class);
    }

    public function response(): ResponseInterface
    {
        return $this->containerize(Response::class);
    }

    public function cookie(): Cookie
    {
        return $this->containerize(Cookie::class);
    }

    public function session(): Session
    {
        return $this->containerize(Session::class);
    }

    /*
     | Creates an object without adding to the container
     */
    public function new($object, $params = null)
    {
        $reflection = new \ReflectionClass($object);
        $constructor = $reflection->getConstructor();

        if ($constructor && $constructor->getNumberOfParameters()) {
            $paramsIoC = $this->getParamsIoC($constructor, $params);

            return $reflection->newInstanceArgs($paramsIoC);
        }

        return new $object();
    }

    public static function run(): RudraInterface
    {
        if (!static::$rudra instanceof static) {
            static::$rudra = new static();
        }

        return static::$rudra;

The expression return static::rudra could return the type null which is incompatible with the type-hinted return Rudra\Container\Interfaces\RudraInterface. Consider adding an additional type-check to rule them out.

    }

    public function get(string $key = null)
    {
        if (isset($key) && !$this->has($key)) {
            if (!$this->services()->has($key)) {
                throw new \InvalidArgumentException("Service '$key' is not installed");
            }

            $this->set([$key, $this->services()->get($key)]);
        }

        return empty($key) ? $this->data : $this->data[$key];
    }

    public function set(array $data): void
    {
        list($key, $object) = $data;

        if (is_array($object)) {
            if (array_key_exists(1, $object) && !is_object($object[0])) {
                $this->iOc($key, $object[0], $object[1]);
                return;
            }

            $this->setObject($object[0], $key);
            return;
        }

        $this->setObject($object, $key);
    }

    public function has(string $key): bool
    {
        return array_key_exists($key, $this->data);
    }

    private function setObject($object, $key): void
    {
        (is_object($object)) ? $this->mergeData($key, $object) : $this->iOc($key, $object);
    }

    private function mergeData(string $key, $object)
    {
        $this->data = array_merge([$key => $object], $this->data);
    }

    private function iOc(string $key, $object, $params = null): void
    {
        $reflection = new \ReflectionClass($object);
        $constructor = $reflection->getConstructor();

        if ($constructor && $constructor->getNumberOfParameters()) {
            $paramsIoC = $this->getParamsIoC($constructor, $params);
            $this->mergeData($key, $reflection->newInstanceArgs($paramsIoC));
            return;
        }

        $this->mergeData($key, new $object());
    }

    private function getParamsIoC(\ReflectionMethod $constructor, $params): array
    {
        $i = 0;
        $paramsIoC = [];
        $params = (is_array($params) && array_key_exists(0, $params)) ? $params : [$params];

        foreach ($constructor->getParameters() as $value) {
            /*
             | If in the constructor expects the implementation of interface,
             | so that the container automatically created the necessary object and substituted as an argument,
             | we need to bind the interface with the implementation.
             */
            if (isset($value->getClass()->name) && $this->binding()->has($value->getClass()->name)) {
                $className = $this->binding()->get($value->getClass()->name);
                $paramsIoC[] = (is_object($className)) ? $className : new $className;
                continue;
            }

            /*
             | If the class constructor contains arguments with default values,
             | then if no arguments are passed,
             | values will be added by default by container
             */
            if ($value->isDefaultValueAvailable() && !isset($params[$i])) {
                $paramsIoC[] = $value->getDefaultValue();
                continue;
            }

            $paramsIoC[] = $params[$i++];
        }

        return $paramsIoC;
    }
}