CacheItemPool::__sleep() - Code Metrics - Inspection of "Made major changes and fix to classes" - biurad/php-cache - Measure and Improve Code Quality continuously with Scrutinizer

Completed
Push — master ( b2545f...e44389 )

by Divine Niiquaye
created 2020-07-16 13:41 UTC
CacheItemPool::__sleep() A

↳ Parent: CacheItemPool
Complexity

Conditions	1
Paths	1
Size

Total Lines	3
Code Lines	1
Duplication

Lines	0
Ratio	0 %
Importance

Changes
Metric	Value
cc	1
eloc	1
nc	1
nop	0
dl	0
loc	3
rs	10
c	0
b	0
f	0
<?php

declare(strict_types=1);

/*
 * This file is part of BiuradPHP opensource projects.
 *
 * PHP version 7.1 and above required
 *
 * @author    Divine Niiquaye Ibok <[email protected]>
 * @copyright 2019 Biurad Group (https://biurad.com/)
 * @license   https://opensource.org/licenses/BSD-3-Clause License
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Biurad\Cache;

use BadMethodCallException;
use Closure;
use Exception;
use Generator;
use Psr\Cache\CacheItemInterface;
use Psr\Cache\CacheItemPoolInterface;
use Psr\SimpleCache\CacheInterface;
use stdClass;
use Traversable;

class CacheItemPool implements CacheItemPoolInterface
{
    /**
     * @var CacheInterface
     */
    protected $pool;

    /**
     * @var Closure needs to be set by class, signature is function(string <key>, mixed <value>, bool <isHit>)
     */
    private $createCacheItem;

    /**
     * @var Closure needs to be set by class, signature is function(array <deferred>, array <&expiredIds>)
     */
    private $mergeByLifetime;

    /** @var array<string,CacheItemInterface> */
    private $deferred = [];

    /** @var array<string,string> */
    private $ids = [];

    /** @var stdclass */
    private $miss;

    /**
     * Cache Constructor.
     *
     * @psalm-suppress InaccessibleProperty
     * @psalm-suppress PossiblyUndefinedVariable
     *
     * @param CacheInterface $psr16
     */
    public function __construct(CacheInterface $psr16)
    {
        $this->pool = $psr16;
        $this->miss = new stdClass();

        $this->createCacheItem = Closure::bind(
            static function ($key, $value, $isHit) {
                $item = new CacheItem();
                $item->key = $key;

                $item->value = $v = $value;

                $item->isHit = $isHit;

                $item->defaultLifetime = 0;

                // Detect wrapped values that encode for their expiry and creation duration
                // For compactness, these values are packed in the key of an array using
                // magic numbers in the form 9D-..-..-..-..-00-..-..-..-5F
                if (
                    \is_array($v) &&
                    1 === \count($v) &&
                    10 === \strlen($k = (string) \key($v)) &&
                    "\x9D" === $k[0] &&
                    "\0" === $k[5] &&
                    "\x5F" === $k[9]
                ) {
                    $item->value = $v[$k];
                }

                return $item;
            },
            null,
            CacheItem::class
        );
        $getId                 = Closure::fromCallable([$this, 'getId']);
        $this->mergeByLifetime = Closure::bind(
            static function ($deferred, &$expiredIds) use ($getId) {
                $byLifetime = [];
                $now = \microtime(true);
                $expiredIds = [];

                foreach ($deferred as $key => $item) {
                    $key = (string) $key;

                    if (null === $item->expiry) {
                        $ttl = 0 < $item->defaultLifetime ? $item->defaultLifetime : 0;
                    } elseif (0 >= $ttl = (int) (0.1 + $item->expiry - $now)) {
                        $expiredIds[] = $getId($key);

                        continue;
                    }

                    // For compactness, expiry and creation duration are packed in the key of an array,
                    // using magic numbers as separators
                    $byLifetime[$ttl][$getId($key)] = $item->value;
                }

                return $byLifetime;
            },
            null,
            CacheItem::class
        );
    }

    public function __destruct()
    {
        if (\count($this->deferred) > 0) {
            $this->commit();
        }
    }

    public function __sleep(): void
    {
        throw new BadMethodCallException('Cannot serialize ' . __CLASS__);
    }

    public function __wakeup(): void
    {
        throw new BadMethodCallException('Cannot unserialize ' . __CLASS__);
    }

    /**
     * {@inheritdoc}
     */
    public function getItem($key)
    {
        if (\count($this->deferred) > 0) {
            $this->commit();
        }

        $id    = $this->getId($key);
        $f     = $this->createCacheItem;
        $isHit = false;
        $value = null;

        try {
            foreach ($this->doFetch([$id]) as $value) {
                $isHit = true;
            }

            return $f($key, $value, $isHit);
        } catch (Exception $e) {
            return $f($key, null, false);
        }
    }

    /**
     * {@inheritdoc}
     *
     * @return array<string,CacheItemInterface>|Traversable
     */
    public function getItems(array $keys = [])
    {
        if (\count($this->deferred) > 0) {
            $this->commit();
        }
        $kIds = [];

        foreach ($keys as $key) {
            $kIds[] = $this->getId($key);
        }

        $items  = $this->doFetch($kIds);
        $kIds   = \array_combine($kIds, $keys);

        return $this->generateItems($items, $kIds);
        return $this->generateItems($items, /** @scrutinizer ignore-type */ $kIds);
    }

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

        if (isset($this->deferred[$key])) {
            $this->commit();
        }

        return $this->doHave($id);
    }

    /**
     * {@inheritdoc}
     */
    public function clear()
    {
        $this->deferred = [];

        return $this->doClear();
    }

    /**
     * {@inheritdoc}
     */
    public function deleteItem($key)
    {
        return $this->deleteItems([$key]);
    }

    /**
     * {@inheritdoc}
     */
    public function deleteItems(array $keys)
    {
        $kIds = [];

        foreach ($keys as $key) {
            $kIds[$key] = $this->getId($key);
            unset($this->deferred[$key]);
        }

        return $this->doDelete($kIds);
    }

    /**
     * {@inheritdoc}
     */
    public function save(CacheItemInterface $item)
    {
        $this->saveDeferred($item);

        return $this->commit();
    }

    /**
     * {@inheritdoc}
     */
    public function saveDeferred(CacheItemInterface $item)
    {
        $this->deferred[$item->getKey()] = $item;

        return true;
    }

    /**
     * {@inheritdoc}
     */
    public function commit()
    {
        $ok             = true;
        $byLifetime     = $this->mergeByLifetime;
        $this->deferred = $expiredIds = [];
        $byLifetime     = $byLifetime($this->deferred, $expiredIds);

        if (\count($expiredIds) > 0) {
            $this->doDelete($expiredIds);
        }

        foreach ($byLifetime as $lifetime => $values) {
            if ($this->doSave($values, $lifetime)) {
                continue;
            }

            $ok = false;
        }

        return $ok;
    }

    /**
     * Fetches several cache items.
     *
     * @param array<mixed,string> $ids The cache identifiers to fetch
     *
     * @return iterable<string,CacheItemInterface> The corresponding values found in the cache
     */
    protected function doFetch(array $ids)
    {
        $fetched = $this->pool->getMultiple($ids, $this->miss);

        if ($fetched instanceof Generator) {
            $fetched = $fetched->getReturn();
        }

        foreach ($fetched as $key => $value) {
            if ($this->miss !== $value) {
                yield $key => $value;
            }
        }
    }

    /**
     * Confirms if the cache contains specified cache item.
     *
     * @param string $id The identifier for which to check existence
     *
     * @return bool True if item exists in the cache, false otherwise
     */
    protected function doHave(string $id)
    {
        return $this->pool->has($id);
    }

    /**
     * Deletes all items in the pool.
     *
     * @return bool True if the pool was successfully cleared, false otherwise
     */
    protected function doClear()
    {
        return $this->pool->clear();
    }

    /**
     * Removes multiple items from the pool.
     *
     * @param array<string,string> $ids An array of identifiers that should be removed from the pool
     *
     * @return bool True if the items were successfully removed, false otherwise
     */
    protected function doDelete(array $ids)
    {
        return $this->pool->deleteMultiple($ids);
    }

    /**
     * Persists several cache items immediately.
     *
     * @param array<string,mixed> $values   The values to cache, indexed by their cache identifier
     * @param int                 $lifetime The lifetime of the cached values, 0 for persisting until manual cleaning
     *
     * @return bool a boolean stating if caching succeeded or not
     */
    protected function doSave(array $values, int $lifetime)
    {
        return $this->pool->setMultiple($values, 0 === $lifetime ? null : $lifetime);
    }

    /**
     * @param iterable<string,mixed> $items
     * @param array<string,string>   $keys
     *
     * @return array<string,CacheItemInterface>|Traversable
     */
    private function generateItems(iterable $items, array &$keys)
    {
        $f = $this->createCacheItem;

        foreach ($items as $id => $value) {
            if (!isset($keys[$id])) {
                $id = \key($keys);
            }
            $key = $keys[$id];
            unset($keys[$id]);

            yield $key => $f($key, $value, true);
        }

        foreach ($keys as $key) {
            yield $key => $f($key, null, false);
        }
    }

    /**
     * @param mixed $key
     *
     * @return string
     */
    private function getId($key)
    {
        if (\is_string($key) && isset($this->ids[$key])) {
            return $this->ids[$key];
        }
        CacheItem::validateKey($key);
        $this->ids[$key] = $key;

        return $key;
    }
}

biurad / php-cache

Push — master ( b2545f...e44389 )

CacheItemPool::__sleep() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
