Cache - Code Metrics - Inspection of "FIxed cache and performance improvements" - psfs/core - Measure and Improve Code Quality continuously with Scrutinizer

Test Failed

Push — master ( 0d14a6...e876c1 )

by Fran

created 2017-07-18 21:04 UTC

Cache B

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	223
Duplicated Lines	20.18 %

Coupling/Cohesion

Components	1
Dependencies	8

Test Coverage

Coverage

92.5%

Importance

Changes

Metric	Value
dl	45
loc	223
ccs	74
cts	80
cp	0.925
rs	8.2769
c	0
b	0
f	0
wmc	41
lcom	1
cbo	8

13 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	canUseMemcache()	0	4	3
A	saveTextToFile()	7	7	2
A	getDataFromFile()	0	10	3
A	hasExpiredCache()	0	7	2
B	extractDataWithFormat()	19	19	7
B	transformData()	19	19	6
A	storeData()	0	7	2
A	readFromCache()	0	14	4
A	checkAdminSite()	0	4	1
B	needCache()	0	14	6
A	getRequestCacheHash()	0	15	3
A	flushCache()	0	6	1

How to fix Duplicated Code Complexity

Duplicated Code

Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.

Common duplication problems, and corresponding solutions are:

If you have the same expression in different places: Extract expression to a method
If you have the same method in different sub-classes: Extract method, and pull up field to the parent class
If you have the same code in unrelated classes: Consider extracting the code to a new class, and injecting that class

Complex Class

Tip: Before tackling complexity, make sure that you eliminate any duplication first. This often can reduce the size of classes significantly.

Complex classes like Cache often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.

Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.

While breaking up the class, it is a good idea to analyze how other classes use Cache, and based on these observations, apply Extract Interface, too.

<?php
namespace PSFS\base;

use PSFS\base\config\Config;
use PSFS\base\exception\ConfigException;
use PSFS\base\types\helpers\GeneratorHelper;
use PSFS\base\types\helpers\FileHelper;
use PSFS\base\types\traits\SingletonTrait;

/**
 * Class Cache
 * @package PSFS\base
 * Gestión de los ficheros de cache
 */
class Cache
{
    /**
     * @var \Memcache
     */
    protected $memcache = null;

    const JSON = 1;
    const TEXT = 2;
    const GZIP = 3;
    const JSONGZ = 4;
    const MEMCACHE = 5;

    use SingletonTrait;

    public function __construct()
    {
        $this->setLoaded(true);
    }

    /**
     * @return bool
     */
    public static function canUseMemcache()
    {
        return Config::getParam('psfs.memcache', false) && !Config::getParam('debug') && class_exists('Memcached');
    }

    /**
     * Método que guarda un text en un fichero
     * @param string $data
     * @param string $path
     * @throws ConfigException
     */
    private function saveTextToFile($data, $path)
    {
        GeneratorHelper::createDir(dirname($path));
        if (false === FileHelper::writeFile($path, $data)) {
            throw new ConfigException(_('No se tienen los permisos suficientes para escribir en el fichero ') . $path);
        }
    }

    /**
     * Método que extrae el texto de un fichero
     * @param string $path
     * @param int $transform
     * @param boolean $absolute
     * @return mixed

     */
    public function getDataFromFile($path, $transform = Cache::TEXT, $absolute = false)
    {
        Logger::log('Gathering data from cache', LOG_DEBUG, ['path' => $path]);
        $data = null;
        $absolutePath = ($absolute) ? $path : CACHE_DIR . DIRECTORY_SEPARATOR . $path;
        if (file_exists($absolutePath)) {
            $data = FileHelper::readFile($absolutePath);
        }
        return Cache::extractDataWithFormat($data, $transform);
    }

    /**
     * Método que verifica si un fichero tiene la cache expirada
     * @param string $path
     * @param int $expires
     * @param boolean $absolute
     * @return bool
     */
    private function hasExpiredCache($path, $expires = 300, $absolute = false)
    {
        Logger::log('Checking expiration', LOG_DEBUG, ['path' => $path]);
        $absolutePath = ($absolute) ? $path : CACHE_DIR . DIRECTORY_SEPARATOR . $path;
        $lasModificationDate = filemtime($absolutePath);
        return ($lasModificationDate + $expires <= time());
    }

    /**
     * Método que transforma los datos de salida
     * @param string $data
     * @param int $transform
     * @return array|string|null
     */
    public static function extractDataWithFormat($data, $transform = Cache::TEXT)
    {
        Logger::log('Extracting data from cache', LOG_DEBUG);
        switch ($transform) {
            case Cache::JSON:
                $data = json_decode($data, true);
                break;
            case Cache::JSONGZ:
                $data = Cache::extractDataWithFormat($data, Cache::GZIP);
                $data = Cache::extractDataWithFormat($data, Cache::JSON);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
                break;
            case Cache::GZIP:
                if (function_exists('gzuncompress') && !empty($data)) {
                    $data = @gzuncompress($data ?: '');
                }
                break;
        }
        return $data;
    }

    /**
     * Método que transforma los datos de entrada del fichero
     * @param string $data
     * @param int $transform
     * @return string
     */
    public static function transformData($data, $transform = Cache::TEXT)
    {
        Logger::log('Transform data in cache', LOG_DEBUG);
        switch ($transform) {
            case Cache::JSON:
                $data = json_encode($data, JSON_PRETTY_PRINT);
                break;
            case Cache::JSONGZ:
                $data = Cache::transformData($data, Cache::JSON);
                $data = Cache::transformData($data, Cache::GZIP);
                break;
            case Cache::GZIP:
                if (function_exists('gzcompress')) {
                    $data = gzcompress($data ?: '');
                }
                break;
        }
        return $data;
    }

    /**
     * Método que guarda en fichero los datos pasados
     * @param $path
     * @param $data
     * @param int $transform
     * @param boolean $absolute
     * @param integer $expires
     */
    public function storeData($path, $data, $transform = Cache::TEXT, $absolute = false, $expires = 600)

    {
        Logger::log('Store data in cache', LOG_DEBUG, ['path' => $path]);
        $data = Cache::transformData($data, $transform);
        $absolutePath = ($absolute) ? $path : CACHE_DIR . DIRECTORY_SEPARATOR . $path;
        $this->saveTextToFile($data, $absolutePath);
    }

    /**
     * Método que verifica si tiene que leer o no un fichero de cache
     * @param string $path
     * @param int $expires
     * @param callable $function

     * @param int $transform
     * @return mixed
     */
    public function readFromCache($path, $expires = 300, $function = null, $transform = Cache::TEXT)
    {
        $data = null;
        Logger::log('Reading data from cache', LOG_DEBUG, ['path' => $path]);
        if (file_exists(CACHE_DIR . DIRECTORY_SEPARATOR . $path)) {
            if (is_callable($function) && $this->hasExpiredCache($path, $expires)) {
                $data = call_user_func($function);
                $this->storeData($path, $data, $transform, false, $expires);
            } else {
                $data = $this->getDataFromFile($path, $transform);
            }
        }
        return $data;
    }

    /**
     * @return bool
     */
    private static function checkAdminSite()
    {
        return Security::getInstance()->canAccessRestrictedAdmin();
    }

    /**
     * Método estático que revisa si se necesita cachear la respuesta de un servicio o no
     * @return integer|boolean
     */
    public static function needCache()
    {
        return true;
        $needCache = false;
        Logger::log('Checking cache requirements', LOG_DEBUG);
        if (!self::checkAdminSite() && !Config::getParam('debug')) {
            $action = Security::getInstance()->getSessionKey("__CACHE__");
            Logger::log('Gathering cache params from Session', LOG_DEBUG, $action);
            if (null !== $action && array_key_exists("cache", $action) && $action["cache"] > 0) {
                $needCache = $action["cache"];
            }
        }
        return $needCache;
    }

    /**
     * Método que construye un hash para almacenar la cache
     * @return array

     */
    public function getRequestCacheHash()
    {
        $hashPath = null;
        $filename = null;
        $action = Security::getInstance()->getSessionKey("__CACHE__");
        Logger::log('Gathering cache hash for request', LOG_DEBUG, $action);
        if (null !== $action && $action["cache"] > 0) {
            $query = $action['params'];
            $query['X-API-LANG'] = Request::header('X-API-LANG', 'es');
            $filename = FileHelper::generateHashFilename($action["http"], $action["slug"], $query);
            $hashPath = FileHelper::generateCachePath($action, $query);
            Logger::log('Cache file calculated', LOG_DEBUG, ['file' => $filename, 'hash' => $hashPath]);
        }
        return [$hashPath, $filename];
    }

    /**
     * Flush cache when save a registry
     */
    public function flushCache() {
        Logger::log('Flushing cache', LOG_DEBUG);
        $action = Security::getInstance()->getSessionKey("__CACHE__");
        $hashPath = FileHelper::generateCachePath($action, $action['params']) . '..' . DIRECTORY_SEPARATOR . ' .. ' . DIRECTORY_SEPARATOR . '..' . DIRECTORY_SEPARATOR;

        FileHelper::deleteDir($hashPath);
    }
}


1			<?php
2			namespace PSFS\base;
3
4			use PSFS\base\config\Config;
5			use PSFS\base\exception\ConfigException;
6			use PSFS\base\types\helpers\GeneratorHelper;
7			use PSFS\base\types\helpers\FileHelper;
8			use PSFS\base\types\traits\SingletonTrait;
9
10			/**
11			* Class Cache
12			* @package PSFS\base
13			* Gestión de los ficheros de cache
14			*/
15			class Cache
16			{
17			/**
18			* @var \Memcache
19			*/
20			protected $memcache = null;
21
22			const JSON = 1;
23			const TEXT = 2;
24			const GZIP = 3;
25			const JSONGZ = 4;
26			const MEMCACHE = 5;
27
28			use SingletonTrait;
29
30			public function __construct()
31			{
32			$this->setLoaded(true);
33	2		}
34
35	2		/**
36			* @return bool
37			*/
38			public static function canUseMemcache()
39			{
40			return Config::getParam('psfs.memcache', false) && !Config::getParam('debug') && class_exists('Memcached');
41			}
42
43			/**
44	4		* Método que guarda un text en un fichero
45			* @param string $data
46	4		* @param string $path
47	4		* @throws ConfigException
48			*/
49		View Code Duplication	private function saveTextToFile($data, $path)
50	4		{
51			GeneratorHelper::createDir(dirname($path));
52			if (false === FileHelper::writeFile($path, $data)) {
53			throw new ConfigException(_('No se tienen los permisos suficientes para escribir en el fichero ') . $path);
54			}
55			}
56
57			/**
58			* Método que extrae el texto de un fichero
59	6		* @param string $path
60			* @param int $transform
61	6		* @param boolean $absolute
62	6		* @return mixed
			0 ignored issues – show Documentation introduced 2016-11-07 20:44 UTC by Report Bug Copy Issue Report Consider making the return type a bit more specific; maybe use `array\|string\|null`. This check looks for the generic type `array` as a return type and suggests a more specific type. This type is inferred from the actual code. Loading history...
63	6		*/
64	4		public function getDataFromFile($path, $transform = Cache::TEXT, $absolute = false)
65			{
66	6		Logger::log('Gathering data from cache', LOG_DEBUG, ['path' => $path]);
67			$data = null;
68			$absolutePath = ($absolute) ? $path : CACHE_DIR . DIRECTORY_SEPARATOR . $path;
69			if (file_exists($absolutePath)) {
70			$data = FileHelper::readFile($absolutePath);
71			}
72			return Cache::extractDataWithFormat($data, $transform);
73			}
74
75			/**
76	1		* Método que verifica si un fichero tiene la cache expirada
77			* @param string $path
78	1		* @param int $expires
79	1		* @param boolean $absolute
80	1		* @return bool
81			*/
82			private function hasExpiredCache($path, $expires = 300, $absolute = false)
83			{
84			Logger::log('Checking expiration', LOG_DEBUG, ['path' => $path]);
85			$absolutePath = ($absolute) ? $path : CACHE_DIR . DIRECTORY_SEPARATOR . $path;
86			$lasModificationDate = filemtime($absolutePath);
87			return ($lasModificationDate + $expires <= time());
88			}
89	6
90			/**
91			* Método que transforma los datos de salida
92	6		* @param string $data
93	6		* @param int $transform
94	6		* @return array\|string\|null
95	4		*/
96	4	View Code Duplication	public static function extractDataWithFormat($data, $transform = Cache::TEXT)
97	4		{
98	4		Logger::log('Extracting data from cache', LOG_DEBUG);
99	4		switch ($transform) {
100	4		case Cache::JSON:
101	2		$data = json_decode($data, true);
102			break;
103	4		case Cache::JSONGZ:
104			$data = Cache::extractDataWithFormat($data, Cache::GZIP);
105	6		$data = Cache::extractDataWithFormat($data, Cache::JSON);
			0 ignored issues – show Bug introduced 2017-07-18 21:13 UTC by Report Bug Copy Issue Report It seems like `$data` defined by `\PSFS\base\Cache::extrac...\PSFS\base\Cache::JSON)` on line `105` can also be of type `array` or `null`; however, `PSFS\base\Cache::extractDataWithFormat()` does only seem to accept `string`, maybe add an additional type check? If a method or function can return multiple different values and unless you are sure that you only can receive a single value in this context, we recommend to add an additional type check: /** * @return array\|string */ function returnsDifferentValues($x) { if ($x) { return 'foo'; } return array(); } $x = returnsDifferentValues($y); if (is_array($x)) { // $x is an array. } If this a common case that PHP Analyzer should handle natively, please let us know by opening an issue. Loading history...
106			break;
107			case Cache::GZIP:
108			if (function_exists('gzuncompress') && !empty($data)) {
109			$data = @gzuncompress($data ?: '');
110			}
111			break;
112			}
113			return $data;
114	4		}
115
116			/**
117	4		* Método que transforma los datos de entrada del fichero
118	4		* @param string $data
119	4		* @param int $transform
120	3		* @return string
121	2		*/
122	2	View Code Duplication	public static function transformData($data, $transform = Cache::TEXT)
123	2		{
124	3		Logger::log('Transform data in cache', LOG_DEBUG);
125	2		switch ($transform) {
126	2		case Cache::JSON:
127			$data = json_encode($data, JSON_PRETTY_PRINT);
128	2		break;
129			case Cache::JSONGZ:
130	4		$data = Cache::transformData($data, Cache::JSON);
131			$data = Cache::transformData($data, Cache::GZIP);
132			break;
133			case Cache::GZIP:
134			if (function_exists('gzcompress')) {
135			$data = gzcompress($data ?: '');
136			}
137			break;
138			}
139			return $data;
140			}
141	4
142			/**
143	4		* Método que guarda en fichero los datos pasados
144	4		* @param $path
145	4		* @param $data
146	4		* @param int $transform
147			* @param boolean $absolute
148			* @param integer $expires
149			*/
150			public function storeData($path, $data, $transform = Cache::TEXT, $absolute = false, $expires = 600)
			0 ignored issues – show Unused Code introduced 2017-03-10 08:24 UTC by Report Bug Copy Issue Report The parameter `$expires` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history...
151			{
152			Logger::log('Store data in cache', LOG_DEBUG, ['path' => $path]);
153			$data = Cache::transformData($data, $transform);
154			$absolutePath = ($absolute) ? $path : CACHE_DIR . DIRECTORY_SEPARATOR . $path;
155			$this->saveTextToFile($data, $absolutePath);
156	1		}
157
158	1		/**
159	1		* Método que verifica si tiene que leer o no un fichero de cache
160	1		* @param string $path
161	1		* @param int $expires
162	1		* @param callable $function
			0 ignored issues – show Documentation introduced 2017-07-18 21:13 UTC by Report Bug Copy Issue Report Should the type for parameter `$function` not be `callable\|null`? Also, consider making the array more specific, something like `array<String>`, or `String[]`. This check looks for `@param` annotations where the type inferred by our type inference engine differs from the declared type. It makes a suggestion as to what type it considers more descriptive. In addition it looks for parameters that have the generic type `array` and suggests a stricter type like `array<String>`. Most often this is a case of a parameter that can be null in addition to its declared types. Loading history...
163			* @param int $transform
164	1		* @return mixed
165			*/
166			public function readFromCache($path, $expires = 300, $function = null, $transform = Cache::TEXT)
167	1		{
168			$data = null;
169			Logger::log('Reading data from cache', LOG_DEBUG, ['path' => $path]);
170			if (file_exists(CACHE_DIR . DIRECTORY_SEPARATOR . $path)) {
171			if (is_callable($function) && $this->hasExpiredCache($path, $expires)) {
172			$data = call_user_func($function);
173	1		$this->storeData($path, $data, $transform, false, $expires);
174			} else {
175	1		$data = $this->getDataFromFile($path, $transform);
176			}
177			}
178			return $data;
179			}
180
181			/**
182	1		* @return bool
183			*/
184	1		private static function checkAdminSite()
185	1		{
186	1		return Security::getInstance()->canAccessRestrictedAdmin();
187	1		}
188	1
189			/**
190			* Método estático que revisa si se necesita cachear la respuesta de un servicio o no
191	1		* @return integer\|boolean
192			*/
193			public static function needCache()
194			{
195			return true;
196			$needCache = false;
197			Logger::log('Checking cache requirements', LOG_DEBUG);
198	1		if (!self::checkAdminSite() && !Config::getParam('debug')) {
199			$action = Security::getInstance()->getSessionKey("__CACHE__");
200	1		Logger::log('Gathering cache params from Session', LOG_DEBUG, $action);
201	1		if (null !== $action && array_key_exists("cache", $action) && $action["cache"] > 0) {
202	1		$needCache = $action["cache"];
203	1		}
204	1		}
205	1		return $needCache;
206	1		}
207	1
208			/**
209	1		* Método que construye un hash para almacenar la cache
210			* @return array
			0 ignored issues – show Documentation introduced 2017-03-17 20:23 UTC by Report Bug Copy Issue Report Consider making the return type a bit more specific; maybe use `array<string\|null>`. This check looks for the generic type `array` as a return type and suggests a more specific type. This type is inferred from the actual code. Loading history...
211			*/
212			public function getRequestCacheHash()
213			{
214			$hashPath = null;
215			$filename = null;
216			$action = Security::getInstance()->getSessionKey("__CACHE__");
217			Logger::log('Gathering cache hash for request', LOG_DEBUG, $action);
218			if (null !== $action && $action["cache"] > 0) {
219			$query = $action['params'];
220			$query['X-API-LANG'] = Request::header('X-API-LANG', 'es');
221			$filename = FileHelper::generateHashFilename($action["http"], $action["slug"], $query);
222			$hashPath = FileHelper::generateCachePath($action, $query);
223			Logger::log('Cache file calculated', LOG_DEBUG, ['file' => $filename, 'hash' => $hashPath]);
224			}
225			return [$hashPath, $filename];
226			}
227
228			/**
229			* Flush cache when save a registry
230			*/
231			public function flushCache() {
232			Logger::log('Flushing cache', LOG_DEBUG);
233			$action = Security::getInstance()->getSessionKey("__CACHE__");
234			$hashPath = FileHelper::generateCachePath($action, $action['params']) . '..' . DIRECTORY_SEPARATOR . ' .. ' . DIRECTORY_SEPARATOR . '..' . DIRECTORY_SEPARATOR;
			0 ignored issues – show Coding Style introduced 2017-07-18 21:13 UTC by Report Bug Copy Issue Report This line exceeds maximum limit of 120 characters; contains 167 characters Overly long lines are hard to read on any screen. Most code styles therefor impose a maximum limit on the number of characters in a line. Loading history...
235			FileHelper::deleteDir($hashPath);
236			}
237			}
238

psfs / core