Stabilized version

Author: kodeart

.gitattributes

@@ -1,6 +1,7 @@
 *.php diff=php
 
-/build     export-ignore
-/Tests     export-ignore
-/phpunit.* export-ignore
-/*.yml     export-ignore
+/build      export-ignore
+/Tests      export-ignore
+/phpunit.*  export-ignore
+/composer.* export-ignore
+/*.yml      export-ignore

.gitignore

@@ -1,9 +1,4 @@
 build
 vendor
-.DS_Store
 .idea
-composer.lock
-phpunit.phar
-*.yml
-.env
-!.travis.yml
+composer.lock

CacheItem.php

@@ -7,79 +7,81 @@
 
 abstract class CacheItem implements CacheItemInterface
 {
+    /** @var string */
+    protected $key;
+
     /** @var mixed */
     protected $value;
 
-    /** @var Cache */
-    protected $client;
+    /** @var bool */
+    protected $isHit = false;
 
-    /** @var string */
-    private $key;
+    /** @var int Number of seconds for the expiration time */
+    protected $expiresAt;
 
-    /** @var int Unix timestamp for expiration time */
-    private $expiresAt;
 
-    public function __construct(Cache $client, string $key)
+    public function __construct($key, ?int $ttl)
     {
+        verify_key($key);
         $this->key = $key;
-        $this->client = $client;
+        $this->expiresAt = $ttl;
     }
 
-    public function __destruct()
-    {
-        unset($this->client);
-    }
 
     public function getKey(): string
     {
         return $this->key;
     }
 
+
     public function get()
     {
-        return $this->isHit() ? $this->value : null;
+        return $this->value;
     }
 
+
     public function isHit(): bool
     {
-        return $this->client->has($this->key);
+        return $this->isHit;
     }
 
+
     public function set($value)
     {
         $this->value = $value;
 
         return $this;
     }
 
-    public function expiresAt($expiration)
-    {
-        $this->expiresAt = $expiration;
 
-        return $this;
+    public function expiresAfter($time)
+    {
+        // The TTL is calculated in the cache client instance
+        return $this->expiresAt($time);
     }
 
-    public function expiresAfter($time)
+
+    public function expiresAt($expiration)
     {
-        if (null === $time && null !== $global = $this->client->getTtl()) {
-            $this->expiresAt = time() + cache_ttl($global);
+        $this->expiresAt = normalize_ttl($expiration ?? $this->expiresAt);
 
-            return $this;
+        if ($this->expiresAt < 1) {
+            $this->isHit = false;
         }
 
-        $seconds = cache_ttl($time);
-        $this->expiresAt = $seconds ? time() + $seconds : null;
-
         return $this;
     }
 
     /**
-     * Returns expiration time for the cache item.
+     * Returns expiration seconds for the cache item.
+     * NULL is reserved for clients who do not support expiry
+     * to implement some custom logic around the TTL.
+     *
      * This method is not part of the PSR-6.
      *
-     * @return int|null|\DateInterval|\DateTimeInterface
+     * @return int|null
      */
-    public function ttl()
+    public function getExpiresAt(): ?int
     {
         return $this->expiresAt;
     }

CacheItemPool.php

@@ -5,119 +5,140 @@
 use Exception;
 use Koded\Caching\Client\CacheClientFactory;
 use Psr\Cache\{CacheItemInterface, CacheItemPoolInterface};
-use Psr\SimpleCache\CacheInterface;
+use function Koded\Stdlib\now;
 
 
 abstract class CacheItemPool implements CacheItemPoolInterface
 {
-    /** @var CacheInterface */
+    /** @var Cache */
     protected $client;
 
     /** @var CacheItemInterface[] */
-    private $deferred = [];
+    protected $deferred = [];
+
 
     abstract public function __construct(CacheClientFactory $factory, string $client);
 
+    // @codeCoverageIgnoreStart
     public function __destruct()
     {
-        unset($this->client);
+        $this->commit();
+    }
+    // @codeCoverageIgnoreEnd
+
+    public function commit(): bool
+    {
+        foreach ($this->deferred as $key => $item) {
+            if (true === $this->save($item)) {
+                unset($this->deferred[$key]);
+            }
+        }
+
+        return empty($this->deferred);
+    }
+
+
+    public function save(CacheItemInterface $item): bool
+    {
+        /** @var CacheItem $item */
+        return $this->client->set($item->getKey(), $item->get(), $item->getExpiresAt());
     }
 
+
     public function getItems(array $keys = []): array
     {
-        $collection = [];
+        $items = [];
         foreach ($keys as $key) {
-            $collection[$key] = $this->getItem($key);
+            $items[$key] = $this->getItem($key);
         }
 
-        return $collection;
+        return $items;
     }
 
+
     public function getItem($key): CacheItemInterface
     {
-        if (isset($this->deferred[$key])) {
-            return $this->deferred[$key];
-        }
-
         try {
-            return (new class($this->client, $key) extends CacheItem
-            {
-            })->set($this->client->get($key));
+            $item = new class($key, $this->client->getTtl()) extends CacheItem {};
+
+            if (false === $this->client->has($key)) {
+                if (isset($this->deferred[$key])) {
+                    return clone $this->deferred[$key];
+                }
+                return $item;
+            }
+
+            (function() {
+                $this->isHit = true;
+
+                return $this;
+            })->call($item);
+
+            return $item->set($this->client->get($key));
 
         } catch (Exception $e) {
-            throw ExtendedCacheException::from($e);
+            throw CachePoolException::from($e);
         }
     }
 
+
     public function hasItem($key): bool
     {
         try {
-            return $this->client->has($key);
+            return isset($this->deferred[$key]) || $this->client->has($key);
         } catch (Exception $e) {
-            throw ExtendedCacheException::from($e);
+            throw CachePoolException::from($e);
         }
     }
 
+
     public function clear(): bool
     {
-        if ($this->client->clear()) {
+        if ($cleared = $this->client->clear()) {
             $this->deferred = [];
-            return true;
         }
 
-        return false;
+        return $cleared;
     }
 
+
     public function deleteItems(array $keys): bool
     {
-        $deleted = 0;
-        foreach ($keys as $key) {
-            $this->deleteItem($key) && ++$deleted;
+        try {
+            return $this->client->deleteMultiple($keys);
+        } catch (Exception $e) {
+            throw CachePoolException::from($e);
         }
-
-        return count($keys) === $deleted;
     }
 
+
     public function deleteItem($key): bool
     {
         try {
-            if ($this->client->delete($key)) {
+            if ($deleted = $this->client->delete($key)) {
                 unset($this->deferred[$key]);
-                return true;
             }
 
-            return false;
+            return $deleted;
 
         } catch (Exception $e) {
-            throw ExtendedCacheException::from($e);
+            throw CachePoolException::from($e);
         }
     }
 
-    public function saveDeferred(CacheItemInterface $item): bool
-    {
-        $this->deferred[$item->getKey()] = $item;
 
-        return true;
-    }
-
-    public function commit(): bool
+    public function saveDeferred(CacheItemInterface $item): bool
     {
-        foreach ($this->deferred as $key => $item) {
-            if (true === $this->save($item)) {
-                unset($this->deferred[$key]);
-            }
+        /** @var CacheItem $item */
+        if (null !== $item->getExpiresAt() && $item->getExpiresAt() <= now()->getTimestamp()) {
+            return false;
         }
 
-        return empty($this->deferred);
-    }
+        $this->deferred[$item->getKey()] = (function() {
+            $this->isHit = true;
+            return $this;
+        })->call($item);
 
-    public function save(CacheItemInterface $item): bool
-    {
-        /** @var CacheItem $item */
-        $value = (function() {
-            return $this->value;
-        })->bindTo($item, $item);
-
-        return $this->client->set($item->getKey(), $value(), cache_ttl($item->ttl()));
+        return true;
     }
 }

CachePool.php

@@ -0,0 +1,69 @@
+<?php
+
+namespace Koded\Caching;
+
+use Exception;
+use Koded\Caching\Client\CacheClientFactory;
+use Koded\Caching\Configuration\ConfigFactory;
+use Psr\Cache\CacheItemPoolInterface;
+use Psr\Cache\InvalidArgumentException;
+
+/**
+ * CachePool creates instances of CacheItemPoolInterface classes.
+ * The instances are created only once.
+ *
+ * Production ready:
+ *
+ *  - Redis, with redis extension
+ *  - Redis, with Predis library
+ *  - Memcached
+ *
+ * Additional for development:
+ *  - File
+ *  - Memory
+ *
+ */
+final class CachePool
+{
+    /**
+     * @var CacheItemPoolInterface[] The registry
+     */
+    private static $instances = [];
+
+    /**
+     * @param string $client     The name of the cache client
+     * @param array  $parameters [optional] Configuration parameters for the cache client
+     *
+     * @return CacheItemPoolInterface
+     */
+    public static function use(string $client, array $parameters = []): CacheItemPoolInterface
+    {
+        $ident = md5($client . serialize($parameters));
+
+        if (isset(self::$instances[$ident])) {
+            return self::$instances[$ident];
+        }
+
+        $factory = new CacheClientFactory(new ConfigFactory($parameters));
+
+        return self::$instances[$ident] = new class($factory, strtolower($client)) extends CacheItemPool
+        {
+            public function __construct(CacheClientFactory $factory, string $client)
+            {
+                $this->client = $factory->new($client);
+            }
+        };
+    }
+}
+
+/**
+ * Implementation for \Psr\Cache\InvalidArgumentException
+ *
+ */
+class CachePoolException extends Exception implements InvalidArgumentException
+{
+    public static function from(Exception $e)
+    {
+        return new self($e->getMessage(), $e->getCode());
+    }
+}