Phile\Core\Container

Complexity

Total Complexity

14

Size/Duplication

Total Lines	102
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	2

Test Coverage

Coverage

100%

Importance

Changes

0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	setInstance()	0	4	1
A	getInstance()	0	4	1
A	has()	0	4	1
A	get()	0	17	4
A	set()	0	7	2
A	typeCheck()	0	12	4

<?php
/**
 * @author PhileCMS
 * @link https://github.com/PhileCMS/Phile
 * @license http://opensource.org/licenses/MIT
 */

namespace Phile\Core;

use Psr\Container\ContainerInterface;
use Phile\Exception\ContainerNotFoundException as NotFoundException;

/**
 * Implements a simple PSR-11 container
 */
class Container implements ContainerInterface
{
    protected $config = [];

    /** @var ContainerInterface */
    protected static $instance;

    /** @var array raw items */
    protected $raw = [];

    /** @var evaluated items */
    protected $build = [];

    public function __construct($config = [])
    {
        $this->config = $config;
    }

    /**
     * Sets instance for static usage
     *
     * @param ContainerInterface $instance
     */
    public static function setInstance(ContainerInterface $instance)
    {
        self::$instance = $instance;
    }

    /**
     * Gets instance for static usage
     *
     * @return ContainerInterface
     */
    public static function getInstance()
    {
        return self::$instance;
    }

    /**
     * {@inheritdoc}
     */
    public function has($id)
    {
        return array_key_exists($id, $this->raw);
    }

    /**
     * {@inheritdoc}
     */
    public function get($id)
    {
        if (!$this->has($id)) {
            throw new NotFoundException(
                sprintf('Item "%s" not found in Container.', $id),
                1519111836
            );
        }
        if (!is_callable($this->raw[$id])) {
            return $this->raw[$id];
        }
        if (!isset($this->build[$id])) {
            $this->build[$id] = call_user_func($this->raw[$id], $this);
            $this->typeCheck($id, $this->build[$id]);
        }
        return $this->build[$id];
    }

    /**
     * Set an object
     *
     * @param string $id Identifier for the object to set
     * @param type $object Object to set
     */
    public function set($id, $object)
    {
        if (!is_callable($object)) {
            $this->typeCheck($id, $object);
        }
        $this->raw[$id] = $object;
    }

    /**
     * Check object-type matches required type for that ID
     *
     * @param string $id
     * @param mixed $object
     * @return void
     * @throws \Phile\Exception\ContainerException
     */
    protected function typeCheck($id, $object)
    {
        if (!isset($this->config['types'][$id])) {
            return;
        }
        $requirement = $this->config['types'][$id];
        if (get_class($object) === $requirement || is_subclass_of($object, $requirement)) {

Due to PHP Bug #53727, is_subclass_of might return inconsistent results on some PHP versions if $requirement can be an interface. If so, you could instead use ReflectionClass::implementsInterface.

            return;
        }
        $msg = sprintf('The Container-item "%s" must implement the interface: "%s"', $id, $requirement);
        throw new \Phile\Exception\ContainerException($msg, 1398536617);
    }
}