CybozuHttp\Subscriber\CacheSubscriber

Complexity

Total Complexity

10

Size/Duplication

Total Lines	90
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	8

Importance

Changes	1
Bugs	0	Features	1

7 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	attach()	0	8	1
A	getEvents()	0	7	1
A	onBefore()	0	13	2
A	onComplete()	0	12	2
A	cacheMiss()	0	4	1
A	addResponseHeaders()	0	12	2

<?php

namespace CybozuHttp\Subscriber;

use CybozuHttp\Subscriber\Cache\CacheStorage;
use GuzzleHttp\Event\HasEmitterInterface;
use GuzzleHttp\Event\BeforeEvent;
use GuzzleHttp\Event\CompleteEvent;
use GuzzleHttp\Event\RequestEvents;
use GuzzleHttp\Event\SubscriberInterface;
use GuzzleHttp\Message\RequestInterface;
use GuzzleHttp\Message\ResponseInterface;

/**
 * @author ochi51 <ochiai07@gmail.com>
 */
class CacheSubscriber implements SubscriberInterface
{
    /** @var CacheStorage $cache Object used to cache responses */
    protected $storage;

    /**
     * @param CacheStorage $cache    Cache storage
     */
    public function __construct(CacheStorage $cache)
    {
        $this->storage = $cache;
    }

    /**
     * @param HasEmitterInterface $subject
     * @param CacheStorage|null $storage
     * @return array
     */
    public static function attach(HasEmitterInterface $subject, CacheStorage $storage)
    {
        $emitter = $subject->getEmitter();
        $cache = new self($storage);
        $emitter->attach($cache);

        return ['subscriber' => $cache, 'storage' => $storage];
    }

    /**
     * @return array
     */
    public function getEvents()
    {
        return [
            'before'   => ['onBefore', RequestEvents::LATE],
            'complete' => ['onComplete', RequestEvents::EARLY]
        ];
    }

    /**
     * Checks if a request can be cached, and if so, intercepts with a cached
     * response is available.
     */
    public function onBefore(BeforeEvent $event)
    {
        $request = $event->getRequest();

        if (!($response = $this->storage->fetch($request))) {
            $this->cacheMiss($request);
            return;
        }

        $request->getConfig()->set('cache_lookup', 'HIT');
        $request->getConfig()->set('cache_hit', true);
        $event->intercept($response);
    }

    /**
     * Checks if the request and response can be cached, and if so, store it
     */
    public function onComplete(CompleteEvent $event)
    {
        $request = $event->getRequest();
        $response = $event->getResponse();

        // Cache the response if it can be cached and isn't already
        if ($request->getConfig()->get('cache_lookup') === 'MISS') {
            $this->storage->cache($request, $response);

It seems like $response defined by $event->getResponse() on line 79 can be null; however, CybozuHttp\Subscriber\Cache\CacheStorage::cache() does not accept null, maybe add an additional type check?

        }

        $this->addResponseHeaders($request, $response);

It seems like $response defined by $event->getResponse() on line 79 can be null; however, CybozuHttp\Subscriber\CacheSubscriber::addResponseHeaders() does not accept null, maybe add an additional type check?

    }

    private function cacheMiss(RequestInterface $request)
    {
        $request->getConfig()->set('cache_lookup', 'MISS');
    }

    private function addResponseHeaders(RequestInterface $request, ResponseInterface $response)
    {
        $params = $request->getConfig();
        $lookup = $params['cache_lookup'] . ' from GuzzleCache';
        $response->addHeader('X-Cache-Lookup', $lookup);

        if ($params['cache_hit'] === true) {
            $response->addHeader('X-Cache', 'HIT from GuzzleCache');
        } else {
            $response->addHeader('X-Cache', 'MISS from GuzzleCache');
        }
    }
}