Flatdown\Middlewares\ResultConverter

Complexity

Total Complexity

12

Size/Duplication

Total Lines	85
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	5

Test Coverage

Coverage

42.31%

Importance

Changes

0

3 Methods

Rating	Name	Duplication	Size	Complexity
A	attribute()	0	6	1
A	converter()	0	6	1
D	process()	0	36	10

<?php

namespace Flatdown\Middlewares;

use Interop\Http\ServerMiddleware\DelegateInterface;
use Interop\Http\ServerMiddleware\MiddlewareInterface;
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 handler result into a string.
 *
 * By default arrays and objects will be converted to JSON.
 *
 */
class ResultConverter implements MiddlewareInterface
{
    /**
     * @var string Attribute name for handler reference
     */
    private $attribute = 'request-handler';

    /**
     * @var callable Converter for non scalar values
     */
    private $converter;

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

        return $this;
    }

    /**
     * Replaces the default converter
     *
     * @param callable $converter Converter for non scalar values
     *
     * @return self
     */
    public function converter(callable $converter)
    {
        $this->converter = $converter;

        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->attribute);

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

        $converter = $this->converter ?: function ($value) {
            if ((is_array($value) || is_object($value)) && !($value instanceof \Closure)) {
                $response = Utils\Factory::createResponse(200);
                $response->getBody()->write(json_encode($value));

                return $response->withHeader('content-type', 'application/json');
            }
            throw new \RuntimeException("Incompatible return value returned in the route handler.");
        };

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

            if (($result instanceof ResponseInterface) || is_scalar($result)) {
                return $result;
            }

            if (is_object($result) && method_exists($result, '__toString')) {
                return $result->__toString();
            }

            return $converter($result);
        };

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

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