Flipbox\Relay\Runner\Runner

Complexity

Total Complexity

14

Size/Duplication

Total Lines	112
Duplicated Lines	0 %

Coupling/Cohesion

Components	0
Dependencies	4

Test Coverage

Coverage

0%

Importance

Changes

0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	__invoke()	0	10	1
A	resolve()	0	10	2
A	resolveMiddleware()	0	21	4
A	isMiddleware()	0	4	2
A	resolveRequest()	0	8	2
A	resolveResponse()	0	8	2

<?php

/**
 * @copyright  Copyright (c) Flipbox Digital Limited
 * @license    https://github.com/flipbox/relay/blob/master/LICENSE
 * @link       https://github.com/flipbox/relay
 */

namespace Flipbox\Relay\Runner;

use Flipbox\Skeleton\Helpers\ObjectHelper;
use Psr\Http\Message\RequestInterface;
use Psr\Http\Message\ResponseInterface;
use Psr\Log\InvalidArgumentException;
use Relay\MiddlewareInterface;
use Zend\Diactoros\Request;
use Zend\Diactoros\Response;

/**
 * @author Flipbox Factory <hello@flipboxfactory.com>
 * @since 3.0.0
 */
class Runner
{
    /**
     * @var (callable|MiddlewareInterface)[]
     */
    private $middleware = [];

    /**
     * @param array $queue
     */
    public function __construct(array $queue)
    {
        $this->middleware = $queue;
    }

    /**
     *
     * Calls the next middleware in the queue.
     *
     * @param RequestInterface $request The incoming request.
     * @param ResponseInterface $response The outgoing response.
     * @return ResponseInterface
     */
    public function __invoke(RequestInterface $request = null, ResponseInterface $response = null)
    {
        $middleware = array_shift($this->middleware);
        $middleware = $this->resolve($middleware);

It seems like $middleware defined by $this->resolve($middleware) on line 49 can also be of type null; however, Flipbox\Relay\Runner\Runner::resolve() does only seem to accept callable, maybe add an additional type check?

        return $middleware(
            $this->resolveRequest($request),

It seems like $request defined by parameter $request on line 46 can also be of type object<Psr\Http\Message\RequestInterface>; however, Flipbox\Relay\Runner\Runner::resolveRequest() does only seem to accept null, maybe add an additional type check?

            $this->resolveResponse($response),

It seems like $response defined by parameter $response on line 46 can also be of type object<Psr\Http\Message\ResponseInterface>; however, Flipbox\Relay\Runner\Runner::resolveResponse() does only seem to accept null, maybe add an additional type check?

            $this
        );
    }

    /**
     * Converts a queue middleware to a callable.
     *
     * @param string|array|callable|MiddlewareInterface $middleware
     * @return callable
     */
    protected function resolve($middleware): callable
    {
        if (null === $middleware) {
            return function (RequestInterface $request, ResponseInterface $response, callable $next) {

The parameter $next is not used and could be removed.

                return $response;
            };
        }

        return $this->resolveMiddleware($middleware);
    }

    /**
     * @param $middleware
     * @return callable|\Flipbox\Skeleton\Object\ObjectInterface|MiddlewareInterface
     */
    private function resolveMiddleware($middleware)
    {
        if ($this->isMiddleware($middleware)) {
            return $middleware;
        }

        try {
            /** @var callable|MiddlewareInterface $middleware */
            $middleware = ObjectHelper::create(
                $middleware
            );
        } catch (\Exception $e) {
            throw new InvalidArgumentException($e->getMessage());
        }

        if (!$this->isMiddleware($middleware)) {
            throw new InvalidArgumentException("Unable to resolve middleware");
        }

        return $middleware;
    }

    /**
     * @param $middleware
     * @return bool
     */
    protected function isMiddleware($middleware): bool
    {
        return is_callable($middleware) || $middleware instanceof MiddlewareInterface;
    }

    /**
     * @param null $request
     * @return RequestInterface
     */
    protected function resolveRequest($request = null): RequestInterface
    {
        if ($request instanceof RequestInterface) {
            return $request;
        }

        return new Request();
    }

    /**
     * @param null $response
     * @return ResponseInterface
     */
    protected function resolveResponse($response = null): ResponseInterface
    {
        if ($response instanceof ResponseInterface) {
            return $response;
        }

        return new Response();
    }
}