Issues in RouteHandler.php - All Issues - Inspection of "Adding additional testcases" - canax/router - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 799419...2ea7db )

by Mikael

created 2019-11-22 15:23 UTC

src/Route/RouteHandler.php (3 issues)

Labels

Severity

Informational 3

Upgrade to new PHP Analysis Engine

These results are based on our legacy PHP analysis, consider migrating to our new PHP analysis engine instead. Learn more

<?php

namespace Anax\Route;

use Anax\Commons\ContainerInjectableInterface;
use Anax\Route\Exception\ConfigurationException;
use Anax\Route\Exception\NotFoundException;
use Psr\Container\ContainerInterface;

/**
 * Call a routes handler and return the results.
 */
class RouteHandler
{
    /**
     * @var ContainerInterface $di the dependency/service container.
     */
    protected $di;



    /**
     * Handle the action for a route and return the results.
     *
     * @param string                       $method    the request method.
     * @param string                       $path      that was matched.
     * @param string|array                 $action    base for the callable.
     * @param array                        $arguments optional arguments.
     * @param ContainerInjectableInterface $di        container with services.
     *
     * @return mixed as the result from the route handler.
     */
    public function handle(
        string $method = null,
        string $path = null,
        $action,
        array $arguments = [],
        ContainerInterface $di = null
    ) {
        $this->di = $di;

        if (is_null($action)) {
            return;
        }

        if (is_callable($action)) {
            if (is_array($action)
                && is_string($action[0])
                && class_exists($action[0])
            ) {
                $action[] = $arguments;
                return $this->handleAsControllerAction($action);
            }
            return $this->handleAsCallable($action, $arguments);
        }

        if (is_string($action) && class_exists($action)) {
            $callable = $this->isControllerAction($method, $path, $action);
            if ($callable) {
                return $this->handleAsControllerAction($callable);
            }
        }

        if ($di
            && is_array($action)
            && isset($action[0])
            && isset($action[1])
            && is_string($action[0])
        ) {
            // Try to load service from app/di injected container
            return $this->handleUsingDi($action, $arguments, $di);
        }
        
        throw new ConfigurationException("Handler for route does not seem to be a callable action.");
    }



    /**
     * Get  an informative string representing the handler type.
     *
     * @param string|array                 $action    base for the callable.
     * @param ContainerInjectableInterface $di        container with services.
     *
     * @return string as the type of handler.
     */
    public function getHandlerType(
        $action,
        ContainerInterface $di = null
    ) {
        if (is_null($action)) {
            return "null";
        }

        if (is_callable($action)) {
            return "callable";
        }

        if (is_string($action) && class_exists($action)) {
            $callable = $this->isControllerAction(null, null, $action);
            if ($callable) {
                return "controller";
            }
        }

        if ($di
            && is_array($action)
            && isset($action[0])
            && isset($action[1])
            && is_string($action[0])
            && $di->has($action[0])
            && is_callable([$di->get($action[0]), $action[1]])
        ) {
            return "di";
        }

        return "not found";
    }



    /**
     * Check if items can be used to call a controller action, verify
     * that the controller exists, the action has a class-method to call.
     *
     * @param string $method the request method.
     * @param string $path   the matched path, base for the controller action
     *                       and the arguments.
     * @param string $class  the controller class
     *
     * @return array with callable details.
     */
    protected function isControllerAction(
        string $method = null,
        string $path = null,
        string $class
    ) {
        $method = ucfirst(strtolower($method));
        $args = explode("/", $path);
        $action = array_shift($args);
        $action = empty($action) ? "index" : $action;
        $action = str_replace("-", "", $action);
        $action1 = "{$action}Action{$method}";
        $action2 = "{$action}Action";
        $action3 = "catchAll{$method}";
        $action4 = "catchAll";

        foreach ([$action1, $action2] as $target) {
            try {
                $refl = new \ReflectionMethod($class, $target);
                if (!$refl->isPublic()) {
                    throw new NotFoundException("Controller method '$class::$target' is not a public method.");
                }

                return [$class, $target, $args];
            } catch (\ReflectionException $e) {

                ;
            }
        }

        foreach ([$action3, $action4] as $target) {
            try {
                $refl = new \ReflectionMethod($class, $target);
                if (!$refl->isPublic()) {
                    throw new NotFoundException("Controller method '$class::$target' is not a public method.");
                }

                array_unshift($args, $action);
                return [$class, $target, $args];
            } catch (\ReflectionException $e) {

                ;
            }
        }

        return false;
    }



    /**
     * Call the controller action with optional arguments and call
     * initialisation methods if available.
     *
     * @param string $callable with details on what controller action to call.
     *
     * @return mixed result from the handler.
     */
    protected function handleAsControllerAction(array $callable)
    {
        $class = $callable[0];
        $action = $callable[1];
        $args = $callable[2];
        $obj = new $class();

        $refl = new \ReflectionClass($class);
        $diInterface = "Anax\Commons\ContainerInjectableInterface";
        $appInterface = "Anax\Commons\AppInjectableInterface";

        if ($this->di && $refl->implementsInterface($diInterface)) {
            $obj->setDI($this->di);
        } elseif ($this->di && $refl->implementsInterface($appInterface)) {
            if (!$this->di->has("app")) {
                throw new ConfigurationException(
                    "Controller '$class' implements AppInjectableInterface but \$app is not available in \$di."
                );
            }
            $obj->setApp($this->di->get("app"));
        }

        try {
            $refl = new \ReflectionMethod($class, "initialize");
            if ($refl->isPublic()) {
                $obj->initialize();
            }
        } catch (\ReflectionException $e) {

            ;
        }

        $refl = new \ReflectionMethod($obj, $action);
        $paramIsVariadic = false;
        foreach ($refl->getParameters() as $param) {
            if ($param->isVariadic()) {
                $paramIsVariadic = true;
                break;
            }
        }

        if (!$paramIsVariadic
            && $refl->getNumberOfParameters() < count($args)
        ) {
            throw new NotFoundException(
                "Controller '$class' with action method '$action' valid but to many parameters. Got "
                . count($args)
                . ", expected "
                . $refl->getNumberOfParameters() . "."
            );
        }

        try {
            $res = $obj->$action(...$args);
        } catch (\ArgumentCountError $e) {
            throw new NotFoundException($e->getMessage());
        } catch (\TypeError $e) {
            throw new NotFoundException($e->getMessage());
        }

        return $res;
    }



    /**
     * Handle as callable support callables where the method is not static.
     *
     * @param string|array                 $action    base for the callable
     * @param array                        $arguments optional arguments
     * @param ContainerInjectableInterface $di        container with services
     *
     * @return mixed as the result from the route handler.
     */
    protected function handleAsCallable(
        $action,
        array $arguments
    ) {
        if (is_array($action)
            && isset($action[0])
            && isset($action[1])
            && is_string($action[0])
            && is_string($action[1])
            && class_exists($action[0])
        ) {
            // ["SomeClass", "someMethod"] but not static
            $refl = new \ReflectionMethod($action[0], $action[1]);
            if ($refl->isPublic() && !$refl->isStatic()) {
                $obj = new $action[0]();
                return $obj->{$action[1]}(...$arguments);
            }
        }

        // Add $di to param list, if defined by the callback
        $refl = is_array($action)
            ? new \ReflectionMethod($action[0], $action[1])
            : new \ReflectionFunction($action);
        $params = $refl->getParameters();
        if (isset($params[0]) && $params[0]->getName() === "di") {
            array_unshift($arguments, $this->di);
        }

        return call_user_func($action, ...$arguments);
    }



    /**
     * Load callable as a service from the $di container.
     *
     * @param string|array                 $action    base for the callable
     * @param array                        $arguments optional arguments
     * @param ContainerInjectableInterface $di        container with services
     *
     * @return mixed as the result from the route handler.
     */
    protected function handleUsingDi(
        $action,
        array $arguments,
        ContainerInterface $di
    ) {
        if (!$di->has($action[0])) {
            throw new ConfigurationException("Routehandler '{$action[0]}' not loaded in di.");
        }
    
        $service = $di->get($action[0]);
        if (!is_callable([$service, $action[1]])) {
            throw new ConfigurationException(
                "Routehandler '{$action[0]}' does not have a callable method '{$action[1]}'."
            );
        }
    
        return call_user_func(
            [$service, $action[1]],
            ...$arguments
        );
    }
}


1			<?php
2
3			namespace Anax\Route;
4
5			use Anax\Commons\ContainerInjectableInterface;
6			use Anax\Route\Exception\ConfigurationException;
7			use Anax\Route\Exception\NotFoundException;
8			use Psr\Container\ContainerInterface;
9
10			/**
11			* Call a routes handler and return the results.
12			*/
13			class RouteHandler
14			{
15			/**
16			* @var ContainerInterface $di the dependency/service container.
17			*/
18			protected $di;
19
20
21
22			/**
23			* Handle the action for a route and return the results.
24			*
25			* @param string $method the request method.
26			* @param string $path that was matched.
27			* @param string\|array $action base for the callable.
28			* @param array $arguments optional arguments.
29			* @param ContainerInjectableInterface $di container with services.
30			*
31			* @return mixed as the result from the route handler.
32			*/
33	147		public function handle(
34			string $method = null,
35			string $path = null,
36			$action,
37			array $arguments = [],
38			ContainerInterface $di = null
39			) {
40	147		$this->di = $di;
41
42	147		if (is_null($action)) {
43	1		return;
44			}
45
46	146		if (is_callable($action)) {
47	118		if (is_array($action)
48	118		&& is_string($action[0])
49	118		&& class_exists($action[0])
50			) {
51	2		$action[] = $arguments;
52	2		return $this->handleAsControllerAction($action);
53			}
54	116		return $this->handleAsCallable($action, $arguments);
55			}
56
57	28		if (is_string($action) && class_exists($action)) {
58	24		$callable = $this->isControllerAction($method, $path, $action);
59	23		if ($callable) {
60	20		return $this->handleAsControllerAction($callable);
61			}
62			}
63
64	8		if ($di
65	8		&& is_array($action)
66	8		&& isset($action[0])
67	8		&& isset($action[1])
68	8		&& is_string($action[0])
69			) {
70			// Try to load service from app/di injected container
71	3		return $this->handleUsingDi($action, $arguments, $di);
72			}
73
74	5		throw new ConfigurationException("Handler for route does not seem to be a callable action.");
75			}
76
77
78
79			/**
80			* Get an informative string representing the handler type.
81			*
82			* @param string\|array $action base for the callable.
83			* @param ContainerInjectableInterface $di container with services.
84			*
85			* @return string as the type of handler.
86			*/
87	2		public function getHandlerType(
88			$action,
89			ContainerInterface $di = null
90			) {
91	2		if (is_null($action)) {
92	1		return "null";
93			}
94
95	2		if (is_callable($action)) {
96	1		return "callable";
97			}
98
99	2		if (is_string($action) && class_exists($action)) {
100	1		$callable = $this->isControllerAction(null, null, $action);
101	1		if ($callable) {
102	1		return "controller";
103			}
104			}
105
106	2		if ($di
107	2		&& is_array($action)
108	2		&& isset($action[0])
109	2		&& isset($action[1])
110	2		&& is_string($action[0])
111	2		&& $di->has($action[0])
112	2		&& is_callable([$di->get($action[0]), $action[1]])
113			) {
114	1		return "di";
115			}
116
117	1		return "not found";
118			}
119
120
121
122			/**
123			* Check if items can be used to call a controller action, verify
124			* that the controller exists, the action has a class-method to call.
125			*
126			* @param string $method the request method.
127			* @param string $path the matched path, base for the controller action
128			* and the arguments.
129			* @param string $class the controller class
130			*
131			* @return array with callable details.
132			*/
133	25		protected function isControllerAction(
134			string $method = null,
135			string $path = null,
136			string $class
137			) {
138	25		$method = ucfirst(strtolower($method));
139	25		$args = explode("/", $path);
140	25		$action = array_shift($args);
141	25		$action = empty($action) ? "index" : $action;
142	25		$action = str_replace("-", "", $action);
143	25		$action1 = "{$action}Action{$method}";
144	25		$action2 = "{$action}Action";
145	25		$action3 = "catchAll{$method}";
146	25		$action4 = "catchAll";
147
148	25	View Code Duplication	foreach ([$action1, $action2] as $target) {
149			try {
150	25		$refl = new \ReflectionMethod($class, $target);
151	18		if (!$refl->isPublic()) {
152	1		throw new NotFoundException("Controller method '$class::$target' is not a public method.");
153			}
154
155	17		return [$class, $target, $args];
156	17		} catch (\ReflectionException $e) {
			0 ignored issues – show Coding Style Comprehensibility introduced 2018-08-07 12:38 UTC by Report Bug Copy Issue Report Show Similar Issues like this Consider adding a comment why this CATCH block is empty. Loading history...
157			;
158			}
159			}
160
161	8	View Code Duplication	foreach ([$action3, $action4] as $target) {
162			try {
163	8		$refl = new \ReflectionMethod($class, $target);
164	4		if (!$refl->isPublic()) {
165			throw new NotFoundException("Controller method '$class::$target' is not a public method.");
166			}
167
168	4		array_unshift($args, $action);
169	4		return [$class, $target, $args];
170	5		} catch (\ReflectionException $e) {
			0 ignored issues – show Coding Style Comprehensibility introduced 2018-11-22 14:23 UTC by Report Bug Copy Issue Report Show Similar Issues like this Consider adding a comment why this CATCH block is empty. Loading history...
171			;
172			}
173			}
174
175	4		return false;
176			}
177
178
179
180			/**
181			* Call the controller action with optional arguments and call
182			* initialisation methods if available.
183			*
184			* @param string $callable with details on what controller action to call.
185			*
186			* @return mixed result from the handler.
187			*/
188	22		protected function handleAsControllerAction(array $callable)
189			{
190	22		$class = $callable[0];
191	22		$action = $callable[1];
192	22		$args = $callable[2];
193	22		$obj = new $class();
194
195	22		$refl = new \ReflectionClass($class);
196	22		$diInterface = "Anax\Commons\ContainerInjectableInterface";
197	22		$appInterface = "Anax\Commons\AppInjectableInterface";
198
199	22		if ($this->di && $refl->implementsInterface($diInterface)) {
200	1		$obj->setDI($this->di);
201	21		} elseif ($this->di && $refl->implementsInterface($appInterface)) {
202	2		if (!$this->di->has("app")) {
203	1		throw new ConfigurationException(
204	1		"Controller '$class' implements AppInjectableInterface but \$app is not available in \$di."
205			);
206			}
207	1		$obj->setApp($this->di->get("app"));
208			}
209
210			try {
211	21		$refl = new \ReflectionMethod($class, "initialize");
212	14		if ($refl->isPublic()) {
213	14		$obj->initialize();
214			}
215	7		} catch (\ReflectionException $e) {
			0 ignored issues – show Coding Style Comprehensibility introduced 2018-08-08 13:13 UTC by Report Bug Copy Issue Report Show Similar Issues like this Consider adding a comment why this CATCH block is empty. Loading history...
216			;
217			}
218
219	21		$refl = new \ReflectionMethod($obj, $action);
220	21		$paramIsVariadic = false;
221	21		foreach ($refl->getParameters() as $param) {
222	9		if ($param->isVariadic()) {
223	4		$paramIsVariadic = true;
224	9		break;
225			}
226			}
227
228	21		if (!$paramIsVariadic
229	21		&& $refl->getNumberOfParameters() < count($args)
230			) {
231	1		throw new NotFoundException(
232	1		"Controller '$class' with action method '$action' valid but to many parameters. Got "
233	1		. count($args)
234	1		. ", expected "
235	1		. $refl->getNumberOfParameters() . "."
236			);
237			}
238
239			try {
240	20		$res = $obj->$action(...$args);
241	2		} catch (\ArgumentCountError $e) {
242	1		throw new NotFoundException($e->getMessage());
243	1		} catch (\TypeError $e) {
244	1		throw new NotFoundException($e->getMessage());
245			}
246
247	18		return $res;
248			}
249
250
251
252			/**
253			* Handle as callable support callables where the method is not static.
254			*
255			* @param string\|array $action base for the callable
256			* @param array $arguments optional arguments
257			* @param ContainerInjectableInterface $di container with services
258			*
259			* @return mixed as the result from the route handler.
260			*/
261	116		protected function handleAsCallable(
262			$action,
263			array $arguments
264			) {
265	116		if (is_array($action)
266	116		&& isset($action[0])
267	116		&& isset($action[1])
268	116		&& is_string($action[0])
269	116		&& is_string($action[1])
270	116		&& class_exists($action[0])
271			) {
272			// ["SomeClass", "someMethod"] but not static
273			$refl = new \ReflectionMethod($action[0], $action[1]);
274			if ($refl->isPublic() && !$refl->isStatic()) {
275			$obj = new $action[0]();
276			return $obj->{$action[1]}(...$arguments);
277			}
278			}
279
280			// Add $di to param list, if defined by the callback
281	116		$refl = is_array($action)
282	1		? new \ReflectionMethod($action[0], $action[1])
283	116		: new \ReflectionFunction($action);
284	116		$params = $refl->getParameters();
285	116		if (isset($params[0]) && $params[0]->getName() === "di") {
286	1		array_unshift($arguments, $this->di);
287			}
288
289	116		return call_user_func($action, ...$arguments);
290			}
291
292
293
294			/**
295			* Load callable as a service from the $di container.
296			*
297			* @param string\|array $action base for the callable
298			* @param array $arguments optional arguments
299			* @param ContainerInjectableInterface $di container with services
300			*
301			* @return mixed as the result from the route handler.
302			*/
303	3		protected function handleUsingDi(
304			$action,
305			array $arguments,
306			ContainerInterface $di
307			) {
308	3		if (!$di->has($action[0])) {
309	1		throw new ConfigurationException("Routehandler '{$action[0]}' not loaded in di.");
310			}
311
312	2		$service = $di->get($action[0]);
313	2		if (!is_callable([$service, $action[1]])) {
314	1		throw new ConfigurationException(
315	1		"Routehandler '{$action[0]}' does not have a callable method '{$action[1]}'."
316			);
317			}
318
319	1		return call_user_func(
320	1		[$service, $action[1]],
321	1		...$arguments
322			);
323			}
324			}
325

canax / router

Push — master ( 799419...2ea7db )

src/Route/RouteHandler.php (3 issues)

Labels

Severity

Introduced By

Upgrade to new PHP Analysis Engine

Duplication Side-by-Side

Filter issues like