CacheConfiguration::cacheKey() - Code Metrics - Inspection of "Extract all decision logic into CacheConfiguration" - WyriHaximus/reactphp-http-middleware-response-cache - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#4)

by Cees-Jan

created 2018-04-05 20:34 UTC

CacheConfiguration::cacheKey() A

↳ Parent: CacheConfiguration

Complexity

Conditions	3
Paths	2

Size

Total Lines	9
Code Lines	5

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	6
CRAP Score	3

Importance

Changes

Metric	Value
dl	0
loc	9
ccs	6
cts	6
cp	1
rs	9.6666
c	0
b	0
f	0
cc	3
eloc	5
nc	2
nop	1
crap	3

<?php declare(strict_types=1);

namespace WyriHaximus\React\Http\Middleware;

use Lcobucci\Clock\Clock;
use Lcobucci\Clock\SystemClock;
use Psr\Http\Message\ResponseInterface;
use Psr\Http\Message\ServerRequestInterface;
use RingCentral\Psr7\Response;
use function RingCentral\Psr7\stream_for;

final class CacheConfiguration implements CacheConfigurationInterface
{
    private const PREFIX_WITHOUT_QUERY = '***';
    private const PREFIX_WITH_QUERY = '???';
    private const PREFIXES = [
        self::PREFIX_WITH_QUERY,
        self::PREFIX_WITHOUT_QUERY,
    ];

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

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

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

    /**
     * @var array
     */
    private $headers;

    /**
     * @var Clock
     */
    private $clock;

    /**
     * @param array      $urls
     * @param array      $headers
     * @param Clock|null $clock
     */
    public function __construct(array $urls, array $headers = [], Clock $clock = null)
    {
        $this->sortUrls($urls);
        $this->headers = $headers;
        $this->clock = $clock instanceof Clock ? $clock : new SystemClock();
    }

    public function requestIsCacheable(ServerRequestInterface $request): bool
    {
        if ($request->getMethod() !== 'GET') {
            return false;
        }

        if (
            class_exists(SessionMiddleware::class) &&
            $request->getAttribute(SessionMiddleware::ATTRIBUTE_NAME) !== null &&
            $request->getAttribute(SessionMiddleware::ATTRIBUTE_NAME)->isActive() === true
        ) {
            return false;
        }

        $uri = $request->getUri()->getPath();
        if (!\in_array($uri, $this->staticUrls, true) && !$this->matchesPrefixUrl($uri)) {
            return false;
        }

        return true;
    }

    public function responseIsCacheable(ServerRequestInterface $request, ResponseInterface $response): bool
    {
        if (
            class_exists(SessionMiddleware::class) &&
            $request->getAttribute(SessionMiddleware::ATTRIBUTE_NAME) !== null &&
            $request->getAttribute(SessionMiddleware::ATTRIBUTE_NAME)->isActive() === true
        ) {
            return false;
        }

        return true;
    }

    public function cacheKey(ServerRequestInterface $request): string
    {
        $key = $request->getUri()->getPath();
        $query = $request->getUri()->getQuery();
        if (\strlen($query) > 0 && $this->queryInKey($key)) {
            $key .= '?' . $query;
        }

        return $key;
    }

    public function cacheEncode(ResponseInterface $response): array
    {
        $headers = [];
        foreach ($this->headers as $header) {
            if (!$response->hasHeader($header)) {
                continue;
            }

            $headers[$header] = $response->getHeaderLine($header);
        }

        return [
            'body' => (string)$response->getBody(),
            'headers' => $headers,
            'code' => $response->getStatusCode(),
            'time' => (int)$this->clock->now()->format('U'),
        ];
    }

    public function cacheDecode(array $response): ResponseInterface
    {
        $response['headers'] = (array)$response['headers'];
        $response['headers']['Age'] = (int)$this->clock->now()->format('U') - (int)$response['time'];

        return new Response($response['code'], $response['headers'], stream_for($response['body']));
        return new Response(/** @scrutinizer ignore-type */ $response['code'], $response['headers'], stream_for($response['body']));
    }

    private function sortUrls(array $urls)
    {
        foreach ($urls as $url) {
            if (!(\strlen($url) >= 3 && \in_array(substr($url, -3), self::PREFIXES, true))) {
                $this->staticUrls[] = $url;

                continue;
            }

            if (\strlen($url) >= 3 && substr($url, -3) === self::PREFIX_WITHOUT_QUERY) {
                $this->prefixUrlsWithoutQuery[] = substr($url, 0, -3);

                continue;
            }

            if (\strlen($url) >= 3 && substr($url, -3) === self::PREFIX_WITH_QUERY) {
                $this->prefixUrlsWithQuery[] = substr($url, 0, -3);

                continue;
            }
        }
    }

    private function matchesPrefixUrl(string $uri): bool
    {
        if ($this->urlMatchesPrefixes($this->prefixUrlsWithoutQuery, $uri)) {
            return true;
        }

        return $this->urlMatchesPrefixes($this->prefixUrlsWithQuery, $uri);
    }

    private function queryInKey(string $uri): bool
    {
        return $this->urlMatchesPrefixes($this->prefixUrlsWithQuery, $uri);
    }

    private function urlMatchesPrefixes(array $urls, string $uri): bool
    {
        foreach ($urls as $url) {
            if (strpos($uri, $url) === 0) {
                return true;
            }
        }

        return false;
    }
}


WyriHaximus / reactphp-http-middleware-response-cache

GitHub Access Token became invalid

Pull Request — master (#4)

CacheConfiguration::cacheKey() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like