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

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