CachedEntityConfigLookUp::fetchFromCache() - Code Metrics - PeekAndPoke/slumber - Measure and Improve Code Quality continuously with Scrutinizer

CachedEntityConfigLookUp::fetchFromCache() A
last analyzed 2018-08-20 20:36 UTC

↳ Parent: CachedEntityConfigLookUp

Complexity

Conditions	4
Paths	3

Size

Total Lines	12
Code Lines	5

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	6
CRAP Score	4

Importance

Changes

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

<?php
/**
 * File was created 06.10.2015 06:25
 */

namespace PeekAndPoke\Component\Slumber\Core\LookUp;

use Doctrine\Common\Cache\Cache;

/**
 * @author Karsten J. Gerber <[email protected]>
 */
class CachedEntityConfigLookUp implements EntityConfigReader
{
    /** @var EntityConfigReader */
    private $delegate;
    /** @var Cache */
    private $cache;
    /** @var string */
    private $prefix;
    /** @var bool */
    private $debug;

    /**
     * We have another level of caching here
     *
     * @var array
     */
    private $known = [];

    /**
     * @param EntityConfigReader $delegate
     * @param Cache              $cache
     * @param string             $prefix
     * @param bool               $debug
     */
    public function __construct(EntityConfigReader $delegate, Cache $cache, $prefix = '[Slumber]@', $debug = false)
    {
        $this->delegate = $delegate;
        $this->cache    = $cache;
        $this->prefix   = $prefix;
        $this->debug    = $debug;
    }

    /**
     * @param \ReflectionClass $cls
     *
     * @return PropertyMarkedForSlumber[]
     */
    public function getEntityConfig(\ReflectionClass $cls)
    {
        $cacheKey = $this->prefix . $cls->name;

        return $this->loadOrCreate(

            $cacheKey,
            function () use ($cacheKey, $cls) {
                return $this->fetchFromCache($cacheKey, $cls);
            },
            function () use ($cls) {
                return $this->delegate->getEntityConfig($cls);
            },
            $cls
        );
    }

    /**
     * @param string           $cacheKey
     * @param \Closure         $fetcher
     * @param \Closure         $creator
     * @param \ReflectionClass $class
     *
     * @return mixed
     */
    private function loadOrCreate($cacheKey, \Closure $fetcher, \Closure $creator, \ReflectionClass $class)
    {
        if (isset($this->known[$cacheKey])) {
            return $this->known[$cacheKey];
        }

        /** @var EntityConfig $cacheData */
        $cacheData = $fetcher();

        if (false === $cacheData) {

            $cacheData = $creator();
            $this->saveToCache($cacheKey, $cacheData, $class);
        }

        return $this->known[$cacheKey] = $cacheData;
    }

    /**
     * Fetches a value from the cache.
     *
     * @param string           $rawCacheKey The cache key.
     * @param \ReflectionClass $class       The related class.
     *
     * @return mixed The cached value or false when the value is not in cache.
     */
    private function fetchFromCache($rawCacheKey, \ReflectionClass $class)
    {
        $cacheKey = $this->prefix . $rawCacheKey;

        if (($data = $this->cache->fetch($cacheKey)) !== false) {
            /** @noinspection NestedPositiveIfStatementsInspection */
            if (! $this->debug || $this->isCacheFresh($cacheKey, $class)) {
                return $data;
            }
        }

        return false;
    }

    /**
     * Saves a value to the cache.
     *
     * @param string           $rawCacheKey The cache key.
     * @param mixed            $value       The value.
     * @param \ReflectionClass $class
     */
    private function saveToCache($rawCacheKey, $value, \ReflectionClass $class)
    {
        $cacheKey = $this->prefix . $rawCacheKey;
        $this->cache->save($cacheKey, $value);

        // in debug mode record the creation time of the entry
        if ($this->debug && false !== $filename = $class->getFileName()) {

            $this->cache->save('[C]' . $cacheKey, filemtime($filename));
        }
    }

    /**
     * Checks if the cache is fresh.
     *
     * @param string           $cacheKey
     * @param \ReflectionClass $class
     *
     * @return boolean
     */
    private function isCacheFresh($cacheKey, \ReflectionClass $class)
    {
        // built in classes have no filename
        if (false === $filename = $class->getFileName()) {
            return true;
        }

//        echo $cacheKey . " " . $this->cache->fetch('[C]'.$cacheKey) . " " . filemtime($filename) . " " . ($this->cache->fetch('[C]'.$cacheKey) >= filemtime($filename)) . "\n";


        // When we have the creation time (debug mode) and it is less than the current file time, the cache is also not fresh
        return $this->cache->fetch('[C]' . $cacheKey) >= filemtime($filename);
    }
}


1		<?php
2		/**
3		* File was created 06.10.2015 06:25
4		*/
5
6		namespace PeekAndPoke\Component\Slumber\Core\LookUp;
7
8		use Doctrine\Common\Cache\Cache;
9
10		/**
11		* @author Karsten J. Gerber <[email protected]>
12		*/
13		class CachedEntityConfigLookUp implements EntityConfigReader
14		{
15		/** @var EntityConfigReader */
16		private $delegate;
17		/** @var Cache */
18		private $cache;
19		/** @var string */
20		private $prefix;
21		/** @var bool */
22		private $debug;
23
24		/**
25		* We have another level of caching here
26		*
27		* @var array
28		*/
29		private $known = [];
30
31		/**
32		* @param EntityConfigReader $delegate
33		* @param Cache $cache
34		* @param string $prefix
35		* @param bool $debug
36		*/
37	4	public function __construct(EntityConfigReader $delegate, Cache $cache, $prefix = '[Slumber]@', $debug = false)
38		{
39	4	$this->delegate = $delegate;
40	4	$this->cache = $cache;
41	4	$this->prefix = $prefix;
42	4	$this->debug = $debug;
43	4	}
44
45		/**
46		* @param \ReflectionClass $cls
47		*
48		* @return PropertyMarkedForSlumber[]
49		*/
50	4	public function getEntityConfig(\ReflectionClass $cls)
51		{
52	4	$cacheKey = $this->prefix . $cls->name;
53
54	4	return $this->loadOrCreate(
		0 ignored issues – show Bug Best Practice introduced 2018-02-27 06:14 UTC by Report Bug Copy Issue Report The expression `return $this->loadOrCrea....) { /* ... */ }, $cls)` also could return the type `PeekAndPoke\Component\Sl...ore\LookUp\EntityConfig` which is incompatible with the documented return type `PeekAndPoke\Component\Sl...pertyMarkedForSlumber[]`. Loading history...
55	4	$cacheKey,
56	4	function () use ($cacheKey, $cls) {
57	4	return $this->fetchFromCache($cacheKey, $cls);
58	4	},
59	4	function () use ($cls) {
60	4	return $this->delegate->getEntityConfig($cls);
61	4	},
62	4	$cls
63		);
64		}
65
66		/**
67		* @param string $cacheKey
68		* @param \Closure $fetcher
69		* @param \Closure $creator
70		* @param \ReflectionClass $class
71		*
72		* @return mixed
73		*/
74	4	private function loadOrCreate($cacheKey, \Closure $fetcher, \Closure $creator, \ReflectionClass $class)
75		{
76	4	if (isset($this->known[$cacheKey])) {
77	1	return $this->known[$cacheKey];
78		}
79
80		/** @var EntityConfig $cacheData */
81	4	$cacheData = $fetcher();
82
83	4	if (false === $cacheData) {
		0 ignored issues – show introduced 2018-07-23 12:02 UTC by Report Bug Copy Issue Report The condition `$cacheData` is always `false`. If `$cacheData` can have other possible types, add them to `src/Slumber/Core/LookUp/...dEntityConfigLookUp.php`:`80` Loading history...
84	4	$cacheData = $creator();
85	4	$this->saveToCache($cacheKey, $cacheData, $class);
86		}
87
88	4	return $this->known[$cacheKey] = $cacheData;
89		}
90
91		/**
92		* Fetches a value from the cache.
93		*
94		* @param string $rawCacheKey The cache key.
95		* @param \ReflectionClass $class The related class.
96		*
97		* @return mixed The cached value or false when the value is not in cache.
98		*/
99	4	private function fetchFromCache($rawCacheKey, \ReflectionClass $class)
100		{
101	4	$cacheKey = $this->prefix . $rawCacheKey;
102
103	4	if (($data = $this->cache->fetch($cacheKey)) !== false) {
104		/** @noinspection NestedPositiveIfStatementsInspection */
105	2	if (! $this->debug \|\| $this->isCacheFresh($cacheKey, $class)) {
106	2	return $data;
107		}
108		}
109
110	4	return false;
111		}
112
113		/**
114		* Saves a value to the cache.
115		*
116		* @param string $rawCacheKey The cache key.
117		* @param mixed $value The value.
118		* @param \ReflectionClass $class
119		*/
120	4	private function saveToCache($rawCacheKey, $value, \ReflectionClass $class)
121		{
122	4	$cacheKey = $this->prefix . $rawCacheKey;
123	4	$this->cache->save($cacheKey, $value);
124
125		// in debug mode record the creation time of the entry
126	4	if ($this->debug && false !== $filename = $class->getFileName()) {
127
128	3	$this->cache->save('[C]' . $cacheKey, filemtime($filename));
129		}
130	4	}
131
132		/**
133		* Checks if the cache is fresh.
134		*
135		* @param string $cacheKey
136		* @param \ReflectionClass $class
137		*
138		* @return boolean
139		*/
140	2	private function isCacheFresh($cacheKey, \ReflectionClass $class)
141		{
142		// built in classes have no filename
143	2	if (false === $filename = $class->getFileName()) {
144	1	return true;
145		}
146
147		// echo $cacheKey . " " . $this->cache->fetch('[C]'.$cacheKey) . " " . filemtime($filename) . " " . ($this->cache->fetch('[C]'.$cacheKey) >= filemtime($filename)) . "\n";
		0 ignored issues – show Unused Code Comprehensibility introduced 2017-05-18 06:57 UTC by Report Bug Copy Issue Report `46%` of this comment could be valid code. Did you maybe forget this after debugging? Sometimes obsolete code just ends up commented out instead of removed. In this case it is better to remove the code once you have checked you do not need it. The code might also have been commented out for debugging purposes. In this case it is vital that someone uncomments it again or your project may behave in very unexpected ways in production. This check looks for comments that seem to be mostly valid code and reports them. Loading history...
148
149		// When we have the creation time (debug mode) and it is less than the current file time, the cache is also not fresh
150	1	return $this->cache->fetch('[C]' . $cacheKey) >= filemtime($filename);
151		}
152		}
153

PeekAndPoke / slumber

CachedEntityConfigLookUp::fetchFromCache() A last analyzed 2018-08-20 20:36 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

CachedEntityConfigLookUp::fetchFromCache() A
last analyzed 2018-08-20 20:36 UTC