CacheManager::getRouteCache() - Code Metrics - Inspection of "path cache duration" - phpMv/ubiquity - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 53c194...170cd7 )

by Jean-Christophe

created 2017-04-21 01:26 UTC

CacheManager::getRouteCache() A

↳ Parent: CacheManager

Complexity

Conditions	2
Paths	2

Size

Total Lines	9
Code Lines	7

Duplication

Lines	0
Ratio	0 %

Importance

Changes

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

<?php
namespace micro\cache;
use mindplay\annotations\Annotations;
use mindplay\annotations\AnnotationCache;
use mindplay\annotations\AnnotationManager;
use micro\orm\parser\ModelParser;
use micro\utils\JArray;
use micro\controllers\Router;
use micro\controllers\Startup;

class CacheManager {
	public static $cache;
	private static $routes=[];
	private static $cacheDirectory;

	public static function start(&$config){
		self::$cacheDirectory=self::initialGetCacheDirectory($config);
		$cacheDirectory=ROOT.DS.self::$cacheDirectory;
		Annotations::$config['cache'] = new AnnotationCache($cacheDirectory.'/annotations');
		self::register(Annotations::getManager());
		self::$cache=new ArrayCache($cacheDirectory,".cache");
	}

	public static function startProd(&$config){
		self::$cacheDirectory=self::initialGetCacheDirectory($config);
		$cacheDirectory=ROOT.DS.self::$cacheDirectory;
		self::$cache=new ArrayCache($cacheDirectory,".cache");
	}

	public static function getControllerCache(){
		if(self::$cache->exists("controllers/routes"))
			return self::$cache->fetch("controllers/routes");
		return [];
	}

	public static function getRouteCache($routePath){
		$key=self::getRouteKey($routePath);
		if(self::$cache->exists("controllers/".$key))
			return self::$cache->fetch("controllers/".$key);
		else{
			$response=Startup::runAsString($routePath);
			return self::storeRouteResponse($key, $response);
		}
	}

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

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

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

	private static function initialGetCacheDirectory(&$config){
		$cacheDirectory=@$config["cacheDirectory"];
		if(!isset($cacheDirectory)){
			$config["cacheDirectory"]="cache/";
			$cacheDirectory=$config["cacheDirectory"];
		}
		return $cacheDirectory;
	}

	public static function getCacheDirectory(){
		return self::$cacheDirectory;
	}

	public static function createOrmModelCache($className){
		$key=\str_replace("\\", DIRECTORY_SEPARATOR, $className);
		if(!self::$cache->exists($key)){
			$p=new ModelParser();
			$p->parse($className);
			self::$cache->store($key, $p->__toString());
		}
		return self::$cache->fetch($key);
	}

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

	public static function checkCache(&$config){
		$cacheDirectory=self::initialGetCacheDirectory($config);
		$modelsDir=str_replace("\\", DS, $config["mvcNS"]["models"]);
		$controllersDir=str_replace("\\", DS, $config["mvcNS"]["controllers"]);
		echo "cache directory is ".ROOT.DS.$cacheDirectory."\n";
		$annotationCacheDir=ROOT.DS.$cacheDirectory.DS."annotations";
		$modelsCacheDir=ROOT.DS.$cacheDirectory.DS.$modelsDir;
		$queriesCacheDir=ROOT.DS.$cacheDirectory.DS."queries";
		$controllersCacheDir=ROOT.DS.$cacheDirectory.DS.$controllersDir;
		self::safeMkdir($annotationCacheDir);
		self::safeMkdir($modelsCacheDir);
		self::safeMkdir($controllersCacheDir);
		self::safeMkdir($queriesCacheDir);
		return ["annotations"=>$annotationCacheDir,"models"=>$modelsCacheDir,"controllers"=>$controllersCacheDir,"queries"=>$queriesCacheDir];
	}

	private static function safeMkdir($dir){
		if(!is_dir($dir))
			return mkdir($dir,0777,true);
	}

	private static function deleteAllFilesFromFolder($folder){
		$files = glob($folder.'/*');
		foreach($files as $file){
			if(is_file($file))
				unlink($file);
		}
	}
	public static function clearCache(&$config,$type="all"){
		$cacheDirectories=self::checkCache($config);
		if($type==="all"){
			self::deleteAllFilesFromFolder($cacheDirectories["annotations"]);
		}
		if($type==="all" || $type==="controllers")
			self::deleteAllFilesFromFolder($cacheDirectories["controllers"]);
		if($type==="all" || $type==="models")
			self::deleteAllFilesFromFolder($cacheDirectories["models"]);
		if($type==="all" || $type==="queries")
			self::deleteAllFilesFromFolder($cacheDirectories["queries"]);
	}

	public static function initCache(&$config,$type="all"){
		self::checkCache($config);
		self::start($config);
		if($type==="all" || $type==="models")
			self::initModelsCache($config);
		if($type==="all" || $type==="controllers")
			self::initControllersCache($config);
	}

	private static function initModelsCache(&$config){
		$modelsNS=$config["mvcNS"]["models"];
		$modelsDir=ROOT.DS.str_replace("\\", DS, $modelsNS);
		echo "Models directory is ".ROOT.$modelsNS."\n";
		$files = glob($modelsDir.DS.'*');
		$namespace="";
		if(isset($modelsNS) && $modelsNS!=="")
			$namespace=$modelsNS."\\";
		foreach($files as $file){
			if(is_file($file)){
				$model=self::getClassNameFromFile($file,$namespace);
				new $model();
			}
		}
	}

	private static function getClassNameFromFile($file,$namespace=""){
		$fileName=pathinfo($file, PATHINFO_FILENAME);
		return $namespace.ucfirst($fileName);
	}

	private static function initControllersCache(&$config){
		$controllersNS=$config["mvcNS"]["controllers"];
		$controllersDir=ROOT.DS.str_replace("\\", DS, $controllersNS);
		echo "Controllers directory is ".ROOT.$controllersNS."\n";
		$files = glob($controllersDir.DS.'*');
		$namespace="";
		if(isset($controllersNS) && $controllersNS!=="")
			$namespace=$controllersNS."\\";
		foreach($files as $file){
			if(is_file($file)){
				$controller=self::getClassNameFromFile($file,$namespace);
				self::addControllerCache($controller);
			}
		}
		if($config["debug"])
			self::addAdminRoutes();
		self::$cache->store("controllers/routes", "return ".JArray::asPhpArray(self::$routes,"array").";");
	}

	private static function register(AnnotationManager $annotationManager){
		$annotationManager->registry=array_merge($annotationManager->registry,[
				'id' => 'micro\annotations\IdAnnotation',
				'manyToOne' => 'micro\annotations\ManyToOneAnnotation',
				'oneToMany' => 'micro\annotations\OneToManyAnnotation',
				'manyToMany' => 'micro\annotations\ManyToManyAnnotation',
				'joinColumn' => 'micro\annotations\JoinColumnAnnotation',
				'table' => 'micro\annotations\TableAnnotation',
				'transient' => 'micro\annotations\TransientAnnotation',
				'column' => 'micro\annotations\ColumnAnnotation',
				'joinTable' => 'micro\annotations\JoinTableAnnotation',
				'route' => 'micro\annotations\router\RouteAnnotation'
		]);
	}

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

	public static function getRoutes(){
		$result=self::getControllerCache();
		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","return ".JArray::asPhpArray($controllerCache,"array").";");
	}
}


1			<?php
2			namespace micro\cache;
3			use mindplay\annotations\Annotations;
4			use mindplay\annotations\AnnotationCache;
5			use mindplay\annotations\AnnotationManager;
6			use micro\orm\parser\ModelParser;
7			use micro\utils\JArray;
8			use micro\controllers\Router;
9			use micro\controllers\Startup;
10
11			class CacheManager {
12			public static $cache;
13			private static $routes=[];
14			private static $cacheDirectory;
15
16			public static function start(&$config){
17			self::$cacheDirectory=self::initialGetCacheDirectory($config);
18			$cacheDirectory=ROOT.DS.self::$cacheDirectory;
19			Annotations::$config['cache'] = new AnnotationCache($cacheDirectory.'/annotations');
20			self::register(Annotations::getManager());
21			self::$cache=new ArrayCache($cacheDirectory,".cache");
22			}
23
24			public static function startProd(&$config){
25			self::$cacheDirectory=self::initialGetCacheDirectory($config);
26			$cacheDirectory=ROOT.DS.self::$cacheDirectory;
27			self::$cache=new ArrayCache($cacheDirectory,".cache");
28			}
29
30			public static function getControllerCache(){
31			if(self::$cache->exists("controllers/routes"))
32			return self::$cache->fetch("controllers/routes");
33			return [];
34			}
35
36			public static function getRouteCache($routePath){
37			$key=self::getRouteKey($routePath);
38			if(self::$cache->exists("controllers/".$key))
39			return self::$cache->fetch("controllers/".$key);
40			else{
41			$response=Startup::runAsString($routePath);
42			return self::storeRouteResponse($key, $response);
43			}
44			}
45
46			public static function setRouteCache($routePath){
47			$key=self::getRouteKey($routePath);
48			$response=Startup::runAsString($routePath);
49			return self::storeRouteResponse($key, $response);
50			}
51
52			private static function storeRouteResponse($key,$response){
53			self::$cache->store("controllers/".$key, $response);
54			return $response;
55			}
56
57			private static function getRouteKey($routePath){
58			return \md5(\implode("", $routePath));
59			}
60
61			private static function initialGetCacheDirectory(&$config){
62			$cacheDirectory=@$config["cacheDirectory"];
63			if(!isset($cacheDirectory)){
64			$config["cacheDirectory"]="cache/";
65			$cacheDirectory=$config["cacheDirectory"];
66			}
67			return $cacheDirectory;
68			}
69
70			public static function getCacheDirectory(){
71			return self::$cacheDirectory;
72			}
73
74			public static function createOrmModelCache($className){
75			$key=\str_replace("\\", DIRECTORY_SEPARATOR, $className);
76			if(!self::$cache->exists($key)){
77			$p=new ModelParser();
78			$p->parse($className);
79			self::$cache->store($key, $p->__toString());
80			}
81			return self::$cache->fetch($key);
82			}
83
84			private static function addControllerCache($classname){
85			$parser=new ControllerParser();
86			try {
87			$parser->parse($classname);
88			self::$routes=\array_merge($parser->asArray(),self::$routes);
89			} catch (\Exception $e) {
90			//Nothing to do
91			}
92			}
93
94			public static function checkCache(&$config){
95			$cacheDirectory=self::initialGetCacheDirectory($config);
96			$modelsDir=str_replace("\\", DS, $config["mvcNS"]["models"]);
97			$controllersDir=str_replace("\\", DS, $config["mvcNS"]["controllers"]);
98			echo "cache directory is ".ROOT.DS.$cacheDirectory."\n";
99			$annotationCacheDir=ROOT.DS.$cacheDirectory.DS."annotations";
100			$modelsCacheDir=ROOT.DS.$cacheDirectory.DS.$modelsDir;
101			$queriesCacheDir=ROOT.DS.$cacheDirectory.DS."queries";
102			$controllersCacheDir=ROOT.DS.$cacheDirectory.DS.$controllersDir;
103			self::safeMkdir($annotationCacheDir);
104			self::safeMkdir($modelsCacheDir);
105			self::safeMkdir($controllersCacheDir);
106			self::safeMkdir($queriesCacheDir);
107			return ["annotations"=>$annotationCacheDir,"models"=>$modelsCacheDir,"controllers"=>$controllersCacheDir,"queries"=>$queriesCacheDir];
108			}
109
110			private static function safeMkdir($dir){
111			if(!is_dir($dir))
112			return mkdir($dir,0777,true);
113			}
114
115			private static function deleteAllFilesFromFolder($folder){
116			$files = glob($folder.'/*');
117			foreach($files as $file){
118			if(is_file($file))
119			unlink($file);
120			}
121			}
122			public static function clearCache(&$config,$type="all"){
123			$cacheDirectories=self::checkCache($config);
124			if($type==="all"){
125			self::deleteAllFilesFromFolder($cacheDirectories["annotations"]);
126			}
127			if($type==="all" \|\| $type==="controllers")
128			self::deleteAllFilesFromFolder($cacheDirectories["controllers"]);
129			if($type==="all" \|\| $type==="models")
130			self::deleteAllFilesFromFolder($cacheDirectories["models"]);
131			if($type==="all" \|\| $type==="queries")
132			self::deleteAllFilesFromFolder($cacheDirectories["queries"]);
133			}
134
135			public static function initCache(&$config,$type="all"){
136			self::checkCache($config);
137			self::start($config);
138			if($type==="all" \|\| $type==="models")
139			self::initModelsCache($config);
140			if($type==="all" \|\| $type==="controllers")
141			self::initControllersCache($config);
142			}
143
144			private static function initModelsCache(&$config){
145			$modelsNS=$config["mvcNS"]["models"];
146			$modelsDir=ROOT.DS.str_replace("\\", DS, $modelsNS);
147			echo "Models directory is ".ROOT.$modelsNS."\n";
148			$files = glob($modelsDir.DS.'*');
149			$namespace="";
150			if(isset($modelsNS) && $modelsNS!=="")
151			$namespace=$modelsNS."\\";
152			foreach($files as $file){
153			if(is_file($file)){
154			$model=self::getClassNameFromFile($file,$namespace);
155			new $model();
156			}
157			}
158			}
159
160			private static function getClassNameFromFile($file,$namespace=""){
161			$fileName=pathinfo($file, PATHINFO_FILENAME);
162			return $namespace.ucfirst($fileName);
163			}
164
165			private static function initControllersCache(&$config){
166			$controllersNS=$config["mvcNS"]["controllers"];
167			$controllersDir=ROOT.DS.str_replace("\\", DS, $controllersNS);
168			echo "Controllers directory is ".ROOT.$controllersNS."\n";
169			$files = glob($controllersDir.DS.'*');
170			$namespace="";
171			if(isset($controllersNS) && $controllersNS!=="")
172			$namespace=$controllersNS."\\";
173			foreach($files as $file){
174			if(is_file($file)){
175			$controller=self::getClassNameFromFile($file,$namespace);
176			self::addControllerCache($controller);
177			}
178			}
179			if($config["debug"])
180			self::addAdminRoutes();
181			self::$cache->store("controllers/routes", "return ".JArray::asPhpArray(self::$routes,"array").";");
182			}
183
184			private static function register(AnnotationManager $annotationManager){
185			$annotationManager->registry=array_merge($annotationManager->registry,[
186			'id' => 'micro\annotations\IdAnnotation',
187			'manyToOne' => 'micro\annotations\ManyToOneAnnotation',
188			'oneToMany' => 'micro\annotations\OneToManyAnnotation',
189			'manyToMany' => 'micro\annotations\ManyToManyAnnotation',
190			'joinColumn' => 'micro\annotations\JoinColumnAnnotation',
191			'table' => 'micro\annotations\TableAnnotation',
192			'transient' => 'micro\annotations\TransientAnnotation',
193			'column' => 'micro\annotations\ColumnAnnotation',
194			'joinTable' => 'micro\annotations\JoinTableAnnotation',
195			'route' => 'micro\annotations\router\RouteAnnotation'
196			]);
197			}
198
199			public static function addAdminRoutes(){
200			self::addControllerCache("micro\controllers\Admin");
201			}
202
203			public static function getRoutes(){
204			$result=self::getControllerCache();
205			return $result;
206			}
207
208			public static function addRoute($path,$controller,$action="index",$methods=null,$name=""){
209			$controllerCache=self::getControllerCache();
210			Router::addRouteToRoutes($controllerCache, $path, $controller,$action,$methods,$name);
211			self::$cache->store("controllers/routes","return ".JArray::asPhpArray($controllerCache,"array").";");
212			}
213			}
214

phpMv / ubiquity

Push — master ( 53c194...170cd7 )

CacheManager::getRouteCache() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like