BenTools\Currency\Cache\ArrayCache

Complexity

Total Complexity

22

Size/Duplication

Total Lines	128
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	0

Importance

Changes

0

12 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	get()	0	10	3
A	set()	0	5	1
A	delete()	0	4	1
A	clear()	0	5	1
A	getMultiple()	0	6	2
A	setMultiple()	0	6	2
A	deleteMultiple()	0	6	2
A	has()	0	4	2
A	isIterable()	0	4	2
A	computeExpiryTime()	0	8	2
A	isExpired()	0	7	3

<?php

namespace BenTools\Currency\Cache;

use Psr\SimpleCache\CacheInterface;
use Traversable;

class ArrayCache implements CacheInterface
{

    private $defaultTtl;
    private $storage = [];
    private $expiries = [];

    /**
     * ArrayCache constructor.
     * @param int|null $defaultTtl
     */
    public function __construct(int $defaultTtl = null)
    {
        $this->defaultTtl = $defaultTtl;
    }

    /**
     * @inheritDoc
     */
    public function get($key, $default = null)
    {
        if ($this->has($key)) {
            return $this->storage[$key];
        }
        if ($this->isExpired($key)) {
            $this->delete($key);
        }
        return $default;
    }

    /**
     * @inheritDoc
     */
    public function set($key, $value, $ttl = null)
    {
        $this->storage[$key] = $value;
        $this->expiries[$key] = $this->computeExpiryTime($ttl);

It seems like $ttl defined by parameter $ttl on line 41 can also be of type object<DateInterval>; however, BenTools\Currency\Cache\ArrayCache::computeExpiryTime() does only seem to accept null|integer, maybe add an additional type check?

    }

    /**
     * @inheritDoc
     */
    public function delete($key)
    {
        unset($this->storage[$key], $this->expiries[$key]);
    }

    /**
     * @inheritDoc
     */
    public function clear()
    {
        $this->storage = [];
        $this->expiries = [];
    }

    /**
     * @inheritDoc
     */
    public function getMultiple($keys, $default = null)
    {
        foreach ($keys as $key) {
            yield $key => $this->get($key, $default);
        }
    }

    /**
     * @inheritDoc
     */
    public function setMultiple($values, $ttl = null)
    {
        if (!$this->isIterable($values)) {
            throw new \InvalidArgumentException("Values must be array or Traversable");
        }
    }

    /**
     * @inheritDoc
     */
    public function deleteMultiple($keys)
    {
        foreach ($keys as $key) {
            $this->delete($key);
        }
    }

    /**
     * @inheritDoc
     */
    public function has($key)
    {
        return isset($this->storage[$key]) && !$this->isExpired($key);
    }

    /**
     * @param $values
     * @return bool
     */
    private function isIterable($values): bool
    {
        return is_array($values) || $values instanceof Traversable;
    }

    /**
     * @param int|null $ttl
     * @return int|null
     */
    private function computeExpiryTime(int $ttl = null): ?int
    {
        $ttl = $ttl ?? $this->defaultTtl;
        if (null === $ttl) {
            return null;
        }
        return time() + $ttl;
    }

    /**
     * @param $key
     * @return bool
     */
    private function isExpired($key): bool
    {
        if (isset($this->expiries[$key]) && null !== $this->expiries[$key]) {
            return time() <= $this->expiries[$key];
        }
        return false;
    }
}