CacheItem::__construct() - Code Metrics - kuzmichus/cache - Measure and Improve Code Quality continuously with Scrutinizer

CacheItem::__construct() A
last analyzed 2016-03-01 09:05 UTC

↳ Parent: CacheItem

Complexity

Conditions	1
Paths	1

Size

Total Lines	7
Code Lines	4

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	1
eloc	4
c	1
b	0
f	0
nc	1
nop	3
dl	0
loc	7
rs	9.4285

<?php
/**
 *
 * PHP version 5.5
 *
 * @package Cache
 * @author  Sergey V.Kuzin <[email protected]>
 * @license MIT
 */

namespace Cache;

use Psr\Cache\CacheItemInterface;

class CacheItem implements CacheItemInterface
{
    protected $key;

    protected $value;

    protected $expiration;

    protected $hit;

    public function __construct($key, $ttl = null, $hit = false)
    {
        $this->key = $key;
        $this->setExpiration($ttl);

        $this->setHit($hit);
    }


    /**
     * Returns the key for the current cache item.
     *
     * The key is loaded by the Implementing Library, but should be available to
     * the higher level callers when needed.
     *
     * @return string
     *   The key string for this cache item.
     */
    public function getKey()
    {
        return $this->key;
    }

    /**
     * Retrieves the value of the item from the cache associated with this objects key.
     *
     * The value returned must be identical to the value original stored by set().
     *
     * if isHit() returns false, this method MUST return null. Note that null
     * is a legitimate cached value, so the isHit() method SHOULD be used to
     * differentiate between "null value was found" and "no value was found."
     *
     * @return mixed
     *   The value corresponding to this cache item's key, or null if not found.
     */
    public function get()
    {
        return $this->value;
    }

    /**
     * Sets the value represented by this cache item.
     *
     * The $value argument may be any item that can be serialized by PHP,
     * although the method of serialization is left up to the Implementing
     * Library.
     *
     * Implementing Libraries MAY provide a default TTL if one is not specified.
     * If no TTL is specified and no default TTL has been set, the TTL MUST
     * be set to the maximum possible duration of the underlying storage
     * mechanism, or permanent if possible.
     *
     * @param mixed $value
     *   The serializable value to be stored.
     * @param int|\DateTime $ttl
     *   - If an integer is passed, it is interpreted as the number of seconds
     *     after which the item MUST be considered expired.
     *   - If a DateTime object is passed, it is interpreted as the point in
     *     time after which the item MUST be considered expired.
     *   - If no value is passed, 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 invoked object.
     */
    public function set($value, $ttl = null)
    {
        $this->value = $value;
        $this->setExpiration($ttl);

        return $this;
    }

    /**
     * Confirms if the cache item lookup resulted in a cache hit.
     *
     * Note: This method MUST NOT have a race condition between calling isHit()
     * and calling get().
     *
     * @return boolean
     *   True if the request resulted in a cache hit.  False otherwise.
     */
    public function isHit()
    {
        return $this->hit;
    }

    /**
     * Confirms if the cache item exists in the cache.
     *
     * Note: This method MAY avoid retrieving the cached value for performance
     * reasons, which could result in a race condition between exists() and get().
     * To avoid that potential race condition use isHit() instead.
     *
     * @return boolean
     *  True if item exists in the cache, false otherwise.
     */
    public function exists()
    {
        return $this->isHit();
    }

    /**
     * Sets the expiration time this cache item.
     *
     * @param \DateTime|\DateTimeImmutable $expiration
     *   The point in time after which the item MUST be considered expired.
     *   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.
     */
    public function expiresAt($expiration)
    {
        if ($expiration instanceof \DateTime) {
            $this->expiration = $expiration;
        } elseif ($expiration instanceof \DateTimeImmutable) {
if ($x instanceof DoesNotExist) {
    // Do something.
}
            $this->expiration = $this->expiration = $expiration;
        } else {
            throw new InvalidArgumentException();
        }

        return $this;
    }

    /**
     * Sets the expiration time 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.
     *
     * @return static
     *   The called object.
     */
    public function expiresAfter($time)
    {
        if (true === is_numeric($time)) {
            $this->expiration = new \DateTime('now +' . $time . ' seconds');
        } elseif ($time instanceof \DateInterval) {
            $this->expiration = new \DateTime('now +' . $time->format('U') . ' seconds');
        } else {
            throw new InvalidArgumentException();
        }

        return $this;
    }

    /**
     * Returns the expiration time of a not-yet-expired cache item.
     *
     * If this cache item is a Cache Miss, this method MAY return the time at
     * which the item expired or the current time if that is not available.
     *
     * @return \DateTime
     *   The timestamp at which this cache item will expire.
     */
    public function getExpiration()
    {
        return $this->expiration;

    }

    /**
     * @param null $ttl
     * @return $this
     */
    public function setExpiration($ttl = null)
    {
        if (true === is_numeric($ttl)) {
            $this->expiration = new \DateTime('now +' . $ttl . ' seconds');
        } elseif ($ttl instanceof \DateTime) {
            $this->expiration = $ttl;
        } elseif (null === $ttl) {
            $this->expiration = new \DateTime('now + 10 years');
        } else {
            throw new InvalidArgumentException();
        }
        return $this;
    }

    /**
     * @param boolean $hit
     *
     * @return CacheItem
     * @throws InvalidArgumentException not a boolean value given
     */
    public function setHit($hit)
    {
        /*        if (false === is_bool($hit)) {

            throw InvalidArgumentException::typeMismatch($hit, 'Boolean');
        }*/
        $this->hit = $hit;
        return $this;
    }
}


CacheItem::__construct() A
last analyzed 2016-03-01 09:05 UTC

Complexity

Size

Duplication

Importance

1. Missing dependencies

2. Missing use statement

1			<?php
2			/**
3			*
4			* PHP version 5.5
5			*
6			* @package Cache
7			* @author Sergey V.Kuzin <[email protected]>
8			* @license MIT
9			*/
10
11			namespace Cache;
12
13			use Psr\Cache\CacheItemInterface;
14
15			class CacheItem implements CacheItemInterface
16			{
17			protected $key;
18
19			protected $value;
20
21			protected $expiration;
22
23			protected $hit;
24
25			public function __construct($key, $ttl = null, $hit = false)
26			{
27			$this->key = $key;
28			$this->setExpiration($ttl);
29
30			$this->setHit($hit);
31			}
32
33
34			/**
35			* Returns the key for the current cache item.
36			*
37			* The key is loaded by the Implementing Library, but should be available to
38			* the higher level callers when needed.
39			*
40			* @return string
41			* The key string for this cache item.
42			*/
43			public function getKey()
44			{
45			return $this->key;
46			}
47
48			/**
49			* Retrieves the value of the item from the cache associated with this objects key.
50			*
51			* The value returned must be identical to the value original stored by set().
52			*
53			* if isHit() returns false, this method MUST return null. Note that null
54			* is a legitimate cached value, so the isHit() method SHOULD be used to
55			* differentiate between "null value was found" and "no value was found."
56			*
57			* @return mixed
58			* The value corresponding to this cache item's key, or null if not found.
59			*/
60			public function get()
61			{
62			return $this->value;
63			}
64
65			/**
66			* Sets the value represented by this cache item.
67			*
68			* The $value argument may be any item that can be serialized by PHP,
69			* although the method of serialization is left up to the Implementing
70			* Library.
71			*
72			* Implementing Libraries MAY provide a default TTL if one is not specified.
73			* If no TTL is specified and no default TTL has been set, the TTL MUST
74			* be set to the maximum possible duration of the underlying storage
75			* mechanism, or permanent if possible.
76			*
77			* @param mixed $value
78			* The serializable value to be stored.
79			* @param int\|\DateTime $ttl
80			* - If an integer is passed, it is interpreted as the number of seconds
81			* after which the item MUST be considered expired.
82			* - If a DateTime object is passed, it is interpreted as the point in
83			* time after which the item MUST be considered expired.
84			* - If no value is passed, a default value MAY be used. If none is set,
85			* the value should be stored permanently or for as long as the
86			* implementation allows.
87			* @return static
88			* The invoked object.
89			*/
90			public function set($value, $ttl = null)
91			{
92			$this->value = $value;
93			$this->setExpiration($ttl);
			0 ignored issues – show Bug introduced 2016-03-01 09:04 UTC by Report Bug Copy Issue Report It seems like `$ttl` defined by parameter `$ttl` on line 90 can also be of type `integer` or `object<DateTime>`; however, `Cache\CacheItem::setExpiration()` does only seem to accept `null`, maybe add an additional type check? This check looks at variables that have been passed in as parameters and are passed out again to other methods. If the outgoing method call has stricter type requirements than the method itself, an issue is raised. An additional type check may prevent trouble. Loading history...
94			return $this;
95			}
96
97			/**
98			* Confirms if the cache item lookup resulted in a cache hit.
99			*
100			* Note: This method MUST NOT have a race condition between calling isHit()
101			* and calling get().
102			*
103			* @return boolean
104			* True if the request resulted in a cache hit. False otherwise.
105			*/
106			public function isHit()
107			{
108			return $this->hit;
109			}
110
111			/**
112			* Confirms if the cache item exists in the cache.
113			*
114			* Note: This method MAY avoid retrieving the cached value for performance
115			* reasons, which could result in a race condition between exists() and get().
116			* To avoid that potential race condition use isHit() instead.
117			*
118			* @return boolean
119			* True if item exists in the cache, false otherwise.
120			*/
121			public function exists()
122			{
123			return $this->isHit();
124			}
125
126			/**
127			* Sets the expiration time this cache item.
128			*
129			* @param \DateTime\|\DateTimeImmutable $expiration
130			* The point in time after which the item MUST be considered expired.
131			* If null is passed explicitly, a default value MAY be used. If none is set,
132			* the value should be stored permanently or for as long as the
133			* implementation allows.
134			*
135			* @return static
136			* The called object.
137			*/
138			public function expiresAt($expiration)
139			{
140			if ($expiration instanceof \DateTime) {
141			$this->expiration = $expiration;
142			} elseif ($expiration instanceof \DateTimeImmutable) {
			0 ignored issues – show Bug introduced 2015-12-29 07:05 UTC by Report Bug Copy Issue Report The class `DateTimeImmutable` does not exist. Did you forget a USE statement, or did you not list all dependencies? This error could be the result of: 1. Missing dependencies PHP Analyzer uses your `composer.json` file (if available) to determine the dependencies of your project and to determine all the available classes and functions. It expects the `composer.json` to be in the root folder of your repository. Are you sure this class is defined by one of your dependencies, or did you maybe not list a dependency in either the `require` or `require-dev` section? 2. Missing use statement PHP does not complain about undefined classes in `ìnstanceof` checks. For example, the following PHP code will work perfectly fine: if ($x instanceof DoesNotExist) { // Do something. } If you have not tested against this specific condition, such errors might go unnoticed. Loading history...
143			$this->expiration = $this->expiration = $expiration;
144			} else {
145			throw new InvalidArgumentException();
146			}
147
148			return $this;
149			}
150
151			/**
152			* Sets the expiration time this cache item.
153			*
154			* @param int\|\DateInterval $time
155			* The period of time from the present after which the item MUST be considered
156			* expired. An integer parameter is understood to be the time in seconds until
157			* expiration.
158			*
159			* @return static
160			* The called object.
161			*/
162			public function expiresAfter($time)
163			{
164			if (true === is_numeric($time)) {
165			$this->expiration = new \DateTime('now +' . $time . ' seconds');
166			} elseif ($time instanceof \DateInterval) {
167			$this->expiration = new \DateTime('now +' . $time->format('U') . ' seconds');
168			} else {
169			throw new InvalidArgumentException();
170			}
171
172			return $this;
173			}
174
175			/**
176			* Returns the expiration time of a not-yet-expired cache item.
177			*
178			* If this cache item is a Cache Miss, this method MAY return the time at
179			* which the item expired or the current time if that is not available.
180			*
181			* @return \DateTime
182			* The timestamp at which this cache item will expire.
183			*/
184			public function getExpiration()
185			{
186			return $this->expiration;
			0 ignored issues – show Bug Compatibility introduced 2016-03-01 09:04 UTC by Report Bug Copy Issue Report The expression `$this->expiration;` of type `DateTime\|DateTimeImmutable` adds the type `DateTimeImmutable` to the return on line 186 which is incompatible with the return type documented by `Cache\CacheItem::getExpiration` of type `DateTime`. Loading history...
187			}
188
189			/**
190			* @param null $ttl
191			* @return $this
192			*/
193			public function setExpiration($ttl = null)
194			{
195			if (true === is_numeric($ttl)) {
196			$this->expiration = new \DateTime('now +' . $ttl . ' seconds');
197			} elseif ($ttl instanceof \DateTime) {
198			$this->expiration = $ttl;
199			} elseif (null === $ttl) {
200			$this->expiration = new \DateTime('now + 10 years');
201			} else {
202			throw new InvalidArgumentException();
203			}
204			return $this;
205			}
206
207			/**
208			* @param boolean $hit
209			*
210			* @return CacheItem
211			* @throws InvalidArgumentException not a boolean value given
212			*/
213			public function setHit($hit)
214			{
215			/* if (false === is_bool($hit)) {
			0 ignored issues – show Unused Code Comprehensibility introduced 2016-03-01 09:04 UTC by Report Bug Copy Issue Report `57%` 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...
216			throw InvalidArgumentException::typeMismatch($hit, 'Boolean');
217			}*/
218			$this->hit = $hit;
219			return $this;
220			}
221			}
222

kuzmichus / cache

CacheItem::__construct() A last analyzed 2016-03-01 09:05 UTC

Complexity

Size

Duplication

Importance

1. Missing dependencies

2. Missing use statement

Duplication Side-by-Side

Filter issues like

CacheItem::__construct() A
last analyzed 2016-03-01 09:05 UTC