Preetender\Routing\RouteReflection

Complexity

Total Complexity

13

Size/Duplication

Total Lines	87
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	2

Importance

Changes

0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	createReflection()	0	7	2
A	getPointersAndReturnRequired()	0	4	1
B	resolveParameters()	0	20	5
A	checkClassRegisterContainer()	0	7	2
A	getParametersObject()	0	10	3

<?php

namespace Preetender\Routing;

use League\Container\Exception\ContainerException;

/**
 * Trait RouteReflection
 * @package Preetender\Routing
 */
trait RouteReflection
{
    /** @var array */
    protected static $numberOfParameters = [];

    /** @var */
    protected static $reflectionObject;

    /** @var null  */
    protected static $resolveMethodName = null;

    /**
     * @param object $object
     * @param string|null $method
     */
    protected static function createReflection($object, string $method = null)
    {
        self::$reflectionObject = $object;
        if($method) {

The expression $method of type null|string is loosely compared to true; this is ambiguous if the string can be empty. You might want to explicitly use !== null instead.

            self::$resolveMethodName = $method;

It seems like $method of type string is incompatible with the declared type null of property $resolveMethodName.

        }
    }

    /**
     * @param int $position
     * @return int
     */
    protected static function getPointersAndReturnRequired(int $position)
    {
        return self::$parameters[ array_flip( self::$numberOfParameters)[$position] ];
    }

    /**
     * ...
     * @return array
     */
    protected static function resolveParameters()
    {
        $attributes = [];
        $parameters = self::getParametersObject();
        if(count($parameters) > 0) {
            foreach ($parameters as $parameter) {
                /** @var \ReflectionParameter $parameter */
                if(!$parameter->getClass()) {
                    self::$numberOfParameters[] = $parameter->getPosition();
                    $attributes[$parameter->getPosition()] = self::getPointersAndReturnRequired($parameter->getPosition());
                    continue;
                }
                $className = $parameter->getClass()->getName();
                if(self::checkClassRegisterContainer($className)) {
                    $attributes[$parameter->getPosition()] = Kernel::getContainer()->get($className);
                }
            }
        }
        return $attributes;
    }

    /**
     * Check whether injected class is registered in container.
     *
     * @param string $className
     * @return bool
     */
    protected static function checkClassRegisterContainer(string $className)
    {
        if(!Kernel::getContainer()->has($className)) {
            throw new ContainerException("Class [{$className}] not registered in the container.");
        }
        return true;
    }

    /**
     * Get all parameters to object
     *
     * @return mixed
     */
    protected static function getParametersObject()
    {
        if( self::$reflectionObject instanceof \ReflectionClass) {
            $method = self::$reflectionObject->getMethod(self::$resolveMethodName);
            return $method->getParameters();
        }
        if ( self::$reflectionObject instanceof \ReflectionFunction) {
            return self::$reflectionObject->getParameters();
        }
    }
}