PhpWinTools\WmiScripting\Support\Cache\CacheProvider

Complexity

Total Complexity

40

Size/Duplication

Total Lines	295
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

17 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
A	setMultiple()	0	3	2
A	empty()	0	3	1
A	set()	0	13	3
A	notEmpty()	0	3	1
A	clear()	0	9	2
A	has()	0	3	1
A	delayedFire()	0	5	1
A	deleteMultiple()	0	3	2
A	fire()	0	5	1
A	driver()	0	3	1
A	removeExpired()	0	9	2
A	get()	0	21	4
A	getMultiple()	0	25	6
A	delete()	0	13	3
B	multiple()	0	22	7
A	flushDelayedEvents()	0	11	2

<?php

namespace PhpWinTools\WmiScripting\Support\Cache;

use Closure;
use Psr\SimpleCache\CacheInterface;
use Psr\SimpleCache\InvalidArgumentException;
use PhpWinTools\WmiScripting\Configuration\Config;
use PhpWinTools\WmiScripting\Support\Events\Event;
use PhpWinTools\WmiScripting\Support\Events\EventProvider;
use function PhpWinTools\WmiScripting\Support\reduce_value;
use PhpWinTools\WmiScripting\Support\Cache\Events\CacheHit;
use PhpWinTools\WmiScripting\Support\Cache\Events\CacheMissed;
use PhpWinTools\WmiScripting\Support\Cache\Events\CacheCleared;
use PhpWinTools\WmiScripting\Support\Cache\Events\CacheKeyStored;
use PhpWinTools\WmiScripting\Support\Cache\Events\CacheKeyDeleted;
use PhpWinTools\WmiScripting\Support\Cache\Events\CacheKeyExpired;
use PhpWinTools\WmiScripting\Exceptions\CacheInvalidArgumentException;

class CacheProvider implements CacheInterface
{
    /** @var Config */
    protected $config;

    /** @var CacheDriver */
    protected $driver;

    /** @var EventProvider */
    protected $events;

    /** @var array|Event[] */
    protected $delayedEvents = [];

    public function __construct(Config $config = null, CacheDriver $driver = null, EventProvider $events = null)
    {
        $this->config = $config ?? Config::instance();
        $this->driver = $driver ?? $this->config->getCacheDriver();
        $this->events = $events ?? $this->config->eventProvider();
    }

    /**
     * @param string|array       $key
     * @param Closure|null|mixed $default
     *
     * @throws CacheInvalidArgumentException|InvalidArgumentException
     *
     * @return iterable|mixed|null
     */
    public function get($key, $default = null)
    {
        if (is_array($key)) {
            return $this->getMultiple($key, $default);

It seems like $default can also be of type Closure; however, parameter $default of PhpWinTools\WmiScripting\Support\Cache\CacheProvider::getMultiple() does only seem to accept null, maybe add an additional type check?

        }

        $value = $this->driver()->get($key, null);

        if ($this->driver()->expired($key)) {
            $this->removeExpired($key, $value);
            $value = null;
        }

        if (is_null($value)) {
            $value = reduce_value($default);
            $this->fire(new CacheMissed($this->driver(), $key));
        } else {
            $this->fire(new CacheHit($this->driver(), $key, $value));
        }

        return $value;
    }

    /**
     * Accepts either a string or a key-value pair array. If given an array then the second value is used as the
     * ttl, unless $ttl is explicitly set.
     *
     * @param string|array $key
     * @param mixed        $value
     * @param null|int     $ttl
     *
     * @throws CacheInvalidArgumentException|InvalidArgumentException
     *
     * @return bool
     */
    public function set($key, $value = null, $ttl = null)
    {
        if (is_array($key)) {
            return $this->setMultiple($key, $ttl ?? $value);

It seems like $ttl ?? $value can also be of type integer; however, parameter $ttl of PhpWinTools\WmiScripting\Support\Cache\CacheProvider::setMultiple() does only seem to accept null, maybe add an additional type check?

        }

        $result = $this->driver()->set($key, $value, $ttl);

        if ($result) {
            $this->fire(new CacheKeyStored($this->driver(), $key, $value, $ttl));
        }

        return $result;
    }

    /**
     * @param string|array $key
     *
     * @throws CacheInvalidArgumentException|InvalidArgumentException
     *
     * @return bool
     */
    public function delete($key)
    {
        if (is_array($key)) {
            return $this->deleteMultiple($key);
        }

        $result = $this->driver()->delete($key);

        if ($result) {
            $this->fire(new CacheKeyDeleted($this->driver(), $key));
        }

        return $result;
    }

    /**
     * @return bool
     */
    public function clear()
    {
        $result = $this->driver->clear();

        if ($result) {
            $this->fire(new CacheCleared($this->driver));
        }

        return $result;
    }

    /**
     * @param iterable $keys
     * @param null     $default

Are you sure the doc-type for parameter $default is correct as it would always require null to be passed?

     *
     * @throws InvalidArgumentException|CacheInvalidArgumentException
     *
     * @return iterable
     */
    public function getMultiple($keys, $default = null)
    {
        $hit = [];

        foreach ($keys as $key) {
            if ($this->driver()->expired($key)) {
                $this->removeExpired($key);
            }

            if ($this->driver()->canGet($key)) {
                $hit[$key] = $key;
            }
        }

        $results = $this->driver()->getMultiple($keys, $default);

        foreach ($results as $key => $value) {
            if (array_key_exists($key, $hit)) {
                $this->fire(new CacheHit($this->driver(), $key, $value));
            } else {
                $this->fire(new CacheMissed($this->driver(), $key));
            }
        }

        return $results;
    }

    /**
     * @param iterable $values
     * @param null     $ttl

Are you sure the doc-type for parameter $ttl is correct as it would always require null to be passed?

     *
     * @return bool
     */
    public function setMultiple($values, $ttl = null)
    {
        return $this->multiple('set', $values, $ttl) ? $this->driver()->setMultiple($values, $ttl) : false;
    }

    /**
     * @param iterable $keys
     *
     * @return bool
     */
    public function deleteMultiple($keys)
    {
        return $this->multiple('delete', $keys) ? $this->driver()->deleteMultiple($keys) : false;
    }

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

    /**
     * @return bool
     */
    public function empty(): bool
    {
        return $this->driver()->empty();
    }

    /**
     * @return bool
     */
    public function notEmpty(): bool
    {
        return $this->driver()->notEmpty();
    }

    /**
     * @return CacheDriver
     */
    public function driver()
    {
        return $this->driver;
    }

    /**
     * @param string         $method
     * @param iterable       $keys
     * @param null|int|mixed $ttl
     *
     * @return bool
     */
    protected function multiple(string $method, $keys, $ttl = null): bool
    {
        foreach ($keys as $key => $value) {
            $result = false;

            if ($method === 'set' && $result = $this->driver()->canSet($key, $value)) {
                $this->delayedFire(new CacheKeyStored($this->driver, $key, $value, $ttl));
            }

            if ($method === 'delete' && $result = $this->driver()->canDelete($value)) {
                $this->delayedFire(new CacheKeyDeleted($this->driver, $value));
            }

            if ($result === false) {
                $this->flushDelayedEvents(false);
                return false;
            }
        }

        $this->flushDelayedEvents();

        return true;
    }

    /**
     * @param      $key
     * @param null $value

Are you sure the doc-type for parameter $value is correct as it would always require null to be passed?

     *
     * @throws CacheInvalidArgumentException|InvalidArgumentException
     *
     * @return self
     */
    protected function removeExpired($key, $value = null): self
    {
        if ($this->driver()->expired($key)) {
            $this->fire(new CacheKeyExpired($this->driver(), $key, $value));
            $this->delete($key);
        }


        return $this;
    }

    /**
     * @param Event $event
     *
     * @return self
     */
    protected function fire(Event $event): self
    {
        $this->events->fire($event);

        return $this;
    }

    /**
     * @param bool $fire
     *
     * @return self
     */
    protected function flushDelayedEvents(bool $fire = true): self
    {
        if ($fire) {
            array_map(function (Event $event) {
                $this->fire($event);
            }, $this->delayedEvents);
        }

        $this->delayedEvents = [];

        return $this;
    }

    /**
     * @param Event $event
     *
     * @return $this
     */
    protected function delayedFire(Event $event): self
    {
        $this->delayedEvents[] = $event;

        return $this;
    }
}