FileCacheDriver::checkKey() - Code Metrics - override2k/psr-cache - Measure and Improve Code Quality continuously with Scrutinizer

FileCacheDriver::checkKey() A
last analyzed 2019-09-25 16:33 UTC

↳ Parent: FileCacheDriver
Complexity

Conditions	3
Paths	3
Size

Total Lines	9
Code Lines	5
Duplication

Lines	0
Ratio	0 %
Importance

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

/*
 * Created by Fernando Robledo <[email protected]>.
 */

namespace Overdesign\PsrCache;

use Psr\Cache\CacheItemInterface;
use Psr\Cache\CacheItemPoolInterface;

class FileCacheDriver implements CacheItemPoolInterface
{
    /** @var string */
    protected $path;
    /** @var CacheItem[] */
    protected $deferred = array();

    /**
     * FileCacheDriver constructor.
     *
     * @param string $path
     */
    public function __construct($path = __DIR__)
    {
        $this->path = substr($path, strlen($path) - 1, 1) === DIRECTORY_SEPARATOR ? $path : $path . DIRECTORY_SEPARATOR;
    }

    /**
     * Returns current cache folder path
     *
     * @return string
     */
    public function getPath()
    {
        return $this->path;
    }

    /**
     * @param string $key
     *
     * @return string hashed key
     * @throws InvalidArgumentException
     */
    private function checkKey($key)
    {
        if (!is_string($key)) {

            throw new InvalidArgumentException('The given key must be a string.');
        } elseif (!preg_match('/^[a-zA-Z\d\.\_]+$/', $key)) {
            throw new InvalidArgumentException(sprintf('The given key %s contains invalid characters.', $key));
        }

        return $key;
    }

    /**
     * @param string $key
     * @param bool $hash
     *
     * @return string
     */
    private function getFilename($key, $hash = true)
    {
        $key = $hash ? sha1($key) : $key;
        return $this->path . "cachepool-{$key}.php";
    }

    /**
     * Returns a Cache Item representing the specified key.
     *
     * This method must always return a CacheItemInterface object, even in case of
     * a cache miss. It MUST NOT return null.
     *
     * @param string $key
     *   The key for which to return the corresponding Cache Item.
     *
     * @throws InvalidArgumentException
     *   If the $key string is not a legal value a \Psr\Cache\InvalidArgumentException
     *   MUST be thrown.
     *
     * @return CacheItemInterface
     *   The corresponding Cache Item.
     */
    public function getItem($key)
    {
        $key = $this->checkKey($key);

        if (array_key_exists($key, $this->deferred)) {
            return clone $this->deferred[$key];
        }

        $file = $this->getFilename($key);

        return $this->readCacheFile($file) ?: new CacheItem($key);
    }

    /**
     * @param string $file filename
     *
     * @return false|CacheItem
     * @throws InvalidArgumentException
     */
    private function readCacheFile($file)
    {
        if (!is_file($file) || !is_readable($file)) {
            return false;
        }

        $item = file_get_contents($file);
        $item = $item === false ? false : unserialize($item);

        if ($item === false || !$item instanceof CacheItem) {
            return false;
        }

        if ($item->isHit() === false) {
            $this->deleteItem($item->getKey()); // clear expired
        }

        return $item;
    }

    /**
     * Gets a cache file by key hash
     *
     * @param string $hash sha1 key hash
     *
     * @return CacheItem
     *
     * @throws InvalidArgumentException
     */
    private function getItemByHash($hash)
    {
        $file = $this->getFilename($hash, false);

        return $this->readCacheFile($file) ?: new CacheItem($key);

    }

    /**
     * Returns a traversable set of cache items.
     *
     * @param string[] $keys
     *   An indexed array of keys of items to retrieve.
     *
     * @throws InvalidArgumentException
     *   If any of the keys in $keys are not a legal value a \Psr\Cache\InvalidArgumentException
     *   MUST be thrown.
     *
     * @return array|\Traversable
     *   A traversable collection of Cache Items keyed by the cache keys of
     *   each item. A Cache item will be returned for each key, even if that
     *   key is not found. However, if no keys are specified then an empty
     *   traversable MUST be returned instead.
     */
    public function getItems(array $keys = array())
    {
        $collection = array();

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

        return $collection;
    }

    /**
     * Confirms if the cache contains specified cache item.
     *
     * Note: This method MAY avoid retrieving the cached value for performance reasons.
     * This could result in a race condition with CacheItemInterface::get(). To avoid
     * such situation use CacheItemInterface::isHit() instead.
     *
     * @param string $key
     *   The key for which to check existence.
     *
     * @throws InvalidArgumentException
     *   If the $key string is not a legal value a \Psr\Cache\InvalidArgumentException
     *   MUST be thrown.
     *
     * @return bool
     *   True if item exists in the cache, false otherwise.
     */
    public function hasItem($key)
    {
        return $this->getItem($key)->isHit();
    }

    /**
     * Deletes all items in the pool.
     *
     * @return bool
     *   True if the pool was successfully cleared. False if there was an error.
     */
    public function clear()
    {
        $this->deferred = array();

        $files  = glob($this->path . 'cachepool-*.php', GLOB_NOSORT);
        $result = true;

        foreach ($files as $file) {
            if (is_file($file)) {
                $result = @unlink($file) && $result;
            }
        }

        return $result;
    }

    /**
     * Removes the item from the pool.
     *
     * @param string $key
     *   The key to delete.
     *
     * @throws InvalidArgumentException
     *   If the $key string is not a legal value a \Psr\Cache\InvalidArgumentException
     *   MUST be thrown.
     *
     * @return bool
     *   True if the item was successfully removed. False if there was an error.
     */
    public function deleteItem($key)
    {
        $key = $this->checkKey($key);

        if (array_key_exists($key, $this->deferred)) {
            unset($this->deferred[$key]);
        }

        $file = $this->getFilename($key);

        return file_exists($file) ? @unlink($file) : true;
    }

    /**
     * Removes multiple items from the pool.
     *
     * @param string[] $keys
     *   An array of keys that should be removed from the pool.
     *
     * @throws InvalidArgumentException
     *   If any of the keys in $keys are not a legal value a \Psr\Cache\InvalidArgumentException
     *   MUST be thrown.
     *
     * @return bool
     *   True if the items were successfully removed. False if there was an error.
     */
    public function deleteItems(array $keys)
    {
        $result = true;

        foreach ($keys as $key) {
            $result = $this->deleteItem($key) && $result;
        }

        return $result;
    }

    /**
     * Persists a cache item immediately.
     *
     * @param CacheItemInterface $item
     *   The cache item to save.
     *
     * @return bool True if the item was successfully persisted. False if there was an error.
     * True if the item was successfully persisted. False if there was an error.
     *
     * @throws CacheException
     */
    public function save(CacheItemInterface $item)
    {
        $file = $this->getFilename($item->getKey());

        if (false === file_put_contents($file, serialize($item))) {
            throw new CacheException(sprintf('Cant write to cache file %s', $file), CacheException::ERROR_CANT_WRITE);
        }

        return true;
    }

    /**
     * Sets a cache item to be persisted later.
     *
     * @param CacheItemInterface $item
     *   The cache item to save.
     *
     * @return bool
     *   False if the item could not be queued or if a commit was attempted and failed. True otherwise.
     */
    public function saveDeferred(CacheItemInterface $item)
    {
        $this->deferred[$item->getKey()] = $item;

        return true;
    }

    /**
     * Persists any deferred cache items.
     *
     * @return bool True if all not-yet-saved items were successfully saved or there were none. False otherwise.
     * True if all not-yet-saved items were successfully saved or there were none. False otherwise.
     *
     * @throws CacheException
     */
    public function commit()
    {
        $allSaved = true;

        foreach ($this->deferred as $item) {
            $allSaved = $this->save($item) && $allSaved;
            unset($this->deferred[$item->getKey()]);
        }

        return $allSaved;
    }

    /**
     * Deletes all the expired items in the pool.
     *
     * @return bool
     *   True if the pool was successfully cleared. False if there was an error.
     */
    public function clearExpired()
    {
        $regex  = '/cachepool-(?P<hash>[0-9a-f]+)\.php$/';
        $files  = glob($this->path . 'cachepool-*.php', GLOB_NOSORT);
        $result = true;

        foreach ($files as $file) {
            if (preg_match($regex, $file, $hash) === false) {
                continue;
            }

            try {
                $this->getItemByHash($hash['hash']); // Get item auto clears expired items
            } catch (InvalidArgumentException $e) {
                $result = false;
            }
        }

        return $result;
    }

    /**
     * Cache pool garbage collector, deletes all cache files and optional empty directories in the current cache path
     * It can do a recursive search over the main directory, the maximum deep for the recursive can be specified
     *
     * @param bool $checkExpired if true only deletes the items that are expired else deletes all cached files
     * @param bool $recursive true for doing a recursive gc over the main path
     * @param bool $deleteEmpty true for deleting empty directories inside the path
     * @param int $depth maximum search depth
     *
     * @return bool True if all the items where deleted
     *
     * @throws InvalidArgumentException
     */
    public function gc($checkExpired = true, $recursive = false, $deleteEmpty = true, $depth = 1)
    {
        $recursive = $recursive && $depth > 0;
        $result    = $checkExpired ? $this->clearExpired() : $this->clear();

        if (!$recursive) {
            return $result;
        }

        $dirs = glob($this->path . '*', GLOB_ONLYDIR | GLOB_NOSORT);

        foreach ($dirs as $dir) {
            $pool = new self($dir);
            $result = $result && $pool->gc($recursive, $deleteEmpty, --$depth);
            $result = $result && $pool->gc($recursive, $deleteEmpty, /** @scrutinizer ignore-type */ --$depth);

            if ($deleteEmpty && count(glob($dir . DIRECTORY_SEPARATOR . '*', GLOB_NOSORT)) === 0) {
            if ($deleteEmpty && count(/** @scrutinizer ignore-type */ glob($dir . DIRECTORY_SEPARATOR . '*', GLOB_NOSORT)) === 0) {
                rmdir($dir);
            }
        }

        return $result;
    }

    /**
     * Save deferred items before destruct
     */
    public function __destruct()
    {
        $this->commit();
    }
}

override2k / psr-cache

FileCacheDriver::checkKey() A last analyzed 2019-09-25 16:33 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

FileCacheDriver::checkKey() A
last analyzed 2019-09-25 16:33 UTC
