Invokable::reflectionCallable() - Code Metrics - Inspection of "Invoker class introduced." - venta/framework - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( cee9ed...b93948 )

by Alexey

created 2017-01-11 16:06 UTC

Invokable::reflectionCallable() A

↳ Parent: Invokable

Complexity

Conditions	4
Paths	4

Size

Total Lines	11
Code Lines	6

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	3
CRAP Score	6

Importance

Changes

Metric	Value
cc	4
eloc	6
nc	4
nop	1
dl	0
loc	11
ccs	3
cts	6
cp	0.5
crap	6
rs	9.2
c	0
b	0
f	0

<?php declare(strict_types = 1);

namespace Venta\Container;

use Closure;
use InvalidArgumentException;
use ReflectionFunction;
use ReflectionFunctionAbstract;
use ReflectionMethod;

/**
 * Class Invokable
 *
 * @package Venta\Container
 */
class Invokable
{

    /**
     * @var callable
     */
    private $callable;

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

    /**
     * ReflectedCallable constructor.
     *
     * @param callable|ReflectionFunctionAbstract $callable
     */
    public function __construct($callable)
    {
        if ($callable instanceof ReflectionFunctionAbstract) {
            $this->callable = $this->reflectionCallable($callable);
            $this->reflection = $callable;
        } else {
            $this->callable = $this->normalizeCallable($callable);
        }
    }

    /**
     * @return callable
     */
    public function callable()
    {
        return $this->callable;
    }

    /**
     * @return bool
     */
    public function isFunction(): bool
    {
        return !is_array($this->callable);
    }

    /**
     * @return ReflectionFunctionAbstract|ReflectionMethod|ReflectionFunction
     */
    public function reflection(): ReflectionFunctionAbstract
    {
        if (empty($this->reflection)) {
            $this->reflection = $this->isFunction()
                ? new ReflectionFunction($this->callable)
                : new ReflectionMethod($this->callable[0], $this->callable[1]);
        }

        return $this->reflection;
    }

    /**
     * @param $callable
     * @return callable

     * @throws InvalidArgumentException
     */
    private function normalizeCallable($callable)
    {
        if (is_object($callable)) {
            if ($callable instanceof Closure) {
                return $callable;
            } else {
                if (!method_exists($callable, '__invoke')) {
                    throw new InvalidArgumentException('Invalid callable provided.');
                }

                // Callable object is an instance with magic __invoke() method.
                return [$callable, '__invoke'];
            }
        }

        if (is_string($callable)) {
            // Existing function is always callable.
            if (function_exists($callable)) {
                return $callable;
            }
            if (method_exists($callable, '__invoke')) {
                // We allow to call class by name if `__invoke()` method is implemented.
                return [$callable, '__invoke'];
            }
            if (strpos($callable, '::') !== false) {
                // Replace "ClassName::methodName" string with ["ClassName", "methodName"] array.

                $callable = explode('::', $callable);
            }
        }

        // Is correct callable array.
        if (is_array($callable) && isset($callable[0], $callable[1]) && method_exists($callable[0], $callable[1])) {
            return $callable;
        }

        throw new InvalidArgumentException('Invalid callable provided.');
    }

    /**
     * @param ReflectionFunctionAbstract $reflection
     * @return array|Closure|string
     * @throws InvalidArgumentException
     */
    private function reflectionCallable(ReflectionFunctionAbstract $reflection)
    {
        if ($reflection instanceof ReflectionMethod) {
            return [$reflection->class, $reflection->name];
        }
        if ($reflection instanceof ReflectionFunction) {
            return $reflection->isClosure() ? $reflection->getClosure() : $reflection->name;
        }

        throw new InvalidArgumentException('Invalid callable provided.');
    }
}

1		<?php declare(strict_types = 1);
2
3		namespace Venta\Container;
4
5		use Closure;
6		use InvalidArgumentException;
7		use ReflectionFunction;
8		use ReflectionFunctionAbstract;
9		use ReflectionMethod;
10
11		/**
12		* Class Invokable
13		*
14		* @package Venta\Container
15		*/
16		class Invokable
17		{
18
19		/**
20		* @var callable
21		*/
22		private $callable;
23
24		/**
25		* @var ReflectionFunctionAbstract
26		*/
27		private $reflection;
28
29		/**
30		* ReflectedCallable constructor.
31		*
32		* @param callable\|ReflectionFunctionAbstract $callable
33		*/
34	53	public function __construct($callable)
35		{
36	53	if ($callable instanceof ReflectionFunctionAbstract) {
37	15	$this->callable = $this->reflectionCallable($callable);
38	15	$this->reflection = $callable;
39		} else {
40	45	$this->callable = $this->normalizeCallable($callable);
41		}
42	46	}
43
44		/**
45		* @return callable
46		*/
47	40	public function callable()
48		{
49	40	return $this->callable;
50		}
51
52		/**
53		* @return bool
54		*/
55	33	public function isFunction(): bool
56		{
57	33	return !is_array($this->callable);
58		}
59
60		/**
61		* @return ReflectionFunctionAbstract\|ReflectionMethod\|ReflectionFunction
62		*/
63	33	public function reflection(): ReflectionFunctionAbstract
64		{
65	33	if (empty($this->reflection)) {
66	25	$this->reflection = $this->isFunction()
67	11	? new ReflectionFunction($this->callable)
68	14	: new ReflectionMethod($this->callable[0], $this->callable[1]);
69		}
70
71	33	return $this->reflection;
72		}
73
74		/**
75		* @param $callable
76		* @return callable
		0 ignored issues – show Documentation introduced 2017-01-10 16:09 UTC by Report Bug Copy Issue Report Consider making the return type a bit more specific; maybe use `Closure\|string\|array`. This check looks for the generic type `array` as a return type and suggests a more specific type. This type is inferred from the actual code. Loading history...
77		* @throws InvalidArgumentException
78		*/
79	45	private function normalizeCallable($callable)
80		{
81	45	if (is_object($callable)) {
82	14	if ($callable instanceof Closure) {
83	9	return $callable;
84		} else {
85	5	if (!method_exists($callable, '__invoke')) {
86	1	throw new InvalidArgumentException('Invalid callable provided.');
87		}
88
89		// Callable object is an instance with magic __invoke() method.
90	4	return [$callable, '__invoke'];
91		}
92		}
93
94	31	if (is_string($callable)) {
95		// Existing function is always callable.
96	20	if (function_exists($callable)) {
97	5	return $callable;
98		}
99	15	if (method_exists($callable, '__invoke')) {
100		// We allow to call class by name if `__invoke()` method is implemented.
101	2	return [$callable, '__invoke'];
102		}
103	13	if (strpos($callable, '::') !== false) {
104		// Replace "ClassName::methodName" string with ["ClassName", "methodName"] array.
		0 ignored issues – show Unused Code Comprehensibility introduced 2017-01-10 16:09 UTC by Report Bug Copy Issue Report `39%` of this comment could be valid code. Did you maybe forget this after debugging? Sometimes obsolete code just ends up commented out instead of removed. In this case it is better to remove the code once you have checked you do not need it. The code might also have been commented out for debugging purposes. In this case it is vital that someone uncomments it again or your project may behave in very unexpected ways in production. This check looks for comments that seem to be mostly valid code and reports them. Loading history...
105	10	$callable = explode('::', $callable);
106		}
107		}
108
109		// Is correct callable array.
110	24	if (is_array($callable) && isset($callable[0], $callable[1]) && method_exists($callable[0], $callable[1])) {
111	18	return $callable;
112		}
113
114	6	throw new InvalidArgumentException('Invalid callable provided.');
115		}
116
117		/**
118		* @param ReflectionFunctionAbstract $reflection
119		* @return array\|Closure\|string
120		* @throws InvalidArgumentException
121		*/
122	15	private function reflectionCallable(ReflectionFunctionAbstract $reflection)
123		{
124	15	if ($reflection instanceof ReflectionMethod) {
125	15	return [$reflection->class, $reflection->name];
126		}
127		if ($reflection instanceof ReflectionFunction) {
128		return $reflection->isClosure() ? $reflection->getClosure() : $reflection->name;
129		}
130
131		throw new InvalidArgumentException('Invalid callable provided.');
132		}
133		}

venta / framework

Push — master ( cee9ed...b93948 )

Invokable::reflectionCallable() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like