Router::addRouteFromConfig() - 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 07:50 UTC

Router::addRouteFromConfig() A

↳ Parent: Router

Complexity

Conditions	4
Paths	8

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	6
CRAP Score	4

Importance

Changes

Metric	Value
dl	0
loc	7
ccs	6
cts	6
cp	1
rs	10
c	0
b	0
f	0
cc	4
nc	8
nop	3
crap	4

<?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 $path => $routeConfig) {
                $name = $path;
                if (array_key_exists('path', $routeConfig)) {
                    $path = $routeConfig['path'];
                }
                $this->addRouteFromConfig($path, $routeConfig, $name);
            }
        }
    }

    /**
     * @param string $path
     * @param array $routeConfig
     */
    private function addRouteFromConfig($path, array $routeConfig, $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 $route
     */
    public function addRoute(Route $route, $name = null)
    {
        if (null === $name) {
            $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		}
93
94	11	if (isset($options['defaultModule'])) {
95	1	$this->defaultModule = $options['defaultModule'];
96		}
97
98	11	if (isset($options['defaultController'])) {
99	1	$this->defaultController = $options['defaultController'];
100		}
101
102	11	if (isset($options['defaultAction'])) {
103	1	$this->defaultAction = $options['defaultAction'];
104		}
105
106	11	if (!empty($options['routes'])) {
107	1	foreach ($options['routes'] as $path => $routeConfig) {
108	1	$name = $path;
109	1	if (array_key_exists('path', $routeConfig)) {
110	1	$path = $routeConfig['path'];
111		}
112	1	$this->addRouteFromConfig($path, $routeConfig, $name);
113		}
114		}
115	11	}
116
117		/**
118		* @param string $path
119		* @param array $routeConfig
120		*/
121	1	private function addRouteFromConfig($path, array $routeConfig, $name)
122		{
123	1	$defaults = isset($routeConfig['defaults']) ? $routeConfig['defaults'] : [];
124	1	$requirements = isset($routeConfig['requirements']) ? $routeConfig['requirements'] : [];
125	1	$methods = isset($routeConfig['methods']) ? $routeConfig['methods'] : [];
126	1	$this->addRoute(new Route($path, $defaults, $requirements, [], '', [], $methods), $name);
127	1	}
128
129		/**
130		* @return string
131		*/
132	1	public function getDefaultModule()
133		{
134	1	return $this->defaultModule;
135		}
136
137		/**
138		* @return string
139		*/
140	1	public function getDefaultController()
141		{
142	1	return $this->defaultController;
143		}
144
145		/**
146		* @return string
147		*/
148	1	public function getDefaultAction()
149		{
150	1	return $this->defaultAction;
151		}
152
153		/**
154		* Add route.
155		*
156		* @param Route $route
157		* @param string\|null $route
158		*/
159	11	public function addRoute(Route $route, $name = null)
160		{
161	11	if (null === $name) {
162	11	$name = $route->getPath();
163		}
164	11	$this->routes->add($name, $route);
165	11	}
166
167		/**
168		* Clear any added routes.
169		*/
170	1	public function clearRoutes()
171		{
172	1	$this->routes = new RouteCollection();
173	1	}
174
175		/**
176		* Get routes collection.
177		*
178		* @return RouteCollection\|Route[]
179		*/
180	3	public function getRoutes()
181		{
182	3	return $this->routes;
183		}
184
185		/**
186		* Resolve controller action and return callable properties.
187		*
188		* @param Request $request
189		* @return AbstractController
190		* @throws ResourceNotFoundException
191		*/
192	3	public function route(Request $request)
193		{
194		// Match route
195	3	$context = new RequestContext();
196	3	$context->fromRequest($request);
197	3	$matcher = new UrlMatcher($this->routes, $context);
198
199	3	$match = $matcher->match($request->getPathInfo());
200	3	$request->attributes->add($match);
201
202
203		// Set request properties with defaults
204	3	$module = $this->getRequestModule($request);
205	3	$controller = $this->getRequestController($request);
206	3	$action = $this->getRequestAction($request);
207	3	$request->attributes->add(compact('module', 'controller', 'action'));
208
209		// Get callable names
210	3	$controllerClass = $this->getControllerClass($controller, $module);
211	3	$actionMethod = $this->getActionMethod($action);
212
213		// Check that controller exist
214	3	if (!class_exists($controllerClass)) {
215	1	throw new ResourceNotFoundException("Controller \"{$controllerClass}\" does not exist");
216		}
217
218		// Check that action exist (we don't use method_exists because PHP's method case insensitivity)
219	2	$controllerMethods = get_class_methods($controllerClass);
220	2	if (!in_array($actionMethod, $controllerMethods, true)) {
221	1	throw new ResourceNotFoundException("Action method \"{$controllerClass}::{$actionMethod}\" does not exist");
222		}
223
224	1	$actualController = new $controllerClass($this->app, $request);
225
226	1	return $actualController;
227		}
228
229		/**
230		* @param string $controller Controller name as lowercase separated string
231		* @param string\|null $module Module as lowercase separated string
232		* @return string
233		*/
234	4	public function getControllerClass($controller, $module = null)
235		{
236	4	$moduleNamespace = null;
237	4	if (!empty($module)) {
238	1	$moduleNamespace = Str::separatorToCamel($module, '-', true);
239		}
240
241	4	$controllerClassName = Str::separatorToCamel($controller, '-', true) . $this->controllerClassSuffix;
242
243	4	return '\\' . implode('\\', array_filter([
244	4	$moduleNamespace,
245	4	$this->controllerNamespace,
246	4	$controllerClassName
247		]));
248		}
249
250		/**
251		* @param string $action Action name as lowercase separated string
252		* @return string
253		*/
254	4	public function getActionMethod($action)
255		{
256	4	return Str::separatorToCamel($action, '-') . $this->actionMethodSuffix;
257		}
258
259		/**
260		* @param Request $request
261		* @return string
262		*/
263	3	public function getRequestModule(Request $request)
264		{
265	3	return $request->attributes->get('module', $this->defaultModule);
266		}
267
268		/**
269		* @param Request $request
270		* @return string
271		*/
272	3	public function getRequestController(Request $request)
273		{
274	3	return $request->attributes->get('controller', $this->defaultController);
275		}
276
277		/**
278		* @param Request $request
279		* @return string
280		*/
281	3	public function getRequestAction(Request $request)
282		{
283	3	return $request->attributes->get('action', $this->defaultAction);
284		}
285		}
286

starweb / starlit-app

GitHub Access Token became invalid

Pull Request — master (#1)

Router::addRouteFromConfig() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like