N1215\CakeCandle\Reflection\ReflectionCallable

Complexity

Total Complexity

9

Size/Duplication

Total Lines	70
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes	5
Bugs	0	Features	0

4 Methods

Rating	Name	Duplication	Size	Complexity
A	invoke()	0	3	1
A	__construct()	0	4	1
A	createReflectionFunctionAbstract()	0	26	6
A	getParameters()	0	3	1

<?php
declare(strict_types=1);

namespace N1215\CakeCandle\Reflection;

use Closure;
use ReflectionException;
use ReflectionFunction;
use ReflectionFunctionAbstract;
use ReflectionMethod;
use ReflectionParameter;

/**
 * Class ReflectionCallable
 * @package N1215\CakeCandle\Reflection
 */
final class ReflectionCallable
{
    /**
     * @var callable
     */
    private $callable;

    /**
     * @var ReflectionFunctionAbstract
     */
    private $reflectionFunctionAbstract;

    /**
     * @param callable $callable
     * @throws ReflectionException
     */
    public function __construct(callable $callable)
    {
        $this->callable = $callable;
        $this->reflectionFunctionAbstract = $this->createReflectionFunctionAbstract($callable);
    }

    /**
     * @param callable $callable
     * @return ReflectionFunctionAbstract
     * @throws ReflectionException
     */
    private function createReflectionFunctionAbstract(callable $callable)
    {
        // array
        if (is_array($callable)) {
            list($class, $method) = $callable;
            return new ReflectionMethod($class, $method);
        }

        // closure
        if ($callable instanceof Closure) {
            return new ReflectionFunction($callable);
        }

        // callable object
        if (is_object($callable) && method_exists($callable, '__invoke')) {
            return new ReflectionMethod($callable, '__invoke');
        }

        // standard function
        if (function_exists($callable)) {

$callable of type callable is incompatible with the type string expected by parameter $function_name of function_exists().

            return new ReflectionFunction($callable);
        }

        // static method
        $parts = explode('::', $callable);

$callable of type callable is incompatible with the type string expected by parameter $string of explode().

        return new ReflectionMethod($parts[0], $parts[1]);
    }

    /**
     * @return ReflectionParameter[]
     */
    public function getParameters()
    {
        return $this->reflectionFunctionAbstract->getParameters();
    }

    /**
     * @param array $args
     * @return mixed
     */
    public function invoke(array $args = [])
    {
        return ($this->callable)(...$args);
    }
}