Soupmix\Cache\APCUCache

Complexity

Total Complexity

20

Size/Duplication

Total Lines	117
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	1

Test Coverage

Coverage

100%

Importance

Changes	5
Bugs	0	Features	3

11 Methods

Rating	Name	Duplication	Size	Complexity
A	get()	0	6	2
A	set()	0	8	2
A	delete()	0	5	1
A	clear()	0	4	1
A	getMultiple()	0	8	2
A	setMultiple()	0	11	3
A	deleteMultiple()	0	9	2
A	increment()	0	5	1
A	decrement()	0	5	1
A	has()	0	5	1
A	checkReservedCharacters()	0	13	4

<?php

namespace Soupmix\Cache;

use Soupmix\Cache\Exceptions\InvalidArgumentException;
use Psr\SimpleCache\CacheInterface;
use DateInterval;
use DateTime;

class APCUCache implements CacheInterface
{
    const PSR16_RESERVED_CHARACTERS = ['{','}','(',')','/','@',':'];

    /**
     * {@inheritDoc}
     */
    public function get($key, $default = null)
    {
        $this->checkReservedCharacters($key);
        $value = apcu_fetch($key);
        return $value ?: $default;
    }

    /**
     * {@inheritDoc}
     */
    public function set($key, $value, $ttl = null)
    {
        $this->checkReservedCharacters($key);
        if ($ttl instanceof DateInterval) {
            $ttl = (new DateTime('now'))->add($ttl)->getTimeStamp() - time();
        }
        return apcu_store($key, $value, (int) $ttl);

The expression apcu_store($key, $value, (int) $ttl); of type boolean|array adds the type array to the return on line 33 which is incompatible with the return type declared by the interface Psr\SimpleCache\CacheInterface::set of type boolean.

    }

    /**
     * {@inheritDoc}
     */
    public function delete($key)
    {
        $this->checkReservedCharacters($key);
        return (bool) apcu_delete($key);
    }

    /**
     * {@inheritDoc}
     */
    public function clear()
    {
        return apcu_clear_cache();
    }
    /**
     * {@inheritDoc}
     */
    public function getMultiple($keys, $default = null)
    {
        $defaults = array_fill(0, count($keys), $default);
        foreach ($keys as $key) {
            $this->checkReservedCharacters($key);
        }
        return array_merge(apcu_fetch($keys), $defaults);

The return type of return array_merge(apcu_fetch($keys), $defaults); (array) is incompatible with the return type declared by the interface Psr\SimpleCache\CacheInterface::getMultiple of type Psr\SimpleCache\iterable.

    }

    /**
     * {@inheritDoc}
     */
    public function setMultiple($values, $ttl = null)
    {
        foreach ($values as $key => $value) {
            $this->checkReservedCharacters($key);
        }
        if ($ttl instanceof DateInterval) {
            $ttl = (new DateTime('now'))->add($ttl)->getTimeStamp() - time();
        }
        $result =  apcu_store($values, null, $ttl);
        return empty($result);
    }

    /**
     * {@inheritDoc}
     */
    public function deleteMultiple($keys)
    {
        $ret = [];
        foreach ($keys as $key) {
            $this->checkReservedCharacters($key);
            $ret[$key] = apcu_delete($key);
        }
        return $ret;

The return type of return $ret; (array) is incompatible with the return type declared by the interface Psr\SimpleCache\CacheInterface::deleteMultiple of type boolean.

    }

    public function increment($key, $step = 1)
    {
        $this->checkReservedCharacters($key);
        return apcu_inc($key, $step);
    }

    public function decrement($key, $step = 1)
    {
        $this->checkReservedCharacters($key);
        return apcu_dec($key, $step);
    }

    /**
     * {@inheritDoc}
     */
    public function has($key)
    {
        $this->checkReservedCharacters($key);
        return apcu_exists($key);

The expression apcu_exists($key); of type boolean|string[] adds the type string[] to the return on line 110 which is incompatible with the return type declared by the interface Psr\SimpleCache\CacheInterface::has of type boolean.

    }

    private function checkReservedCharacters($key)
    {
        if (!is_string($key)) {
            $message = sprintf('key %s is not a string.', $key);
            throw new InvalidArgumentException($message);
        }
        foreach (self::PSR16_RESERVED_CHARACTERS as $needle) {
            if (strpos($key, $needle) !== false) {
                $message = sprintf('%s string is not a legal value.', $key);
                throw new InvalidArgumentException($message);
            }
        }
    }
}