ItemBaseTrait - Code Metrics - Inspection of "Merge branch 'v5' into final (#299)" - PHPSocialNetwork/phpfastcache - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Branch — final (ad8b8d)

by Georges

created 2016-07-01 17:57 UTC

ItemBaseTrait B

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	424
Duplicated Lines	10.85 %

Coupling/Cohesion

Components	4
Dependencies	0

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
c	1
b	0
f	0
dl	46
loc	424
rs	8.3999
wmc	46
lcom	4
cbo	0

26 Methods

Rating	Name	Duplication	Size	Complexity
A	getKey()	0	4	1
A	getUncommittedData()	0	4	1
A	getExpirationDate()	0	4	1
A	isExpired()	0	4	1
A	set()	0	12	1
A	get()	0	4	1
A	isHit()	0	4	1
A	setHit()	0	10	2
A	expiresAt()	0	10	2
A	touch()	0	6	1
A	expiresAfter()	0	19	4
A	getTtl()	0	9	2
A	increment()	11	11	2
A	decrement()	11	11	2
A	append()	12	12	3
A	prepend()	12	12	3
A	addTag()	0	10	2
A	addTags()	0	8	2
A	setTags()	0	12	3
A	getTags()	0	4	1
A	getTagsAsString()	0	4	1
A	removeTag()	0	9	2
A	removeTags()	0	8	2
A	getRemovedTags()	0	4	1
A	getDataAsJsonString()	0	12	3
A	__debugInfo()	0	7	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 ItemBaseTrait 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 ItemBaseTrait, and based on these observations, apply Extract Interface, too.

<?php
/**
 *
 * This file is part of phpFastCache.
 *
 * @license MIT License (MIT)
 *
 * For full copyright and license information, please see the docs/CREDITS.txt file.
 *
 * @author Khoa Bui (khoaofgod)  <[email protected]> http://www.phpfastcache.com
 * @author Georges.L (Geolim4)  <[email protected]>
 *
 */

namespace phpFastCache\Cache;

use phpFastCache\Core\DriverAbstract;

trait ItemBaseTrait
{
    /**
     * @var bool
     */
    protected $fetched = false;

    /**
     * @var DriverAbstract
     */
    protected $driver;

    /**
     * @var string
     */
    protected $key;

    /**
     * @var mixed
     */
    protected $data;

    /**
     * @var \DateTime
     */
    protected $expirationDate;

    /**
     * @var array
     */
    protected $tags = [];

    /**
     * @var array
     */
    protected $removedTags = [];

    /**
     * @var bool
     */
    protected $isHit = false;

    /********************
     *
     * PSR-6 Methods
     *
     *******************/

    /**
     * @return string
     */
    public function getKey()
    {
        return $this->key;
    }

    /**
     * @return mixed
     */
    public function get()
    {
        return $this->data;
    }

    /**
     * @param mixed $value
     * @return $this
     */
    public function set($value)
    {
        /**
         * The user set a value,
         * therefore there is no need to
         * fetch from source anymore
         */
        $this->fetched = true;
        $this->data = $value;

        return $this;
    }

    /**
     * @return bool
     * @throws \InvalidArgumentException
     */
    public function isHit()
    {
        return $this->isHit;
    }

    /**
     * @param bool $isHit
     * @return $this
     * @throws \InvalidArgumentException
     */
    public function setHit($isHit)
    {
        if (is_bool($isHit)) {
            $this->isHit = $isHit;

            return $this;
        } else {
            throw new \InvalidArgumentException('$isHit must be a boolean');
        }
    }

    /**
     * @param \DateTimeInterface $expiration
     * @return $this
     */
    public function expiresAt($expiration)
    {
        if ($expiration instanceof \DateTimeInterface) {
            $this->expirationDate = $expiration;
class Alien {}

class Dalek extends Alien {}

class Plot
{
    /** @var  Dalek */
    public $villain;
}

$alien = new Alien();
$plot = new Plot();
if ($alien instanceof Dalek) {
    $plot->villain = $alien;
}
        } else {
            throw new \InvalidArgumentException('$expiration must be an object implementing the DateTimeInterface');
        }

        return $this;
    }

    /**
     * Sets the expiration time for this cache item.
     *
     * @param int|\DateInterval $time
     *   The period of time from the present after which the item MUST be considered
     *   expired. An integer parameter is understood to be the time in seconds until
     *   expiration. If null is passed explicitly, a default value MAY be used.
     *   If none is set, the value should be stored permanently or for as long as the
     *   implementation allows.
     *
     * @return static
     *   The called object.
     *
     * @deprecated Use CacheItemInterface::expiresAfter() instead
     */
    public function touch($time)
    {
        trigger_error('touch() is deprecated and will be removed in the next major release, use CacheItemInterface::expiresAfter() instead');

        return $this->expiresAfter($time);
    }

    /**
     * @param \DateInterval|int $time
     * @return $this
     * @throws \InvalidArgumentException
     */
    public function expiresAfter($time)
    {
        if (is_numeric($time)) {
            if ($time <= 0) {
                /**
                 * 5 years, however memcached or memory cached will gone when u restart it
                 * just recommended for sqlite. files
                 */
                $time = 30 * 24 * 3600 * 5;
            }
            $this->expirationDate = $this->expirationDate->add(new \DateInterval(sprintf('PT%dS', $time)));
        } else if ($time instanceof \DateInterval) {
            $this->expirationDate = $this->expirationDate->add($time);
        } else {
            throw new \InvalidArgumentException('Invalid date format');
        }

        return $this;
    }

    /********************
     *
     * PSR-6 Extended Methods
     *
     *******************/


    /**
     * @return mixed
     */
    public function getUncommittedData()
    {
        return $this->data;
    }

    /**
     * @return \DateTimeInterface
     */
    public function getExpirationDate()
    {
        return $this->expirationDate;
    }

    /**
     * @return int
     */
    public function getTtl()
    {
        $ttl = $this->expirationDate->getTimestamp() - time();
        if ($ttl > 2592000) {
            $ttl = time() + $ttl;
        }

        return $ttl;
    }

    /**
     * @return bool
     */
    public function isExpired()
    {
        return $this->expirationDate->getTimestamp() < (new \DateTime())->getTimestamp();
    }

    /**
     * @param int $step
     * @return $this
     * @throws \InvalidArgumentException
     */
    public function increment($step = 1)

    {
        if (is_int($step)) {
            $this->fetched = true;
            $this->data += $step;
        } else {
            throw new \InvalidArgumentException('$step must be numeric.');
        }

        return $this;
    }

    /**
     * @param int $step
     * @return $this
     * @throws \InvalidArgumentException
     */
    public function decrement($step = 1)

    {
        if (is_int($step)) {
            $this->fetched = true;
            $this->data -= $step;
        } else {
            throw new \InvalidArgumentException('$step must be numeric.');
        }

        return $this;
    }

    /**
     * @param array|string $data
     * @return $this
     * @throws \InvalidArgumentException
     */
    public function append($data)

    {
        if (is_array($this->data)) {
            array_push($this->data, $data);
        } else if (is_string($data)) {
            $this->data .= (string) $data;
        } else {
            throw new \InvalidArgumentException('$data must be either array nor string.');
        }

        return $this;
    }


    /**
     * @param array|string $data
     * @return $this
     * @throws \InvalidArgumentException
     */
    public function prepend($data)

    {
        if (is_array($this->data)) {
            array_unshift($this->data, $data);
        } else if (is_string($data)) {
            $this->data = (string) $data . $this->data;
        } else {
            throw new \InvalidArgumentException('$data must be either array nor string.');
        }

        return $this;
    }

    /**
     * @param $tagName
     * @return $this
     * @throws \InvalidArgumentException
     */
    public function addTag($tagName)
    {
        if (is_string($tagName)) {
            $this->tags = array_unique(array_merge($this->tags, [$tagName]));

            return $this;
        } else {
            throw new \InvalidArgumentException('$tagName must be a string');
        }
    }

    /**
     * @param array $tagNames
     * @return $this
     */
    public function addTags(array $tagNames)
    {
        foreach ($tagNames as $tagName) {
            $this->addTag($tagName);
        }

        return $this;
    }

    /**
     * @param array $tags
     * @return $this
     * @throws \InvalidArgumentException
     */
    public function setTags(array $tags)
    {
        if (count($tags)) {
            if (array_filter($tags, 'is_string')) {
                $this->tags = $tags;
            } else {
                throw new \InvalidArgumentException('$tagName must be an array of string');
            }
        }

        return $this;
    }

    /**
     * @return array
     */
    public function getTags()
    {
        return $this->tags;
    }

    /**
     * @return string
     */
    public function getTagsAsString($separator = ', ')
    {
        return implode($separator, $this->tags);
    }

    /**
     * @param $tagName
     * @return $this
     */
    public function removeTag($tagName)
    {
        if (($key = array_search($tagName, $this->tags)) !== false) {
            unset($this->tags[ $key ]);
            $this->removedTags[] = $tagName;
        }

        return $this;
    }

    /**
     * @param array $tagNames
     * @return $this
     */
    public function removeTags(array $tagNames)
    {
        foreach ($tagNames as $tagName) {
            $this->removeTag($tagName);
        }

        return $this;
    }

    /**
     * @return array
     */
    public function getRemovedTags()
    {
        return array_diff($this->removedTags, $this->tags);
    }

    /**
     * Return the data as a well-formatted string.
     * Any scalar value will be casted to an array
     * @param int $option json_encode() options
     * @param int $depth json_encode() depth
     * @return string
     */
    public function getDataAsJsonString($option = 0, $depth = 512)
    {
        $data = $this->get();

        if (is_object($data) || is_array($data)) {
            $data = json_encode($data, $option, $depth);
        } else {
            $data = json_encode([$data], $option, $depth);
        }

        return json_encode($data, $option, $depth);
    }

    /**
     * @throws \RuntimeException
     */
    /*    final public function __sleep()

        {
            $info = get_object_vars($this);
            $info[ 'driver' ] = 'object(' . get_class($info[ 'driver' ]) . ')';
    
            return (array) $info;
        }*/

    /**
     * Prevent recursions for Debug (php 5.6+)
     * @return array
     */
    final public function __debugInfo()
    {
        $info = get_object_vars($this);
        $info[ 'driver' ] = 'object(' . get_class($info[ 'driver' ]) . ')';

        return (array) $info;
    }
}


1		<?php
2		/**
3		*
4		* This file is part of phpFastCache.
5		*
6		* @license MIT License (MIT)
7		*
8		* For full copyright and license information, please see the docs/CREDITS.txt file.
9		*
10		* @author Khoa Bui (khoaofgod) <[email protected]> http://www.phpfastcache.com
11		* @author Georges.L (Geolim4) <[email protected]>
12		*
13		*/
14
15		namespace phpFastCache\Cache;
16
17		use phpFastCache\Core\DriverAbstract;
18
19		trait ItemBaseTrait
20		{
21		/**
22		* @var bool
23		*/
24		protected $fetched = false;
25
26		/**
27		* @var DriverAbstract
28		*/
29		protected $driver;
30
31		/**
32		* @var string
33		*/
34		protected $key;
35
36		/**
37		* @var mixed
38		*/
39		protected $data;
40
41		/**
42		* @var \DateTime
43		*/
44		protected $expirationDate;
45
46		/**
47		* @var array
48		*/
49		protected $tags = [];
50
51		/**
52		* @var array
53		*/
54		protected $removedTags = [];
55
56		/**
57		* @var bool
58		*/
59		protected $isHit = false;
60
61		/********************
62		*
63		* PSR-6 Methods
64		*
65		*******************/
66
67		/**
68		* @return string
69		*/
70		public function getKey()
71		{
72		return $this->key;
73		}
74
75		/**
76		* @return mixed
77		*/
78		public function get()
79		{
80		return $this->data;
81		}
82
83		/**
84		* @param mixed $value
85		* @return $this
86		*/
87		public function set($value)
88		{
89		/**
90		* The user set a value,
91		* therefore there is no need to
92		* fetch from source anymore
93		*/
94		$this->fetched = true;
95		$this->data = $value;
96
97		return $this;
98		}
99
100		/**
101		* @return bool
102		* @throws \InvalidArgumentException
103		*/
104		public function isHit()
105		{
106		return $this->isHit;
107		}
108
109		/**
110		* @param bool $isHit
111		* @return $this
112		* @throws \InvalidArgumentException
113		*/
114		public function setHit($isHit)
115		{
116		if (is_bool($isHit)) {
117		$this->isHit = $isHit;
118
119		return $this;
120		} else {
121		throw new \InvalidArgumentException('$isHit must be a boolean');
122		}
123		}
124
125		/**
126		* @param \DateTimeInterface $expiration
127		* @return $this
128		*/
129		public function expiresAt($expiration)
130		{
131		if ($expiration instanceof \DateTimeInterface) {
132		$this->expirationDate = $expiration;
		0 ignored issues – show Documentation Bug introduced 2016-05-12 20:38 UTC by Report Bug Copy Issue Report `$expiration` is of type `object<DateTimeInterface>`, but the property `$expirationDate` was declared to be of type `object<DateTime>`. Are you sure that you always receive this specific sub-class here, or does it make sense to add an `instanceof` check? Our type inference engine has found a suspicous assignment of a value to a property. This check raises an issue when a value that can be of a given class or a super-class is assigned to a property that is type hinted more strictly. Either this assignment is in error or an instanceof check should be added for that assignment. class Alien {} class Dalek extends Alien {} class Plot { /** @var Dalek */ public $villain; } $alien = new Alien(); $plot = new Plot(); if ($alien instanceof Dalek) { $plot->villain = $alien; } Loading history...
133		} else {
134		throw new \InvalidArgumentException('$expiration must be an object implementing the DateTimeInterface');
135		}
136
137		return $this;
138		}
139
140		/**
141		* Sets the expiration time for this cache item.
142		*
143		* @param int\|\DateInterval $time
144		* The period of time from the present after which the item MUST be considered
145		* expired. An integer parameter is understood to be the time in seconds until
146		* expiration. If null is passed explicitly, a default value MAY be used.
147		* If none is set, the value should be stored permanently or for as long as the
148		* implementation allows.
149		*
150		* @return static
151		* The called object.
152		*
153		* @deprecated Use CacheItemInterface::expiresAfter() instead
154		*/
155		public function touch($time)
156		{
157		trigger_error('touch() is deprecated and will be removed in the next major release, use CacheItemInterface::expiresAfter() instead');
158
159		return $this->expiresAfter($time);
160		}
161
162		/**
163		* @param \DateInterval\|int $time
164		* @return $this
165		* @throws \InvalidArgumentException
166		*/
167		public function expiresAfter($time)
168		{
169		if (is_numeric($time)) {
170		if ($time <= 0) {
171		/**
172		* 5 years, however memcached or memory cached will gone when u restart it
173		* just recommended for sqlite. files
174		*/
175		$time = 30 * 24 * 3600 * 5;
176		}
177		$this->expirationDate = $this->expirationDate->add(new \DateInterval(sprintf('PT%dS', $time)));
178		} else if ($time instanceof \DateInterval) {
179		$this->expirationDate = $this->expirationDate->add($time);
180		} else {
181		throw new \InvalidArgumentException('Invalid date format');
182		}
183
184		return $this;
185		}
186
187		/********************
188		*
189		* PSR-6 Extended Methods
190		*
191		*******************/
192
193
194		/**
195		* @return mixed
196		*/
197		public function getUncommittedData()
198		{
199		return $this->data;
200		}
201
202		/**
203		* @return \DateTimeInterface
204		*/
205		public function getExpirationDate()
206		{
207		return $this->expirationDate;
208		}
209
210		/**
211		* @return int
212		*/
213		public function getTtl()
214		{
215		$ttl = $this->expirationDate->getTimestamp() - time();
216		if ($ttl > 2592000) {
217		$ttl = time() + $ttl;
218		}
219
220		return $ttl;
221		}
222
223		/**
224		* @return bool
225		*/
226		public function isExpired()
227		{
228		return $this->expirationDate->getTimestamp() < (new \DateTime())->getTimestamp();
229		}
230
231		/**
232		* @param int $step
233		* @return $this
234		* @throws \InvalidArgumentException
235		*/
236	View Code Duplication	public function increment($step = 1)
		1 ignored issue – show Duplication introduced 2016-05-12 20:38 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...
237		{
238		if (is_int($step)) {
239		$this->fetched = true;
240		$this->data += $step;
241		} else {
242		throw new \InvalidArgumentException('$step must be numeric.');
243		}
244
245		return $this;
246		}
247
248		/**
249		* @param int $step
250		* @return $this
251		* @throws \InvalidArgumentException
252		*/
253	View Code Duplication	public function decrement($step = 1)
		1 ignored issue – show Duplication introduced 2016-05-12 20:38 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		if (is_int($step)) {
256		$this->fetched = true;
257		$this->data -= $step;
258		} else {
259		throw new \InvalidArgumentException('$step must be numeric.');
260		}
261
262		return $this;
263		}
264
265		/**
266		* @param array\|string $data
267		* @return $this
268		* @throws \InvalidArgumentException
269		*/
270	View Code Duplication	public function append($data)
		1 ignored issue – show Duplication introduced 2016-05-12 20:38 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...
271		{
272		if (is_array($this->data)) {
273		array_push($this->data, $data);
274		} else if (is_string($data)) {
275		$this->data .= (string) $data;
276		} else {
277		throw new \InvalidArgumentException('$data must be either array nor string.');
278		}
279
280		return $this;
281		}
282
283
284		/**
285		* @param array\|string $data
286		* @return $this
287		* @throws \InvalidArgumentException
288		*/
289	View Code Duplication	public function prepend($data)
		1 ignored issue – show Duplication introduced 2016-05-12 20:38 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...
290		{
291		if (is_array($this->data)) {
292		array_unshift($this->data, $data);
293		} else if (is_string($data)) {
294		$this->data = (string) $data . $this->data;
295		} else {
296		throw new \InvalidArgumentException('$data must be either array nor string.');
297		}
298
299		return $this;
300		}
301
302		/**
303		* @param $tagName
304		* @return $this
305		* @throws \InvalidArgumentException
306		*/
307		public function addTag($tagName)
308		{
309		if (is_string($tagName)) {
310		$this->tags = array_unique(array_merge($this->tags, [$tagName]));
311
312		return $this;
313		} else {
314		throw new \InvalidArgumentException('$tagName must be a string');
315		}
316		}
317
318		/**
319		* @param array $tagNames
320		* @return $this
321		*/
322		public function addTags(array $tagNames)
323		{
324		foreach ($tagNames as $tagName) {
325		$this->addTag($tagName);
326		}
327
328		return $this;
329		}
330
331		/**
332		* @param array $tags
333		* @return $this
334		* @throws \InvalidArgumentException
335		*/
336		public function setTags(array $tags)
337		{
338		if (count($tags)) {
339		if (array_filter($tags, 'is_string')) {
340		$this->tags = $tags;
341		} else {
342		throw new \InvalidArgumentException('$tagName must be an array of string');
343		}
344		}
345
346		return $this;
347		}
348
349		/**
350		* @return array
351		*/
352		public function getTags()
353		{
354		return $this->tags;
355		}
356
357		/**
358		* @return string
359		*/
360		public function getTagsAsString($separator = ', ')
361		{
362		return implode($separator, $this->tags);
363		}
364
365		/**
366		* @param $tagName
367		* @return $this
368		*/
369		public function removeTag($tagName)
370		{
371		if (($key = array_search($tagName, $this->tags)) !== false) {
372		unset($this->tags[ $key ]);
373		$this->removedTags[] = $tagName;
374		}
375
376		return $this;
377		}
378
379		/**
380		* @param array $tagNames
381		* @return $this
382		*/
383		public function removeTags(array $tagNames)
384		{
385		foreach ($tagNames as $tagName) {
386		$this->removeTag($tagName);
387		}
388
389		return $this;
390		}
391
392		/**
393		* @return array
394		*/
395		public function getRemovedTags()
396		{
397		return array_diff($this->removedTags, $this->tags);
398		}
399
400		/**
401		* Return the data as a well-formatted string.
402		* Any scalar value will be casted to an array
403		* @param int $option json_encode() options
404		* @param int $depth json_encode() depth
405		* @return string
406		*/
407		public function getDataAsJsonString($option = 0, $depth = 512)
408		{
409		$data = $this->get();
410
411		if (is_object($data) \|\| is_array($data)) {
412		$data = json_encode($data, $option, $depth);
413		} else {
414		$data = json_encode([$data], $option, $depth);
415		}
416
417		return json_encode($data, $option, $depth);
418		}
419
420		/**
421		* @throws \RuntimeException
422		*/
423		/* final public function __sleep()
		0 ignored issues – show Unused Code Comprehensibility introduced 2016-05-15 19:56 UTC by Report Bug Copy Issue Report `49%` 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...
424		{
425		$info = get_object_vars($this);
426		$info[ 'driver' ] = 'object(' . get_class($info[ 'driver' ]) . ')';
427
428		return (array) $info;
429		}*/
430
431		/**
432		* Prevent recursions for Debug (php 5.6+)
433		* @return array
434		*/
435		final public function __debugInfo()
436		{
437		$info = get_object_vars($this);
438		$info[ 'driver' ] = 'object(' . get_class($info[ 'driver' ]) . ')';
439
440		return (array) $info;
441		}
442		}
443

PHPSocialNetwork / phpfastcache