RouterCacheTrait::addControllerCache() - Code Metrics - Inspection of "travis files" - phpMv/ubiquity - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 2c93a3...b8d7dd )

by Jean-Christophe

created 2019-02-02 02:53 UTC

RouterCacheTrait::addControllerCache() A

↳ Parent: RouterCacheTrait

Complexity

Conditions	2
Paths	3

Size

Total Lines	9
Code Lines	6

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	6

Importance

Changes

Metric	Value
cc	2
eloc	6
nc	3
nop	1
dl	0
loc	9
ccs	0
cts	6
cp	0
crap	6
rs	10
c	0
b	0
f	0

<?php

namespace Ubiquity\cache\traits;

use Ubiquity\controllers\Startup;
use Ubiquity\controllers\Router;
use Ubiquity\cache\parser\ControllerParser;
use Ubiquity\cache\ClassUtils;
use Ubiquity\utils\base\UArray;
use Ubiquity\cache\CacheManager;

/**
 * @author jcheron <[email protected]>
 * @version 1.0.3
 * @staticvar AbstractDataCache $cache
 *
 */
trait RouterCacheTrait{
	public static $minify=false;
	
	abstract protected static function _getFiles(&$config, $type, $silent=false);
	private static $expiredRoutes=[ ];

	private static function addControllerCache($classname) {
		$parser=new ControllerParser();
		try {
			$parser->parse($classname);
			return $parser->asArray(self::$minify);
		} catch ( \Exception $e ) {
			// Nothing to do
		}
		return [ ];
	}

	private static function initRouterCache(&$config, $silent=false) {
		$routes=[ "rest" => [ ],"default" => [ ] ];
		$files=self::getControllersFiles($config,$silent);
		foreach ( $files as $file ) {
			if (is_file($file)) {
				$controller=ClassUtils::getClassFullNameFromFile($file);
				$parser=new ControllerParser();
				try {
					$parser->parse($controller);
					$ret=$parser->asArray(self::$minify);
					$key=($parser->isRest()) ? "rest" : "default";
					$routes[$key]=\array_merge($routes[$key], $ret);
				} catch ( \Exception $e ) {
					// Nothing to do
				}
			}
		}
		self::$cache->store("controllers/routes.default", "return " . UArray::asPhpArray($routes["default"], "array") . ";", 'controllers');
		self::$cache->store("controllers/routes.rest", "return " . UArray::asPhpArray($routes["rest"], "array") . ";", 'controllers');
		if (!$silent) {
			echo "Router cache reset\n";
		}
	}

	private static function storeRouteResponse($key, $response) {
		self::setKeyExpired($key, false);
		self::$cache->store("controllers/" . $key, $response, 'controllers', false);
		return $response;
	}

	private static function getRouteKey($routePath) {
		return "path" . \md5(\implode("", $routePath));
	}

	private static function setKeyExpired($key, $expired=true) {
		if ($expired) {
			self::$expiredRoutes[$key]=true;
		} else {
			unset(self::$expiredRoutes[$key]);
		}
	}

	/**
	 * @param boolean $isRest
	 * @return array
	 */
	public static function getControllerCache($isRest=false) {
		$key=($isRest) ? "rest" : "default";
		if (self::$cache->exists("controllers/routes." . $key))
			return self::$cache->fetch("controllers/routes." . $key);
		return [ ];
	}

	public static function getRouteCache($routePath, $duration) {
		$key=self::getRouteKey($routePath);

		if (self::$cache->exists("controllers/" . $key) && !self::expired($key, $duration)) {
			$response=self::$cache->file_get_contents("controllers/" . $key);
			return $response;
		} else {
			$response=Startup::runAsString($routePath);
			return self::storeRouteResponse($key, $response);
		}
	}

	public static function expired($key, $duration) {
		return self::$cache->expired("controllers/" . $key, $duration) === true || \array_key_exists($key, self::$expiredRoutes);
	}

	public static function isExpired($path, $duration) {
		$route=Router::getRoute($path, false);
		if ($route !== false && \is_array($route)) {
			return self::expired(self::getRouteKey($route), $duration);
		}
		return true;
	}

	public static function setExpired($routePath, $expired=true) {
		$key=self::getRouteKey($routePath);
		self::setKeyExpired($key, $expired);
	}

	public static function setRouteCache($routePath) {
		$key=self::getRouteKey($routePath);
		$response=Startup::runAsString($routePath);
		return self::storeRouteResponse($key, $response);
	}

	public static function addAdminRoutes() {
		self::addControllerCache("Ubiquity\controllers\Admin");
	}

	public static function getRoutes() {
		$result=self::getControllerCache();
		return $result;
	}

	public static function getControllerRoutes($controllerClass, $isRest=false) {
		$result=[ ];
		$ctrlCache=self::getControllerCache($isRest);
		foreach ( $ctrlCache as $path => $routeAttributes ) {
			if (isset($routeAttributes["controller"])) {
				if ($routeAttributes["controller"] === $controllerClass) {
					$result[$path]=$routeAttributes;
				}
			} else {
				$firstValue=current($routeAttributes);
				if (isset($firstValue) && isset($firstValue["controller"])) {
					if ($firstValue["controller"] === $controllerClass) {
						$result[$path]=$routeAttributes;
					}
				}
			}
		}
		return $result;
	}

	public static function addRoute($path, $controller, $action="index", $methods=null, $name="") {
		$controllerCache=self::getControllerCache();
		Router::addRouteToRoutes($controllerCache, $path, $controller, $action, $methods, $name);
		self::$cache->store("controllers/routes.default", "return " . UArray::asPhpArray($controllerCache, "array") . ";", 'controllers');
	}
	
	public static function addRoutes($pathArray, $controller, $action="index", $methods=null, $name="") {
		self::addRoutes_($pathArray, $controller,$action,$methods,$name,false);
	}
	
	public static function addRestRoutes($pathArray, $controller, $action="index", $methods=null, $name="") {
		self::addRoutes_($pathArray, $controller,$action,$methods,$name,true);
	}
	
	private static function addRoutes_($pathArray, $controller, $action="index", $methods=null, $name="",$isRest=false) {
		$controllerCache=self::getControllerCache($isRest);
		$postfix="default";
		if($isRest){
			$postfix="rest";
		}
		Router::addRoutesToRoutes($controllerCache, $pathArray, $controller, $action, $methods, $name);
		if(self::$minify){
			ControllerParser::minifyRoutes($controllerCache);
		}
		self::$cache->store("controllers/routes.".$postfix, "return " . UArray::asPhpArray($controllerCache, "array") . ";", 'controllers');
	}

	public static function getControllersFiles(&$config, $silent=false) {
		return self::_getFiles($config, "controllers", $silent);
	}

	public static function getControllers($subClass="\\Ubiquity\\controllers\\Controller",$backslash=false,$includeSubclass=false) {
		$result=[ ];
		if($includeSubclass){
			$result[]=$subClass;
		}
		$config=Startup::getConfig();
		$files=self::getControllersFiles($config, true);
		try {
			$restCtrls=CacheManager::getRestCache();
		} catch ( \Exception $e ) {
			$restCtrls=[ ];
		}
		foreach ( $files as $file ) {
			if (is_file($file)) {
				$controllerClass=ClassUtils::getClassFullNameFromFile($file,$backslash);
				if (isset($restCtrls[$controllerClass]) === false) {
					$r=new \ReflectionClass($controllerClass);
					if($r->isSubclassOf($subClass) && !$r->isAbstract()){
						$result[]=$controllerClass;
					}
				}
			}
		}
		return $result;
	}
}


1		<?php
2
3		namespace Ubiquity\cache\traits;
4
5		use Ubiquity\controllers\Startup;
6		use Ubiquity\controllers\Router;
7		use Ubiquity\cache\parser\ControllerParser;
8		use Ubiquity\cache\ClassUtils;
9		use Ubiquity\utils\base\UArray;
10		use Ubiquity\cache\CacheManager;
11
12		/**
13		* @author jcheron <[email protected]>
14		* @version 1.0.3
15		* @staticvar AbstractDataCache $cache
16		*
17		*/
18		trait RouterCacheTrait{
19		public static $minify=false;
20
21		abstract protected static function _getFiles(&$config, $type, $silent=false);
22		private static $expiredRoutes=[ ];
23
24		private static function addControllerCache($classname) {
25		$parser=new ControllerParser();
26		try {
27		$parser->parse($classname);
28		return $parser->asArray(self::$minify);
29		} catch ( \Exception $e ) {
30		// Nothing to do
31		}
32		return [ ];
33		}
34
35	1	private static function initRouterCache(&$config, $silent=false) {
36	1	$routes=[ "rest" => [ ],"default" => [ ] ];
37	1	$files=self::getControllersFiles($config,$silent);
38	1	foreach ( $files as $file ) {
39	1	if (is_file($file)) {
40	1	$controller=ClassUtils::getClassFullNameFromFile($file);
41	1	$parser=new ControllerParser();
42		try {
43	1	$parser->parse($controller);
44	1	$ret=$parser->asArray(self::$minify);
45	1	$key=($parser->isRest()) ? "rest" : "default";
46	1	$routes[$key]=\array_merge($routes[$key], $ret);
47		} catch ( \Exception $e ) {
48		// Nothing to do
49		}
50		}
51		}
52	1	self::$cache->store("controllers/routes.default", "return " . UArray::asPhpArray($routes["default"], "array") . ";", 'controllers');
53	1	self::$cache->store("controllers/routes.rest", "return " . UArray::asPhpArray($routes["rest"], "array") . ";", 'controllers');
54	1	if (!$silent) {
55	1	echo "Router cache reset\n";
56		}
57	1	}
58
59		private static function storeRouteResponse($key, $response) {
60		self::setKeyExpired($key, false);
61		self::$cache->store("controllers/" . $key, $response, 'controllers', false);
62		return $response;
63		}
64
65		private static function getRouteKey($routePath) {
66		return "path" . \md5(\implode("", $routePath));
67		}
68
69		private static function setKeyExpired($key, $expired=true) {
70		if ($expired) {
71		self::$expiredRoutes[$key]=true;
72		} else {
73		unset(self::$expiredRoutes[$key]);
74		}
75		}
76
77		/**
78		* @param boolean $isRest
79		* @return array
80		*/
81	22	public static function getControllerCache($isRest=false) {
82	22	$key=($isRest) ? "rest" : "default";
83	22	if (self::$cache->exists("controllers/routes." . $key))
84	19	return self::$cache->fetch("controllers/routes." . $key);
85	4	return [ ];
86		}
87
88		public static function getRouteCache($routePath, $duration) {
89		$key=self::getRouteKey($routePath);
90
91		if (self::$cache->exists("controllers/" . $key) && !self::expired($key, $duration)) {
92		$response=self::$cache->file_get_contents("controllers/" . $key);
93		return $response;
94		} else {
95		$response=Startup::runAsString($routePath);
96		return self::storeRouteResponse($key, $response);
97		}
98		}
99
100		public static function expired($key, $duration) {
101		return self::$cache->expired("controllers/" . $key, $duration) === true \|\| \array_key_exists($key, self::$expiredRoutes);
102		}
103
104		public static function isExpired($path, $duration) {
105		$route=Router::getRoute($path, false);
106		if ($route !== false && \is_array($route)) {
107		return self::expired(self::getRouteKey($route), $duration);
108		}
109		return true;
110		}
111
112		public static function setExpired($routePath, $expired=true) {
113		$key=self::getRouteKey($routePath);
114		self::setKeyExpired($key, $expired);
115		}
116
117		public static function setRouteCache($routePath) {
118		$key=self::getRouteKey($routePath);
119		$response=Startup::runAsString($routePath);
120		return self::storeRouteResponse($key, $response);
121		}
122
123		public static function addAdminRoutes() {
124		self::addControllerCache("Ubiquity\controllers\Admin");
125		}
126
127	1	public static function getRoutes() {
128	1	$result=self::getControllerCache();
129	1	return $result;
130		}
131
132		public static function getControllerRoutes($controllerClass, $isRest=false) {
133		$result=[ ];
134		$ctrlCache=self::getControllerCache($isRest);
135		foreach ( $ctrlCache as $path => $routeAttributes ) {
136		if (isset($routeAttributes["controller"])) {
137		if ($routeAttributes["controller"] === $controllerClass) {
138		$result[$path]=$routeAttributes;
139		}
140		} else {
141		$firstValue=current($routeAttributes);
142		if (isset($firstValue) && isset($firstValue["controller"])) {
143		if ($firstValue["controller"] === $controllerClass) {
144		$result[$path]=$routeAttributes;
145		}
146		}
147		}
148		}
149		return $result;
150		}
151
152		public static function addRoute($path, $controller, $action="index", $methods=null, $name="") {
153		$controllerCache=self::getControllerCache();
154		Router::addRouteToRoutes($controllerCache, $path, $controller, $action, $methods, $name);
155		self::$cache->store("controllers/routes.default", "return " . UArray::asPhpArray($controllerCache, "array") . ";", 'controllers');
156		}
157
158		public static function addRoutes($pathArray, $controller, $action="index", $methods=null, $name="") {
159		self::addRoutes_($pathArray, $controller,$action,$methods,$name,false);
160		}
161
162		public static function addRestRoutes($pathArray, $controller, $action="index", $methods=null, $name="") {
163		self::addRoutes_($pathArray, $controller,$action,$methods,$name,true);
164		}
165
166		private static function addRoutes_($pathArray, $controller, $action="index", $methods=null, $name="",$isRest=false) {
167		$controllerCache=self::getControllerCache($isRest);
168		$postfix="default";
169		if($isRest){
170		$postfix="rest";
171		}
172		Router::addRoutesToRoutes($controllerCache, $pathArray, $controller, $action, $methods, $name);
173		if(self::$minify){
174		ControllerParser::minifyRoutes($controllerCache);
175		}
176		self::$cache->store("controllers/routes.".$postfix, "return " . UArray::asPhpArray($controllerCache, "array") . ";", 'controllers');
177		}
178
179	3	public static function getControllersFiles(&$config, $silent=false) {
180	3	return self::_getFiles($config, "controllers", $silent);
181		}
182
183		public static function getControllers($subClass="\\Ubiquity\\controllers\\Controller",$backslash=false,$includeSubclass=false) {
184		$result=[ ];
185		if($includeSubclass){
186		$result[]=$subClass;
187		}
188		$config=Startup::getConfig();
189		$files=self::getControllersFiles($config, true);
190		try {
191		$restCtrls=CacheManager::getRestCache();
192		} catch ( \Exception $e ) {
193		$restCtrls=[ ];
194		}
195		foreach ( $files as $file ) {
196		if (is_file($file)) {
197		$controllerClass=ClassUtils::getClassFullNameFromFile($file,$backslash);
198		if (isset($restCtrls[$controllerClass]) === false) {
199		$r=new \ReflectionClass($controllerClass);
200		if($r->isSubclassOf($subClass) && !$r->isAbstract()){
201		$result[]=$controllerClass;
202		}
203		}
204		}
205		}
206		return $result;
207		}
208		}
209

phpMv / ubiquity

Push — master ( 2c93a3...b8d7dd )

RouterCacheTrait::addControllerCache() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like