WebHemi\Middleware\FinalMiddleware

Complexity

Total Complexity

11

Size/Duplication

Total Lines	99
Duplicated Lines	0 %

Coupling/Cohesion

Components	0
Dependencies	5

Importance

Changes	1
Bugs	0	Features	1

4 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
B	__invoke()	0	41	6
A	injectContentLength()	0	8	3
A	filterHeaderName()	0	6	1

<?php
/**
 * WebHemi.
 *
 * PHP version 5.6
 *
 * @copyright 2012 - 2016 Gixx-web (http://www.gixx-web.com)
 * @license   https://opensource.org/licenses/MIT The MIT License (MIT)
 *
 * @link      http://www.gixx-web.com
 */
namespace WebHemi\Middleware;

use Psr\Http\Message\ResponseInterface;
use Psr\Http\Message\ServerRequestInterface;
use RuntimeException;
use WebHemi\Config\ConfigInterface;
use WebHemi\Adapter\Renderer\RendererAdapterInterface;

/**
 * Class FinalMiddleware.
 */
class FinalMiddleware implements MiddlewareInterface
{
    /** @var RendererAdapterInterface */
    private $templateRenderer;
    /** @var ConfigInterface */
    private $templateConfig;

    /**
     * FinalMiddleware constructor.
     *
     * @param RendererAdapterInterface $templateRenderer
     * @param ConfigInterface          $templateConfig
     */
    public function __construct(RendererAdapterInterface $templateRenderer, ConfigInterface $templateConfig)
    {
        $this->templateRenderer = $templateRenderer;
        $this->templateConfig = $templateConfig;
    }

    /**
     * Sends out the headers and prints the response body to the output.
     *
     * @param ServerRequestInterface $request
     * @param ResponseInterface      $response
     *
     * @return ResponseInterface
     */
    public function __invoke(ServerRequestInterface &$request, ResponseInterface $response)
    {
        if (headers_sent()) {
            throw new RuntimeException('Unable to emit response; headers already sent');
        }

        $content = $response->getBody();

        // Handle errors here.
        if ($response->getStatusCode() !== 200) {
            $errorTemplate = $this->templateConfig->get('template_map/error' . $response->getStatusCode());
            $error = $request->getAttribute('exception');
            $content = $this->templateRenderer->render($errorTemplate, ['exception' => $error]);

$errorTemplate is of type array|object<WebHemi\Config\Config>, but the function expects a string.

        }

        $response = $this->injectContentLength($response);

        $reasonPhrase = $response->getReasonPhrase();
        header(sprintf(
            'HTTP/%s %d%s',
            $response->getProtocolVersion(),
            $response->getStatusCode(),
            ($reasonPhrase ? ' ' . $reasonPhrase : '')
        ));

        foreach ($response->getHeaders() as $headerName => $values) {
            $name  = $this->filterHeaderName($headerName);
            $first = true;
            foreach ($values as $value) {
                header(sprintf(
                    '%s: %s',
                    $name,
                    $value
                ), $first);
                $first = false;
            }
        }

        echo $content;
        return $response;
    }

    /**
     * Inject the Content-Length header if is not already present.
     *
     * @param ResponseInterface $response
     *
     * @return ResponseInterface
     */
    private function injectContentLength(ResponseInterface $response)
    {
        if (!$response->hasHeader('Content-Length')&& !is_null($response->getBody()->getSize())) {
            $response = $response->withHeader('Content-Length', (string) $response->getBody()->getSize());
        }

        return $response;
    }

    /**
     * Filter a header name to word case.
     *
     * @param string $headerName
     *
     * @return string
     */
    private function filterHeaderName($headerName)
    {
        $filtered = str_replace('-', ' ', $headerName);
        $filtered = ucwords($filtered);
        return str_replace(' ', '-', $filtered);
    }
}