CapMousse\ReactRestify\Container\Container

Complexity

Total Complexity

21

Size/Duplication

Total Lines	148
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	0

Importance

Changes

0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	getInstance()	0	8	2
A	add()	0	12	3
A	has()	0	8	2
A	get()	0	4	1
A	call()	0	11	2
A	getActionReflection()	0	9	2
A	build()	0	11	2
C	getParameters()	0	25	7

<?php

namespace CapMousse\ReactRestify\Container;

use ReflectionClass;
use ReflectionMethod;
use ReflectionFunction;
use ReflectionFunctionAbstract;

class Container
{
    private static $instance;

    /**
     * Resolved types
     * @var array
     */
    protected $definitions = [];

    /**
     * Globally available container
     * 
     * @return static
     */
    public static function getInstance()
    {
        if (is_null(self::$instance)) {
            static::$instance = new static;

Since $instance is declared private, accessing it with static will lead to errors in possible sub-classes; consider using self, or increasing the visibility of $instance to at least protected.

        }

        return static::$instance;

Since $instance is declared private, accessing it with static will lead to errors in possible sub-classes; consider using self, or increasing the visibility of $instance to at least protected.

    }

    /**
     * Add item to the container
     * @param string $alias    
     * @param mixed|null $concrete
     */
    public function add($alias, $concrete = null)
    {
        if (is_null($concrete)) {
            $concrete = $alias;
        }

        $instance = $this->build($concrete);

        if (!$instance) {
            $this->definitions[$alias] = $instance;
        }
    }

    /**
     * Check if item is available in container
     * @param  string  $alias
     * @return boolean
     */
    public function has($alias)
    {
        if (array_key_exists($alias, $this->definitions)) {
            return true;
        }

        return false;
    }

    /**
     * Get an item of the container
     * @param  string $alias 
     * @return mixed
     */
    public function get($alias)
    {
        return $this->definitions[$alias];
    }

    /**
     * Call method with given parameters
     * @param  string|callable  $action     
     * @param  array            $args 
     * @return mixed
     */
    public function call ($action, array $args = [])
    {
        if (is_string($action)) {
            list($class, $method) = explode('@', $action);
            $action = [$this->build($class), $method];
        }

        $reflection = $this->getActionReflection($action);

        return call_user_func_array($action, $this->getParameters($reflection, $args));
    }

    /**
     * Get reflection from an action
     * @param  array|callable $action
     * @return ReflectionFunctionAbstract
     */
    public function getActionReflection($action)
    {
        if(is_array($action)) {
            list($class, $method) = $action;
            return new ReflectionMethod($class, $method);
        }

        return new ReflectionFunction($action);
    }

    /**
     * Create a new container for asked class
     * @param  string $concrete

There is no parameter named $concrete. Was it maybe removed?

     * @return Container
     */
    public function build ($class)
    {
        $reflection = new ReflectionClass($class);
        $parameters = [];

        if (!is_null($reflection->getConstructor())) {
            $parameters = $this->getParameters($reflection->getConstructor());
        }

        return new $class(...$parameters);
    }

    /**
     * Get reflection parameters
     * @param  ReflectionFunctionAbstract $reflection 
     * @param  array                      $args       
     * @return array                                 
     */
    public function getParameters(ReflectionFunctionAbstract $reflection, $args = [])
    {
        $dependencies = $reflection->getParameters();
        $parameters = [];

        foreach ($dependencies as $parameter) {
            $class = $parameter->getClass();

            if ($class && $this->has($class->getName())) {
                $parameters[] = $this->get($class->getName());
                continue;
            }

            if ($class && array_key_exists($class->getName(), $args)) {
                $parameters[] = $args[$class->getName()];
                continue;
            }

            if (array_key_exists($parameter->getName(), $args)) {

Consider using $parameter->name. There is an issue with getName() and APC-enabled PHP versions.

                $parameters[] = $args[$parameter->getName()];

Consider using $parameter->name. There is an issue with getName() and APC-enabled PHP versions.

            }
        }

        return $parameters;
    }
}