Jaxon\Di\Container

Complexity

Total Complexity

29

Size/Duplication

Total Lines	306
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

17 Methods

Rating	Name	Duplication	Size	Complexity
A	setContainer()	0	3	1
A	h()	0	3	1
A	set()	0	4	1
A	__construct()	0	20	1
A	getParameter()	0	19	4
A	registerAll()	0	10	1
A	g()	0	3	1
A	getLogger()	0	3	1
A	has()	0	7	3
A	val()	0	3	1
A	setSessionManager()	0	3	1
A	get()	0	17	4
A	alias()	0	4	1
A	auto()	0	4	1
A	setLogger()	0	3	1
A	make()	0	20	4
A	getSessionManager()	0	3	2

<?php

/**
 * Container.php
 *
 * Jaxon DI container. Provide container service for Jaxon classes.
 *
 * @package jaxon-core

Package name "jaxon-core" is not valid; consider "Jaxoncore" instead

 * @author Thierry Feuzeu <thierry.feuzeu@gmail.com>
 * @copyright 2016 Thierry Feuzeu <thierry.feuzeu@gmail.com>
 * @license https://opensource.org/licenses/BSD-3-Clause BSD 3-Clause License
 * @link https://github.com/jaxon-php/jaxon-core
 */

PHP version not specified

Missing @category tag in file comment

namespace Jaxon\Di;

use Jaxon\App\Ajax;
use Jaxon\App\I18n\Translator;
use Jaxon\App\Session\SessionInterface;
use Jaxon\Exception\SetupException;
use Pimple\Container as PimpleContainer;
use Psr\Container\ContainerInterface;
use Psr\Log\LoggerInterface;
use Psr\Log\NullLogger;

use Closure;
use Exception;
use ReflectionClass;
use ReflectionException;
use ReflectionNamedType;
use ReflectionParameter;
use Throwable;

use function array_map;
use function realpath;

class Container

Missing doc comment for class Container

{
    use Traits\AppTrait;
    use Traits\PsrTrait;
    use Traits\RequestTrait;
    use Traits\ResponseTrait;
    use Traits\PluginTrait;
    use Traits\CallableTrait;
    use Traits\RegisterTrait;
    use Traits\ViewTrait;
    use Traits\UtilTrait;

    /**
     * The library Dependency Injection Container
     *
     * @var PimpleContainer
     */
    private $xLibContainer;

    /**
     * The application or framework Dependency Injection Container
     *
     * @var ContainerInterface
     */
    private $xAppContainer = null;

    /**

Parameter $jaxon should have a doc-comment as per coding-style.

     * The class constructor
     */
    public function __construct(Ajax $jaxon)

Expected 2 blank lines before function; 1 found

    {
        $this->xLibContainer = new PimpleContainer();

        // Save the Ajax and Container instances
        $this->val(Ajax::class, $jaxon);
        $this->val(Container::class, $this);

As per coding style, self should be used for accessing local static members.

        // Register the null logger by default
        $this->setLogger(new NullLogger());

        // Template directory
        $sTemplateDir = realpath(__DIR__ . '/../../templates');
        $this->val('jaxon.core.dir.template', $sTemplateDir);

        // Translation directory
        $sTranslationDir = realpath(__DIR__ . '/../../translations');
        $this->val('jaxon.core.dir.translation', $sTranslationDir);

        $this->registerAll();
    }

Expected 2 blank lines after function; 1 found

    /**
     * Register the values into the container
     *
     * @return void
     */
    private function registerAll()
    {
        $this->registerApp();
        $this->registerPsr();
        $this->registerRequests();
        $this->registerResponses();
        $this->registerPlugins();
        $this->registerCallables();
        $this->registerViews();
        $this->registerUtils();
    }

Expected 2 blank lines after function; 1 found

    /**
     * Set the logger
     *
     * @param LoggerInterface $xLogger

Missing parameter comment

     *
     * @return void
     */
    public function setLogger(LoggerInterface $xLogger)
    {
        $this->val(LoggerInterface::class, $xLogger);
    }

Expected 2 blank lines after function; 1 found

    /**
     * Get the logger
     *
     * @return LoggerInterface
     */
    public function getLogger(): LoggerInterface
    {
        return $this->get(LoggerInterface::class);
    }

Expected 2 blank lines after function; 1 found

    /**
     * Set the container provided by the integrated framework
     *
     * @param ContainerInterface $xContainer    The container implementation

Expected 1 spaces after parameter name; 4 found

     *
     * @return void
     */
    public function setContainer(ContainerInterface $xContainer)
    {
        $this->xAppContainer = $xContainer;
    }

Expected 2 blank lines after function; 1 found

    /**
     * Check if a class is defined in the container
     *
     * @param string $sClass    The full class name

Expected 1 spaces after parameter name; 4 found

     *
     * @return bool
     */
    public function h(string $sClass): bool
    {
        return $this->xLibContainer->offsetExists($sClass);
    }

Expected 2 blank lines after function; 1 found

    /**
     * Check if a class is defined in the container
     *
     * @param string $sClass    The full class name

Expected 1 spaces after parameter name; 4 found

     *
     * @return bool
     */
    public function has(string $sClass): bool
    {
        if($this->xAppContainer != null && $this->xAppContainer->has($sClass))
        {
            return true;
        }
        return $this->xLibContainer->offsetExists($sClass);
    }

Expected 2 blank lines after function; 1 found

    /**
     * Get a class instance
     *
     * @param string $sClass    The full class name

Expected 1 spaces after parameter name; 4 found

     *
     * @return mixed
     */
    public function g(string $sClass)
    {
        return $this->xLibContainer->offsetGet($sClass);
    }

Expected 2 blank lines after function; 1 found

    /**
     * Get a class instance
     *
     * @param string $sClass The full class name
     *
     * @return mixed
     * @throws SetupException
     */
    public function get(string $sClass)
    {
        try
        {
            if($this->xAppContainer != null && $this->xAppContainer->has($sClass))
            {
                return $this->xAppContainer->get($sClass);
            }
            return $this->xLibContainer->offsetGet($sClass);
        }
        catch(Exception|Throwable $e)

Expected 1 space before "|"; 0 found

Expected 1 space after "|"; 0 found

        {
            $xLogger = $this->g(LoggerInterface::class);

Equals sign not aligned with surrounding assignments; expected 5 spaces but found 1 space

            $xTranslator = $this->g(Translator::class);
            $sMessage = $e->getMessage() . ': ' . $xTranslator->trans('errors.class.container', ['name' => $sClass]);

Equals sign not aligned with surrounding assignments; expected 4 spaces but found 1 space

            $xLogger->error($e->getMessage(), ['message' => $sMessage]);
            throw new SetupException($sMessage);
        }
    }

Expected 2 blank lines after function; 1 found

    /**
     * Save a closure in the container
     *
     * @param string $sClass    The full class name

Expected 3 spaces after parameter name; 4 found

Expected 2 spaces after parameter type; 1 found

     * @param Closure $xClosure    The closure

Expected 1 spaces after parameter name; 4 found

     *
     * @return void
     */
    public function set(string $sClass, Closure $xClosure)
    {
       $this->xLibContainer->offsetSet($sClass, function() use($xClosure) {
            return $xClosure($this);
        });
    }

Expected 2 blank lines after function; 1 found

    /**
     * Save a value in the container
     *
     * @param string $sKey    The key

Expected 3 spaces after parameter name; 4 found

     * @param mixed $xValue    The value

Expected 2 spaces after parameter type; 1 found

Expected 1 spaces after parameter name; 4 found

     *
     * @return void
     */
    public function val(string $sKey, $xValue)
    {
       $this->xLibContainer->offsetSet($sKey, $xValue);
    }

Expected 2 blank lines after function; 1 found

    /**
     * Set an alias in the container
     *
     * @param string $sAlias    The alias name

Expected 1 spaces after parameter name; 4 found

     * @param string $sClass    The class name

Expected 1 spaces after parameter name; 4 found

     *
     * @return void
     */
    public function alias(string $sAlias, string $sClass)
    {
        $this->set($sAlias, function($di) use ($sClass) {
            return $di->get($sClass);
        });
    }

Expected 2 blank lines after function; 1 found

    /**
     * @param ReflectionClass $xClass

Missing parameter comment

Expected 5 spaces after parameter type; 1 found

     * @param ReflectionParameter $xParameter

Missing parameter comment

     *
     * @return mixed
     * @throws SetupException
     */
    protected function getParameter(ReflectionClass $xClass, ReflectionParameter $xParameter)

The parameter $xClass is not used and could be removed.

    {
        $xType = $xParameter->getType();
        // Check the parameter class first.
        if($xType instanceof ReflectionNamedType)
        {
            // Check the class + the name
            if($this->has($xType->getName() . ' $' . $xParameter->getName()))
            {
                return $this->get($xType->getName() . ' $' . $xParameter->getName());
            }
            // Check the class only
            if($this->get($xType->getName()))
            {
                return $this->get($xType->getName());
            }
        }
        // Check the name only
        return $this->get('$' . $xParameter->getName());
    }

Expected 2 blank lines after function; 1 found

    /**
     * Create an instance of a class, getting the constructor parameters from the DI container
     *
     * @param string|ReflectionClass $xClass The class name or the reflection class
     *
     * @return object|null
     * @throws ReflectionException
     * @throws SetupException
     */
    public function make($xClass)
    {
        if(is_string($xClass))
        {
            $xClass = new ReflectionClass($xClass); // Create the reflection class instance
        }
        if(!($xClass instanceof ReflectionClass))

$xClass is always a sub-type of ReflectionClass.

        {
            return null;
        }
        // Use the Reflection class to get the parameters of the constructor
        if(($constructor = $xClass->getConstructor()) === null)

Variable assignment found within a condition. Did you mean to do a comparison ?

        {
            return $xClass->newInstance();
        }
        $aParameterInstances = array_map(function($xParameter) use($xClass) {
            return $this->getParameter($xClass, $xParameter);
        }, $constructor->getParameters());

        return $xClass->newInstanceArgs($aParameterInstances);
    }

Expected 2 blank lines after function; 1 found

    /**
     * Create an instance of a class by automatically fetching the dependencies in the constructor.
     *
     * @param string $sClass    The class name

Expected 1 spaces after parameter name; 4 found

     *
     * @return void
     */
    public function auto(string $sClass)
    {
        $this->set($sClass, function() use ($sClass) {
            return $this->make($sClass);
        });
    }

Expected 2 blank lines after function; 1 found

    /**
     * Get the session manager
     *
     * @return SessionInterface|null
     */
    public function getSessionManager(): ?SessionInterface
    {
        return $this->h(SessionInterface::class) ? $this->g(SessionInterface::class) : null;
    }

Expected 2 blank lines after function; 1 found

    /**
     * Set the session manager
     *
     * @param Closure $xClosure    A closure to create the session manager instance

Expected 1 spaces after parameter name; 4 found

     *
     * @return void
     */
    public function setSessionManager(Closure $xClosure)
    {
        $this->set(SessionInterface::class, $xClosure);
    }

Expected 2 blank lines after function; 0 found

}