Rudra\Container\Container

Complexity

Total Complexity

34

Size/Duplication

Total Lines	227
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	3

Importance

Changes

0

14 Methods

Rating	Name	Duplication	Size	Complexity
A	app()	0	8	2
A	setServices()	0	14	4
A	get()	0	4	2
A	set()	0	8	2
A	rawSet()	0	4	1
A	iOc()	0	17	3
A	new()	0	17	3
B	getParamsIoC()	0	15	5
A	has()	0	4	2
A	getParam()	0	8	3
A	setParam()	0	6	2
A	hasParam()	0	6	3
A	getBinding()	0	4	1
A	setBinding()	0	4	1

<?php

declare(strict_types = 1);

/**
 * Date: 25.08.2016
 * Time: 14:50
 *
 * @author    : Korotkov Danila <dankorot@gmail.com>
 * @copyright Copyright (c) 2016, Korotkov Danila
 * @license   http://www.gnu.org/licenses/gpl.html GNU GPLv3.0
 */

namespace Rudra\Container;


use \ReflectionClass;


/**
 * Class ContainerInterface
 *
 * @package Rudra
 */
class Container implements ContainerInterface
{

    use ContainerCookieTrait;
    use ContainerGlobalsTrait;
    use ContainerSessionTrait;

    /**
     * @var ContainerInterface
     */
    public static $app;

    /**
     * @var array
     */
    protected $objects = [];

    /**
     * @var array
     */
    protected $bind = [];

    /**
     * @return ContainerInterface
     */
    public static function app(): ContainerInterface
    {
        if (!static::$app instanceof static) {
            static::$app = new static();
        }

        return static::$app;
    }

    /**
     * @param $app
     */
    public function setServices(array $app): void
    {
        foreach ($app['services'] as $name => $service) {
            foreach ($app['contracts'] as $interface => $contract) {
                $this->setBinding($interface, $contract);
            }

            if (array_key_exists(1, $service)) {
                $this->set($name, $service[0], $service[1]);
            } else {
                $this->set($name, $service[0]);
            }
        }
    }

    /**
     * @param $key
     *
     * @return mixed
     */
    public function get(string $key = null)
    {
        return ($key === null) ? $this->objects : $this->objects[$key];
    }

    /**
     * @param string $key
     * @param        $object
     * @param array  $params
     *
     * @return object|void
     */
    public function set(string $key, $object, $params = null)
    {
        if ('raw' == $params) {
            return $this->rawSet($key, $object);
        }

        return $this->iOc($key, $object, $params);

It seems like $params defined by parameter $params on line 94 can also be of type array; however, Rudra\Container\Container::iOc() does only seem to accept null, maybe add an additional type check?

    }

    /**
     * @param string $key
     * @param        $object
     */
    protected function rawSet(string $key, $object)
    {
        $this->objects[$key] = $object;
    }

    /**
     * @param      $key
     * @param      $object
     * @param null $params
     *
     * @return object
     */
    protected function iOc(string $key, $object, $params = null)
    {
        $reflection  = new ReflectionClass($object);
        $constructor = $reflection->getConstructor();

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

                return $this->objects[$key] = $reflection->newInstanceArgs($paramsIoC);
            } else {
                return $this->objects[$key] = new $object;
            }
        } else {
            return $this->objects[$key] = new $object;
        }
    }

    /**
     * @param      $object
     * @param null $params
     *
     * @return object
     */
    public function new($object, $params = null)
    {
        $reflection  = new ReflectionClass($object);
        $constructor = $reflection->getConstructor();

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

                return $reflection->newInstanceArgs($paramsIoC);
            } else {
                return new $object;
            }
        } else {
            return new $object;
        }
    }

    /**
     * @param $constructor
     * @param $params
     *
     * @return array
     */
    protected function getParamsIoC($constructor, $params)
    {
        $paramsIoC = [];
        foreach ($constructor->getParameters() as $key => $value) {
            if (isset($value->getClass()->name)) {
                $className       = $this->getBinding($value->getClass()->name);
                $paramsIoC[$key] = (is_object($className)) ? $className : new $className;
            } else {
                $paramsIoC[$key] = ($value->isDefaultValueAvailable())
                    ? $value->getDefaultValue() : $params[$value->getName()];
            }
        }

        return $paramsIoC;
    }

    /**
     * @param $key
     *
     * @return bool
     */
    public function has(string $key): bool
    {
        return isset($this->objects[$key]) ? true : false;
    }

    /**
     * @param string $key
     * @param string $param
     *
     * @return mixed
     */
    public function getParam(string $key, string $param)
    {
        if ($this->has($key)) {
            if (isset($this->get($key)->$param)) {
                return $this->get($key)->$param;
            }
        }
    }

    /**
     * @param string $key
     * @param string $param
     * @param        $value
     */
    public function setParam(string $key, string $param, $value): void
    {
        if (isset($this->objects[$key])) {
            $this->get($key)->$param = $value;
        }
    }

    /**
     * @param string $key
     * @param string $param
     *
     * @return bool
     */
    public function hasParam(string $key, string $param)
    {
        if ($this->has($key)) {
            return isset($this->get($key)->$param) ? true : false;
        }
    }

     /**
     * @param string $key
     *
     * @return mixed|string
     */
    public function getBinding(string $key)
    {
        return $this->bind[$key] ?? $key;
    }

    /**
     * @param string $key
     * @param        $value
     */
    public function setBinding(string $key, $value): void
    {
        $this->bind[$key] = $value;
    }
}