Code Coverage
 
Classes and Traits
Functions and Methods
Lines
Total
100.00% covered (success)
100.00%
1 / 1
100.00% covered (success)
100.00%
10 / 10
CRAP
100.00% covered (success)
100.00%
40 / 40
Pool
100.00% covered (success)
100.00%
1 / 1
100.00% covered (success)
100.00%
10 / 10
21
100.00% covered (success)
100.00%
40 / 40
 __construct
100.00% covered (success)
100.00%
1 / 1
2
100.00% covered (success)
100.00%
4 / 4
 getItem
100.00% covered (success)
100.00%
1 / 1
2
100.00% covered (success)
100.00%
4 / 4
 getItems
100.00% covered (success)
100.00%
1 / 1
4
100.00% covered (success)
100.00%
9 / 9
 hasItem
100.00% covered (success)
100.00%
1 / 1
2
100.00% covered (success)
100.00%
4 / 4
 clear
100.00% covered (success)
100.00%
1 / 1
1
100.00% covered (success)
100.00%
1 / 1
 deleteItem
100.00% covered (success)
100.00%
1 / 1
2
100.00% covered (success)
100.00%
4 / 4
 deleteItems
100.00% covered (success)
100.00%
1 / 1
1
100.00% covered (success)
100.00%
2 / 2
 save
100.00% covered (success)
100.00%
1 / 1
1
100.00% covered (success)
100.00%
1 / 1
 saveDeferred
100.00% covered (success)
100.00%
1 / 1
1
100.00% covered (success)
100.00%
3 / 3
 commit
100.00% covered (success)
100.00%
1 / 1
5
100.00% covered (success)
100.00%
8 / 8
1<?php declare(strict_types=1);
2/**
3 * Banker
4 *
5 * A Caching library implementing psr/cache (PSR 6) and psr/simple-cache (PSR 16)
6 *
7 * PHP version 7.4
8 *
9 * @package     Banker
10 * @author      Timothy J. Warren <tim@timshomepage.net>
11 * @copyright   2016 - 2020  Timothy J. Warren
12 * @license     http://www.opensource.org/licenses/mit-license.html  MIT License
13 * @version     3.1.0
14 * @link        https://git.timshomepage.net/timw4mail/banker
15 */
16namespace Aviat\Banker;
17
18use Aviat\Banker\Exception\InvalidArgumentException;
19use Psr\Cache\{CacheItemInterface, CacheItemPoolInterface};
20use Psr\Log\{LoggerAwareInterface, LoggerInterface};
21
22use function is_string;
23
24/**
25 * The main cache manager
26 */
27final class Pool implements CacheItemPoolInterface, LoggerAwareInterface {
28    use _Driver;
29    use LoggerTrait;
30
31    /**
32     * Cache Items to be saved
33     *
34     * @var array
35     */
36    protected array $deferred = [];
37
38    /**
39     * Set up the cache backend
40     *
41     * @param array $config
42     * @param LoggerInterface $logger
43     */
44    public function __construct(array $config, ?LoggerInterface $logger = NULL)
45    {
46        $this->driver = $this->loadDriver($config);
47
48        if ($logger !== NULL)
49        {
50            $this->setLogger($logger);
51        }
52    }
53
54    /**
55     * Returns a Cache Item representing the specified key.
56     *
57     * This method must always return a CacheItemInterface object, even in case of
58     * a cache miss. It MUST NOT return null.
59     *
60     * @param string $key
61     *   The key for which to return the corresponding Cache Item.
62     *
63     * @throws InvalidArgumentException
64     *   If the $key string is not a legal value a \Psr\Cache\InvalidArgumentException
65     *   MUST be thrown.
66     *
67     * @return CacheItemInterface
68     *   The corresponding Cache Item.
69     */
70    public function getItem($key): CacheItemInterface
71    {
72        $this->validateKey($key);
73
74        // If a deferred item exists, return that
75        if (array_key_exists($key, $this->deferred))
76        {
77            return $this->deferred[$key];
78        }
79
80        return new Item($this->driver, $key);
81    }
82
83    /**
84     * Returns a traversable set of cache items.
85     *
86     * @param string[] $keys
87     *   An indexed array of keys of items to retrieve.
88     *
89     * @throws InvalidArgumentException
90     *   If any of the keys in $keys are not a legal value a \Psr\Cache\InvalidArgumentException
91     *   MUST be thrown.
92     *
93     * @return array|\Traversable
94     *   A traversable collection of Cache Items keyed by the cache keys of
95     *   each item. A Cache item will be returned for each key, even if that
96     *   key is not found. However, if no keys are specified then an empty
97     *   traversable MUST be returned instead.
98     */
99    public function getItems(array $keys = [])
100    {
101        $this->validateKeys($keys);
102
103        if (empty($keys))
104        {
105            return new ItemCollection([]);
106        }
107
108        // Get the set of items selected
109        $items = [];
110        foreach($keys as $key)
111        {
112            $items[$key] = array_key_exists($key, $this->deferred)
113                ? $this->deferred[$key]
114                : new Item($this->driver, $key);
115        }
116
117        return new ItemCollection($items);
118    }
119
120    /**
121     * Confirms if the cache contains specified cache item.
122     *
123     * Note: This method MAY avoid retrieving the cached value for performance reasons.
124     * This could result in a race condition with CacheItemInterface::get(). To avoid
125     * such situation use CacheItemInterface::isHit() instead.
126     *
127     * @param string $key
128     *   The key for which to check existence.
129     *
130     * @throws InvalidArgumentException
131     *   If the $key string is not a legal value a \Psr\Cache\InvalidArgumentException
132     *   MUST be thrown.
133     *
134     * @return bool
135     *   True if item exists in the cache, false otherwise.
136     */
137    public function hasItem($key): bool
138    {
139        $this->validateKey($key);
140
141        // See if there are any deferred items
142        if (array_key_exists($key, $this->deferred))
143        {
144            return TRUE;
145        }
146
147        return $this->driver->exists($key);
148    }
149
150    /**
151     * Deletes all items in the pool.
152     *
153     * @return bool
154     *   True if the pool was successfully cleared. False if there was an error.
155     */
156    public function clear(): bool
157    {
158        return $this->driver->flush();
159    }
160
161    /**
162     * Removes the item from the pool.
163     *
164     * @param string $key
165     *   The key to delete.
166     *
167     * @throws InvalidArgumentException
168     *   If the $key string is not a legal value a \Psr\Cache\InvalidArgumentException
169     *   MUST be thrown.
170     *
171     * @return bool
172     *   True if the item was successfully removed. False if there was an error.
173     */
174    public function deleteItem($key): bool
175    {
176        $this->validateKey($key);
177
178        if ( ! $this->hasItem($key))
179        {
180            return FALSE;
181        }
182
183        return $this->driver->delete($key);
184    }
185
186    /**
187     * Removes multiple items from the pool.
188     *
189     * @param string[] $keys
190     *   An array of keys that should be removed from the pool.
191
192     * @throws InvalidArgumentException
193     *   If any of the keys in $keys are not a legal value a \Psr\Cache\InvalidArgumentException
194     *   MUST be thrown.
195     *
196     * @return bool
197     *   True if the items were successfully removed. False if there was an error.
198     */
199    public function deleteItems(array $keys): bool
200    {
201        $this->validateKeys($keys);
202
203        return $this->driver->deleteMultiple($keys);
204    }
205
206    /**
207     * Persists a cache item immediately.
208     *
209     * @param CacheItemInterface $item
210     *   The cache item to save.
211     *
212     * @return bool
213     *   True if the item was successfully persisted. False if there was an error.
214     */
215    public function save(CacheItemInterface $item): bool
216    {
217        return $item->save();
218    }
219
220    /**
221     * Sets a cache item to be persisted later.
222     *
223     * @param CacheItemInterface $item
224     *   The cache item to save.
225     *
226     * @return bool
227     *   False if the item could not be queued or if a commit was attempted and failed. True otherwise.
228     */
229    public function saveDeferred(CacheItemInterface $item): bool
230    {
231        $key = $item->getKey();
232        $this->deferred[$key] = $item;
233
234        return TRUE;
235    }
236
237    /**
238     * Persists any deferred cache items.
239     *
240     * @return bool
241     *   True if all not-yet-saved items were successfully saved or there were none. False otherwise.
242     */
243    public function commit(): bool
244    {
245        if (empty($this->deferred))
246        {
247            return TRUE;
248        }
249
250        $result = TRUE;
251
252        foreach($this->deferred as $item)
253        {
254            $result = $result && $this->save($item);
255        }
256
257        if ($result === TRUE)
258        {
259            $this->deferred = [];
260        }
261
262        return $result;
263    }
264}