Initial commit

Author: kodeart

.gitattributes

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

.gitignore

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

CacheItem.php

@@ -0,0 +1,86 @@
+<?php
+
+namespace Koded\Caching;
+
+use Psr\Cache\CacheItemInterface;
+
+
+abstract class CacheItem implements CacheItemInterface
+{
+    /** @var mixed */
+    protected $value;
+
+    /** @var Cache */
+    protected $client;
+
+    /** @var string */
+    private $key;
+
+    /** @var int Unix timestamp for expiration time */
+    private $expiresAt;
+
+    public function __construct(Cache $client, string $key)
+    {
+        $this->key = $key;
+        $this->client = $client;
+    }
+
+    public function __destruct()
+    {
+        unset($this->client);
+    }
+
+    public function getKey(): string
+    {
+        return $this->key;
+    }
+
+    public function get()
+    {
+        return $this->isHit() ? $this->value : null;
+    }
+
+    public function isHit(): bool
+    {
+        return $this->client->has($this->key);
+    }
+
+    public function set($value)
+    {
+        $this->value = $value;
+
+        return $this;
+    }
+
+    public function expiresAt($expiration)
+    {
+        $this->expiresAt = $expiration;
+
+        return $this;
+    }
+
+    public function expiresAfter($time)
+    {
+        if (null === $time && null !== $global = $this->client->getTtl()) {
+            $this->expiresAt = time() + cache_ttl($global);
+
+            return $this;
+        }
+
+        $seconds = cache_ttl($time);
+        $this->expiresAt = $seconds ? time() + $seconds : null;
+
+        return $this;
+    }
+
+    /**
+     * Returns expiration time for the cache item.
+     * This method is not part of the PSR-6.
+     *
+     * @return int|null|\DateInterval|\DateTimeInterface
+     */
+    public function ttl()
+    {
+        return $this->expiresAt;
+    }
+}

CacheItemPool.php

@@ -0,0 +1,123 @@
+<?php
+
+namespace Koded\Caching;
+
+use Exception;
+use Koded\Caching\Client\CacheClientFactory;
+use Psr\Cache\{CacheItemInterface, CacheItemPoolInterface};
+use Psr\SimpleCache\CacheInterface;
+
+
+abstract class CacheItemPool implements CacheItemPoolInterface
+{
+    /** @var CacheInterface */
+    protected $client;
+
+    /** @var CacheItemInterface[] */
+    private $deferred = [];
+
+    abstract public function __construct(CacheClientFactory $factory, string $client);
+
+    public function __destruct()
+    {
+        unset($this->client);
+    }
+
+    public function getItems(array $keys = []): array
+    {
+        $collection = [];
+        foreach ($keys as $key) {
+            $collection[$key] = $this->getItem($key);
+        }
+
+        return $collection;
+    }
+
+    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));
+
+        } catch (Exception $e) {
+            throw ExtendedCacheException::from($e);
+        }
+    }
+
+    public function hasItem($key): bool
+    {
+        try {
+            return $this->client->has($key);
+        } catch (Exception $e) {
+            throw ExtendedCacheException::from($e);
+        }
+    }
+
+    public function clear(): bool
+    {
+        if ($this->client->clear()) {
+            $this->deferred = [];
+            return true;
+        }
+
+        return false;
+    }
+
+    public function deleteItems(array $keys): bool
+    {
+        $deleted = 0;
+        foreach ($keys as $key) {
+            $this->deleteItem($key) && ++$deleted;
+        }
+
+        return count($keys) === $deleted;
+    }
+
+    public function deleteItem($key): bool
+    {
+        try {
+            if ($this->client->delete($key)) {
+                unset($this->deferred[$key]);
+                return true;
+            }
+
+            return false;
+
+        } catch (Exception $e) {
+            throw ExtendedCacheException::from($e);
+        }
+    }
+
+    public function saveDeferred(CacheItemInterface $item): bool
+    {
+        $this->deferred[$item->getKey()] = $item;
+
+        return true;
+    }
+
+    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 */
+        $value = (function() {
+            return $this->value;
+        })->bindTo($item, $item);
+
+        return $this->client->set($item->getKey(), $value(), cache_ttl($item->ttl()));
+    }
+}

CachePoolFactory.php

@@ -0,0 +1,38 @@
+<?php
+
+namespace Koded\Caching;
+
+use Koded\Caching\Client\CacheClientFactory;
+use Koded\Caching\Configuration\ConfigFactory;
+use Psr\Cache\CacheItemPoolInterface;
+
+/**
+ * CachePoolFactory creates a new instance of CacheItemPoolInterface classes.
+ *
+ * Production ready:
+ *
+ *  - Redis with redis extension
+ *  - Redis with Predis library
+ *  - Memcached
+ *
+ * Additional for development:
+ *  - File
+ *  - Memory (for testing)
+ *  - Null
+ */
+class CachePoolFactory
+{
+
+    public static function new(string $client, array $parameters = []): CacheItemPoolInterface
+    {
+        $factory = new CacheClientFactory(new ConfigFactory($parameters));
+
+        return new class($factory, strtolower($client)) extends CacheItemPool
+        {
+            public function __construct(CacheClientFactory $factory, string $client)
+            {
+                $this->client = $factory->build($client);
+            }
+        };
+    }
+}

ExtendedCacheException.php

@@ -0,0 +1,15 @@
+<?php
+
+namespace Koded\Caching;
+
+use Exception;
+use Psr\Cache\InvalidArgumentException;
+
+class ExtendedCacheException extends \RuntimeException implements InvalidArgumentException
+{
+
+    public static function from(Exception $e)
+    {
+        return new self($e->getMessage(), $e->getCode(), $e);
+    }
+}

LICENSE

@@ -0,0 +1,30 @@
+BSD 3-Clause License
+
+Koded - Extended Caching Library
+Copyright (c) 2018, Mihail Binev
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+* Neither the name of the copyright holder nor the names of its
+  contributors may be used to endorse or promote products derived from
+  this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

README.md

@@ -0,0 +1,45 @@
+Koded - Extended Caching Library
+================================
+
+[![Minimum PHP Version](https://img.shields.io/badge/php-%3E%3D%207.1-8892BF.svg)](https://php.net/)
+[![Build Status](https://scrutinizer-ci.com/g/kodedphp/cache-extended/badges/build.png?b=master)](https://scrutinizer-ci.com/g/kodedphp/cache-extended/build-status/master)
+[![Code Coverage](https://scrutinizer-ci.com/g/kodedphp/cache-extended/badges/coverage.png?b=master)](https://scrutinizer-ci.com/g/kodedphp/cache-extended/?branch=master)
+[![Scrutinizer Code Quality](https://scrutinizer-ci.com/g/kodedphp/cache-extended/badges/quality-score.png?b=master)](https://scrutinizer-ci.com/g/kodedphp/cache-extended/?branch=master)
+[![Latest Stable Version](https://img.shields.io/packagist/v/koded/cache-extended.svg)](https://packagist.org/packages/koded/cache-extended)
+[![Software license](https://img.shields.io/badge/License-BSD%203--Clause-blue.svg)](LICENSE)
+
+A PSR-6 caching library for PHP 7 using several caching technologies.
+
+
+Requirements
+------------
+
+> The library is not tested on any Windows OS and may not work as expected there.
+
+- PHP 7.1 or higher
+
+
+Usage
+-----
+
+- create an instance of `CacheItemPoolInterface` with desired caching technology
+- manipulate the cache items with the `pool` instance
+
+
+```php
+$pool = CachePoolFactory::new('redis');
+
+$item = $pool->getItem('fubar');
+$item->set('some value');
+$item->expiresAfter(new \DateTime('+3 days'));
+
+$pool->save();
+```
+
+NOTE: The `CachePoolFactory` accepts specific parameters for the underlying caching technology.
+
+This library uses the [Koded Simple Cache][koded-cache-simple]. Please see the README in that repository.
+
+
+
+[koded-cache-simple]: https://github.com/kodedphp/cache-simple