SimpleDIC\DIC

Complexity

Total Complexity

42

Size/Duplication

Total Lines	265
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

15 Methods

Rating	Name	Duplication	Size	Complexity
A	count()	0	3	1
A	init()	0	3	1
A	__construct()	0	5	1
A	has()	0	3	1
A	keys()	0	3	1
A	initFromFile()	0	3	1
A	get()	0	4	2
A	resolveDependencies()	0	4	2
C	set()	0	55	16
A	getArgumentToInject()	0	7	2
A	getParamKey()	0	3	1
A	getArgumentsToInject()	0	11	3
A	callClassMethod()	0	13	3
A	getFromEnvOrDICParams()	0	11	5
A	getEnvKey()	0	5	2

<?php

namespace SimpleDIC;

use Pimple\Container;
use SimpleDIC\Parser\Parser;

class DIC
{
    /**
     * @var Container
     */
    private static $container;

    /**
     * DIC constructor.
     *
     * @param array $config
     */
    private function __construct(array $config = [])
    {
        self::$container = new Container();

        $this->resolveDependencies($config);
    }

    /**
     * @return int
     */
    public static function count()
    {
        return count(self::keys());
    }

    /**
     * Initialise the DIC
     *
     * @param array $config
     *
     * @return DIC
     */
    public static function init(array $config = [])
    {
        return new self($config);
    }

    /**
     * @param string $filename
     *
     * @return DIC
     * @throws \Exception
     */
    public static function initFromFile($filename)
    {
        return new self(Parser::parse($filename));
    }

    /**
     * @return array
     */
    public static function keys()
    {
        return self::$container->keys();
    }

    /**
     * Resolve the dependencies and register into the DIC
     *
     * @param array $config
     */
    private function resolveDependencies(array $config = [])
    {
        foreach ($config as $key => $content) {
            self::set($key, $content);
        }
    }

    /**
     *
     * Check for an entry existence within the container
     *
     * @param string $dependency
     *
     * @return bool
     */
    public static function has($dependency)
    {
        return isset(self::$container[$dependency]);
    }

    /**
     * Get an entry from the container.
     *
     * The method returns:
     * - false if the entry has a wrong configuration
     * - NULL if the entry does not exists
     *
     * @param string $dependency
     *
     * @return mixed
     */
    public static function get($dependency)
    {
        if (self::has($dependency)) {
            return self::$container[$dependency];
        }
    }

    /**
     * Set an entry in the container.
     *
     * @param string $key
     * @param array|mixed $content
     *
     * @return mixed|bool|null
     */
    private static function set($key, $content)
    {
        if (false === self::has($key)) {
            self::$container[$key] = function ($c) use ($content) {

                // if is not a class set the entry value in DIC
                if (false === isset($content['class'])) {
                    return self::getFromEnvOrDICParams($content);
                }

                // otherwise it's a class, so extract variables
                $class           = isset($content['class']) ? $content['class'] : null;
                $classArguments  = isset($content['arguments']) ? $content['arguments'] : null;
                $method          = isset($content['method']) ? $content['method'] : null;
                $methodArguments = isset($content['method_arguments']) ? $content['method_arguments'] : null;

                if (false === class_exists($class)) {
                    return false;
                }

                // if specified, call a method
                if ($method) {

                    // if specified, call the method with provided arguments
                    if ($methodArguments) {
                        try {
                            return call_user_func_array([$class, $method], self::getArgumentsToInject($c, $methodArguments));
                        } catch (\Error $error) {
                            return false;
                        } catch (\Exception $exception) {
                            return false;
                        }
                    }

                    // if not, call the method with no arguments
                    try {
                        return self::callClassMethod($class, $method);
                    } catch (\Error $error) {
                        return false;
                    } catch (\Exception $exception) {
                        return false;
                    }
                }

                // if the method is not specified, call the constructor
                try {
                    return new $class(...self::getArgumentsToInject($c, $classArguments));
                } catch (\Error $error) {
                    return false;
                } catch (\Exception $exception) {
                    return false;
                }
            };

            return null;
        }
    }

    /**
     * @param string $class
     * @param string $method
     *
     * @return bool|mixed
     * @throws \ReflectionException
     */
    private static function callClassMethod($class, $method)
    {
        $reflected = new \ReflectionClass($class);

        if (false === $reflected->hasMethod($method)) {
            return false;
        }

        if ($reflected->getMethod($method)->isStatic()) {
            return call_user_func([$class, $method]);
        }

        return (new $class)->$method();
    }

    /**
     * Get the arguments to inject into the class to instantiate within DIC.
     *
     * @param Container $c
     * @param null      $providedArguments

Are you sure the doc-type for parameter $providedArguments is correct as it would always require null to be passed?

     *
     * @return array
     */
    private static function getArgumentsToInject(Container $c, $providedArguments = null)
    {
        $returnArguments = [];

        if (null != $providedArguments) {

The condition null != $providedArguments is always false.

            foreach ($providedArguments as $argument) {
                $returnArguments[] = self::getArgumentToInject($argument, $c);
            }
        }

        return $returnArguments;
    }

    /**
     * @param   string        $argument
     * @param Container $c
     *
     * @return mixed|string|null
     */
    private static function getArgumentToInject($argument, Container $c)
    {
        if (isset($c[ltrim($argument, '@')])) {
            return $c[ltrim($argument, '@')];
        }

        return self::getFromEnvOrDICParams($argument);
    }

    /**
     * @param string $parameter
     *
     * @return mixed|string|null
     */
    private static function getFromEnvOrDICParams($parameter)
    {
        if (is_string($parameter)) {

The condition is_string($parameter) is always true.

            if (null !== self::getEnvKey($parameter)) {
                return (getenv(self::getEnvKey($parameter))) ? getenv(self::getEnvKey($parameter)) : $parameter;
            }

            return (DICParams::has(self::getParamKey($parameter))) ? DICParams::get(self::getParamKey($parameter)) : $parameter;
        }

        return $parameter;
    }

    /**
     * Extract from a string like %env(FOO)%
     *
     * @param string $string
     *
     * @return mixed|null
     */
    private static function getEnvKey($string)
    {
        preg_match('~%env\((.*?)\)%~', $string, $matches);

        return (count($matches) > 0) ? $matches[1] : null;
    }

    /**
     * @param string $string
     *
     * @return string
     */
    private static function getParamKey($string)
    {
        return trim($string, '%');
    }
}