Middleware::callHandler() - Code Metrics - Inspection of "refactor" - jetfirephp/routing - Measure and Improve Code Quality continuously with Scrutinizer

Test Failed

Push — master ( 4c92de...3b4c18 )

by Sinnarasa

created 2017-07-16 12:42 UTC

Middleware::callHandler() A

↳ Parent: Middleware

Complexity

Conditions	4
Paths	4

Size

Total Lines	16
Code Lines	11

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
dl	0
loc	16
rs	9.2
c	1
b	0
f	0
cc	4
eloc	11
nc	4
nop	1

<?php

namespace JetFire\Routing;

use ReflectionMethod;


/**
 * Class Middleware
 * @package JetFire\Routing
 */
class Middleware implements MiddlewareInterface
{

    /**
     * @var Router
     */
    private $router;

    /**
     * @var array
     */
    private $callbacks = [
        'globalMiddleware',
        'blockMiddleware',
        'classMiddleware',
        'routeMiddleware',
    ];

    /**
     * @var array
     */
    private $middleware = [];

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

    /**
     * @return array
     */
    public function getMiddleware()
    {
        return $this->middleware;
    }

    /**
     * @param $middleware
     * @return mixed|void
     */
    public function setBeforeCallback($middleware)
    {
        $this->setMiddleware('before', $middleware);
    }

    /**
     * @param $middleware
     * @return mixed|void
     */
    public function setAfterCallback($middleware)
    {
        $this->setMiddleware('after', $middleware);
    }

    /**
     * @param $action
     * @param $middleware
     */
    private function setMiddleware($action, $middleware)
    {
        if (is_string($middleware)) {
            $middleware = rtrim($middleware, '/');
        }
        if (is_array($middleware)) {
            $this->middleware[$action] = $middleware;
        } elseif (is_file($middleware) && is_array($mid = include $middleware)) {
            $this->middleware[$action] = $mid;
        } else {
            throw new \InvalidArgumentException('Accepted argument for setMiddleware are array and array file');
        }
    }

    /**
     * @return Router
     */
    public function getCallbacks()
    {
        return $this->callbacks;
    }

    /**
     * @description global middleware
     * @param $action
     * @return bool|mixed
     */
    public function globalMiddleware($action)
    {
        if (isset($this->middleware[$action][$action]['global_middleware'])) {
            foreach ($this->middleware[$action]['global_middleware'] as $class) {
                if (class_exists($class)) return $this->callHandler($class);
            }
        }
        return true;
    }

    /**
     * @description block middleware
     * @param $action
     * @return bool|mixed
     */
    public function blockMiddleware($action)

    {
        if (isset($this->middleware[$action]['block_middleware'])) {
            if (isset($this->middleware[$action]['block_middleware'][$this->router->route->getTarget('block')])) {
                $blocks = $this->middleware[$action]['block_middleware'][$this->router->route->getTarget('block')];
                if (is_array($blocks)) {
                    foreach ($blocks as $block) {
                        if (class_exists($block)) {
                            if ($this->callHandler($block) === false) return false;
                        }
                    }
                } elseif (is_string($blocks) && class_exists($blocks)) {
                    return $this->callHandler($blocks);
                }
            }
        }
        return true;
    }

    /**
     * @description controller middleware
     * @param $action
     * @return bool|mixed
     */
    public function classMiddleware($action)

    {
        if (isset($this->middleware[$action]['class_middleware'])) {
            $ctrl = str_replace('\\', '/', $this->router->route->getTarget('controller'));
            if (isset($this->middleware[$action]['class_middleware'][$ctrl]) && class_exists($this->router->route->getTarget('controller'))) {
                $classes = $this->middleware[$action]['class_middleware'][$ctrl];
                if (is_array($classes)) {
                    foreach ($classes as $class) {
                        if ($this->callHandler($class) === false) return false;
                    }
                } elseif (is_string($classes)) {
                    return $this->callHandler($classes);
                }
            }
        }
        return true;
    }

    /**
     * @description route middleware
     * @param $action
     * @return bool|mixed
     */
    public function routeMiddleware($action)
    {
        if (isset($this->middleware[$action]['route_middleware'])) {
            if (isset($this->router->route->getPath()['middleware']) && class_exists($this->middleware[$action]['route_middleware'][$this->router->route->getPath()['middleware']])) {
                $classes = $this->middleware[$action]['route_middleware'][$this->router->route->getPath()['middleware']];
                if (is_array($classes)) {
                    foreach ($classes as $class) {
                        if ($this->callHandler($class) === false) return false;
                    }
                } elseif (is_string($classes)) {
                    return $this->callHandler($classes);
                }
            }
        }
        return true;
    }

    /**
     * @param $class
     * @return mixed
     */
    private function callHandler($class)
    {
        $instance = call_user_func($this->router->getConfig()['di'], $class);
        if (method_exists($instance, 'handle')) {
            $reflectionMethod = new ReflectionMethod($instance, 'handle');
            $dependencies = [];
            foreach ($reflectionMethod->getParameters() as $arg) {
                if (!is_null($arg->getClass())) {
                    $dependencies[] = $this->getClass($arg->getClass()->name);
                }
            }
            $dependencies = array_merge($dependencies, [$this->router->route]);
            return $reflectionMethod->invokeArgs($instance, $dependencies);
        }
        return true;
    }

    /**
     * @param $class
     * @return Route|RouteCollection|Router|mixed
     */
    private function getClass($class)
    {
        switch ($class) {
            case Route::class:
                return $this->router->route;
            case Router::class:
                return $this->router;
            case RouteCollection::class:
                return $this->router->collection;
            case Response::class:
                return $this->router->response;
            default:
                return call_user_func_array($this->router->getConfig()['di'], [$class]);
        }
    }
}


1		<?php
2
3		namespace JetFire\Routing;
4
5		use ReflectionMethod;
6
7
8		/**
9		* Class Middleware
10		* @package JetFire\Routing
11		*/
12		class Middleware implements MiddlewareInterface
13		{
14
15		/**
16		* @var Router
17		*/
18		private $router;
19
20		/**
21		* @var array
22		*/
23		private $callbacks = [
24		'globalMiddleware',
25		'blockMiddleware',
26		'classMiddleware',
27		'routeMiddleware',
28		];
29
30		/**
31		* @var array
32		*/
33		private $middleware = [];
34
35		/**
36		* @param Router $router
37		*/
38		public function __construct(Router $router)
39		{
40		$this->router = $router;
41		}
42
43		/**
44		* @return array
45		*/
46		public function getMiddleware()
47		{
48		return $this->middleware;
49		}
50
51		/**
52		* @param $middleware
53		* @return mixed\|void
54		*/
55		public function setBeforeCallback($middleware)
56		{
57		$this->setMiddleware('before', $middleware);
58		}
59
60		/**
61		* @param $middleware
62		* @return mixed\|void
63		*/
64		public function setAfterCallback($middleware)
65		{
66		$this->setMiddleware('after', $middleware);
67		}
68
69		/**
70		* @param $action
71		* @param $middleware
72		*/
73		private function setMiddleware($action, $middleware)
74		{
75		if (is_string($middleware)) {
76		$middleware = rtrim($middleware, '/');
77		}
78		if (is_array($middleware)) {
79		$this->middleware[$action] = $middleware;
80		} elseif (is_file($middleware) && is_array($mid = include $middleware)) {
81		$this->middleware[$action] = $mid;
82		} else {
83		throw new \InvalidArgumentException('Accepted argument for setMiddleware are array and array file');
84		}
85		}
86
87		/**
88		* @return Router
89		*/
90		public function getCallbacks()
91		{
92		return $this->callbacks;
93		}
94
95		/**
96		* @description global middleware
97		* @param $action
98		* @return bool\|mixed
99		*/
100		public function globalMiddleware($action)
101		{
102		if (isset($this->middleware[$action][$action]['global_middleware'])) {
103		foreach ($this->middleware[$action]['global_middleware'] as $class) {
104		if (class_exists($class)) return $this->callHandler($class);
105		}
106		}
107		return true;
108		}
109
110		/**
111		* @description block middleware
112		* @param $action
113		* @return bool\|mixed
114		*/
115	View Code Duplication	public function blockMiddleware($action)
		0 ignored issues – show Duplication introduced 2017-07-16 12:46 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
116		{
117		if (isset($this->middleware[$action]['block_middleware'])) {
118		if (isset($this->middleware[$action]['block_middleware'][$this->router->route->getTarget('block')])) {
119		$blocks = $this->middleware[$action]['block_middleware'][$this->router->route->getTarget('block')];
120		if (is_array($blocks)) {
121		foreach ($blocks as $block) {
122		if (class_exists($block)) {
123		if ($this->callHandler($block) === false) return false;
124		}
125		}
126		} elseif (is_string($blocks) && class_exists($blocks)) {
127		return $this->callHandler($blocks);
128		}
129		}
130		}
131		return true;
132		}
133
134		/**
135		* @description controller middleware
136		* @param $action
137		* @return bool\|mixed
138		*/
139	View Code Duplication	public function classMiddleware($action)
		0 ignored issues – show Duplication introduced 2017-07-16 12:46 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
140		{
141		if (isset($this->middleware[$action]['class_middleware'])) {
142		$ctrl = str_replace('\\', '/', $this->router->route->getTarget('controller'));
143		if (isset($this->middleware[$action]['class_middleware'][$ctrl]) && class_exists($this->router->route->getTarget('controller'))) {
144		$classes = $this->middleware[$action]['class_middleware'][$ctrl];
145		if (is_array($classes)) {
146		foreach ($classes as $class) {
147		if ($this->callHandler($class) === false) return false;
148		}
149		} elseif (is_string($classes)) {
150		return $this->callHandler($classes);
151		}
152		}
153		}
154		return true;
155		}
156
157		/**
158		* @description route middleware
159		* @param $action
160		* @return bool\|mixed
161		*/
162		public function routeMiddleware($action)
163		{
164		if (isset($this->middleware[$action]['route_middleware'])) {
165		if (isset($this->router->route->getPath()['middleware']) && class_exists($this->middleware[$action]['route_middleware'][$this->router->route->getPath()['middleware']])) {
166		$classes = $this->middleware[$action]['route_middleware'][$this->router->route->getPath()['middleware']];
167		if (is_array($classes)) {
168		foreach ($classes as $class) {
169		if ($this->callHandler($class) === false) return false;
170		}
171		} elseif (is_string($classes)) {
172		return $this->callHandler($classes);
173		}
174		}
175		}
176		return true;
177		}
178
179		/**
180		* @param $class
181		* @return mixed
182		*/
183		private function callHandler($class)
184		{
185		$instance = call_user_func($this->router->getConfig()['di'], $class);
186		if (method_exists($instance, 'handle')) {
187		$reflectionMethod = new ReflectionMethod($instance, 'handle');
188		$dependencies = [];
189		foreach ($reflectionMethod->getParameters() as $arg) {
190		if (!is_null($arg->getClass())) {
191		$dependencies[] = $this->getClass($arg->getClass()->name);
192		}
193		}
194		$dependencies = array_merge($dependencies, [$this->router->route]);
195		return $reflectionMethod->invokeArgs($instance, $dependencies);
196		}
197		return true;
198		}
199
200		/**
201		* @param $class
202		* @return Route\|RouteCollection\|Router\|mixed
203		*/
204		private function getClass($class)
205		{
206		switch ($class) {
207		case Route::class:
208		return $this->router->route;
209		case Router::class:
210		return $this->router;
211		case RouteCollection::class:
212		return $this->router->collection;
213		case Response::class:
214		return $this->router->response;
215		default:
216		return call_user_func_array($this->router->getConfig()['di'], [$class]);
217		}
218		}
219		}
220

jetfirephp / routing

Push — master ( 4c92de...3b4c18 )

Middleware::callHandler() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like