Philae\Middlewares\ResponseTransformer

Complexity

Total Complexity

13

Size/Duplication

Total Lines	84
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	6

Test Coverage

Coverage

83.33%

Importance

Changes

0

3 Methods

Rating	Name	Duplication	Size	Complexity
A	handlerAttribute()	0	6	1
B	process()	0	27	4
B	transform()	0	21	8

<?php

namespace Philae\Middlewares;

use Interop\Http\ServerMiddleware\DelegateInterface;
use Middlewares\Utils;
use Psr\Http\Message\ResponseInterface;
use Psr\Http\Message\ServerRequestInterface;

/**
 * Wraps the request handler callback in another one that will
 * try to convert the request handler result into a PSR-7 Response
 * and/or apply some changes to the response object itself
 * (like setting/fixing the Content Length header).
 */
class ResponseTransformer extends AbstractMiddleware
{
    /**
     * @var string Attribute name for handler reference
     */
    protected $handlerAttribute = 'request-handler';

    /**
     * Set the attribute name to store handler reference.
     *
     * @param string $handlerAttribute
     *
     * @return self
     */
    public function handlerAttribute(string $handlerAttribute)
    {
        $this->handlerAttribute = $handlerAttribute;

        return $this;
    }

    /**
     * Process a server request and return a response.
     *
     * @param ServerRequestInterface $request
     * @param DelegateInterface $delegate
     *
     * @return ResponseInterface
     */
    public function process(ServerRequestInterface $request, DelegateInterface $delegate)
    {
        $handler = $request->getAttribute($this->handlerAttribute);

        if (!is_callable($handler)) {
            return $delegate->process($request);
        }

        $handlerWrapper = function (...$args) use ($handler) {
            $result = call_user_func($handler, ...$args);

            $response = $this->transform($result);

            if (!($response instanceof ResponseInterface)) {
                $type = is_object($response) ? get_class($response) : gettype($response);
                throw new \UnexpectedValueException(
                    'Cannot convert the request handler result of type `' . $type . '` into a Response object.'
                );
            }

            return $response;
        };

        $request = $request->withAttribute($this->handlerAttribute, $handlerWrapper);

        return $delegate->process($request);
    }

    /**
     * Tries to transform the given result into a Response object, otherwise it is returned back.
     * @param mixed $result
     * @return ResponseInterface|mixed
     */
    public function transform($result)
    {
        if ($result instanceof ResponseInterface) {
            return $result->withHeader('Content-Length', $result->getBody()->getSize());
        }

        if (is_scalar($result) || is_null($result)) {
            $result = strval($result);
        } elseif (is_object($result) && method_exists($result, '__toString')) {
            $result = $result->__toString();
        }

        if (!is_string($result)) {
            return $result;
        }

        $response = Utils\Factory::createResponse((strlen($result) > 0) ? 200 : 204);
        $response->getBody()->write($result);

        return $response;
    }
}