Phauthentic / presentation

src/Service/RenderService.php

<?php
declare(strict_types = 1);

namespace Phauthentic\Presentation\Service;

use Phauthentic\Presentation\Renderer\NativePHPRenderer;
use Phauthentic\Presentation\Renderer\RendererInterface;
use Phauthentic\Presentation\Renderer\WkhtmlToPdfRenderer;
use Phauthentic\Presentation\View\ViewInterface;
use Psr\Http\Message\ResponseFactoryInterface;
use Psr\Http\Message\ResponseInterface;
use Psr\Http\Message\ServerRequestInterface;
use RuntimeException;

/**
 * Maps mime types to renderer implementations
 */
class RenderService implements RenderServiceInterface, ResponseRenderServiceInterface
{
    /**
     * Map of output types to renderers
     *
     * @var array
     */
    protected $rendererMap = [];

    /**
     * Response Factory
     *
     * @var \Psr\Http\Message\ResponseFactoryInterface
     */
    protected $responseFactory;

    /**
     * Map of mime types to output types
     *
     * @var array
     */
    protected $mimeTypeMap = [
        // html
        'text/html' => NativePHPRenderer::class,
        'application/xhtml' => NativePHPRenderer::class,
        'application/xhtml+xml' => NativePHPRenderer::class,
        // json
        'application/json' => 'json',
        // xml
        'application/xml' => 'xml',
        // pdf
        'application/pdf' => WkhtmlToPdfRenderer::class
    ];

    protected $outputMimeType = 'text/html';

    /**
     * Constructor
     */
    public function __construct(
        ResponseFactoryInterface $responseFactory
    ) {
        $this->responseFactory = $responseFactory;
    }

    /**
     * Adds a renderer and maps it to an output type
     *
     * @return $this
     */
    public function addRenderer(string $outputType, RendererInterface $renderer): RenderServiceInterface
    {
        $this->rendererMap[$outputType] = $renderer;

        return $this;
    }

    /**
     * Validate Mime Type
     *
     * @param string $mimeType Mime Type
     * @return bool
     */
    protected function validateMimeType(string $mimeType): void
    {
        if (!preg_match('#^[-\w+]+/[-\w+]+$#', $mimeType)) {
            throw new RuntimeException('Invalid mime type string');
        }
    }

    /**
     * Maps a mime type to an output type
     *
     * @param string $mimeType Mime Type
     * @param string $renderAs Abbreviation for the renderer
     * @return $this
     */
    public function addMimeTypeMapping(string $mimeType, string $renderAs): RenderServiceInterface
    {
        $this->validateMimeType($mimeType);
        $this->mimeTypeMap[$mimeType] = $renderAs;

        return $this;
    }

    /**
     * Checks if the given mime type can be rendered as output
     *
     * @param string $type Content type to render
     * @return bool
     */
    public function canRender(string $type): bool
    {
        if (isset($this->mimeTypeMap[$type])) {
            $type = $this->mimeTypeMap[$type];
        }

        return isset($this->rendererMap[$type]);
    }

    /**
     * Renders the view to the response
     *
     * @param \Phauthentic\Presentation\Renderer\ViewInterface $view

The type Phauthentic\Presentation\Renderer\ViewInterface was not found. Maybe you did not declare it correctly or list all dependencies?

     * @param string $renderAs Type of output to render
     * @return string
     */
    public function render(ViewInterface $view, ?string $renderAs = 'text/html'): string
    {
        if (!$this->canRender($renderAs)) {

It seems like $renderAs can also be of type null; however, parameter $type of Phauthentic\Presentation\Service\RenderService::canRender() does only seem to accept string, maybe add an additional type check?

            throw new RuntimeException(sprintf(
                'No renderer found for the requested output `%s`',
                $renderAs
            ));
        }

        return $this->rendererMap[$this->mimeTypeMap[$renderAs]]->render($view);
    }

    public function setOutputMimeType(string $mimeType): RenderServiceInterface
    {
        $this->outputMimeType = $mimeType;

        return $this;
    }

    /**
     * Gets a list of mime types the client accepts from the request
     *
     * @param \Psr\Http\Message\ServerRequestInterface $request Server Request Object
     * @return A list of mime types the client accepts

The type Phauthentic\Presentation\Service\A was not found. Did you mean A? If so, make sure to prefix the type with \.

     */
    public function getMimeTypesFromRequest(ServerRequestInterface $request): array
    {
        $mimeTypes = $request->getHeader('Accept');

        if (empty($mimeTypes)) {
            throw new RuntimeException(
                'Could not get an accept header from the request'
            );
        }

        return $mimeTypes;

The expression return $mimeTypes returns the type string[] which is incompatible with the documented return type Phauthentic\Presentation\Service\A.

    }

    /**
     * @todo Should this return an immutable instance?
     */
    public function setOutputMimeTypeByRequest(ServerRequestInterface $request): self
    {
        $mimeTypes = $this->getMimeTypesFromRequest($request);

        foreach ($mimeTypes as $mimeType) {
            if ($this->canRender($mimeType)) {
                $this->outPutMimeType = $mimeType;

The property outPutMimeType does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly.

                return $this;
            }
        }

        throw new RuntimeException(sprintf(
            'No renderer found for the requested output `%s`',
            $mimeType

The variable $mimeType seems to be defined by a foreach iteration on line 170. Are you sure the iterator is never empty, otherwise this variable is not defined?

        ));
    }

    /**
     * Renders the output to the response object
     *
     * @param \Psr\Http\Message\ResponseInterface $response Response object
     * @param \Phauthentic\Presentation\Renderer\ViewInterface $view View DTO
     * @param string $outputMimeType Output format
     * @return \Psr\Http\Message\ResponseInterface
     */
    public function renderToResponse(
        ResponseInterface $response,
        ViewInterface $view,
        ?string $outputMimeType = null
    ): ResponseInterface {
        $outputMimeType = $outputMimeType === null ? $this->outputMimeType : $outputMimeType;

        $stream = $response->getBody();
        $stream->write($this->render($view, $outputMimeType));

        return $response
            ->withBody($stream)
            ->withHeader('content-type', $outputMimeType);
    }

    /**
     * @param \Phauthentic\Presentation\Renderer\ViewInterface $view View DTO
     * @param string $outputMimeType Output format
     * @return \Psr\Http\Message\ResponseInterface
     */
    public function renderResponse(
        ViewInterface $view,
        ?string $outputMimeType = null
    ): ResponseInterface {
        $response = $this->responseFactory->createResponse();

The assignment to $response is dead and can be removed.

        return $this->renderToResponse($view, $outputMimeType);

$outputMimeType of type null|string is incompatible with the type Phauthentic\Presentation\View\ViewInterface expected by parameter $view of Phauthentic\Presentation\Service\RenderService::renderToResponse().

$view of type Phauthentic\Presentation\View\ViewInterface is incompatible with the type Psr\Http\Message\ResponseInterface expected by parameter $response of Phauthentic\Presentation\Service\RenderService::renderToResponse().

    }
}

/*
$view = new View();
$renderService = new RenderService();
$templateMapperService = new RequestToTemplateMapperService();

$view = $templateMapperService->requestToViewTemplate($request, $view);

$response = $renderService
    ->addRenderer('html', new NativePhpRenderer())
    ->addMimeTypeMapping('text/html', 'html')
    ->addMimeTypeMapping('application/xhtml')
    ->addRenderer('json', new NativeJsonRenderer())
    ->addMimeTypeMapping('application/json', 'json')
    ->setOutputMimeTypeByRequest($request)
    ->renderToResponse($response, $view);
*/