Magium\Configuration\Container\GenericContainer

Complexity

Total Complexity

17

Size/Duplication

Total Lines	79
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	1

Test Coverage

Coverage

100%

Importance

Changes

0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
A	set()	0	19	6
A	get()	0	7	2
A	newInstance()	0	12	2
A	getParams()	0	20	5
A	has()	0	4	1

<?php

namespace Magium\Configuration\Container;

use Interop\Container\ContainerInterface;

class GenericContainer implements ContainerInterface
{

    protected $container = [];

    public function __construct(array $defaults = [])
    {
        $this->container = $defaults;
        $this->set($this);
    }

    public function set($value)
    {
        if (!is_object($value)) {
            throw new InvalidObjectException('The GenericContainer can only accept objects');
        }
        $class = new \ReflectionClass($value);
        $interfaces = $class->getInterfaces();
        foreach ($interfaces as $interface) {
            if (!$interface->isInternal()) {
                $this->container[$interface->getName()] = $value;

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

            }
        }
        do {
            if ($class->isInternal()) {
                return; // Our work is done here.
            }
            $this->container[$class->getName()] = $value;

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

        } while (($class = $class->getParentClass()) instanceof \ReflectionClass);
    }

    public function get($id)
    {
        if (!isset($this->container[$id])) {
            $this->set($this->newInstance($id));
        }
        return $this->container[$id];
    }

    public function newInstance($type)
    {
        $reflection = new \ReflectionClass($type);
        $constructor = $reflection->getConstructor();
        $constructorParams = $this->getParams($constructor);
        if ($constructorParams) {

The expression $constructorParams of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using ! empty($expr) instead to make it clear that you intend to check for an array without elements.

            $requestedInstance = $reflection->newInstanceArgs($constructorParams);
        } else {
            $requestedInstance = $reflection->newInstance();
        }
        return $requestedInstance;
    }

    protected function getParams(\ReflectionMethod $method = null)
    {
        if (!$method instanceof \ReflectionMethod) {
            return [];
        }
        $constructorParams = [];
        $params = $method->getParameters();
        foreach ($params as $param) {
            if ($param->getClass() instanceof \ReflectionClass) {
                $class = $param->getClass()->getName();
                $instance = $this->get($class);
                $constructorParams[] = $instance;
            } else if (!$param->isOptional()) {
                throw new InvalidObjectException(
                    'The generic container will only manage constructor arguments that are objects'
                );
            }
        }
        return $constructorParams;
    }

    public function has($id)
    {
        return isset($this->container[$id]);
    }

}