Router::getActionMethod() - Code Metrics - Inspection of "adds support for route names and http methods in t..." - starweb/starlit-app - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#1)

unknown

created 2018-08-09 11:32 UTC

Router::getActionMethod() A

↳ Parent: Router

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	2
CRAP Score	1

Importance

Changes

Metric	Value
dl	0
loc	4
ccs	2
cts	2
cp	1
rs	10
c	0
b	0
f	0
cc	1
nc	1
nop	1
crap	1

<?php
/**
 * Starlit App.
 *
 * @copyright Copyright (c) 2016 Starweb AB
 * @license   BSD 3-Clause
 */

namespace Starlit\App;

use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\Routing\Route;
use Symfony\Component\Routing\RouteCollection;
use Symfony\Component\Routing\RequestContext;
use Symfony\Component\Routing\Matcher\UrlMatcher;
use Symfony\Component\Routing\Exception\ResourceNotFoundException;
use Starlit\Utils\Str;

/**
 * Class for routing URL request to controllers.
 *
 * @author Andreas Nilsson <http://github.com/jandreasn>
 */
class Router
{
    /**
     * @var BaseApp
     */
    protected $app;

    /**
     * @var RouteCollection
     */
    protected $routes;

    /**
     * @var string
     */
    protected $controllerNamespace = 'App\\Controller';

    /**
     * @var string|null
     */
    protected $defaultModule;

    /**
     * @var string
     */
    protected $defaultController = 'index';

    /**
     * @var string
     */
    protected $defaultAction = 'index';

    /**
     * @var string
     */
    protected $controllerClassSuffix = 'Controller';

    /**
     * @var string
     */
    protected $actionMethodSuffix = 'Action';

    /**
     * Constructor.
     *
     * @param BaseApp $app
     * @param array   $options
     */
    public function __construct(BaseApp $app, array $options = [])
    {
        $this->app = $app;
        $this->routes = new RouteCollection();

        $this->setOptions($options);

        // Default routes
        $this->addRoute(new Route('/'));
        $this->addRoute(new Route('/{action}', [], ['action' => '[a-z-]+']));
        $this->addRoute(new Route('/{controller}/{action}', [], ['controller' => '[a-z-]+', 'action' => '[a-z-]+']));
    }

    /**
     * @param array $options
     */
    public function setOptions(array $options)
    {
        if (isset($options['controllerNamespace'])) {
            $this->controllerNamespace = $options['controllerNamespace'];
        }

        if (isset($options['defaultModule'])) {
            $this->defaultModule = $options['defaultModule'];
        }

        if (isset($options['defaultController'])) {
            $this->defaultController = $options['defaultController'];
        }

        if (isset($options['defaultAction'])) {
            $this->defaultAction = $options['defaultAction'];
        }

        if (!empty($options['routes'])) {
            foreach ($options['routes'] as $name => $routeConfig) {
                $this->addRouteFromConfig($name, $routeConfig);
            }
        }
    }

    /**
     * @param string $name
     * @param array $routeConfig
     */
    private function addRouteFromConfig($name, array $routeConfig)
    {
        if (array_key_exists('path', $routeConfig)) {
            $path = $routeConfig['path'];
        } else {
            $path = $name;
        }

        $defaults = isset($routeConfig['defaults']) ? $routeConfig['defaults'] : [];
        $requirements = isset($routeConfig['requirements']) ? $routeConfig['requirements'] : [];
        $methods = isset($routeConfig['methods']) ? $routeConfig['methods'] : [];
        $this->addRoute(new Route($path, $defaults, $requirements, [], '', [], $methods), $name);
    }

    /**
     * @return string
     */
    public function getDefaultModule()
    {
        return $this->defaultModule;
    }

    /**
     * @return string
     */
    public function getDefaultController()
    {
        return $this->defaultController;
    }

    /**
     * @return string
     */
    public function getDefaultAction()
    {
        return $this->defaultAction;
    }

    /**
     * Add route.
     *
     * @param Route $route
     * @param string|null $name
     */
    public function addRoute(Route $route, $name = null)
    {
        if ($name === null) {
            $name = $route->getPath();
        }
        $this->routes->add($name, $route);
    }

    /**
     * Clear any added routes.
     */
    public function clearRoutes()
    {
        $this->routes = new RouteCollection();
    }

    /**
     * Get routes collection.
     *
     * @return RouteCollection|Route[]
     */
    public function getRoutes()
    {
        return $this->routes;
    }

    /**
     * Resolve controller action and return callable properties.
     *
     * @param Request $request
     * @return AbstractController
     * @throws ResourceNotFoundException
     */
    public function route(Request $request)
    {
        // Match route
        $context = new RequestContext();
        $context->fromRequest($request);
        $matcher = new UrlMatcher($this->routes, $context);

        $match = $matcher->match($request->getPathInfo());
        $request->attributes->add($match);


        // Set request properties with defaults
        $module = $this->getRequestModule($request);
        $controller = $this->getRequestController($request);
        $action = $this->getRequestAction($request);
        $request->attributes->add(compact('module', 'controller', 'action'));

        // Get callable names
        $controllerClass = $this->getControllerClass($controller, $module);
        $actionMethod = $this->getActionMethod($action);

        // Check that controller exist
        if (!class_exists($controllerClass)) {
            throw new ResourceNotFoundException("Controller \"{$controllerClass}\" does not exist");
        }

        // Check that action exist (we don't use method_exists because PHP's method case insensitivity)
        $controllerMethods = get_class_methods($controllerClass);
        if (!in_array($actionMethod, $controllerMethods, true)) {
            throw new ResourceNotFoundException("Action method \"{$controllerClass}::{$actionMethod}\" does not exist");
        }

        $actualController = new $controllerClass($this->app, $request);

        return $actualController;
    }

    /**
     * @param string      $controller Controller name as lowercase separated string
     * @param string|null $module     Module as lowercase separated string
     * @return string
     */
    public function getControllerClass($controller, $module = null)
    {
        $moduleNamespace = null;
        if (!empty($module)) {
            $moduleNamespace = Str::separatorToCamel($module, '-', true);
        }

        $controllerClassName = Str::separatorToCamel($controller, '-', true) . $this->controllerClassSuffix;

        return '\\' . implode('\\', array_filter([
            $moduleNamespace,
            $this->controllerNamespace,
            $controllerClassName
        ]));
    }

    /**
     * @param string $action Action name as lowercase separated string
     * @return string
     */
    public function getActionMethod($action)
    {
        return Str::separatorToCamel($action, '-') . $this->actionMethodSuffix;
    }

    /**
     * @param Request $request
     * @return string
     */
    public function getRequestModule(Request $request)
    {
        return $request->attributes->get('module', $this->defaultModule);
    }

    /**
     * @param Request $request
     * @return string
     */
    public function getRequestController(Request $request)
    {
        return $request->attributes->get('controller', $this->defaultController);
    }

    /**
     * @param Request $request
     * @return string
     */
    public function getRequestAction(Request $request)
    {
        return $request->attributes->get('action', $this->defaultAction);
    }
}


1		<?php
2		/**
3		* Starlit App.
4		*
5		* @copyright Copyright (c) 2016 Starweb AB
6		* @license BSD 3-Clause
7		*/
8
9		namespace Starlit\App;
10
11		use Symfony\Component\HttpFoundation\Request;
12		use Symfony\Component\Routing\Route;
13		use Symfony\Component\Routing\RouteCollection;
14		use Symfony\Component\Routing\RequestContext;
15		use Symfony\Component\Routing\Matcher\UrlMatcher;
16		use Symfony\Component\Routing\Exception\ResourceNotFoundException;
17		use Starlit\Utils\Str;
18
19		/**
20		* Class for routing URL request to controllers.
21		*
22		* @author Andreas Nilsson <http://github.com/jandreasn>
23		*/
24		class Router
25		{
26		/**
27		* @var BaseApp
28		*/
29		protected $app;
30
31		/**
32		* @var RouteCollection
33		*/
34		protected $routes;
35
36		/**
37		* @var string
38		*/
39		protected $controllerNamespace = 'App\\Controller';
40
41		/**
42		* @var string\|null
43		*/
44		protected $defaultModule;
45
46		/**
47		* @var string
48		*/
49		protected $defaultController = 'index';
50
51		/**
52		* @var string
53		*/
54		protected $defaultAction = 'index';
55
56		/**
57		* @var string
58		*/
59		protected $controllerClassSuffix = 'Controller';
60
61		/**
62		* @var string
63		*/
64		protected $actionMethodSuffix = 'Action';
65
66		/**
67		* Constructor.
68		*
69		* @param BaseApp $app
70		* @param array $options
71		*/
72	11	public function __construct(BaseApp $app, array $options = [])
73		{
74	11	$this->app = $app;
75	11	$this->routes = new RouteCollection();
76
77	11	$this->setOptions($options);
78
79		// Default routes
80	11	$this->addRoute(new Route('/'));
81	11	$this->addRoute(new Route('/{action}', [], ['action' => '[a-z-]+']));
82	11	$this->addRoute(new Route('/{controller}/{action}', [], ['controller' => '[a-z-]+', 'action' => '[a-z-]+']));
83	11	}
84
85		/**
86		* @param array $options
87		*/
88	11	public function setOptions(array $options)
89		{
90	11	if (isset($options['controllerNamespace'])) {
91	11	$this->controllerNamespace = $options['controllerNamespace'];
92	11	}
93
94	11	if (isset($options['defaultModule'])) {
95	1	$this->defaultModule = $options['defaultModule'];
96	1	}
97
98	11	if (isset($options['defaultController'])) {
99	1	$this->defaultController = $options['defaultController'];
100	1	}
101
102	11	if (isset($options['defaultAction'])) {
103	1	$this->defaultAction = $options['defaultAction'];
104	1	}
105
106	11	if (!empty($options['routes'])) {
107	1	foreach ($options['routes'] as $name => $routeConfig) {
108	1	$this->addRouteFromConfig($name, $routeConfig);
109	1	}
110	1	}
111	11	}
112
113		/**
114		* @param string $name
115		* @param array $routeConfig
116		*/
117	1	private function addRouteFromConfig($name, array $routeConfig)
118		{
119	1	if (array_key_exists('path', $routeConfig)) {
120	1	$path = $routeConfig['path'];
121	1	} else {
122	1	$path = $name;
123		}
124
125	1	$defaults = isset($routeConfig['defaults']) ? $routeConfig['defaults'] : [];
126	1	$requirements = isset($routeConfig['requirements']) ? $routeConfig['requirements'] : [];
127	1	$methods = isset($routeConfig['methods']) ? $routeConfig['methods'] : [];
128	1	$this->addRoute(new Route($path, $defaults, $requirements, [], '', [], $methods), $name);
129	1	}
130
131		/**
132		* @return string
133		*/
134	1	public function getDefaultModule()
135		{
136	1	return $this->defaultModule;
137		}
138
139		/**
140		* @return string
141		*/
142	1	public function getDefaultController()
143		{
144	1	return $this->defaultController;
145		}
146
147		/**
148		* @return string
149		*/
150	1	public function getDefaultAction()
151		{
152	1	return $this->defaultAction;
153		}
154
155		/**
156		* Add route.
157		*
158		* @param Route $route
159		* @param string\|null $name
160		*/
161	11	public function addRoute(Route $route, $name = null)
162		{
163	11	if ($name === null) {
164	11	$name = $route->getPath();
165	11	}
166	11	$this->routes->add($name, $route);
167	11	}
168
169		/**
170		* Clear any added routes.
171		*/
172	1	public function clearRoutes()
173		{
174	1	$this->routes = new RouteCollection();
175	1	}
176
177		/**
178		* Get routes collection.
179		*
180		* @return RouteCollection\|Route[]
181		*/
182	3	public function getRoutes()
183		{
184	3	return $this->routes;
185		}
186
187		/**
188		* Resolve controller action and return callable properties.
189		*
190		* @param Request $request
191		* @return AbstractController
192		* @throws ResourceNotFoundException
193		*/
194	3	public function route(Request $request)
195		{
196		// Match route
197	3	$context = new RequestContext();
198	3	$context->fromRequest($request);
199	3	$matcher = new UrlMatcher($this->routes, $context);
200
201	3	$match = $matcher->match($request->getPathInfo());
202	3	$request->attributes->add($match);
203
204
205		// Set request properties with defaults
206	3	$module = $this->getRequestModule($request);
207	3	$controller = $this->getRequestController($request);
208	3	$action = $this->getRequestAction($request);
209	3	$request->attributes->add(compact('module', 'controller', 'action'));
210
211		// Get callable names
212	3	$controllerClass = $this->getControllerClass($controller, $module);
213	3	$actionMethod = $this->getActionMethod($action);
214
215		// Check that controller exist
216	3	if (!class_exists($controllerClass)) {
217	1	throw new ResourceNotFoundException("Controller \"{$controllerClass}\" does not exist");
218		}
219
220		// Check that action exist (we don't use method_exists because PHP's method case insensitivity)
221	2	$controllerMethods = get_class_methods($controllerClass);
222	2	if (!in_array($actionMethod, $controllerMethods, true)) {
223	1	throw new ResourceNotFoundException("Action method \"{$controllerClass}::{$actionMethod}\" does not exist");
224		}
225
226	1	$actualController = new $controllerClass($this->app, $request);
227
228	1	return $actualController;
229		}
230
231		/**
232		* @param string $controller Controller name as lowercase separated string
233		* @param string\|null $module Module as lowercase separated string
234		* @return string
235		*/
236	4	public function getControllerClass($controller, $module = null)
237		{
238	4	$moduleNamespace = null;
239	4	if (!empty($module)) {
240	1	$moduleNamespace = Str::separatorToCamel($module, '-', true);
241	1	}
242
243	4	$controllerClassName = Str::separatorToCamel($controller, '-', true) . $this->controllerClassSuffix;
244
245	4	return '\\' . implode('\\', array_filter([
246	4	$moduleNamespace,
247	4	$this->controllerNamespace,
248		$controllerClassName
249	4	]));
250		}
251
252		/**
253		* @param string $action Action name as lowercase separated string
254		* @return string
255		*/
256	4	public function getActionMethod($action)
257		{
258	4	return Str::separatorToCamel($action, '-') . $this->actionMethodSuffix;
259		}
260
261		/**
262		* @param Request $request
263		* @return string
264		*/
265	3	public function getRequestModule(Request $request)
266		{
267	3	return $request->attributes->get('module', $this->defaultModule);
268		}
269
270		/**
271		* @param Request $request
272		* @return string
273		*/
274	3	public function getRequestController(Request $request)
275		{
276	3	return $request->attributes->get('controller', $this->defaultController);
277		}
278
279		/**
280		* @param Request $request
281		* @return string
282		*/
283	3	public function getRequestAction(Request $request)
284		{
285	3	return $request->attributes->get('action', $this->defaultAction);
286		}
287		}
288

starweb / starlit-app

GitHub Access Token became invalid

Pull Request — master (#1)

Router::getActionMethod() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like