Cache::getRequestCacheHash() - Code Metrics - Inspection of "Changes in monolog" - psfs/core - Measure and Improve Code Quality continuously with Scrutinizer

Test Failed

Push — master ( 21e806...ed25dd )

by Fran

created 2018-09-14 00:48 UTC

Cache::getRequestCacheHash() A

↳ Parent: Cache

Complexity

Conditions	3
Paths	2

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	5
CRAP Score	4.7861

Importance

Changes

Metric	Value
cc	3
nc	2
nop	0
dl	0
loc	15
ccs	5
cts	12
cp	0.4167
crap	4.7861
rs	9.7666
c	0
b	0
f	0

<?php
namespace PSFS\base;

use PSFS\base\config\Config;
use PSFS\base\exception\ConfigException;
use PSFS\base\exception\GeneratorException;
use PSFS\base\types\Api;
use PSFS\base\types\helpers\FileHelper;
use PSFS\base\types\helpers\GeneratorHelper;
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;

    const CACHE_SESSION_VAR = '__CACHE__';

    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');
    }

    /**
     * @param string $data
     * @param string $path
     * @throws GeneratorException
     * @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);
        }
    }

    /**
     * @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 self::extractDataWithFormat($data, $transform);
    }

    /**
     * @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());
    }

    /**
     * @param string $data

     * @param int $transform
     * @return mixed
     */
    public static function extractDataWithFormat($data = null, $transform = Cache::TEXT)
    {
        Logger::log('Extracting data from cache');
        switch ($transform) {
            case self::JSON:
                $data = json_decode($data, true);
                break;
            case self::JSONGZ:
                $data = self::extractDataWithFormat($data, self::GZIP);
                $data = self::extractDataWithFormat($data, self::JSON);
                break;
            case self::GZIP:
                if (null !== $data && function_exists('gzuncompress')) {
                    $data = @gzuncompress($data ?: '');
                }
                break;
        }
        return $data;
    }

    /**
     * @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 self::JSON:
                $data = json_encode($data, JSON_PRETTY_PRINT);
                break;
            case self::JSONGZ:
                $data = self::transformData($data, self::JSON);
                $data = self::transformData($data, self::GZIP);
                break;
            case self::GZIP:
                if (function_exists('gzcompress')) {
                    $data = gzcompress($data ?: '');
                }
                break;
        }
        return $data;
    }

    /**
     * @param string $path
     * @param mixed $data
     * @param int $transform
     * @param bool $absolute
     * @throws GeneratorException
     * @throws ConfigException
     */
    public function storeData($path, $data, $transform = Cache::TEXT, $absolute = false)
    {
        Logger::log('Store data in cache', LOG_DEBUG, ['path' => $path]);
        $data = self::transformData($data, $transform);
        $absolutePath = $absolute ? $path : CACHE_DIR . DIRECTORY_SEPARATOR . $path;
        $this->saveTextToFile($data, $absolutePath);
    }

    /**
     * @param string $path
     * @param int $expires
     * @param null $function
     * @param int $transform
     * @return mixed|null
     * @throws GeneratorException
     * @throws ConfigException
     */
    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 = $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();
    }

    /**
     * @return integer|boolean
     */
    public static function needCache()
    {
        $needCache = false;
        Logger::log('Checking cache requirements');
        if (!self::checkAdminSite() && !Config::getParam('debug') && Config::getParam('cache.data.enable', false)) {
            $action = Security::getInstance()->getSessionKey(self::CACHE_SESSION_VAR);
            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;
    }

    /**
     * @return array

     */
    public function getRequestCacheHash()
    {
        $hashPath = null;
        $filename = null;
        $action = Security::getInstance()->getSessionKey(self::CACHE_SESSION_VAR);
        Logger::log('Gathering cache hash for request', LOG_DEBUG, $action);
        if (null !== $action && $action['cache'] > 0) {
            $query = $action['params'];
            $query[Api::HEADER_API_LANG] = Request::header(Api::HEADER_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];
    }

    public function flushCache() {
        if(Config::getParam('cache.data.enable', false)) {
            Logger::log('Flushing cache', LOG_DEBUG);
            $action = Security::getInstance()->getSessionKey(self::CACHE_SESSION_VAR);
            if(is_array($action)) {
                $hashPath = FileHelper::generateCachePath($action, $action['params']) . '..' . DIRECTORY_SEPARATOR . ' .. ' . DIRECTORY_SEPARATOR . '..' . DIRECTORY_SEPARATOR;
                if(!file_exists($hashPath)) {
                    $hashPath = CACHE_DIR . DIRECTORY_SEPARATOR . $hashPath;
                }
                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\exception\GeneratorException;
7			use PSFS\base\types\Api;
8			use PSFS\base\types\helpers\FileHelper;
9			use PSFS\base\types\helpers\GeneratorHelper;
10			use PSFS\base\types\traits\SingletonTrait;
11
12			/**
13			* Class Cache
14			* @package PSFS\base
15			* Gestión de los ficheros de cache
16			*/
17			class Cache
18			{
19			/**
20			* @var \Memcache
21			*/
22			protected $memcache = null;
23
24			const JSON = 1;
25			const TEXT = 2;
26			const GZIP = 3;
27			const JSONGZ = 4;
28			const MEMCACHE = 5;
29
30			const CACHE_SESSION_VAR = '__CACHE__';
31
32			use SingletonTrait;
33
34	2		public function __construct()
35			{
36	2		$this->setLoaded(true);
37	2		}
38
39			/**
40			* @return bool
41			*/
42			public static function canUseMemcache()
43			{
44			return Config::getParam('psfs.memcache', false) && !Config::getParam('debug') && class_exists('Memcached');
45			}
46
47			/**
48			* @param string $data
49			* @param string $path
50			* @throws GeneratorException
51			* @throws ConfigException
52			*/
53		View Code Duplication	private function saveTextToFile($data, $path)
54			{
55			GeneratorHelper::createDir(dirname($path));
56			if (false === FileHelper::writeFile($path, $data)) {
57			throw new ConfigException(_('No se tienen los permisos suficientes para escribir en el fichero ') . $path);
58			}
59			}
60
61			/**
62			* @param string $path
63			* @param int $transform
64			* @param boolean $absolute
65			* @return mixed
66			*/
67	6		public function getDataFromFile($path, $transform = Cache::TEXT, $absolute = false)
68			{
69	6		Logger::log('Gathering data from cache', LOG_DEBUG, ['path' => $path]);
70			$data = null;
71			$absolutePath = $absolute ? $path : CACHE_DIR . DIRECTORY_SEPARATOR . $path;
72			if (file_exists($absolutePath)) {
73			$data = FileHelper::readFile($absolutePath);
74			}
75			return self::extractDataWithFormat($data, $transform);
76			}
77
78			/**
79			* @param string $path
80			* @param int $expires
81			* @param boolean $absolute
82			* @return bool
83			*/
84			private function hasExpiredCache($path, $expires = 300, $absolute = false)
85			{
86			Logger::log('Checking expiration', LOG_DEBUG, ['path' => $path]);
87			$absolutePath = ($absolute) ? $path : CACHE_DIR . DIRECTORY_SEPARATOR . $path;
88			$lasModificationDate = filemtime($absolutePath);
89			return ($lasModificationDate + $expires <= time());
90			}
91
92			/**
93			* @param string $data
			0 ignored issues – show Documentation introduced 2017-12-11 22:07 UTC by Report Bug Copy Issue Report Should the type for parameter `$data` not be `string\|null`? 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. Most often this is a case of a parameter that can be null in addition to its declared types. Loading history...
94			* @param int $transform
95			* @return mixed
96			*/
97		View Code Duplication	public static function extractDataWithFormat($data = null, $transform = Cache::TEXT)
98			{
99			Logger::log('Extracting data from cache');
100			switch ($transform) {
101			case self::JSON:
102			$data = json_decode($data, true);
103			break;
104			case self::JSONGZ:
105			$data = self::extractDataWithFormat($data, self::GZIP);
106			$data = self::extractDataWithFormat($data, self::JSON);
107			break;
108			case self::GZIP:
109			if (null !== $data && function_exists('gzuncompress')) {
110			$data = @gzuncompress($data ?: '');
111			}
112			break;
113			}
114			return $data;
115			}
116
117			/**
118			* @param string $data
119			* @param int $transform
120			* @return string
121			*/
122		View Code Duplication	public static function transformData($data, $transform = Cache::TEXT)
123			{
124			Logger::log('Transform data in cache', LOG_DEBUG);
125			switch ($transform) {
126			case self::JSON:
127			$data = json_encode($data, JSON_PRETTY_PRINT);
128			break;
129			case self::JSONGZ:
130			$data = self::transformData($data, self::JSON);
131			$data = self::transformData($data, self::GZIP);
132			break;
133			case self::GZIP:
134			if (function_exists('gzcompress')) {
135			$data = gzcompress($data ?: '');
136			}
137			break;
138			}
139			return $data;
140			}
141
142			/**
143			* @param string $path
144			* @param mixed $data
145			* @param int $transform
146			* @param bool $absolute
147			* @throws GeneratorException
148			* @throws ConfigException
149			*/
150	2		public function storeData($path, $data, $transform = Cache::TEXT, $absolute = false)
151			{
152	2		Logger::log('Store data in cache', LOG_DEBUG, ['path' => $path]);
153			$data = self::transformData($data, $transform);
154			$absolutePath = $absolute ? $path : CACHE_DIR . DIRECTORY_SEPARATOR . $path;
155			$this->saveTextToFile($data, $absolutePath);
156			}
157
158			/**
159			* @param string $path
160			* @param int $expires
161			* @param null $function
162			* @param int $transform
163			* @return mixed\|null
164			* @throws GeneratorException
165			* @throws ConfigException
166			*/
167			public function readFromCache($path, $expires = 300, $function = null, $transform = Cache::TEXT)
168			{
169			$data = null;
170			Logger::log('Reading data from cache', LOG_DEBUG, ['path' => $path]);
171			if (file_exists(CACHE_DIR . DIRECTORY_SEPARATOR . $path)) {
172			if (is_callable($function) && $this->hasExpiredCache($path, $expires)) {
173			$data = $function();
174			$this->storeData($path, $data, $transform, false, $expires);
			0 ignored issues – show Unused Code introduced 2017-12-11 22:07 UTC by Report Bug Copy Issue Report The call to `Cache::storeData()` has too many arguments starting with `$expires`. This check compares calls to functions or methods with their respective definitions. If the call has more arguments than are defined, it raises an issue. If a function is defined several times with a different number of parameters, the check may pick up the wrong definition and report false positives. One codebase where this has been known to happen is Wordpress. In this case you can add the `@ignore` PhpDoc annotation to the duplicate definition and it will be ignored. Loading history...
175			} else {
176			$data = $this->getDataFromFile($path, $transform);
177			}
178			}
179			return $data;
180			}
181
182			/**
183			* @return bool
184			*/
185			private static function checkAdminSite()
186			{
187			return Security::getInstance()->canAccessRestrictedAdmin();
188			}
189
190			/**
191			* @return integer\|boolean
192			*/
193			public static function needCache()
194			{
195			$needCache = false;
196			Logger::log('Checking cache requirements');
197			if (!self::checkAdminSite() && !Config::getParam('debug') && Config::getParam('cache.data.enable', false)) {
198			$action = Security::getInstance()->getSessionKey(self::CACHE_SESSION_VAR);
199			Logger::log('Gathering cache params from Session', LOG_DEBUG, $action);
200			if (null !== $action && array_key_exists('cache', $action) && $action['cache'] > 0) {
201			$needCache = $action['cache'];
202			}
203			}
204			return $needCache;
205			}
206
207			/**
208			* @return array
			0 ignored issues – show Documentation introduced 2017-12-11 22:07 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...
209			*/
210	2		public function getRequestCacheHash()
211			{
212	2		$hashPath = null;
213	2		$filename = null;
214	2		$action = Security::getInstance()->getSessionKey(self::CACHE_SESSION_VAR);
215	2		Logger::log('Gathering cache hash for request', LOG_DEBUG, $action);
216			if (null !== $action && $action['cache'] > 0) {
217			$query = $action['params'];
218			$query[Api::HEADER_API_LANG] = Request::header(Api::HEADER_API_LANG, 'es');
219			$filename = FileHelper::generateHashFilename($action['http'], $action['slug'], $query);
220			$hashPath = FileHelper::generateCachePath($action, $query);
221			Logger::log('Cache file calculated', LOG_DEBUG, ['file' => $filename, 'hash' => $hashPath]);
222			}
223			return [$hashPath, $filename];
224			}
225
226			public function flushCache() {
227			if(Config::getParam('cache.data.enable', false)) {
228			Logger::log('Flushing cache', LOG_DEBUG);
229			$action = Security::getInstance()->getSessionKey(self::CACHE_SESSION_VAR);
230			if(is_array($action)) {
231			$hashPath = FileHelper::generateCachePath($action, $action['params']) . '..' . DIRECTORY_SEPARATOR . ' .. ' . DIRECTORY_SEPARATOR . '..' . DIRECTORY_SEPARATOR;
232			if(!file_exists($hashPath)) {
233			$hashPath = CACHE_DIR . DIRECTORY_SEPARATOR . $hashPath;
234			}
235			FileHelper::deleteDir($hashPath);
236			}
237			}
238			}
239			}
240

psfs / core

Push — master ( 21e806...ed25dd )

Cache::getRequestCacheHash() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like