WyriHaximus\React\Http\Middleware\HtmlCompressMiddleware

Complexity

Total Complexity

8

Size/Duplication

Total Lines	58
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

Test Coverage

Coverage

100%

Importance

Changes

0

3 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	8	2
A	handleResponse()	0	20	4
A	__invoke()	0	12	2

<?php declare(strict_types=1);

namespace WyriHaximus\React\Http\Middleware;

use Psr\Http\Message\ResponseInterface;
use Psr\Http\Message\ServerRequestInterface;
use React\Http\Io\HttpBodyStream;
use React\Promise\PromiseInterface;
use function React\Promise\resolve;
use function RingCentral\Psr7\stream_for;
use WyriHaximus\HtmlCompress\Factory;
use WyriHaximus\HtmlCompress\Parser;

final class HtmlCompressMiddleware
{
    const MIME_TYPES = [
        'text/html',
        'text/xhtml',
    ];

    /**
     * @var Parser
     */
    private $compressor;

    /**
     * @param Parser $compressor
     */
    public function __construct(Parser $compressor = null)
    {
        if ($compressor === null) {
            $compressor = Factory::constructFastest();
        }

        $this->compressor = $compressor;

It seems like $compressor can also be of type object<WyriHaximus\HtmlCompress\HtmlCompressorInterface>. However, the property $compressor is declared as type object<WyriHaximus\HtmlCompress\Parser>. Maybe add an additional type check?

    }

    public function __invoke(ServerRequestInterface $request, callable $next)
    {
        $response = $next($request);

        if (!($response instanceof PromiseInterface)) {
            return resolve($this->handleResponse($response));
        }

        return $response->then(function (ResponseInterface $response) {
            return $this->handleResponse($response);
        });
    }

    private function handleResponse(ResponseInterface $response)
    {
        if ($response->getBody() instanceof HttpBodyStream) {
            return $response;
        }

        if (!$response->hasHeader('content-type')) {
            return $response;
        }

        list($contentType) = \explode(';', $response->getHeaderLine('content-type'));
        if (!\in_array($contentType, self::MIME_TYPES, true)) {
            return $response;
        }

        $body = (string)$response->getBody();
        $compressedBody = $this->compressor->compress($body);

        return $response->withBody(stream_for($compressedBody))->withHeader('Content-Length', \strlen($compressedBody));
    }
}