AsyncPHP\Icicle\Cache\Driver\MemoryDriver

Complexity

Total Complexity

14

Size/Duplication

Total Lines	146
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	2

Test Coverage

Coverage

100%

Importance

Changes

0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	get()	0	14	2
A	busy()	0	4	2
A	wait()	0	8	2
A	value()	0	8	2
B	set()	0	35	5
A	forget()	0	11	1

<?php

namespace AsyncPHP\Icicle\Cache\Driver;

use AsyncPHP\Icicle\Cache\Driver;
use Icicle\Concurrent\Forking\Fork;
use Icicle\Coroutine;
use Icicle\Loop;
use Icicle\Promise;
use Icicle\Promise\Deferred;
use Icicle\Promise\PromiseInterface;

class MemoryDriver implements Driver
{
    /**
     * @var array
     */
    private $cache = [];

    /**
     * @var array
     */
    private $waiting = [];

    /**
     * @var array
     */
    private $busy = [];

    /**
     * @inheritdoc
     *
     * @param string $key
     *
     * @return PromiseInterface
     *
     * @resolve mixed
     */
    public function get($key)
    {
        $deferred = new Deferred();

        Loop\queue(function () use ($deferred, $key) {
            if ($this->busy($deferred, $key)) {
                $this->wait($deferred, $key);
            } else {
                $deferred->resolve($this->value($key));
            }
        });

        return $deferred->getPromise();
    }

    /**
     * @param Deferred $deferred
     * @param string $key
     *
     * @return bool
     */
    private function busy(Deferred $deferred, $key)
    {
        return isset($this->busy[$key]) and spl_object_hash($this->busy[$key]) !== spl_object_hash($deferred);

Using logical operators such as and instead of && is generally not recommended.

    }

    /**
     * @param Deferred $deferred
     * @param string $key
     */
    private function wait(Deferred $deferred, $key)
    {
        if (!isset($this->waiting[$key])) {
            $this->waiting[$key] = [];
        }

        $this->waiting[$key][] = $deferred;
    }

    /**
     * @param string $key
     *
     * @return mixed
     */
    private function value($key)
    {
        if (isset($this->cache[$key])) {
            return $this->cache[$key];
        }

        return null;
    }

    /**
     * @inheritdoc
     *
     * @param string $key
     * @param mixed $value
     *
     * @return PromiseInterface
     *
     * @resolve mixed
     */
    public function set($key, $value)
    {
        $deferred = new Deferred();

        Loop\queue(function () use ($deferred, $key, $value) {
            if ($this->busy($deferred, $key)) {
                $this->wait($deferred, $key);
            } else {
                Coroutine\create(function () use ($deferred, $key, $value) {
                    $this->busy[$key] = $deferred;

                    if (is_callable($value)) {
                        $fork = Fork::spawn($value);
                        $value = (yield $fork->join());

Consider using a different name than the imported variable $value, or did you forget to import by reference?

                    }

                    $this->cache[$key] = $value;
                    unset($this->busy[$key]);

                    if (isset($this->waiting[$key])) {
                        while (count($this->waiting[$key])) {
                            /** @var Deferred $next */
                            $next = array_shift($this->waiting[$key]);

                            $next->resolve($value);
                        }
                    }

                    $deferred->resolve($value);
                });
            }
        });

        return $deferred->getPromise();
    }

    /**
     * @inheritdoc
     *
     * @param string $key
     *
     * @return PromiseInterface
     *
     * @resolve void
     */
    public function forget($key)
    {
        $deferred = new Deferred();

        Loop\queue(function () use ($deferred, $key) {
            unset($this->cache[$key]);
            $deferred->resolve();
        });

        return $deferred->getPromise();
    }
}