RedisCache - Code Metrics - Inspection of "Added unit tests" - dazzle-php/cache-redis - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( f29c33...4a98e7 )

by Kamil

created 2017-08-06 18:04 UTC

RedisCache B

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	347
Duplicated Lines	20.46 %

Coupling/Cohesion

Components	2
Dependencies	8

Test Coverage

Coverage

32.41%

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
wmc	46
c	1
b	0
f	0
lcom	2
cbo	8
dl	71
loc	347
ccs	35
cts	108
cp	0.3241
rs	8.3999

24 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	9	1
A	__destruct()	0	5	1
A	isStarted()	0	4	1
A	start()	0	4	1
A	stop()	0	4	1
A	end()	0	4	1
A	isPaused()	0	4	1
A	pause()	0	4	1
A	resume()	0	4	1
B	set()	0	23	5
A	get()	10	10	3
A	remove()	10	10	3
A	exists()	10	10	3
A	setTtl()	0	18	4
A	getTtl()	10	10	3
A	removeTtl()	10	10	2
A	existsTtl()	10	10	2
A	getKeys()	11	11	2
A	getStats()	0	16	3
A	flush()	0	8	2
A	createConfig()	0	4	1
A	createRedis()	0	4	1
A	createEndpoint()	0	8	2
A	attachEvents()	0	12	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 RedisCache 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 RedisCache, and based on these observations, apply Extract Interface, too.

<?php

namespace Dazzle\Cache\Redis;

use Dazzle\Cache\CacheInterface;
use Dazzle\Event\BaseEventEmitter;
use Dazzle\Loop\LoopAwareTrait;
use Dazzle\Loop\LoopInterface;
use Dazzle\Promise\Promise;
use Dazzle\Promise\PromiseInterface;
use Dazzle\Redis\Redis;
use Dazzle\Redis\RedisInterface;
use Dazzle\Throwable\Exception\Runtime\ReadException;
use Dazzle\Throwable\Exception\Runtime\WriteException;
use Error;
use Exception;

class RedisCache extends BaseEventEmitter implements CacheInterface
{
    use LoopAwareTrait;

    /**
     * @var mixed[]
     */
    protected $config;

    /**
     * @var RedisInterface
     */
    protected $redis;

    /**
     * @var int
     */
    protected $selected;

    /**
     * @param LoopInterface $loop
     * @param mixed[] $config
     */
    public function __construct(LoopInterface $loop, $config = [])
    {
        $this->loop = $loop;
        $this->config = $this->createConfig($config);
        $this->redis = $this->createRedis();
        $this->selected = 0;

        $this->attachEvents();
    }

    /**
     *
     */
    public function __destruct()
    {
        $this->stop();
        parent::__destruct();
    }

    /**
     * @override
     * @inheritDoc
     */
    public function isStarted()
    {
        return $this->redis->isStarted();
    }

    /**
     * @override
     * @inheritDoc
     */
    public function start()
    {
        return $this->redis->start()->then(function() { return $this; });
    }

    /**
     * @override
     * @inheritDoc
     */
    public function stop()
    {
        return $this->redis->stop()->then(function() { return $this; });
    }

    /**
     * @override
     * @inheritDoc
     */
    public function end()
    {
        return $this->redis->end()->then(function() { return $this; });
    }

    /**
     * @override
     * @inheritDoc
     */
    public function isPaused()
    {
        return $this->redis->isPaused();
    }

    /**
     * @override
     * @inheritDoc
     */
    public function pause()
    {
        return $this->redis->pause();
    }

    /**
     * @override
     * @inheritDoc
     */
    public function resume()
    {
        return $this->redis->resume();
    }

    /**
     * @override
     * @inheritDoc
     */
    public function set($key, $val, $ttl = 0.0)
    {
        if (!$this->isStarted())
        {
            return Promise::doReject(new WriteException('Cache object is not open.'));
        }
        if (is_object($val))
        {
            return Promise::doReject(new WriteException('Objects are not supported.'));
        }

        $promise = $ttl > 0
            ? $this->redis->setEx($key, round($ttl), json_encode($val))
            : $this->redis->set($key, json_encode($val));

        return $promise->then(function($result) use($val) {
            if ($result !== 'OK')
            {
                throw new WriteException('Value could not be set.');
            }
            return $val;
        });
    }

    /**
     * @override
     * @inheritDoc
     */
    public function get($key)

    {
        if (!$this->isStarted())
        {
            return Promise::doReject(new ReadException('Cache object is not open.'));
        }
        return $this->redis->get($key)->then(function($result) {
            return $result === null ? null : json_decode($result, true);
        });
    }

    /**
     * @override
     * @inheritDoc
     */
    public function remove($key)

    {
        if (!$this->isStarted())
        {
            return Promise::doReject(new WriteException('Cache object is not open.'));
        }
        return $this->redis->del($key)->then(function($count) {
            return $count ? true : false;
        });
    }

    /**
     * @override
     * @inheritDoc
     */
    public function exists($key)

    {
        if (!$this->isStarted())
        {
            return Promise::doReject(new ReadException('Cache object is not open.'));
        }
        return $this->redis->exists($key)->then(function($count) {
            return $count ? true : false;
        });
    }

    /**
     * @override
     * @inheritDoc
     */
    public function setTtl($key, $ttl)
    {
        if (!$this->isStarted())
        {
            return Promise::doReject(new WriteException('Cache object is not open.'));
        }
        if ($ttl <= 0)
        {
            return Promise::doReject(new WriteException('TTL needs to be higher than 0.'));
        }
        return $this->redis->expire($key, round($ttl))->then(function($result) {
            if ($result === 0)
            {
                throw new WriteException('Timeout cannot be set on undefined key.');
            }
            return $result;
        });
    }

    /**
     * @override
     * @inheritDoc
     */
    public function getTtl($key)

    {
        if (!$this->isStarted())
        {
            return Promise::doReject(new ReadException('Cache object is not open.'));
        }
        return $this->redis->ttl($key)->then(function($result) {
            return $result > 0 ? $result : 0;
        });
    }

    /**
     * @override
     * @inheritDoc
     */
    public function removeTtl($key)

    {
        if (!$this->isStarted())
        {
            return Promise::doReject(new WriteException('Cache object is not open.'));
        }
        return $this->redis->persist($key)->then(function($result) {
            return $result > 0;
        });
    }

    /**
     * @override
     * @inheritDoc
     */
    public function existsTtl($key)

    {
        if (!$this->isStarted())
        {
            return Promise::doReject(new ReadException('Cache object is not open.'));
        }
        return $this->redis->ttl($key)->then(function($result) {
            return $result >= 0;
        });
    }

    /**
     * @override
     * @inheritDoc
     */
    public function getKeys()

    {
        if (!$this->isStarted())
        {
            return Promise::doReject(new ReadException('Cache object is not open.'));
        }
        return $this->redis->keys()->then(function($result) {
            sort($result);
            return $result;
        });
    }

    /**
     * @override
     * @inheritDoc
     */
    public function getStats()
    {
        if (!$this->isStarted())
        {
            return Promise::doReject(new ReadException('Cache object is not open.'));
        }
        return $this->redis->info()->then(function($result) {
            preg_match('#keys=([0-9]+)#si', $result['keyspace']['db' . $this->selected], $matches);
            $keys = isset($matches[1]) ? $matches[1] : 0;
            return [
                'keys'   => (int) $keys,
                'hits'   => (int) $result['stats']['keyspace_hits'],
                'misses' => (int) $result['stats']['keyspace_misses'],
            ];
        });
    }

    /**
     * @override
     * @inheritDoc
     */
    public function flush()
    {
        if (!$this->isStarted())
        {
            return Promise::doReject(new WriteException('Cache object is not open.'));
        }
        return $this->redis->flushDb();
    }

    /**
     * Create configuration.
     *
     * @return mixed[]
     */
    protected function createConfig($config = [])
    {
        return array_merge([ 'endpoint' => 'redis://127.0.0.1:6379' ], $config);
    }

    /**
     * Create Redis client.
     *
     * @return RedisInterface
     */
    protected function createRedis()
    {
        return new Redis($this->createEndpoint($this->config['endpoint']), $this->getLoop());
    }

    /**
     * Parse and return endpoint.
     *
     * @param string $endpoint
     * @return string
     */
    protected function createEndpoint($endpoint)
    {
        $endpoint = explode('://', $endpoint, 2);
        $endpoint = explode('/', $endpoint[1]);
        $endpoint = stripos($endpoint[0], ':') === false ? $endpoint[0] . ':6379' : $endpoint[0];
        $endpoint = 'tcp://' . $endpoint;
        return $endpoint;
    }

    /**
     * Attach events.
     */
    private function attachEvents()
    {
        $this->redis->on('start', function($redis) {

            $this->emit('start', [ $this ]);
        });
        $this->redis->on('stop', function($redis) {

            $this->emit('stop', [ $this ]);
        });
        $this->redis->on('error', function($redis, $ex) {
            $this->emit('error', [ $this, $ex ]);
        });
    }
}


1			<?php
2
3			namespace Dazzle\Cache\Redis;
4
5			use Dazzle\Cache\CacheInterface;
6			use Dazzle\Event\BaseEventEmitter;
7			use Dazzle\Loop\LoopAwareTrait;
8			use Dazzle\Loop\LoopInterface;
9			use Dazzle\Promise\Promise;
10			use Dazzle\Promise\PromiseInterface;
11			use Dazzle\Redis\Redis;
12			use Dazzle\Redis\RedisInterface;
13			use Dazzle\Throwable\Exception\Runtime\ReadException;
14			use Dazzle\Throwable\Exception\Runtime\WriteException;
15			use Error;
16			use Exception;
17
18			class RedisCache extends BaseEventEmitter implements CacheInterface
19			{
20			use LoopAwareTrait;
21
22			/**
23			* @var mixed[]
24			*/
25			protected $config;
26
27			/**
28			* @var RedisInterface
29			*/
30			protected $redis;
31
32			/**
33			* @var int
34			*/
35			protected $selected;
36
37			/**
38			* @param LoopInterface $loop
39			* @param mixed[] $config
40			*/
41			public function __construct(LoopInterface $loop, $config = [])
42			{
43			$this->loop = $loop;
44			$this->config = $this->createConfig($config);
45			$this->redis = $this->createRedis();
46			$this->selected = 0;
47
48			$this->attachEvents();
49			}
50
51			/**
52			*
53			*/
54			public function __destruct()
55			{
56			$this->stop();
57			parent::__destruct();
58			}
59
60			/**
61			* @override
62			* @inheritDoc
63			*/
64	11		public function isStarted()
65			{
66	11		return $this->redis->isStarted();
67			}
68
69			/**
70			* @override
71			* @inheritDoc
72			*/
73			public function start()
74			{
75			return $this->redis->start()->then(function() { return $this; });
76			}
77
78			/**
79			* @override
80			* @inheritDoc
81			*/
82			public function stop()
83			{
84			return $this->redis->stop()->then(function() { return $this; });
85			}
86
87			/**
88			* @override
89			* @inheritDoc
90			*/
91			public function end()
92			{
93			return $this->redis->end()->then(function() { return $this; });
94			}
95
96			/**
97			* @override
98			* @inheritDoc
99			*/
100			public function isPaused()
101			{
102			return $this->redis->isPaused();
103			}
104
105			/**
106			* @override
107			* @inheritDoc
108			*/
109			public function pause()
110			{
111			return $this->redis->pause();
112			}
113
114			/**
115			* @override
116			* @inheritDoc
117			*/
118			public function resume()
119			{
120			return $this->redis->resume();
121			}
122
123			/**
124			* @override
125			* @inheritDoc
126			*/
127	1		public function set($key, $val, $ttl = 0.0)
128			{
129	1		if (!$this->isStarted())
130			{
131	1		return Promise::doReject(new WriteException('Cache object is not open.'));
132			}
133			if (is_object($val))
134			{
135			return Promise::doReject(new WriteException('Objects are not supported.'));
136			}
137
138			$promise = $ttl > 0
139			? $this->redis->setEx($key, round($ttl), json_encode($val))
140			: $this->redis->set($key, json_encode($val));
141
142			return $promise->then(function($result) use($val) {
143			if ($result !== 'OK')
144			{
145			throw new WriteException('Value could not be set.');
146			}
147			return $val;
148			});
149			}
150
151			/**
152			* @override
153			* @inheritDoc
154			*/
155	1	View Code Duplication	public function get($key)
			0 ignored issues – show Duplication introduced 2017-08-06 18:07 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
156			{
157	1		if (!$this->isStarted())
158			{
159	1		return Promise::doReject(new ReadException('Cache object is not open.'));
160			}
161			return $this->redis->get($key)->then(function($result) {
162			return $result === null ? null : json_decode($result, true);
163			});
164			}
165
166			/**
167			* @override
168			* @inheritDoc
169			*/
170	1	View Code Duplication	public function remove($key)
			0 ignored issues – show Duplication introduced 2017-08-06 18:07 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
171			{
172	1		if (!$this->isStarted())
173			{
174	1		return Promise::doReject(new WriteException('Cache object is not open.'));
175			}
176			return $this->redis->del($key)->then(function($count) {
177			return $count ? true : false;
178			});
179			}
180
181			/**
182			* @override
183			* @inheritDoc
184			*/
185	1	View Code Duplication	public function exists($key)
			0 ignored issues – show Duplication introduced 2017-08-06 18:07 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
186			{
187	1		if (!$this->isStarted())
188			{
189	1		return Promise::doReject(new ReadException('Cache object is not open.'));
190			}
191			return $this->redis->exists($key)->then(function($count) {
192			return $count ? true : false;
193			});
194			}
195
196			/**
197			* @override
198			* @inheritDoc
199			*/
200	1		public function setTtl($key, $ttl)
201			{
202	1		if (!$this->isStarted())
203			{
204	1		return Promise::doReject(new WriteException('Cache object is not open.'));
205			}
206			if ($ttl <= 0)
207			{
208			return Promise::doReject(new WriteException('TTL needs to be higher than 0.'));
209			}
210			return $this->redis->expire($key, round($ttl))->then(function($result) {
211			if ($result === 0)
212			{
213			throw new WriteException('Timeout cannot be set on undefined key.');
214			}
215			return $result;
216			});
217			}
218
219			/**
220			* @override
221			* @inheritDoc
222			*/
223	1	View Code Duplication	public function getTtl($key)
			0 ignored issues – show Duplication introduced 2017-08-06 18:07 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
224			{
225	1		if (!$this->isStarted())
226			{
227	1		return Promise::doReject(new ReadException('Cache object is not open.'));
228			}
229			return $this->redis->ttl($key)->then(function($result) {
230			return $result > 0 ? $result : 0;
231			});
232			}
233
234			/**
235			* @override
236			* @inheritDoc
237			*/
238	1	View Code Duplication	public function removeTtl($key)
			0 ignored issues – show Duplication introduced 2017-08-06 18:07 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
239			{
240	1		if (!$this->isStarted())
241			{
242	1		return Promise::doReject(new WriteException('Cache object is not open.'));
243			}
244			return $this->redis->persist($key)->then(function($result) {
245			return $result > 0;
246			});
247			}
248
249			/**
250			* @override
251			* @inheritDoc
252			*/
253	1	View Code Duplication	public function existsTtl($key)
			0 ignored issues – show Duplication introduced 2017-08-06 18:07 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
254			{
255	1		if (!$this->isStarted())
256			{
257	1		return Promise::doReject(new ReadException('Cache object is not open.'));
258			}
259			return $this->redis->ttl($key)->then(function($result) {
260			return $result >= 0;
261			});
262			}
263
264			/**
265			* @override
266			* @inheritDoc
267			*/
268	1	View Code Duplication	public function getKeys()
			0 ignored issues – show Duplication introduced 2017-08-06 18:07 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
269			{
270	1		if (!$this->isStarted())
271			{
272	1		return Promise::doReject(new ReadException('Cache object is not open.'));
273			}
274			return $this->redis->keys()->then(function($result) {
275			sort($result);
276			return $result;
277			});
278			}
279
280			/**
281			* @override
282			* @inheritDoc
283			*/
284	1		public function getStats()
285			{
286	1		if (!$this->isStarted())
287			{
288	1		return Promise::doReject(new ReadException('Cache object is not open.'));
289			}
290			return $this->redis->info()->then(function($result) {
291			preg_match('#keys=([0-9]+)#si', $result['keyspace']['db' . $this->selected], $matches);
292			$keys = isset($matches[1]) ? $matches[1] : 0;
293			return [
294			'keys' => (int) $keys,
295			'hits' => (int) $result['stats']['keyspace_hits'],
296			'misses' => (int) $result['stats']['keyspace_misses'],
297			];
298			});
299			}
300
301			/**
302			* @override
303			* @inheritDoc
304			*/
305	1		public function flush()
306			{
307	1		if (!$this->isStarted())
308			{
309	1		return Promise::doReject(new WriteException('Cache object is not open.'));
310			}
311			return $this->redis->flushDb();
312			}
313
314			/**
315			* Create configuration.
316			*
317			* @return mixed[]
318			*/
319			protected function createConfig($config = [])
320			{
321			return array_merge([ 'endpoint' => 'redis://127.0.0.1:6379' ], $config);
322			}
323
324			/**
325			* Create Redis client.
326			*
327			* @return RedisInterface
328			*/
329			protected function createRedis()
330			{
331			return new Redis($this->createEndpoint($this->config['endpoint']), $this->getLoop());
332			}
333
334			/**
335			* Parse and return endpoint.
336			*
337			* @param string $endpoint
338			* @return string
339			*/
340			protected function createEndpoint($endpoint)
341			{
342			$endpoint = explode('://', $endpoint, 2);
343			$endpoint = explode('/', $endpoint[1]);
344			$endpoint = stripos($endpoint[0], ':') === false ? $endpoint[0] . ':6379' : $endpoint[0];
345			$endpoint = 'tcp://' . $endpoint;
346			return $endpoint;
347			}
348
349			/**
350			* Attach events.
351			*/
352			private function attachEvents()
353			{
354			$this->redis->on('start', function($redis) {
			0 ignored issues – show Unused Code introduced 2017-08-06 18:07 UTC by Report Bug Copy Issue Report The parameter `$redis` 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...
355			$this->emit('start', [ $this ]);
356			});
357			$this->redis->on('stop', function($redis) {
			0 ignored issues – show Unused Code introduced 2017-08-06 18:07 UTC by Report Bug Copy Issue Report The parameter `$redis` 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...
358			$this->emit('stop', [ $this ]);
359			});
360			$this->redis->on('error', function($redis, $ex) {
361			$this->emit('error', [ $this, $ex ]);
362			});
363			}
364			}
365

dazzle-php / cache-redis