CachePsr16::setMultiple() - Code Metrics - Inspection of "Merge remote-tracking branch 'origin/master'" - voku/simple-cache - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 67b201...64a3e6 )

by Lars

created 2019-02-24 00:05 UTC

CachePsr16::setMultiple() A

↳ Parent: CachePsr16

Complexity

Conditions	4
Paths	3

Size

Total Lines

Duplication

Lines	3
Ratio	17.65 %

Code Coverage

Tests	0
CRAP Score	20

Importance

Changes

Metric	Value
dl	3
loc	17
ccs	0
cts	8
cp	0
rs	9.7
c	0
b	0
f	0
cc	4
nc	3
nop	2
crap	20

<?php

declare(strict_types=1);

namespace voku\cache;

use Psr\SimpleCache\CacheInterface;
use voku\cache\Exception\InvalidArgumentException;

class CachePsr16 extends Cache implements CacheInterface
{
    /**
     * Wipes clean the entire cache's keys.
     *
     * @return bool true on success and false on failure
     */
    public function clear(): bool
    {
        return $this->removeAll();
    }

    /**
     * Delete an item from the cache by its unique key.
     *
     * @param string $key the unique cache key of the item to delete
     *
     * @throws InvalidArgumentException
     *
     * @return bool True if the item was successfully removed. False if there was an error.
     */
    public function delete($key): bool
    {
        if (!\is_string($key)) {
            throw new InvalidArgumentException('$key is not a string:' . \print_r($key, true));
        }

        return $this->removeItem($key);
    }

    /**
     * Deletes multiple cache items in a single operation.
     *
     * @param iterable $keys a list of string-based keys to be deleted
     *
     * @throws InvalidArgumentException
     *
     * @return bool True if the items were successfully removed. False if there was an error.
     */
    public function deleteMultiple($keys): bool
    {
        if (

            !\is_array($keys)
            &&
            !($keys instanceof \Traversable)
        ) {
            throw new InvalidArgumentException('$keys is not iterable:' . \print_r($keys, true));
        }

        $results = [];
        foreach ((array) $keys as $key) {
            $results[] = $this->delete($key);
        }

        return !\in_array(false, $results, true);
    }

    /**
     * Fetches a value from the cache.
     *
     * @param string $key     the unique key of this item in the cache
     * @param mixed  $default default value to return if the key does not exist
     *
     * @throws InvalidArgumentException
     *
     * @return mixed the value of the item from the cache, or $default in case of cache miss
     */
    public function get($key, $default = null)
    {
        if ($this->has($key)) {
            return $this->getItem($key);
        }

        return $default;
    }

    /**
     * Obtains multiple cache items by their unique keys.
     *
     * @param iterable $keys    a list of keys that can obtained in a single operation
     * @param mixed    $default default value to return for keys that do not exist
     *
     * @throws InvalidArgumentException
     *
     * @return iterable A list of key => value pairs. Cache keys that do not exist or are stale will have $default as
     *                  value.
     */
    public function getMultiple($keys, $default = null)
    {
        if (

            !\is_array($keys)
            &&
            !($keys instanceof \Traversable)
        ) {
            throw new InvalidArgumentException('$keys is not iterable:' . \print_r($keys, true));
        }

        $result = [];
        foreach ((array) $keys as $key) {
            $result[$key] = $this->has($key) ? $this->get($key) : $default;
        }

        return $result;
class Author {
    private $name;

    public function __construct($name) {
        $this->name = $name;
    }

    public function getName() {
        return $this->name;
    }
}

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}
    }

    /**
     * Determines whether an item is present in the cache.
     *
     * NOTE: It is recommended that has() is only to be used for cache warming type purposes
     * and not to be used within your live applications operations for get/set, as this method
     * is subject to a race condition where your has() will return true and immediately after,
     * another script can remove it making the state of your app out of date.
     *
     * @param string $key the cache item key
     *
     * @throws InvalidArgumentException
     *
     * @return bool
     */
    public function has($key): bool
    {
        if (!\is_string($key)) {
            throw new InvalidArgumentException('$key is not a string:' . \print_r($key, true));
        }

        return $this->existsItem($key);
    }

    /**
     * Persists data in the cache, uniquely referenced by a key with an optional expiration TTL time.
     *
     * @param string                 $key   the key of the item to store
     * @param mixed                  $value the value of the item to store, must be serializable
     * @param \DateInterval|int|null $ttl   Optional. The TTL value of this item. If no value is sent and
     *                                      the driver supports TTL then the library may set a default value
     *                                      for it or let the driver take care of that.
     *
     * @throws InvalidArgumentException
     *
     * @return bool true on success and false on failure
     */
    public function set($key, $value, $ttl = null): bool
    {
        if (!\is_string($key)) {
            throw new InvalidArgumentException('$key is not a string:' . \print_r($key, true));
        }

        return $this->setItem($key, $value, $ttl);

    }

    /**
     * Persists a set of key => value pairs in the cache, with an optional TTL.
     *
     * @param iterable               $values a list of key => value pairs for a multiple-set operation
     * @param \DateInterval|int|null $ttl    Optional. The TTL value of this item. If no value is sent and
     *                                       the driver supports TTL then the library may set a default value
     *                                       for it or let the driver take care of that.
     *
     * @throws InvalidArgumentException
     *
     * @return bool true on success and false on failure
     */
    public function setMultiple($values, $ttl = null): bool
    {
        if (

            !\is_array($values)
            &&
            !($values instanceof \Traversable)
        ) {
            throw new InvalidArgumentException('$values is not iterable:' . \print_r($values, true));
        }

        $results = [];
        foreach ((array) $values as $key => $value) {
            $results[] = $this->set($key, $value, $ttl);
        }

        return !\in_array(false, $results, true);
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			namespace voku\cache;
6
7			use Psr\SimpleCache\CacheInterface;
8			use voku\cache\Exception\InvalidArgumentException;
9
10			class CachePsr16 extends Cache implements CacheInterface
11			{
12			/**
13			* Wipes clean the entire cache's keys.
14			*
15			* @return bool true on success and false on failure
16			*/
17			public function clear(): bool
18			{
19			return $this->removeAll();
20			}
21
22			/**
23			* Delete an item from the cache by its unique key.
24			*
25			* @param string $key the unique cache key of the item to delete
26			*
27			* @throws InvalidArgumentException
28			*
29			* @return bool True if the item was successfully removed. False if there was an error.
30			*/
31	1		public function delete($key): bool
32			{
33	1		if (!\is_string($key)) {
34			throw new InvalidArgumentException('$key is not a string:' . \print_r($key, true));
35			}
36
37	1		return $this->removeItem($key);
38			}
39
40			/**
41			* Deletes multiple cache items in a single operation.
42			*
43			* @param iterable $keys a list of string-based keys to be deleted
44			*
45			* @throws InvalidArgumentException
46			*
47			* @return bool True if the items were successfully removed. False if there was an error.
48			*/
49			public function deleteMultiple($keys): bool
50			{
51		View Code Duplication	if (
			0 ignored issues – show Duplication introduced 2019-02-24 00:07 UTC by Report Bug Copy Issue Report This code seems to be duplicated across 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...
52			!\is_array($keys)
53			&&
54			!($keys instanceof \Traversable)
55			) {
56			throw new InvalidArgumentException('$keys is not iterable:' . \print_r($keys, true));
57			}
58
59			$results = [];
60			foreach ((array) $keys as $key) {
61			$results[] = $this->delete($key);
62			}
63
64			return !\in_array(false, $results, true);
65			}
66
67			/**
68			* Fetches a value from the cache.
69			*
70			* @param string $key the unique key of this item in the cache
71			* @param mixed $default default value to return if the key does not exist
72			*
73			* @throws InvalidArgumentException
74			*
75			* @return mixed the value of the item from the cache, or $default in case of cache miss
76			*/
77	3		public function get($key, $default = null)
78			{
79	3		if ($this->has($key)) {
80	1		return $this->getItem($key);
81			}
82
83	2		return $default;
84			}
85
86			/**
87			* Obtains multiple cache items by their unique keys.
88			*
89			* @param iterable $keys a list of keys that can obtained in a single operation
90			* @param mixed $default default value to return for keys that do not exist
91			*
92			* @throws InvalidArgumentException
93			*
94			* @return iterable A list of key => value pairs. Cache keys that do not exist or are stale will have $default as
95			* value.
96			*/
97			public function getMultiple($keys, $default = null)
98			{
99		View Code Duplication	if (
			0 ignored issues – show Duplication introduced 2019-02-24 00:07 UTC by Report Bug Copy Issue Report This code seems to be duplicated across 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...
100			!\is_array($keys)
101			&&
102			!($keys instanceof \Traversable)
103			) {
104			throw new InvalidArgumentException('$keys is not iterable:' . \print_r($keys, true));
105			}
106
107			$result = [];
108			foreach ((array) $keys as $key) {
109			$result[$key] = $this->has($key) ? $this->get($key) : $default;
110			}
111
112			return $result;
			0 ignored issues – show Bug Best Practice introduced 2017-10-06 16:14 UTC by Report Bug Copy Issue Report The return type of `return $result;` (`array`) is incompatible with the return type declared by the interface `Psr\SimpleCache\CacheInterface::getMultiple` of type `Psr\SimpleCache\iterable`. If you return a value from a function or method, it should be a sub-type of the type that is given by the parent type f.e. an interface, or abstract method. This is more formally defined by the Lizkov substitution principle, and guarantees that classes that depend on the parent type can use any instance of a child type interchangably. This principle also belongs to the SOLID principles for object oriented design. Let’s take a look at an example: class Author { private $name; public function __construct($name) { $this->name = $name; } public function getName() { return $this->name; } } abstract class Post { public function getAuthor() { return 'Johannes'; } } class BlogPost extends Post { public function getAuthor() { return new Author('Johannes'); } } class ForumPost extends Post { /* ... */ } function my_function(Post $post) { echo strtoupper($post->getAuthor()); } Our function `my_function` expects a `Post` object, and outputs the author of the post. The base class `Post` returns a simple string and outputting a simple string will work just fine. However, the child class `BlogPost` which is a sub-type of `Post` instead decided to return an `object`, and is therefore violating the SOLID principles. If a `BlogPost` were passed to `my_function`, PHP would not complain, but ultimately fail when executing the `strtoupper` call in its body. Loading history...
113			}
114
115			/**
116			* Determines whether an item is present in the cache.
117			*
118			* NOTE: It is recommended that has() is only to be used for cache warming type purposes
119			* and not to be used within your live applications operations for get/set, as this method
120			* is subject to a race condition where your has() will return true and immediately after,
121			* another script can remove it making the state of your app out of date.
122			*
123			* @param string $key the cache item key
124			*
125			* @throws InvalidArgumentException
126			*
127			* @return bool
128			*/
129	4		public function has($key): bool
130			{
131	4		if (!\is_string($key)) {
132			throw new InvalidArgumentException('$key is not a string:' . \print_r($key, true));
133			}
134
135	4		return $this->existsItem($key);
136			}
137
138			/**
139			* Persists data in the cache, uniquely referenced by a key with an optional expiration TTL time.
140			*
141			* @param string $key the key of the item to store
142			* @param mixed $value the value of the item to store, must be serializable
143			* @param \DateInterval\|int\|null $ttl Optional. The TTL value of this item. If no value is sent and
144			* the driver supports TTL then the library may set a default value
145			* for it or let the driver take care of that.
146			*
147			* @throws InvalidArgumentException
148			*
149			* @return bool true on success and false on failure
150			*/
151	3		public function set($key, $value, $ttl = null): bool
152			{
153	3		if (!\is_string($key)) {
154			throw new InvalidArgumentException('$key is not a string:' . \print_r($key, true));
155			}
156
157	3		return $this->setItem($key, $value, $ttl);
			0 ignored issues – show Bug introduced 2017-10-06 16:14 UTC by Report Bug Copy Issue Report It seems like `$ttl` defined by parameter `$ttl` on line 151 can also be of type `null` or `object<DateInterval>`; however, `voku\cache\Cache::setItem()` does only seem to accept `integer`, 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...
158			}
159
160			/**
161			* Persists a set of key => value pairs in the cache, with an optional TTL.
162			*
163			* @param iterable $values a list of key => value pairs for a multiple-set operation
164			* @param \DateInterval\|int\|null $ttl Optional. The TTL value of this item. If no value is sent and
165			* the driver supports TTL then the library may set a default value
166			* for it or let the driver take care of that.
167			*
168			* @throws InvalidArgumentException
169			*
170			* @return bool true on success and false on failure
171			*/
172			public function setMultiple($values, $ttl = null): bool
173			{
174		View Code Duplication	if (
			0 ignored issues – show Duplication introduced 2019-02-24 00:07 UTC by Report Bug Copy Issue Report This code seems to be duplicated across 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...
175			!\is_array($values)
176			&&
177			!($values instanceof \Traversable)
178			) {
179			throw new InvalidArgumentException('$values is not iterable:' . \print_r($values, true));
180			}
181
182			$results = [];
183			foreach ((array) $values as $key => $value) {
184			$results[] = $this->set($key, $value, $ttl);
185			}
186
187			return !\in_array(false, $results, true);
188			}
189			}
190

voku / simple-cache

Push — master ( 67b201...64a3e6 )

CachePsr16::setMultiple() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like