Mouf\Mvc\Splash\Routers\CacheRouter

Complexity

Total Complexity

11

Size/Duplication

Total Lines	101
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	7

Importance

Changes

0

2 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	6	1
C	process()	0	67	10

<?php

namespace Mouf\Mvc\Splash\Routers;

use Interop\Http\ServerMiddleware\DelegateInterface;
use Interop\Http\ServerMiddleware\MiddlewareInterface;
use Psr\Http\Message\ResponseInterface;
use Psr\Http\Message\ServerRequestInterface;
use Mouf\Utils\Cache\CacheInterface;
use Psr\Log\LoggerInterface;
use Mouf\Utils\Common\ConditionInterface\ConditionInterface;

class CacheRouter implements MiddlewareInterface
{
    /**
     * @var CacheInterface
     */
    private $cache;

    /**
     * @var ConditionInterface
     */
    private $cacheCondition;

    /**
     * @var LoggerInterface
     */
    private $log;

    public function __construct(CacheInterface $cache, LoggerInterface $log, ConditionInterface $cacheCondition)
    {
        $this->cache = $cache;
        $this->cacheCondition = $cacheCondition;
        $this->log = $log;
    }

    /**
     * Process an incoming server request and return a response, optionally delegating
     * to the next middleware component to create the response.
     *
     * @param ServerRequestInterface $request
     * @param DelegateInterface $delegate
     *
     * @return ResponseInterface
     */
    public function process(ServerRequestInterface $request, DelegateInterface $delegate)
    {
        $requestMethod = $request->getMethod();
        $key = str_replace(['\\', '/', ':', '*', '?', '"', '<', '>', '|'], '_', $request->getUri()->getPath().'?'.$request->getUri()->getQuery());

        if ($this->cacheCondition->isOk() && $requestMethod == 'GET') {
            $cacheResponse = $this->cache->get($key);
            if ($cacheResponse) {
                $this->log->debug("Cache HIT on $key");

                return $cacheResponse;
            } else {
                $this->log->debug("Cache MISS on key $key");
                $response = $delegate->process($request);

                $noCache = false;
                if ($response->hasHeader('Mouf-Cache-Control') && $response->getHeader('Mouf-Cache-Control')[0] == 'no-cache') {
                    $noCache = true;
                }

                if ($noCache) {
                    $this->log->debug("Mouf NO CACHE header found, not storing '$key'");
                } else {
                    $ttl = null;

                    // TODO: continue here!
                    // Use PSR-7 response to analyze maxage and expires...
                    // ...or... use a completely different HTTP cache implementation!!!
                    // There must be one around for PSR-7!

                    $maxAge = $response->getMaxAge();

The method getMaxAge() does not seem to exist on object<Psr\Http\Message\ResponseInterface>.

                    $expires = $response->getExpires();

The method getExpires() does not seem to exist on object<Psr\Http\Message\ResponseInterface>.

                    if ($maxAge) {
                        $this->log->debug("MaxAge specified : $maxAge");
                        $ttl = $maxAge;
                    } elseif ($expires) {
                        $this->log->debug("Expires specified : $expires");
                        $ttl = date_diff($expires, new \DateTime())->s;
                    }

                    if ($ttl) {
                        $this->log->debug("TTL is  : $ttl");
                    }

                    // Make sure the response is serializable
                    $serializableResponse = new Response();

The expression new \Mouf\Mvc\Splash\Routers\Response(); of type Mouf\Mvc\Splash\Routers\Response adds the type Mouf\Mvc\Splash\Routers\Response to the return on line 105 which is incompatible with the return type declared by the interface Interop\Http\ServerMiddleware\MiddlewareInterface::process of type Psr\Http\Message\ResponseInterface.

                    $serializableResponse->headers = $response->headers;

Accessing headers on the interface Psr\Http\Message\ResponseInterface suggest that you code against a concrete implementation. How about adding an instanceof check?

                    ob_start();
                    $response->sendContent();

The method sendContent() does not seem to exist on object<Psr\Http\Message\ResponseInterface>.

                    $content = ob_get_clean();

                    $serializableResponse->setContent($content);

                    $this->cache->set($key, $serializableResponse, $ttl);
                    $this->log->debug("Cache STORED on key $key");
                    $response = $serializableResponse;
                }

                return $response;
            }
        } else {
            $this->log->debug("No cache for $key");

            return $this->fallBackRouter->handle($request, $type, $catch);

The property fallBackRouter does not exist. Did you maybe forget to declare it?

The variable $type does not exist. Did you forget to declare it?

The variable $catch does not exist. Did you forget to declare it?

        }
    }
}