CacheMiddleware::post() - Code Metrics - php-api-clients/middleware-cache - Measure and Improve Code Quality continuously with Scrutinizer

CacheMiddleware::post() A
last analyzed 2020-05-11 00:23 UTC

↳ Parent: CacheMiddleware

Complexity

Conditions	4
Paths	3

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	17
CRAP Score	4.054

Importance

Changes

Metric	Value
dl	0
loc	40
ccs	17
cts	20
cp	0.85
rs	9.28
c	0
b	0
f	0
cc	4
nc	3
nop	3
crap	4.054

<?php declare(strict_types=1);

namespace ApiClients\Middleware\Cache;

use ApiClients\Foundation\Middleware\MiddlewareInterface;
use Psr\Http\Message\RequestInterface;
use Psr\Http\Message\ResponseInterface;
use React\Cache\CacheInterface;
use React\Promise\CancellablePromiseInterface;
use React\Promise\PromiseInterface;
use function React\Promise\reject;
use function React\Promise\resolve;
use RingCentral\Psr7\BufferStream;
use Throwable;

final class CacheMiddleware implements MiddlewareInterface
{
    const DEFAULT_GLUE = '/';

    /**
     * @var CacheInterface[]
     */
    private $cache;

    /**
     * @var string[]
     */
    private $key;

    /**
     * @var RequestInterface[]
     */
    private $request;

    /**
     * @var bool[]
     */
    private $store = false;

    /**
     * @var StrategyInterface[]
     */
    private $strategy;

    /**
     * @param  RequestInterface            $request
     * @param  array                       $options
     * @return CancellablePromiseInterface
     */
    public function pre(
        RequestInterface $request,
        string $transactionId,
        array $options = []
    ): CancellablePromiseInterface {
        if (!isset($options[self::class][Options::CACHE]) || !isset($options[self::class][Options::STRATEGY])) {
            return resolve($request);
        }
        $this->cache[$transactionId] = $options[self::class][Options::CACHE];
        $this->strategy[$transactionId] = $options[self::class][Options::STRATEGY];
        if (!($this->cache[$transactionId] instanceof CacheInterface) ||
            !($this->strategy[$transactionId] instanceof StrategyInterface)
        ) {
            return resolve($request);
        }

        if ($request->getMethod() !== 'GET') {
            $this->cleanUpTransaction($transactionId);

            return resolve($request);
        }

        $this->request[$transactionId] = $request;
        $this->key[$transactionId] = CacheKey::create(
            $this->request[$transactionId]->getUri(),
            $options[self::class][Options::GLUE] ?? self::DEFAULT_GLUE
        );

        return $this->cache[$transactionId]->get(
            $this->key[$transactionId]
        )->then(function (string $json) use ($transactionId) {
            $document = Document::createFromString($json);

            if ($document->hasExpired()) {
                $this->cache[$transactionId]->delete($this->key[$transactionId]);

                return resolve($this->request[$transactionId]);
            }

            return reject($document->getResponse());
        }, function () use ($transactionId) {
            return resolve($this->request[$transactionId]);
        });
    }

    /**
     * @param  ResponseInterface           $response
     * @param  array                       $options
     * @return CancellablePromiseInterface
     */
    public function post(
        ResponseInterface $response,
        string $transactionId,
        array $options = []
    ): CancellablePromiseInterface {
        if (!isset($this->request[$transactionId]) ||
            !($this->request[$transactionId] instanceof RequestInterface)
        ) {
            $this->cleanUpTransaction($transactionId);

            return resolve($response);
        }

        $this->store[$transactionId] = $this->strategy[$transactionId]->
            decide($this->request[$transactionId], $response);

        if (!$this->store[$transactionId]) {
            $this->cleanUpTransaction($transactionId);

            return resolve($response);
        }

        return $this->hasBody($response)->then(function (ResponseInterface $response) use ($transactionId) {
            $document = Document::createFromResponse(
                $response,
                $this->strategy[$transactionId]->determineTtl(
                    $this->request[$transactionId],
                    $response
                )
            );

            $this->cache[$transactionId]->set($this->key[$transactionId], (string)$document);

            return resolve($document->getResponse());
        }, function () use ($response) {
            return resolve($response);
        })->always(function () use ($transactionId): void {
            $this->cleanUpTransaction($transactionId);
        });
    }

    public function error(
        Throwable $throwable,
        string $transactionId,
        array $options = []
    ): CancellablePromiseInterface {
        $this->cleanUpTransaction($transactionId);

        return reject($throwable);
    }

    /**
     * @param  ResponseInterface $response
     * @return PromiseInterface
     */
    private function hasBody(ResponseInterface $response): PromiseInterface
    {
        if ($response->getBody() instanceof BufferStream) {
            return resolve($response);
        }

        return reject();
    }

    private function cleanUpTransaction(string $transactionId): void
    {
        if (isset($this->cache[$transactionId])) {
            unset($this->cache[$transactionId]);
        }

        if (isset($this->strategy[$transactionId])) {
            unset($this->strategy[$transactionId]);
        }

        if (isset($this->request[$transactionId])) {
            unset($this->request[$transactionId]);
        }

        if (isset($this->key[$transactionId])) {
            unset($this->key[$transactionId]);
        }

        if (isset($this->store[$transactionId])) {
            unset($this->store[$transactionId]);
        }
    }
}


1		<?php declare(strict_types=1);
2
3		namespace ApiClients\Middleware\Cache;
4
5		use ApiClients\Foundation\Middleware\MiddlewareInterface;
6		use Psr\Http\Message\RequestInterface;
7		use Psr\Http\Message\ResponseInterface;
8		use React\Cache\CacheInterface;
9		use React\Promise\CancellablePromiseInterface;
10		use React\Promise\PromiseInterface;
11		use function React\Promise\reject;
12		use function React\Promise\resolve;
13		use RingCentral\Psr7\BufferStream;
14		use Throwable;
15
16		final class CacheMiddleware implements MiddlewareInterface
17		{
18		const DEFAULT_GLUE = '/';
19
20		/**
21		* @var CacheInterface[]
22		*/
23		private $cache;
24
25		/**
26		* @var string[]
27		*/
28		private $key;
29
30		/**
31		* @var RequestInterface[]
32		*/
33		private $request;
34
35		/**
36		* @var bool[]
37		*/
38		private $store = false;
39
40		/**
41		* @var StrategyInterface[]
42		*/
43		private $strategy;
44
45		/**
46		* @param RequestInterface $request
47		* @param array $options
48		* @return CancellablePromiseInterface
49		*/
50	10	public function pre(
51		RequestInterface $request,
52		string $transactionId,
53		array $options = []
54		): CancellablePromiseInterface {
55	10	if (!isset($options[self::class][Options::CACHE]) \|\| !isset($options[self::class][Options::STRATEGY])) {
56		return resolve($request);
57		}
58	10	$this->cache[$transactionId] = $options[self::class][Options::CACHE];
59	10	$this->strategy[$transactionId] = $options[self::class][Options::STRATEGY];
60	10	if (!($this->cache[$transactionId] instanceof CacheInterface) \|\|
61	10	!($this->strategy[$transactionId] instanceof StrategyInterface)
62		) {
63		return resolve($request);
64		}
65
66	10	if ($request->getMethod() !== 'GET') {
67	6	$this->cleanUpTransaction($transactionId);
68
69	6	return resolve($request);
70		}
71
72	4	$this->request[$transactionId] = $request;
73	4	$this->key[$transactionId] = CacheKey::create(
74	4	$this->request[$transactionId]->getUri(),
75	4	$options[self::class][Options::GLUE] ?? self::DEFAULT_GLUE
76		);
77
78	4	return $this->cache[$transactionId]->get(
79	4	$this->key[$transactionId]
80		)->then(function (string $json) use ($transactionId) {
81	2	$document = Document::createFromString($json);
82
83	2	if ($document->hasExpired()) {
84	1	$this->cache[$transactionId]->delete($this->key[$transactionId]);
85
86	1	return resolve($this->request[$transactionId]);
87		}
88
89	1	return reject($document->getResponse());
90		}, function () use ($transactionId) {
91	2	return resolve($this->request[$transactionId]);
92	4	});
93		}
94
95		/**
96		* @param ResponseInterface $response
97		* @param array $options
98		* @return CancellablePromiseInterface
99		*/
100	7	public function post(
101		ResponseInterface $response,
102		string $transactionId,
103		array $options = []
104		): CancellablePromiseInterface {
105	7	if (!isset($this->request[$transactionId]) \|\|
106	7	!($this->request[$transactionId] instanceof RequestInterface)
107		) {
108	6	$this->cleanUpTransaction($transactionId);
109
110	6	return resolve($response);
111		}
112
113	1	$this->store[$transactionId] = $this->strategy[$transactionId]->
114	1	decide($this->request[$transactionId], $response);
115
116	1	if (!$this->store[$transactionId]) {
117		$this->cleanUpTransaction($transactionId);
118
119		return resolve($response);
120		}
121
122		return $this->hasBody($response)->then(function (ResponseInterface $response) use ($transactionId) {
123	1	$document = Document::createFromResponse(
124	1	$response,
125	1	$this->strategy[$transactionId]->determineTtl(
126	1	$this->request[$transactionId],
127	1	$response
128		)
129		);
130
131	1	$this->cache[$transactionId]->set($this->key[$transactionId], (string)$document);
132
133	1	return resolve($document->getResponse());
134		}, function () use ($response) {
135		return resolve($response);
136		})->always(function () use ($transactionId): void {
137	1	$this->cleanUpTransaction($transactionId);
138	1	});
139		}
140
141		public function error(
142		Throwable $throwable,
143		string $transactionId,
144		array $options = []
145		): CancellablePromiseInterface {
146		$this->cleanUpTransaction($transactionId);
147
148		return reject($throwable);
149		}
150
151		/**
152		* @param ResponseInterface $response
153		* @return PromiseInterface
154		*/
155	1	private function hasBody(ResponseInterface $response): PromiseInterface
156		{
157	1	if ($response->getBody() instanceof BufferStream) {
158	1	return resolve($response);
159		}
160
161		return reject();
162		}
163
164	7	private function cleanUpTransaction(string $transactionId): void
165		{
166	7	if (isset($this->cache[$transactionId])) {
167	7	unset($this->cache[$transactionId]);
168		}
169
170	7	if (isset($this->strategy[$transactionId])) {
171	7	unset($this->strategy[$transactionId]);
172		}
173
174	7	if (isset($this->request[$transactionId])) {
175	1	unset($this->request[$transactionId]);
176		}
177
178	7	if (isset($this->key[$transactionId])) {
179	1	unset($this->key[$transactionId]);
180		}
181
182	7	if (isset($this->store[$transactionId])) {
183	1	unset($this->store[$transactionId]);
184		}
185	7	}
186		}
187

php-api-clients / middleware-cache

GitHub Access Token became invalid

CacheMiddleware::post() A last analyzed 2020-05-11 00:23 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

CacheMiddleware::post() A
last analyzed 2020-05-11 00:23 UTC