CallableResolver::resolveMethodArguments() - Code Metrics - Inspection of "Add code to allow the CallableResolver to resolve..." - slimphp/Slim - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — 3.x (#2341)

unknown

created 2017-11-15 18:05 UTC

CallableResolver::resolveMethodArguments() C

↳ Parent: Project

Complexity

Conditions	7
Paths	4

Size

Total Lines	30
Code Lines	18

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
c	0
b	0
f	0
dl	0
loc	30
rs	6.7272
cc	7
eloc	18
nc	4
nop	1

<?php
/**
 * Slim Framework (https://slimframework.com)
 *
 * @link      https://github.com/slimphp/Slim
 * @copyright Copyright (c) 2011-2017 Josh Lockhart
 * @license   https://github.com/slimphp/Slim/blob/3.x/LICENSE.md (MIT License)
 */
namespace Slim;

use RuntimeException;
use Psr\Container\ContainerInterface;
use Slim\Interfaces\CallableResolverInterface;

/**
 * This class resolves a string of the format 'class:method' into a closure
 * that can be dispatched.
 */
final class CallableResolver implements CallableResolverInterface
{
    const CALLABLE_PATTERN = '!^([^\:]+)\:([a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*)$!';

    /**
     * @var ContainerInterface
     */
    private $container;

    /**
     * @param ContainerInterface $container
     */
    public function __construct(ContainerInterface $container)
    {
        $this->container = $container;
    }

    /**
     * Resolve toResolve into a closure so that the router can dispatch.
     *
     * If toResolve is of the format 'class:method', then try to extract 'class'
     * from the container otherwise instantiate it and then dispatch 'method'.
     *
     * @param mixed $toResolve
     *
     * @return callable
     *
     * @throws RuntimeException if the callable does not exist
     * @throws RuntimeException if the callable is not resolvable
     */
    public function resolve($toResolve)
    {
        if (is_callable($toResolve)) {
            return $toResolve;
        }

        if (!is_string($toResolve)) {
            $this->assertCallable($toResolve);
        }

        // check for slim callable as "class:method"
        if (preg_match(self::CALLABLE_PATTERN, $toResolve, $matches)) {
            $resolved = $this->resolveCallable($matches[1], $matches[2]);
            $this->assertCallable($resolved);

            return $resolved;
        }

        $resolved = $this->resolveCallable($toResolve);
        $this->assertCallable($resolved);

        return $resolved;
    }

    /**
     * Check if string is something in the DIC
     * that's callable or is a class name which has an __invoke() method.
     *
     * @param string $class
     * @param string $method
     * @return callable
     */
    protected function resolveCallable($class, $method = '__invoke')
    {
        if ($this->container->has($class)) {
            return [$this->container->get($class), $method];
        }

        return [$this->constructCallable($class), $method];
    }

    /**
     * Check if string is a class that exists
     * and if so resolve the constructor arguments from the DiC
     *
     * @param string $class
     * @return object
     *
     * @throws \RuntimeException if the callable does not exist
     */
    protected function constructCallable($class)
    {
        if (!class_exists($class)) {
            throw new RuntimeException(sprintf('Callable %s does not exist', $class));
        }

        $reflection = new \ReflectionClass($class);

        $constructor = $reflection->getConstructor();
        $args = [];
        if ($constructor !== null) {
            $args = $this->resolveMethodArguments($constructor);
        }

        $callable = $reflection->newInstanceArgs($args);
        return $callable;
    }

    /**
     * Attempt to resolve method arguments from the DiC or pass in the container itself
     *
     * @param \ReflectionMethod $method
     * @return array
     *
     * @throws \RuntimeException if an argument is not type hinted or a dependency cannot be resolved
     */
    protected function resolveMethodArguments(\ReflectionMethod $method)
    {
        $args = [];

        $parameters = $method->getParameters();
        if (count($parameters) === 1 && $parameters[0]->getClass() === null) {
            // If there is a single un-type hinted argument then inject the container.
            // This is for backwards compatibility.
            $args[] = $this->container;
        } else {
            foreach ($method->getParameters() as $parameter) {
                $class = $parameter->getClass();
                if (!is_object($class)) {
                    throw new RuntimeException(sprintf('Argument %d for %s::%s must be type hinted',
                        $parameter->getPosition(), $method->getDeclaringClass()->getName(), $method->getName()));

                }
                if ($class->getName() == ContainerInterface::class) {

                    $args[] = $this->container;
                    continue;
                }
                if (!$this->container->has($class->getName())) {

                    throw new RuntimeException(sprintf('%s is not resolvable', $class->getName()));

                }

                $args[] = $this->container->get($class->getName());

            }
        }

        return $args;
    }

    /**
     * @param Callable $callable
     *
     * @throws \RuntimeException if the callable is not resolvable
     */
    protected function assertCallable($callable)
    {
        if (!is_callable($callable)) {
            throw new RuntimeException(sprintf(
                '%s is not resolvable',
                is_array($callable) || is_object($callable) ? json_encode($callable) : $callable
            ));
        }
    }
}


1			<?php
2			/**
3			* Slim Framework (https://slimframework.com)
4			*
5			* @link https://github.com/slimphp/Slim
6			* @copyright Copyright (c) 2011-2017 Josh Lockhart
7			* @license https://github.com/slimphp/Slim/blob/3.x/LICENSE.md (MIT License)
8			*/
9			namespace Slim;
10
11			use RuntimeException;
12			use Psr\Container\ContainerInterface;
13			use Slim\Interfaces\CallableResolverInterface;
14
15			/**
16			* This class resolves a string of the format 'class:method' into a closure
17			* that can be dispatched.
18			*/
19			final class CallableResolver implements CallableResolverInterface
20			{
21			const CALLABLE_PATTERN = '!^([^\:]+)\:([a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*)$!';
22
23			/**
24			* @var ContainerInterface
25			*/
26			private $container;
27
28			/**
29			* @param ContainerInterface $container
30			*/
31			public function __construct(ContainerInterface $container)
32			{
33			$this->container = $container;
34			}
35
36			/**
37			* Resolve toResolve into a closure so that the router can dispatch.
38			*
39			* If toResolve is of the format 'class:method', then try to extract 'class'
40			* from the container otherwise instantiate it and then dispatch 'method'.
41			*
42			* @param mixed $toResolve
43			*
44			* @return callable
45			*
46			* @throws RuntimeException if the callable does not exist
47			* @throws RuntimeException if the callable is not resolvable
48			*/
49			public function resolve($toResolve)
50			{
51			if (is_callable($toResolve)) {
52			return $toResolve;
53			}
54
55			if (!is_string($toResolve)) {
56			$this->assertCallable($toResolve);
57			}
58
59			// check for slim callable as "class:method"
60			if (preg_match(self::CALLABLE_PATTERN, $toResolve, $matches)) {
61			$resolved = $this->resolveCallable($matches[1], $matches[2]);
62			$this->assertCallable($resolved);
63
64			return $resolved;
65			}
66
67			$resolved = $this->resolveCallable($toResolve);
68			$this->assertCallable($resolved);
69
70			return $resolved;
71			}
72
73			/**
74			* Check if string is something in the DIC
75			* that's callable or is a class name which has an __invoke() method.
76			*
77			* @param string $class
78			* @param string $method
79			* @return callable
80			*/
81			protected function resolveCallable($class, $method = '__invoke')
82			{
83			if ($this->container->has($class)) {
84			return [$this->container->get($class), $method];
85			}
86
87			return [$this->constructCallable($class), $method];
88			}
89
90			/**
91			* Check if string is a class that exists
92			* and if so resolve the constructor arguments from the DiC
93			*
94			* @param string $class
95			* @return object
96			*
97			* @throws \RuntimeException if the callable does not exist
98			*/
99			protected function constructCallable($class)
100			{
101			if (!class_exists($class)) {
102			throw new RuntimeException(sprintf('Callable %s does not exist', $class));
103			}
104
105			$reflection = new \ReflectionClass($class);
106
107			$constructor = $reflection->getConstructor();
108			$args = [];
109			if ($constructor !== null) {
110			$args = $this->resolveMethodArguments($constructor);
111			}
112
113			$callable = $reflection->newInstanceArgs($args);
114			return $callable;
115			}
116
117			/**
118			* Attempt to resolve method arguments from the DiC or pass in the container itself
119			*
120			* @param \ReflectionMethod $method
121			* @return array
122			*
123			* @throws \RuntimeException if an argument is not type hinted or a dependency cannot be resolved
124			*/
125			protected function resolveMethodArguments(\ReflectionMethod $method)
126			{
127			$args = [];
128
129			$parameters = $method->getParameters();
130			if (count($parameters) === 1 && $parameters[0]->getClass() === null) {
131			// If there is a single un-type hinted argument then inject the container.
132			// This is for backwards compatibility.
133			$args[] = $this->container;
134			} else {
135			foreach ($method->getParameters() as $parameter) {
136			$class = $parameter->getClass();
137			if (!is_object($class)) {
138			throw new RuntimeException(sprintf('Argument %d for %s::%s must be type hinted',
139			$parameter->getPosition(), $method->getDeclaringClass()->getName(), $method->getName()));
			0 ignored issues – show introduced 2017-11-15 18:07 UTC by Report Bug Copy Issue Report Consider using `$method->class`. There is an issue with `getName()` and APC-enabled PHP versions. Loading history... Bug introduced 2017-11-15 18:07 UTC by Report Bug Copy Issue Report Consider using `$method->name`. There is an issue with `getName()` and APC-enabled PHP versions. Loading history...
140			}
141			if ($class->getName() == ContainerInterface::class) {
			0 ignored issues – show Bug introduced 2017-11-15 18:07 UTC by Report Bug Copy Issue Report Consider using `$class->name`. There is an issue with `getName()` and APC-enabled PHP versions. Loading history...
142			$args[] = $this->container;
143			continue;
144			}
145			if (!$this->container->has($class->getName())) {
			0 ignored issues – show Bug introduced 2017-11-15 18:07 UTC by Report Bug Copy Issue Report Consider using `$class->name`. There is an issue with `getName()` and APC-enabled PHP versions. Loading history...
146			throw new RuntimeException(sprintf('%s is not resolvable', $class->getName()));
			0 ignored issues – show Bug introduced 2017-11-15 18:07 UTC by Report Bug Copy Issue Report Consider using `$class->name`. There is an issue with `getName()` and APC-enabled PHP versions. Loading history...
147			}
148
149			$args[] = $this->container->get($class->getName());
			0 ignored issues – show Bug introduced 2017-11-15 18:07 UTC by Report Bug Copy Issue Report Consider using `$class->name`. There is an issue with `getName()` and APC-enabled PHP versions. Loading history...
150			}
151			}
152
153			return $args;
154			}
155
156			/**
157			* @param Callable $callable
158			*
159			* @throws \RuntimeException if the callable is not resolvable
160			*/
161			protected function assertCallable($callable)
162			{
163			if (!is_callable($callable)) {
164			throw new RuntimeException(sprintf(
165			'%s is not resolvable',
166			is_array($callable) \|\| is_object($callable) ? json_encode($callable) : $callable
167			));
168			}
169			}
170			}
171

slimphp / Slim

GitHub Access Token became invalid

Pull Request — 3.x (#2341)

CallableResolver::resolveMethodArguments() C

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like