Desarrolla2\Cache\Memcached

Complexity

Total Complexity

25

Size/Duplication

Total Lines	190
Duplicated Lines	0 %

Test Coverage

Coverage

96.77%

Importance

Changes

0

12 Methods

Rating	Name	Duplication	Size	Complexity
A	has()	0	8	1
A	packValues()	0	10	3
A	delete()	0	7	2
A	assertKey()	0	6	2
A	get()	0	11	2
A	getMultiple()	0	19	4
A	createDefaultPacker()	0	3	1
A	set()	0	14	2
A	ttlToMemcachedTime()	0	10	4
A	setMultiple()	0	12	2
A	__construct()	0	3	1
A	clear()	0	3	1

<?php

/*
 * This file is part of the Cache package.
 *
 * Copyright (c) Daniel González
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 *
 * @author Daniel González <daniel@desarrolla2.com>
 * @author Arnold Daniels <arnold@jasny.net>
 */

declare(strict_types=1);

namespace Desarrolla2\Cache;

use Desarrolla2\Cache\Exception\InvalidArgumentException;
use Desarrolla2\Cache\Packer\PackerInterface;
use Desarrolla2\Cache\Packer\NopPacker;
use Memcached as MemcachedServer;

/**
 * Memcached
 */
class Memcached extends AbstractCache
{
    /**
     * @var MemcachedServer
     */
    protected $server;

    /**
     * @param MemcachedServer $server
     */
    public function __construct(MemcachedServer $server)
    {
        $this->server = $server;
    }


    /**
     * Create the default packer for this cache implementation
     *
     * @return PackerInterface
     */
    protected static function createDefaultPacker(): PackerInterface
    {
        return new NopPacker();
    }

    /**
     * Validate the key
     *
     * @param string $key
     * @return void
     * @throws InvalidArgumentException
     */
    protected function assertKey($key): void
    {
        parent::assertKey($key);

        if (strlen($key) > 250) {
            throw new InvalidArgumentException("Key to long, max 250 characters");
        }
    }

    /**
     * Pack all values and turn keys into ids
     *
     * @param iterable $values
     * @return array
     */
    protected function packValues(iterable $values): array
    {
        $packed = [];

        foreach ($values as $key => $value) {
            $this->assertKey(is_int($key) ? (string)$key : $key);
            $packed[$key] = $this->pack($value);
        }

        return $packed;
    }


    /**
     * {@inheritdoc}
     */
    public function get($key, $default = null)
    {
        $this->assertKey($key);

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

        if ($this->server->getResultCode() !== MemcachedServer::RES_SUCCESS) {
            return $default;
        }

        return $this->unpack($data);
    }

    /**
     * {@inheritdoc}
     */
    public function has($key)
    {
        $this->assertKey($key);
        $this->server->get($key);

        $result = $this->server->getResultCode();

        return $result === MemcachedServer::RES_SUCCESS;
    }

    /**
     * {@inheritdoc}
     */
    public function set($key, $value, $ttl = null)
    {
        $this->assertKey($key);

        $packed = $this->pack($value);
        $ttlTime = $this->ttlToMemcachedTime($ttl);

        if ($ttlTime === false) {

The condition $ttlTime === false is always false.

            return $this->delete($key);
        }

        $success = $this->server->set($key, $packed, $ttlTime);

        return $success;
    }

    /**
     * {@inheritdoc}
     */
    public function delete($key)
    {
        $this->server->delete($this->keyToId($key));

        $result = $this->server->getResultCode();

        return $result === MemcachedServer::RES_SUCCESS || $result === MemcachedServer::RES_NOTFOUND;
    }

    /**
     * {@inheritdoc}
     */
    public function getMultiple($keys, $default = null)
    {
        $this->assertIterable($keys, 'keys not iterable');
        $keysArr = is_array($keys) ? $keys : iterator_to_array($keys, false);
        array_walk($keysArr, [$this, 'assertKey']);

        $result = $this->server->getMulti($keysArr);

        if ($result === false) {
            return false;

Method Desarrolla2\Cache\Memcached::getMultiple() should return iterable but returns false.

The expression return false returns the type false which is incompatible with the return type mandated by Psr\SimpleCache\CacheInterface::getMultiple() of iterable.

        }

        $items = array_fill_keys($keysArr, $default);

        foreach ($result as $key => $value) {
            $items[$key] = $this->unpack($value);
        }

        return $items;
    }

    /**
     * {@inheritdoc}
     */
    public function setMultiple($values, $ttl = null)
    {
        $this->assertIterable($values, 'values not iterable');

        $packed = $this->packValues($values);
        $ttlTime = $this->ttlToMemcachedTime($ttl);

        if ($ttlTime === false) {

The condition $ttlTime === false is always false.

            return $this->server->deleteMulti(array_keys($packed));

Method Desarrolla2\Cache\Memcached::setMultiple() should return bool but returns array.

        }

        return $this->server->setMulti($packed, $ttlTime);
    }

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


    /**
     * Convert ttl to timestamp or seconds.
     *
     * @see http://php.net/manual/en/memcached.expiration.php
     *
     * @param null|int|\DateInterval $ttl
     * @return int|null
     * @throws InvalidArgumentException
     */
    protected function ttlToMemcachedTime($ttl)
    {
        $seconds = $this->ttlToSeconds($ttl);

        if ($seconds <= 0) {
            return isset($seconds) ? false : 0;

The expression return IssetNode ? false : 0 could also return false which is incompatible with the documented return type integer|null. Did you maybe forget to handle an error condition?

        }

        /* 2592000 seconds = 30 days */
        return $seconds <= 2592000 ? $seconds : $this->ttlToTimestamp($ttl);
    }
}