Madewithlove\IlluminatePsrCacheBridge\Laravel\CacheItemPool

Complexity

Total Complexity

30

Size/Duplication

Total Lines	203
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	4

Test Coverage

Coverage

98.67%

Importance

Changes	6
Bugs	2	Features	0

12 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	__destruct()	0	4	1
A	getItem()	0	12	3
A	getItems()	0	6	1
A	hasItem()	0	16	3
A	clear()	0	13	2
A	deleteItem()	0	12	2
A	deleteItems()	0	15	4
B	save()	0	27	4
A	saveDeferred()	0	14	3
A	commit()	0	12	3
A	validateKey()	0	6	3

<?php
namespace Madewithlove\IlluminatePsrCacheBridge\Laravel;

use DateTimeImmutable;
use Exception;
use Illuminate\Contracts\Cache\Repository;
use Madewithlove\IlluminatePsrCacheBridge\Exceptions\InvalidArgumentException;
use Psr\Cache\CacheItemInterface;
use Psr\Cache\CacheItemPoolInterface;

class CacheItemPool implements CacheItemPoolInterface
{
    /**
     * @var \Illuminate\Contracts\Cache\Repository
     */
    private $repository;

    /**
     * @var \Psr\Cache\CacheItemInterface[]
     */
    private $deferred = [];

    /**
     * @param \Illuminate\Contracts\Cache\Repository $repository
     */
    public function __construct(Repository $repository)
    {
        $this->repository = $repository;
    }

    /**
     * Destructor.
     */
    public function __destruct()
    {
        $this->commit();
    }

    /**
     * {@inheritdoc}
     */
    public function getItem($key)
    {
        $this->validateKey($key);

        if (isset($this->deferred[$key])) {
            return clone($this->deferred[$key]);
        } elseif ($this->repository->has($key)) {
            return new CacheItem($key, unserialize($this->repository->get($key)), true);
        } else {
            return new CacheItem($key);
        }
    }

    /**
     * {@inheritdoc}
     */
    public function getItems(array $keys = array())
    {
        return array_combine($keys, array_map(function ($key) {
            return $this->getItem($key);
        }, $keys));
    }

    /**
     * {@inheritdoc}
     */
    public function hasItem($key)
    {
        $this->validateKey($key);

        if (isset($this->deferred[$key])) {
            $item = $this->deferred[$key];

            if (! $item->getExpiresAt()) {

The method getExpiresAt() does not exist on Psr\Cache\CacheItemInterface. Did you maybe mean expiresAt()?

                return true;
            }

            return $item->getExpiresAt() > new DateTimeImmutable();

The method getExpiresAt() does not exist on Psr\Cache\CacheItemInterface. Did you maybe mean expiresAt()?

        }

        return $this->repository->has($key);
    }

    /**
     * {@inheritdoc}
     */
    public function clear()
    {
        try {
            /* @var \Illuminate\Contracts\Cache\Store $store */
            $this->deferred = [];
            $store = $this->repository;
            $store->flush();

It seems like you code against a concrete implementation and not the interface Illuminate\Contracts\Cache\Repository as the method flush() does only exist in the following implementations of said interface: Illuminate\Cache\RedisTaggedCache, Illuminate\Cache\TaggedCache.

        } catch (Exception $exception) {
            return false;
        }

        return true;
    }

    /**
     * {@inheritdoc}
     */
    public function deleteItem($key)
    {
        $this->validateKey($key);

        unset($this->deferred[$key]);

        if (! $this->hasItem($key)) {
            return true;
        }

        return $this->repository->forget($key);
    }

    /**
     * {@inheritdoc}
     */
    public function deleteItems(array $keys)
    {
        // Validating all keys first.
        foreach ($keys as $key) {
            $this->validateKey($key);
        }

        $success = true;

        foreach ($keys as $key) {
            $success = $success && $this->deleteItem($key);
        }

        return $success;
    }

    /**
     * {@inheritdoc}
     */
    public function save(CacheItemInterface $item)
    {
        $expiresAt = $item->getExpiresAt();

The method getExpiresAt() does not exist on Psr\Cache\CacheItemInterface. Did you maybe mean expiresAt()?

        try {
            if (! $expiresAt) {
                $this->repository->forever($item->getKey(), serialize($item->get()));
            } else {
                $now = new DateTimeImmutable('now', $expiresAt->getTimezone());

                $seconds = $expiresAt->getTimestamp() - $now->getTimestamp();
                $minutes = (int) floor($seconds / 60.0);

                if ($minutes <= 0) {
                    $this->repository->forget($item->getKey());

                    return false;
                }

                $this->repository->put($item->getKey(), serialize($item->get()), $minutes);
            }
        } catch (Exception $exception) {
            return false;
        }

        return true;
    }

    /**
     * {@inheritdoc}
     */
    public function saveDeferred(CacheItemInterface $item)
    {
        $expiresAt = $item->getExpiresAt();

The method getExpiresAt() does not exist on Psr\Cache\CacheItemInterface. Did you maybe mean expiresAt()?

        if ($expiresAt && ($expiresAt < new DateTimeImmutable())) {
            return false;
        }

        $item = (new CacheItem($item->getKey(), $item->get(), true))->expiresAt($expiresAt);

        $this->deferred[$item->getKey()] = $item;

        return true;
    }

    /**
     * {@inheritdoc}
     */
    public function commit()
    {
        $success = true;

        foreach ($this->deferred as $key => $item) {
            $success = $success && $this->save($item);
        }

        $this->deferred = [];

        return $success;
    }

    /**
     * @param string $key
     *
     * @throws \Psr\Cache\InvalidArgumentException
     */
    private function validateKey($key)
    {
        if (!is_string($key) || preg_match('#[{}\(\)/\\\\@:]#', $key)) {
            throw new InvalidArgumentException();
        }
    }
}