flipbox\craft\psr16\SimpleCacheAdapter

Complexity

Total Complexity

34

Size/Duplication

Total Lines	205
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	6

Test Coverage

Coverage

0%

Importance

Changes

0

12 Methods

Rating	Name	Duplication	Size	Complexity
A	init()	0	15	3
A	getCache()	0	4	1
A	get()	0	16	3
A	set()	0	8	1
A	delete()	0	5	2
A	clear()	0	4	1
A	getMultiple()	0	13	4
A	setMultiple()	0	18	6
A	deleteMultiple()	0	17	4
A	has()	0	5	1
A	dateIntervalToSeconds()	0	12	4
A	buildKey()	0	7	4

<?php

/**
 * @copyright  Copyright (c) Flipbox Digital Limited
 * @license    https://github.com/flipbox/craft-psr16/blob/master/LICENSE
 * @link       https://github.com/flipbox/craft-psr16
 */

namespace flipbox\craft\psr16;

use Craft;
use DateInterval;
use DateTime;
use Psr\SimpleCache\CacheInterface;
use yii\base\Component;
use yii\base\InvalidArgumentException;
use yii\caching\CacheInterface as YiiCacheInterface;
use yii\di\Instance;
use yii\helpers\StringHelper;

/**
 * @author Flipbox Factory <hello@flipboxfactory.com>
 * @since 1.0.0
 */
class SimpleCacheAdapter extends Component implements CacheInterface
{
    /**
     * @var YiiCacheInterface
     */
    public $cache;

    /**
     * @throws \yii\base\InvalidConfigException
     */
    public function init()
    {
        parent::init();

        if ($this->cache === null) {
            $this->cache = Craft::$app->getCache();
        }

        $this->cache = Instance::ensure(
            $this->cache instanceof \Closure ?
            call_user_func($this->cache) :
            $this->cache,
            YiiCacheInterface::class
        );
    }

    /**
     * @return YiiCacheInterface
     */
    protected function getCache(): YiiCacheInterface
    {
        return $this->cache;
    }

    /**
     * Cache::get() return false if the value is not in the cache or expired, but PSR-16 return $default(null)
     *
     * @param string $key
     * @param null $default
     * @return bool|mixed|null
     * @throws InvalidArgumentException
     */
    public function get($key, $default = null)
    {
        $key = $this->buildKey($key);

        $data = $this->getCache()->get($key);

        if ($data === false) {
            return $default;
        }

        if ($data === null) {
            return false;
        }

        return $data;
    }

    /**
     * @param string $key
     * @param mixed $value
     * @param null $ttl
     * @param null $dependency
     * @return bool
     * @throws InvalidArgumentException
     */
    public function set($key, $value, $ttl = null, $dependency = null)
    {
        $key = $this->buildKey($key);

        $duration = $this->dateIntervalToSeconds($ttl);

        return $this->getCache()->set($key, $value, $duration, $dependency);
    }

    /**
     * @param string $key
     * @return bool
     */
    public function delete($key)
    {
        $key = $this->buildKey($key);
        return $this->has($key) ? $this->getCache()->delete($key) : true;
    }

    /**
     * @return bool
     */
    public function clear()
    {
        return $this->getCache()->flush();
    }

    /**
     * @param iterable $keys
     * @param null $default
     * @return array|iterable
     */
    public function getMultiple($keys, $default = null)
    {
        if (!$keys instanceof \Traversable && !is_array($keys)) {
            throw new InvalidArgumentException(
                'Invalid keys: ' . var_export($keys, true) . '. Keys should be an array or Traversable of strings.'
            );
        }
        $data = [];
        foreach ($keys as $key) {
            $data[$key] = $this->get($key, $default);
        }
        return $data;
    }

    /**
     * @param iterable $values
     * @param null $ttl
     * @return bool
     */
    public function setMultiple($values, $ttl = null)
    {
        if (!$values instanceof \Traversable && !is_array($values)) {
            throw new InvalidArgumentException(
                'Invalid keys: ' . var_export($values, true) . '. Keys should be an array or Traversable of strings.'
            );
        }
        $pairs = [];
        foreach ($values as $key => $value) {
            $key = $this->buildKey($key);
            $pairs[$key] = $value;
        }
        $res = true;
        foreach ($pairs as $key => $value) {
            $res = $res && $this->set($key, $value, $ttl);
        }
        return $res;
    }

    /**
     * @param iterable $keys
     * @return bool
     */
    public function deleteMultiple($keys)
    {
        if ($keys instanceof \Traversable) {
            $keys = iterator_to_array($keys, false);
        } else {
            if (!is_array($keys)) {
                throw new InvalidArgumentException(
                    'Invalid keys: ' . var_export($keys, true) . '. Keys should be an array or Traversable of strings.'
                );
            }
        }
        $res = true;
        array_map(function ($key) use (&$res) {
            $res = $res && $this->delete($key);
        }, $keys);
        return $res;
    }

    /**
     * @param string $key
     * @return bool
     */
    public function has($key)
    {
        $key = $this->buildKey($key);
        return $this->getCache()->exists($key);
    }

    /**
     * @param $ttl
     * @return null|int
     */
    protected function dateIntervalToSeconds($ttl)
    {
        if ($ttl === null || !is_int($ttl)) {
            return $ttl;
        }

        if ($ttl instanceof DateInterval) {
            return ((new DateTime())->add($ttl))->getTimestamp() - (new DateTime())->getTimestamp();
        }

        return null;
    }


    /**
     * Builds a normalized cache key from a given key.
     *
     * If the given key is a string containing alphanumeric characters only and no more than 32 characters,
     * then the key will be returned back as it is. Otherwise, a normalized key is generated by serializing
     * the given key and applying MD5 hashing.
     *
     * @param mixed $key the key to be normalized
     * @return string the generated cache key
     */
    protected function buildKey($key)
    {
        if (is_string($key)) {
            return ctype_alnum($key) && StringHelper::byteLength($key) <= 32 ? $key : md5($key);
        }
        return md5(json_encode($key));
    }
}