Router::setLoggerFromParamOrCreateNewInstance() - Code Metrics - Inspection of "Fix issue, bugs and add two new classes BaseClass..." - tnhfw/tnh-fw - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — 1.0.0-dev ( 93958a...e1c8ef )

by nguereza

created 2020-02-26 18:11 UTC

Router::setLoggerFromParamOrCreateNewInstance() A

↳ Parent: Project

Complexity

Conditions	2
Paths	2

Size

Total Lines	7
Code Lines	5

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	2
eloc	5
c	0
b	0
f	0
nc	2
nop	1
dl	0
loc	7
rs	10

<?php
	defined('ROOT_PATH') or exit('Access denied');
	/**
	 * TNH Framework
	 *
	 * A simple PHP framework using HMVC architecture
	 *
	 * This content is released under the GNU GPL License (GPL)
	 *
	 * Copyright (C) 2017 Tony NGUEREZA
	 *
	 * This program is free software; you can redistribute it and/or
	 * modify it under the terms of the GNU General Public License
	 * as published by the Free Software Foundation; either version 3
	 * of the License, or (at your option) any later version.
	 *
	 * This program is distributed in the hope that it will be useful,
	 * but WITHOUT ANY WARRANTY; without even the implied warranty of
	 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
	 * GNU General Public License for more details.
	 *
	 * You should have received a copy of the GNU General Public License
	 * along with this program; if not, write to the Free Software
	 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
	*/

	class Router extends BaseClass{
		/**
		* @var array $pattern: The list of URIs to validate against
		*/
		private $pattern = array();

		/**
		* @var array $callback: The list of callback to call
		*/
		private $callback = array();

		/**
		* @var string $uriTrim: The char to remove from the URIs
		*/
		protected $uriTrim = '/\^$';

		/**
		* @var string $uri: The route URI to use
		*/
		protected $uri = '';

		/**
		 * The module name of the current request
		 * @var string
		 */
		protected $module = null;
		
		/**
		 * The controller name of the current request
		 * @var string
		 */
		protected $controller = null;

		/**
		 * The controller path
		 * @var string
		 */
		protected $controllerPath = null;

		/**
		 * The method name. The default value is "index"
		 * @var string
		 */
		protected $method = 'index';

		/**
		 * List of argument to pass to the method
		 * @var array
		 */
		protected $args = array();

		/**
		 * List of routes configurations
		 * @var array
		 */
		protected $routes = array();

		/**
		 * The segments array for the current request
		 * @var array
		 */
		protected $segments = array();

		/**
		 * Construct the new Router instance
		 */
		public function __construct(){
			parent::__construct();
			
			//loading routes for module
			$moduleRouteList = array();
			$modulesRoutes = Module::getModulesRoutesConfig();
			if($modulesRoutes && is_array($modulesRoutes)){
				$moduleRouteList = $modulesRoutes;
				unset($modulesRoutes);
			}
			$this->setRouteConfiguration($moduleRouteList);
			$this->logger->info('The routes configuration are listed below: ' . stringfy_vars($this->routes));

			//Set route informations
			$this->setRouteConfigurationInfos();
		}

		/**
		 * Get the route patterns
		 * @return array
		 */
		public function getPattern(){
			return $this->pattern;
		}

		/**
		 * Get the route callbacks
		 * @return array
		 */
		public function getCallback(){
			return $this->callback;
		}

	    /**
		 * Get the module name
		 * @return string
		 */
		public function getModule(){
			return $this->module;
		}
		
		/**
		 * Get the controller name
		 * @return string
		 */
		public function getController(){
			return $this->controller;
		}

		/**
		 * Get the controller file path
		 * @return string
		 */
		public function getControllerPath(){
			return $this->controllerPath;
		}

		/**
		 * Get the controller method
		 * @return string
		 */
		public function getMethod(){
			return $this->method;
		}

		/**
		 * Get the request arguments
		 * @return array
		 */
		public function getArgs(){
			return $this->args;
		}

		/**
		 * Get the URL segments array
		 * @return array
		 */
		public function getSegments(){
			return $this->segments;
		}

	    /**
		 * Get the route URI
		 * @return string
		 */
		public function getRouteUri(){
			return $this->uri;
		}

		/**
		* Add the URI and callback to the list of URIs to validate
		*
		* @param string $uri the request URI
		* @param string $callback the callback function
		*
		* @return object the current instance
		*/
		public function add($uri, $callback) {
			$uri = trim($uri, $this->uriTrim);
			if(in_array($uri, $this->pattern)){
				$this->logger->warning('The route [' . $uri . '] already added, may be adding again can have route conflict');
			}
			$this->pattern[] = $uri;
			$this->callback[] = $callback;
			return $this;
		}

		/**
		* Remove the route configuration
		*
		* @param string $uri the URI
		*
		* @return object the current instance
		*/
		public function removeRoute($uri) {
			$index  = array_search($uri, $this->pattern, true);
			if($index !== false){
				$this->logger->info('Remove route for uri [' . $uri . '] from the configuration');
				unset($this->pattern[$index]);
				unset($this->callback[$index]);
			}
			return $this;
		}


		/**
		* Remove all the routes from the configuration
		*
		* @return object the current instance
		*/
		public function removeAllRoute() {
			$this->logger->info('Remove all routes from the configuration');
			$this->pattern  = array();
			$this->callback = array();
			$this->routes = array();
			return $this;
		}


		/**
	     * Set the route URI to use later
	     * @param string $uri the route URI, if is empty will determine automatically
	     * @return object
	     */
	    public function setRouteUri($uri = ''){
	    	$routeUri = '';
	    	if(! empty($uri)){
	    		$routeUri = $uri;
	    	}
	    	//if the application is running in CLI mode use the first argument
			else if(IS_CLI && isset($_SERVER['argv'][1])){
				$routeUri = $_SERVER['argv'][1];
			}
			else if(isset($_SERVER['REQUEST_URI'])){
				$routeUri = $_SERVER['REQUEST_URI'];
			}
			$this->logger->debug('Check if URL suffix is enabled in the configuration');
			//remove url suffix from the request URI
			$suffix = get_config('url_suffix');
			if ($suffix) {
				$this->logger->info('URL suffix is enabled in the configuration, the value is [' . $suffix . ']' );
				$routeUri = str_ireplace($suffix, '', $routeUri);
			} 
			if (strpos($routeUri, '?') !== false){
				$routeUri = substr($routeUri, 0, strpos($routeUri, '?'));
			}
			$this->uri = trim($routeUri, $this->uriTrim);
			return $this;
	    }

	     /**
		 * Set the route segments informations
		 * @param array $segements the route segments information
		 * 
		 * @return object
		 */
		public function setRouteSegments(array $segments = array()){
			if(! empty($segments)){
				$this->segments = $segments;
			} else if (!empty($this->uri)) {
				$this->segments = explode('/', $this->uri);
			}
			$segment = $this->segments;
			$baseUrl = get_config('base_url');
			//check if the app is not in DOCUMENT_ROOT
			if(isset($segment[0]) && stripos($baseUrl, $segment[0]) !== false){
				array_shift($segment);
				$this->segments = $segment;
			}
			$this->logger->debug('Check if the request URI contains the front controller');
			if(isset($segment[0]) && $segment[0] == SELF){

				$this->logger->info('The request URI contains the front controller');
				array_shift($segment);
				$this->segments = $segment;
			}
			return $this;
		}

		/**
		 * Setting the route parameters like module, controller, method, argument
		 * @return object the current instance
		 */
		public function determineRouteParamsInformation() {
			$this->logger->debug('Routing process start ...');
			
			//determine route parameters using the config
			$this->determineRouteParamsFromConfig();
			
			//if can not determine the module/controller/method via the defined routes configuration we will use
			//the URL like http://domain.com/module/controller/method/arg1/arg2
			if(! $this->controller){
				$this->logger->info('Cannot determine the routing information using the predefined routes configuration, will use the request URI parameters');
				//determine route parameters using the REQUEST_URI param
				$this->determineRouteParamsFromRequestUri();
			}
			//Set the controller file path if not yet set
			$this->setControllerFilePath();
			$this->logger->debug('Routing process end.');

			return $this;
		}
	
		 /**
		 * Routing the request to the correspondant module/controller/method if exists
		 * otherwise send 404 error.
		 */
	    public function processRequest(){
	    	//Setting the route URI
			$this->setRouteUri();

			//setting route segments
			$this->setRouteSegments();

			$this->logger->info('The final Request URI is [' . implode('/', $this->segments) . ']' );

	    	//determine the route parameters information
	    	$this->determineRouteParamsInformation();

	    	$e404 = false;
	    	$classFilePath = $this->controllerPath;
	    	$controller = ucfirst($this->controller);
	    	$this->logger->info('The routing information are: module [' . $this->module . '], controller [' . $controller . '], method [' . $this->method . '], args [' . stringfy_vars($this->args) . ']');
	    	$this->logger->debug('Loading controller [' . $controller . '], the file path is [' . $classFilePath . ']...');
	    	
			if(file_exists($classFilePath)){
				require_once $classFilePath;
				if(! class_exists($controller, false)){
					$e404 = true;
					$this->logger->warning('The controller file [' .$classFilePath. '] exists but does not contain the class [' . $controller . ']');
				}
				else{
					$controllerInstance = new $controller();
					$controllerMethod = $this->getMethod();
					if(! method_exists($controllerInstance, $controllerMethod)){
						$e404 = true;
						$this->logger->warning('The controller [' . $controller . '] exist but does not contain the method [' . $controllerMethod . ']');
					}
					else{
						$this->logger->info('Routing data is set correctly now GO!');
						call_user_func_array(array($controllerInstance, $controllerMethod), $this->args);
						//render the final page to user
						$this->logger->info('Render the final output to the browser');
						get_instance()->response->renderFinalPage();
					}
				}
			}
			else{
				$this->logger->info('The controller file path [' . $classFilePath . '] does not exist');
				$e404 = true;
			}
			if($e404){
				if(IS_CLI){
					set_http_status_header(404);
					echo 'Error 404: page not found.';
				} else {
					$response =& class_loader('Response', 'classes');
					$response->send404();
				}
			}
	    }


	    /**
	    * Setting the route configuration using the configuration file and additional configuration from param
	    * @param array $overwriteConfig the additional configuration to overwrite with the existing one
	    * @param boolean $useConfigFile whether to use route configuration file
		* @return object
	    */
	    public function setRouteConfiguration(array $overwriteConfig = array(), $useConfigFile = true){
	        $route = array();
	        if ($useConfigFile && file_exists(CONFIG_PATH . 'routes.php')){
	            require_once CONFIG_PATH . 'routes.php';
	        }
	        $route = array_merge($route, $overwriteConfig);
	        $this->routes = $route;
	        //if route is empty remove all configuration
	        if(empty($route)){
	        	$this->removeAllRoute();
	        }
			return $this;
	    }

	     /**
		 * Get the route configuration
		 * @return array
		 */
		public function getRouteConfiguration(){
			return $this->routes;
		}

	    
	    /**
	     * Set the controller file path if is not set
	     * @param string $path the file path if is null will using the route 
	     * information
	     *
	     * @return object the current instance
	     */
	    public function setControllerFilePath($path = null){
	    	if($path !== null){
	    		$this->controllerPath = $path;
	    		return $this;
	    	}
	    	//did we set the controller, so set the controller path
			if($this->controller && ! $this->controllerPath){
				$this->logger->debug('Setting the file path for the controller [' . $this->controller . ']');
				$controllerPath = APPS_CONTROLLER_PATH . ucfirst($this->controller) . '.php';
				//if the controller is in module
				if($this->module){
					$path = Module::findControllerFullPath(ucfirst($this->controller), $this->module);
					if($path !== false){
						$controllerPath = $path;
					}
				}
				$this->controllerPath = $controllerPath;
			}
			return $this;
	    }

	    /**
	     * Determine the route parameters from route configuration
	     * @return void
	     */
	    protected function determineRouteParamsFromConfig(){
	    	$uri = implode('/', $this->segments);
	    	/*
	   		* Generics routes patterns
	    	*/
			$pattern = array(':num', ':alpha', ':alnum', ':any');
			$replace = array('[0-9]+', '[a-zA-Z]+', '[a-zA-Z0-9]+', '.*');

			$this->logger->debug(
									'Begin to loop in the predefined routes configuration ' 
									. 'to check if the current request match'
									);

			// Cycle through the URIs stored in the array
			foreach ($this->pattern as $index => $uriList) {
				$uriList = str_ireplace($pattern, $replace, $uriList);
				// Check for an existant matching URI
				if (preg_match("#^$uriList$#", $uri, $args)) {
					$this->logger->info(
										'Route found for request URI [' . $uri . '] using the predefined configuration '
										. ' [' . $this->pattern[$index] . '] --> [' . $this->callback[$index] . ']'
									);
					array_shift($args);
					//check if this contains an module
					$moduleControllerMethod = explode('#', $this->callback[$index]);
					if(is_array($moduleControllerMethod) && count($moduleControllerMethod) >= 2){
						$this->logger->info('The current request use the module [' . $moduleControllerMethod[0] . ']');
						$this->module = $moduleControllerMethod[0];
						$moduleControllerMethod = explode('@', $moduleControllerMethod[1]);
					}
					else{
						$this->logger->info('The current request does not use the module');
						$moduleControllerMethod = explode('@', $this->callback[$index]);
					}
					if(is_array($moduleControllerMethod)){
						if(isset($moduleControllerMethod[0])){
							$this->controller = $moduleControllerMethod[0];	
						}
						if(isset($moduleControllerMethod[1])){
							$this->method = $moduleControllerMethod[1];
						}
						$this->args = $args;
					}
					// stop here
					break;
				}
			}

			//first if the controller is not set and the module is set use the module name as the controller
			if(! $this->controller && $this->module){
				$this->logger->info(
									'After loop in predefined routes configuration, 
									the module name is set but the controller is not set, 
									so we will use module as the controller'
								);
				$this->controller = $this->module;
			}
	    }

	    /**
	     * Determine the route parameters using the server variable "REQUEST_URI"
	     * @return void
	     */
	    protected function determineRouteParamsFromRequestUri(){
	    	$segment = $this->segments;
	    	$nbSegment = count($segment);
			//if segment is null so means no need to perform
			if($nbSegment > 0){
				//get the module list
				$modules = Module::getModuleList();
				//first check if no module
				if(empty($modules)){
					$this->logger->info('No module was loaded will skip the module checking');
					//the application don't use module
					//controller
					if(isset($segment[0])){
						$this->controller = $segment[0];
						array_shift($segment);
					}
					//method
					if(isset($segment[0])){
						$this->method = $segment[0];
						array_shift($segment);
					}
					//args
					$this->args = $segment;
				}
				else{
					$this->logger->info('The application contains a loaded module will check if the current request is found in the module list');
					if(in_array($segment[0], $modules)){
						$this->logger->info('Found, the current request use the module [' . $segment[0] . ']');
						$this->module = $segment[0];
						array_shift($segment);
						//check if the second arg is the controller from module
						if(isset($segment[0])){
							$this->controller = $segment[0];
							//check if the request use the same module name and controller
							$path = Module::findControllerFullPath(ucfirst($this->controller), $this->module);
							if(! $path){
								$this->logger->info('The controller [' . $this->controller . '] not found in the module, may be will use the module [' . $this->module . '] as controller');
								$this->controller = $this->module;
							}
							else{
								$this->controllerPath = $path;
								array_shift($segment);
							}
						}
						//check for method
						if(isset($segment[0])){
							$this->method = $segment[0];
							array_shift($segment);
						}
						//the remaining is for args
						$this->args = $segment;
					}
					else{
						$this->logger->info('The current request information is not found in the module list');
						//controller
						if(isset($segment[0])){
							$this->controller = $segment[0];
							array_shift($segment);
						}
						//method
						if(isset($segment[0])){
							$this->method = $segment[0];
							array_shift($segment);
						}
						//args
						$this->args = $segment;
					}
				}
				if(! $this->controller && $this->module){
					$this->logger->info('After using the request URI the module name is set but the controller is not set so we will use module as the controller');
					$this->controller = $this->module;
				}
			}
	    }

	    /**
	     * Set the route informations using the configuration
	     *
	     * @return object the current instance
	     */
	    protected function setRouteConfigurationInfos(){
	    	//adding route
			foreach($this->routes as $pattern => $callback){
				$this->add($pattern, $callback);
			}
			return $this;
		}
	}


1			<?php
2			defined('ROOT_PATH') or exit('Access denied');
3			/**
4			* TNH Framework
5			*
6			* A simple PHP framework using HMVC architecture
7			*
8			* This content is released under the GNU GPL License (GPL)
9			*
10			* Copyright (C) 2017 Tony NGUEREZA
11			*
12			* This program is free software; you can redistribute it and/or
13			* modify it under the terms of the GNU General Public License
14			* as published by the Free Software Foundation; either version 3
15			* of the License, or (at your option) any later version.
16			*
17			* This program is distributed in the hope that it will be useful,
18			* but WITHOUT ANY WARRANTY; without even the implied warranty of
19			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20			* GNU General Public License for more details.
21			*
22			* You should have received a copy of the GNU General Public License
23			* along with this program; if not, write to the Free Software
24			* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
25			*/
26
27			class Router extends BaseClass{
28			/**
29			* @var array $pattern: The list of URIs to validate against
30			*/
31			private $pattern = array();
32
33			/**
34			* @var array $callback: The list of callback to call
35			*/
36			private $callback = array();
37
38			/**
39			* @var string $uriTrim: The char to remove from the URIs
40			*/
41			protected $uriTrim = '/\^$';
42
43			/**
44			* @var string $uri: The route URI to use
45			*/
46			protected $uri = '';
47
48			/**
49			* The module name of the current request
50			* @var string
51			*/
52			protected $module = null;
53
54			/**
55			* The controller name of the current request
56			* @var string
57			*/
58			protected $controller = null;
59
60			/**
61			* The controller path
62			* @var string
63			*/
64			protected $controllerPath = null;
65
66			/**
67			* The method name. The default value is "index"
68			* @var string
69			*/
70			protected $method = 'index';
71
72			/**
73			* List of argument to pass to the method
74			* @var array
75			*/
76			protected $args = array();
77
78			/**
79			* List of routes configurations
80			* @var array
81			*/
82			protected $routes = array();
83
84			/**
85			* The segments array for the current request
86			* @var array
87			*/
88			protected $segments = array();
89
90			/**
91			* Construct the new Router instance
92			*/
93			public function __construct(){
94			parent::__construct();
95
96			//loading routes for module
97			$moduleRouteList = array();
98			$modulesRoutes = Module::getModulesRoutesConfig();
99			if($modulesRoutes && is_array($modulesRoutes)){
100			$moduleRouteList = $modulesRoutes;
101			unset($modulesRoutes);
102			}
103			$this->setRouteConfiguration($moduleRouteList);
104			$this->logger->info('The routes configuration are listed below: ' . stringfy_vars($this->routes));
105
106			//Set route informations
107			$this->setRouteConfigurationInfos();
108			}
109
110			/**
111			* Get the route patterns
112			* @return array
113			*/
114			public function getPattern(){
115			return $this->pattern;
116			}
117
118			/**
119			* Get the route callbacks
120			* @return array
121			*/
122			public function getCallback(){
123			return $this->callback;
124			}
125
126			/**
127			* Get the module name
128			* @return string
129			*/
130			public function getModule(){
131			return $this->module;
132			}
133
134			/**
135			* Get the controller name
136			* @return string
137			*/
138			public function getController(){
139			return $this->controller;
140			}
141
142			/**
143			* Get the controller file path
144			* @return string
145			*/
146			public function getControllerPath(){
147			return $this->controllerPath;
148			}
149
150			/**
151			* Get the controller method
152			* @return string
153			*/
154			public function getMethod(){
155			return $this->method;
156			}
157
158			/**
159			* Get the request arguments
160			* @return array
161			*/
162			public function getArgs(){
163			return $this->args;
164			}
165
166			/**
167			* Get the URL segments array
168			* @return array
169			*/
170			public function getSegments(){
171			return $this->segments;
172			}
173
174			/**
175			* Get the route URI
176			* @return string
177			*/
178			public function getRouteUri(){
179			return $this->uri;
180			}
181
182			/**
183			* Add the URI and callback to the list of URIs to validate
184			*
185			* @param string $uri the request URI
186			* @param string $callback the callback function
187			*
188			* @return object the current instance
189			*/
190			public function add($uri, $callback) {
191			$uri = trim($uri, $this->uriTrim);
192			if(in_array($uri, $this->pattern)){
193			$this->logger->warning('The route [' . $uri . '] already added, may be adding again can have route conflict');
194			}
195			$this->pattern[] = $uri;
196			$this->callback[] = $callback;
197			return $this;
198			}
199
200			/**
201			* Remove the route configuration
202			*
203			* @param string $uri the URI
204			*
205			* @return object the current instance
206			*/
207			public function removeRoute($uri) {
208			$index = array_search($uri, $this->pattern, true);
209			if($index !== false){
210			$this->logger->info('Remove route for uri [' . $uri . '] from the configuration');
211			unset($this->pattern[$index]);
212			unset($this->callback[$index]);
213			}
214			return $this;
215			}
216
217
218			/**
219			* Remove all the routes from the configuration
220			*
221			* @return object the current instance
222			*/
223			public function removeAllRoute() {
224			$this->logger->info('Remove all routes from the configuration');
225			$this->pattern = array();
226			$this->callback = array();
227			$this->routes = array();
228			return $this;
229			}
230
231
232			/**
233			* Set the route URI to use later
234			* @param string $uri the route URI, if is empty will determine automatically
235			* @return object
236			*/
237			public function setRouteUri($uri = ''){
238			$routeUri = '';
239			if(! empty($uri)){
240			$routeUri = $uri;
241			}
242			//if the application is running in CLI mode use the first argument
243			else if(IS_CLI && isset($_SERVER['argv'][1])){
244			$routeUri = $_SERVER['argv'][1];
245			}
246			else if(isset($_SERVER['REQUEST_URI'])){
247			$routeUri = $_SERVER['REQUEST_URI'];
248			}
249			$this->logger->debug('Check if URL suffix is enabled in the configuration');
250			//remove url suffix from the request URI
251			$suffix = get_config('url_suffix');
252			if ($suffix) {
253			$this->logger->info('URL suffix is enabled in the configuration, the value is [' . $suffix . ']' );
254			$routeUri = str_ireplace($suffix, '', $routeUri);
255			}
256			if (strpos($routeUri, '?') !== false){
257			$routeUri = substr($routeUri, 0, strpos($routeUri, '?'));
258			}
259			$this->uri = trim($routeUri, $this->uriTrim);
260			return $this;
261			}
262
263			/**
264			* Set the route segments informations
265			* @param array $segements the route segments information
266			*
267			* @return object
268			*/
269			public function setRouteSegments(array $segments = array()){
270			if(! empty($segments)){
271			$this->segments = $segments;
272			} else if (!empty($this->uri)) {
273			$this->segments = explode('/', $this->uri);
274			}
275			$segment = $this->segments;
276			$baseUrl = get_config('base_url');
277			//check if the app is not in DOCUMENT_ROOT
278			if(isset($segment[0]) && stripos($baseUrl, $segment[0]) !== false){
279			array_shift($segment);
280			$this->segments = $segment;
281			}
282			$this->logger->debug('Check if the request URI contains the front controller');
283			if(isset($segment[0]) && $segment[0] == SELF){
			0 ignored issues – show Bug introduced 2020-02-18 04:44 UTC by Report Bug Copy Issue Report The constant `self` was not found. Maybe you did not declare it correctly or list all dependencies? Loading history...
284			$this->logger->info('The request URI contains the front controller');
285			array_shift($segment);
286			$this->segments = $segment;
287			}
288			return $this;
289			}
290
291			/**
292			* Setting the route parameters like module, controller, method, argument
293			* @return object the current instance
294			*/
295			public function determineRouteParamsInformation() {
296			$this->logger->debug('Routing process start ...');
297
298			//determine route parameters using the config
299			$this->determineRouteParamsFromConfig();
300
301			//if can not determine the module/controller/method via the defined routes configuration we will use
302			//the URL like http://domain.com/module/controller/method/arg1/arg2
303			if(! $this->controller){
304			$this->logger->info('Cannot determine the routing information using the predefined routes configuration, will use the request URI parameters');
305			//determine route parameters using the REQUEST_URI param
306			$this->determineRouteParamsFromRequestUri();
307			}
308			//Set the controller file path if not yet set
309			$this->setControllerFilePath();
310			$this->logger->debug('Routing process end.');
311
312			return $this;
313			}
314
315			/**
316			* Routing the request to the correspondant module/controller/method if exists
317			* otherwise send 404 error.
318			*/
319			public function processRequest(){
320			//Setting the route URI
321			$this->setRouteUri();
322
323			//setting route segments
324			$this->setRouteSegments();
325
326			$this->logger->info('The final Request URI is [' . implode('/', $this->segments) . ']' );
327
328			//determine the route parameters information
329			$this->determineRouteParamsInformation();
330
331			$e404 = false;
332			$classFilePath = $this->controllerPath;
333			$controller = ucfirst($this->controller);
334			$this->logger->info('The routing information are: module [' . $this->module . '], controller [' . $controller . '], method [' . $this->method . '], args [' . stringfy_vars($this->args) . ']');
335			$this->logger->debug('Loading controller [' . $controller . '], the file path is [' . $classFilePath . ']...');
336
337			if(file_exists($classFilePath)){
338			require_once $classFilePath;
339			if(! class_exists($controller, false)){
340			$e404 = true;
341			$this->logger->warning('The controller file [' .$classFilePath. '] exists but does not contain the class [' . $controller . ']');
342			}
343			else{
344			$controllerInstance = new $controller();
345			$controllerMethod = $this->getMethod();
346			if(! method_exists($controllerInstance, $controllerMethod)){
347			$e404 = true;
348			$this->logger->warning('The controller [' . $controller . '] exist but does not contain the method [' . $controllerMethod . ']');
349			}
350			else{
351			$this->logger->info('Routing data is set correctly now GO!');
352			call_user_func_array(array($controllerInstance, $controllerMethod), $this->args);
353			//render the final page to user
354			$this->logger->info('Render the final output to the browser');
355			get_instance()->response->renderFinalPage();
356			}
357			}
358			}
359			else{
360			$this->logger->info('The controller file path [' . $classFilePath . '] does not exist');
361			$e404 = true;
362			}
363			if($e404){
364			if(IS_CLI){
365			set_http_status_header(404);
366			echo 'Error 404: page not found.';
367			} else {
368			$response =& class_loader('Response', 'classes');
369			$response->send404();
370			}
371			}
372			}
373
374
375			/**
376			* Setting the route configuration using the configuration file and additional configuration from param
377			* @param array $overwriteConfig the additional configuration to overwrite with the existing one
378			* @param boolean $useConfigFile whether to use route configuration file
379			* @return object
380			*/
381			public function setRouteConfiguration(array $overwriteConfig = array(), $useConfigFile = true){
382			$route = array();
383			if ($useConfigFile && file_exists(CONFIG_PATH . 'routes.php')){
384			require_once CONFIG_PATH . 'routes.php';
385			}
386			$route = array_merge($route, $overwriteConfig);
387			$this->routes = $route;
388			//if route is empty remove all configuration
389			if(empty($route)){
390			$this->removeAllRoute();
391			}
392			return $this;
393			}
394
395			/**
396			* Get the route configuration
397			* @return array
398			*/
399			public function getRouteConfiguration(){
400			return $this->routes;
401			}
402
403
404			/**
405			* Set the controller file path if is not set
406			* @param string $path the file path if is null will using the route
407			* information
408			*
409			* @return object the current instance
410			*/
411			public function setControllerFilePath($path = null){
412			if($path !== null){
413			$this->controllerPath = $path;
414			return $this;
415			}
416			//did we set the controller, so set the controller path
417			if($this->controller && ! $this->controllerPath){
418			$this->logger->debug('Setting the file path for the controller [' . $this->controller . ']');
419			$controllerPath = APPS_CONTROLLER_PATH . ucfirst($this->controller) . '.php';
420			//if the controller is in module
421			if($this->module){
422			$path = Module::findControllerFullPath(ucfirst($this->controller), $this->module);
423			if($path !== false){
424			$controllerPath = $path;
425			}
426			}
427			$this->controllerPath = $controllerPath;
428			}
429			return $this;
430			}
431
432			/**
433			* Determine the route parameters from route configuration
434			* @return void
435			*/
436			protected function determineRouteParamsFromConfig(){
437			$uri = implode('/', $this->segments);
438			/*
439			* Generics routes patterns
440			*/
441			$pattern = array(':num', ':alpha', ':alnum', ':any');
442			$replace = array('[0-9]+', '[a-zA-Z]+', '[a-zA-Z0-9]+', '.*');
443
444			$this->logger->debug(
445			'Begin to loop in the predefined routes configuration '
446			. 'to check if the current request match'
447			);
448
449			// Cycle through the URIs stored in the array
450			foreach ($this->pattern as $index => $uriList) {
451			$uriList = str_ireplace($pattern, $replace, $uriList);
452			// Check for an existant matching URI
453			if (preg_match("#^$uriList$#", $uri, $args)) {
454			$this->logger->info(
455			'Route found for request URI [' . $uri . '] using the predefined configuration '
456			. ' [' . $this->pattern[$index] . '] --> [' . $this->callback[$index] . ']'
457			);
458			array_shift($args);
459			//check if this contains an module
460			$moduleControllerMethod = explode('#', $this->callback[$index]);
461			if(is_array($moduleControllerMethod) && count($moduleControllerMethod) >= 2){
462			$this->logger->info('The current request use the module [' . $moduleControllerMethod[0] . ']');
463			$this->module = $moduleControllerMethod[0];
464			$moduleControllerMethod = explode('@', $moduleControllerMethod[1]);
465			}
466			else{
467			$this->logger->info('The current request does not use the module');
468			$moduleControllerMethod = explode('@', $this->callback[$index]);
469			}
470			if(is_array($moduleControllerMethod)){
471			if(isset($moduleControllerMethod[0])){
472			$this->controller = $moduleControllerMethod[0];
473			}
474			if(isset($moduleControllerMethod[1])){
475			$this->method = $moduleControllerMethod[1];
476			}
477			$this->args = $args;
478			}
479			// stop here
480			break;
481			}
482			}
483
484			//first if the controller is not set and the module is set use the module name as the controller
485			if(! $this->controller && $this->module){
486			$this->logger->info(
487			'After loop in predefined routes configuration,
488			the module name is set but the controller is not set,
489			so we will use module as the controller'
490			);
491			$this->controller = $this->module;
492			}
493			}
494
495			/**
496			* Determine the route parameters using the server variable "REQUEST_URI"
497			* @return void
498			*/
499			protected function determineRouteParamsFromRequestUri(){
500			$segment = $this->segments;
501			$nbSegment = count($segment);
502			//if segment is null so means no need to perform
503			if($nbSegment > 0){
504			//get the module list
505			$modules = Module::getModuleList();
506			//first check if no module
507			if(empty($modules)){
508			$this->logger->info('No module was loaded will skip the module checking');
509			//the application don't use module
510			//controller
511			if(isset($segment[0])){
512			$this->controller = $segment[0];
513			array_shift($segment);
514			}
515			//method
516			if(isset($segment[0])){
517			$this->method = $segment[0];
518			array_shift($segment);
519			}
520			//args
521			$this->args = $segment;
522			}
523			else{
524			$this->logger->info('The application contains a loaded module will check if the current request is found in the module list');
525			if(in_array($segment[0], $modules)){
526			$this->logger->info('Found, the current request use the module [' . $segment[0] . ']');
527			$this->module = $segment[0];
528			array_shift($segment);
529			//check if the second arg is the controller from module
530			if(isset($segment[0])){
531			$this->controller = $segment[0];
532			//check if the request use the same module name and controller
533			$path = Module::findControllerFullPath(ucfirst($this->controller), $this->module);
534			if(! $path){
535			$this->logger->info('The controller [' . $this->controller . '] not found in the module, may be will use the module [' . $this->module . '] as controller');
536			$this->controller = $this->module;
537			}
538			else{
539			$this->controllerPath = $path;
540			array_shift($segment);
541			}
542			}
543			//check for method
544			if(isset($segment[0])){
545			$this->method = $segment[0];
546			array_shift($segment);
547			}
548			//the remaining is for args
549			$this->args = $segment;
550			}
551			else{
552			$this->logger->info('The current request information is not found in the module list');
553			//controller
554			if(isset($segment[0])){
555			$this->controller = $segment[0];
556			array_shift($segment);
557			}
558			//method
559			if(isset($segment[0])){
560			$this->method = $segment[0];
561			array_shift($segment);
562			}
563			//args
564			$this->args = $segment;
565			}
566			}
567			if(! $this->controller && $this->module){
568			$this->logger->info('After using the request URI the module name is set but the controller is not set so we will use module as the controller');
569			$this->controller = $this->module;
570			}
571			}
572			}
573
574			/**
575			* Set the route informations using the configuration
576			*
577			* @return object the current instance
578			*/
579			protected function setRouteConfigurationInfos(){
580			//adding route
581			foreach($this->routes as $pattern => $callback){
582			$this->add($pattern, $callback);
583			}
584			return $this;
585			}
586			}
587

tnhfw / tnh-fw

Push — 1.0.0-dev ( 93958a...e1c8ef )

Router::setLoggerFromParamOrCreateNewInstance() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like