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

Completed

Push — master ( d4e951...14a860 )

by Jean-Christophe

created 2019-02-05 02:32 UTC

RouterCacheTrait::isExpired() A

↳ Parent: RouterCacheTrait

Complexity

Conditions	3
Paths	2

Size

Total Lines	6
Code Lines	4

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	12

Importance

Changes

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

phpMv / ubiquity

Push — master ( d4e951...14a860 )

RouterCacheTrait::isExpired() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like