Added support for simple cache (#134)

* Added support for SimpleCache

* Added tests

* Bugfix with cloning

* Style fix

* Minor

* Updated integration tests version

* Bugfix

* Allow same keys

* cs

Author: Nyholm

AbstractCachePool.php

@@ -17,12 +17,13 @@
 use Psr\Cache\CacheItemInterface;
 use Psr\Log\LoggerAwareInterface;
 use Psr\Log\LoggerInterface;
+use Psr\SimpleCache\CacheInterface;
 
 /**
  * @author Aaron Scherer <[email protected]>
  * @author Tobias Nyholm <[email protected]>
  */
-abstract class AbstractCachePool implements PhpCachePool, LoggerAwareInterface
+abstract class AbstractCachePool implements PhpCachePool, LoggerAwareInterface, CacheInterface
 {
     const SEPARATOR_TAG = '!';
 
@@ -281,7 +282,10 @@ protected function validateKey($key)
             ));
             $this->handleException($e, __FUNCTION__);
         }
-
+        if (!isset($key[0])) {
+            $e =  new InvalidArgumentException('Cache key cannot be an empty string');
+            $this->handleException($e, __FUNCTION__);
+        }
         if (preg_match('|[\{\}\(\)/\\\@\:]|', $key)) {
             $e = new InvalidArgumentException(sprintf(
                 'Invalid key: "%s". The key contains one or more characters reserved for future extension: {}()/\@:',
@@ -415,4 +419,140 @@ protected function getTagKey($tag)
     {
         return 'tag'.self::SEPARATOR_TAG.$tag;
     }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function get($key, $default = null)
+    {
+        $item = $this->getItem($key);
+        if (!$item->isHit()) {
+            return $default;
+        }
+
+        return $item->get();
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function set($key, $value, $ttl = null)
+    {
+        $item = $this->getItem($key);
+        $item->set($value);
+        $item->expiresAfter($ttl);
+
+        return $this->save($item);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function delete($key)
+    {
+        return $this->deleteItem($key);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getMultiple($keys, $default = null)
+    {
+        if (!is_array($keys)) {
+            if (!$keys instanceof \Traversable) {
+                throw new InvalidArgumentException('$keys is neither an array nor Traversable');
+            }
+
+            // Since we need to throw an exception if *any* key is invalid, it doesn't
+            // make sense to wrap iterators or something like that.
+            $keys = iterator_to_array($keys, false);
+        }
+
+        $items = $this->getItems($keys);
+
+        return $this->generateValues($default, $items);
+    }
+
+    /**
+     * @param $default
+     * @param $items
+     *
+     * @return \Generator
+     */
+    private function generateValues($default, $items)
+    {
+        foreach ($items as $key => $item) {
+            /** @type $item CacheItemInterface */
+            if (!$item->isHit()) {
+                yield $key => $default;
+            } else {
+                yield $key => $item->get();
+            }
+        }
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function setMultiple($values, $ttl = null)
+    {
+        if (!is_array($values)) {
+            if (!$values instanceof \Traversable) {
+                throw new InvalidArgumentException('$values is neither an array nor Traversable');
+            }
+        }
+
+        $keys        = [];
+        $arrayValues = [];
+        foreach ($values as $key => $value) {
+            if (is_int($key)) {
+                $key = (string) $key;
+            }
+            $this->validateKey($key);
+            $keys[]            = $key;
+            $arrayValues[$key] = $value;
+        }
+
+        $items       = $this->getItems($keys);
+        $itemSuccess = true;
+        foreach ($items as $key => $item) {
+            $item->set($arrayValues[$key]);
+
+            try {
+                $item->expiresAfter($ttl);
+            } catch (InvalidArgumentException $e) {
+                throw new InvalidArgumentException($e->getMessage(), $e->getCode(), $e);
+            }
+
+            $itemSuccess = $itemSuccess && $this->saveDeferred($item);
+        }
+
+        return $itemSuccess && $this->commit();
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function deleteMultiple($keys)
+    {
+        if (!is_array($keys)) {
+            if (!$keys instanceof \Traversable) {
+                throw new InvalidArgumentException('$keys is neither an array nor Traversable');
+            }
+
+            // Since we need to throw an exception if *any* key is invalid, it doesn't
+            // make sense to wrap iterators or something like that.
+            $keys = iterator_to_array($keys, false);
+        }
+
+        return $this->deleteItems($keys);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function has($key)
+    {
+        return $this->hasItem($key);
+    }
 }

CacheItem.php

@@ -12,6 +12,7 @@
 namespace Cache\Adapter\Common;
 
 use Cache\Adapter\Common\Exception\InvalidArgumentException;
+use Cache\TagInterop\TaggableCacheItemInterface;
 
 /**
  * @author Aaron Scherer <[email protected]>
@@ -140,8 +141,10 @@ public function expiresAt($expiration)
     {
         if ($expiration instanceof \DateTimeInterface) {
             $this->expirationTimestamp = $expiration->getTimestamp();
-        } else {
+        } elseif (is_int($expiration) || null === $expiration) {
             $this->expirationTimestamp = $expiration;
+        } else {
+            throw new InvalidArgumentException('Cache item ttl/expiresAt must be of type integer or \DateTimeInterface.');
         }
 
         return $this;
@@ -160,6 +163,8 @@ public function expiresAfter($time)
             $this->expirationTimestamp = $date->getTimestamp();
         } elseif (is_int($time)) {
             $this->expirationTimestamp = time() + $time;
+        } else {
+            throw new InvalidArgumentException('Cache item ttl/expiresAfter must be of type integer or \DateInterval.');
         }
 
         return $this;

Exception/InvalidArgumentException.php

@@ -11,6 +11,9 @@
 
 namespace Cache\Adapter\Common\Exception;
 
-class InvalidArgumentException extends CacheException implements \Psr\Cache\InvalidArgumentException
+use Psr\Cache\InvalidArgumentException as CacheInvalidArgumentException;
+use Psr\SimpleCache\InvalidArgumentException as SimpleCacheInvalidArgumentException;
+
+class InvalidArgumentException extends CacheException implements CacheInvalidArgumentException, SimpleCacheInvalidArgumentException
 {
 }

composer.json

@@ -25,12 +25,13 @@
     "require":           {
         "php":                  "^5.5 || ^7.0",
         "psr/cache":            "^1.0",
+        "psr/simple-cache":     "^1.0",
         "psr/log":              "^1.0",
         "cache/tag-interop":    "^1.0"
     },
     "require-dev":       {
         "phpunit/phpunit":         "^4.0 || ^5.1",
-        "cache/integration-tests": "^0.14"
+        "cache/integration-tests": "^0.16"
     },
     "autoload":          {
         "psr-4": {