Dispatcher::__construct() - Code Metrics - Inspection of "2.0.0" - mindplay-dk/middleman - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#8)

by Rasmus

created 2016-09-29 07:42 UTC

Dispatcher::__construct() A

↳ Parent: Dispatcher

Complexity

Conditions	2
Paths	2

Size

Total Lines	9
Code Lines	5

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	6
CRAP Score	2

Importance

Changes

Metric	Value
dl	0
loc	9
ccs	6
cts	6
cp	1
rs	9.6666
c	0
b	0
f	0
cc	2
eloc	5
nc	2
nop	2
crap	2

<?php

namespace mindplay\middleman;

use Interop\Http\Middleware\DelegateInterface;
use Interop\Http\Middleware\MiddlewareInterface;
use Interop\Http\Middleware\ServerMiddlewareInterface;
use InvalidArgumentException;
use LogicException;
use mindplay\readable;
use Psr\Http\Message\RequestInterface;
use Psr\Http\Message\ResponseInterface;

/**
 * PSR-7 / PSR-15 middleware dispatcher
 */
class Dispatcher implements MiddlewareInterface
{
    /**
     * @var callable middleware resolver
     */
    private $resolver;

    /**
     * @var mixed[] unresolved middleware stack
     */
    private $stack;

    /**
     * @param (callable|MiddlewareInterface|mixed)[] $stack middleware stack (with at least one middleware component)
     * @param callable|null $resolver optional middleware resolver:
     *                                function (string $name): MiddlewareInterface
     *
     * @throws InvalidArgumentException if an empty middleware stack was given
     */
    public function __construct($stack, callable $resolver = null)
    {
        if (count($stack) === 0) {
            throw new InvalidArgumentException("an empty middleware stack was given");
        }

        $this->stack = $stack;
        $this->resolver = $resolver;
    }

    /**
     * Dispatches the middleware stack and returns the resulting `ResponseInterface`.
     *
     * @param RequestInterface $request
     *
     * @return ResponseInterface
     *
     * @throws LogicException on unexpected result from any middleware on the stack
     */
    public function dispatch(RequestInterface $request)
    {
        $resolved = $this->resolve(0);

        return $resolved($request);
    }

    /**
     * @inheritdoc
     */
    public function process(RequestInterface $request, DelegateInterface $delegate)
    {
        $this->stack[] = function (RequestInterface $request) use ($delegate) {
            return $delegate->process($request);
        };

        $response = $this->dispatch($request);

        array_pop($this->stack);

        return $response;
    }

    /**
     * @param int $index middleware stack index
     *
     * @return Delegate
     */
    private function resolve($index)
    {
        if (isset($this->stack[$index])) {
            return new Delegate(function (RequestInterface $request) use ($index) {
                $middleware = $this->resolver
                    ? call_user_func($this->resolver, $this->stack[$index])
                    : $this->stack[$index]; // as-is

                switch (true) {
                    case $middleware instanceof MiddlewareInterface:
                    case $middleware instanceof ServerMiddlewareInterface:
                        $result = $middleware->process($request, $this->resolve($index + 1));
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
                        break;

                    case is_callable($middleware):
                    case is_object($middleware) && method_exists($middleware, "__invoke"):
                        $result = $middleware($request, $this->resolve($index + 1));
                        break;

                    default:
                        $given = readable::callback($middleware);

                        throw new LogicException("unsupported middleware type: {$given}");
                }

                if (! $result instanceof ResponseInterface) {
                    $given = readable::value($result);
                    $source = readable::callback($middleware);

                    throw new LogicException("unexpected middleware result: {$given} returned by: {$source}");
                }

                return $result;
            });
        }

        return new Delegate(function () {
            throw new LogicException("unresolved request: middleware stack exhausted with no result");
        });
    }
}


1		<?php
2
3		namespace mindplay\middleman;
4
5		use Interop\Http\Middleware\DelegateInterface;
6		use Interop\Http\Middleware\MiddlewareInterface;
7		use Interop\Http\Middleware\ServerMiddlewareInterface;
8		use InvalidArgumentException;
9		use LogicException;
10		use mindplay\readable;
11		use Psr\Http\Message\RequestInterface;
12		use Psr\Http\Message\ResponseInterface;
13
14		/**
15		* PSR-7 / PSR-15 middleware dispatcher
16		*/
17		class Dispatcher implements MiddlewareInterface
18		{
19		/**
20		* @var callable middleware resolver
21		*/
22		private $resolver;
23
24		/**
25		* @var mixed[] unresolved middleware stack
26		*/
27		private $stack;
28
29		/**
30		* @param (callable\|MiddlewareInterface\|mixed)[] $stack middleware stack (with at least one middleware component)
31		* @param callable\|null $resolver optional middleware resolver:
32		* function (string $name): MiddlewareInterface
33		*
34		* @throws InvalidArgumentException if an empty middleware stack was given
35		*/
36	1	public function __construct($stack, callable $resolver = null)
37		{
38	1	if (count($stack) === 0) {
39	1	throw new InvalidArgumentException("an empty middleware stack was given");
40		}
41
42	1	$this->stack = $stack;
43	1	$this->resolver = $resolver;
44	1	}
45
46		/**
47		* Dispatches the middleware stack and returns the resulting `ResponseInterface`.
48		*
49		* @param RequestInterface $request
50		*
51		* @return ResponseInterface
52		*
53		* @throws LogicException on unexpected result from any middleware on the stack
54		*/
55	1	public function dispatch(RequestInterface $request)
56		{
57	1	$resolved = $this->resolve(0);
58
59	1	return $resolved($request);
60		}
61
62		/**
63		* @inheritdoc
64		*/
65	1	public function process(RequestInterface $request, DelegateInterface $delegate)
66		{
67		$this->stack[] = function (RequestInterface $request) use ($delegate) {
68	1	return $delegate->process($request);
69		};
70
71	1	$response = $this->dispatch($request);
72
73	1	array_pop($this->stack);
74
75	1	return $response;
76		}
77
78		/**
79		* @param int $index middleware stack index
80		*
81		* @return Delegate
82		*/
83	1	private function resolve($index)
84		{
85	1	if (isset($this->stack[$index])) {
86		return new Delegate(function (RequestInterface $request) use ($index) {
87	1	$middleware = $this->resolver
88	1	? call_user_func($this->resolver, $this->stack[$index])
89	1	: $this->stack[$index]; // as-is
90
91	1	switch (true) {
92	1	case $middleware instanceof MiddlewareInterface:
93	1	case $middleware instanceof ServerMiddlewareInterface:
94	1	$result = $middleware->process($request, $this->resolve($index + 1));
		0 ignored issues – show Documentation introduced 2016-09-27 13:23 UTC by Report Bug Copy Issue Report `$request` is of type `object<Psr\Http\Message\RequestInterface>`, but the function expects a `object<Psr\Http\Message\ServerRequestInterface>`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
95	1	break;
96
97	1	case is_callable($middleware):
98	1	case is_object($middleware) && method_exists($middleware, "__invoke"):
99	1	$result = $middleware($request, $this->resolve($index + 1));
100	1	break;
101
102		default:
103		$given = readable::callback($middleware);
104
105		throw new LogicException("unsupported middleware type: {$given}");
106		}
107
108	1	if (! $result instanceof ResponseInterface) {
109	1	$given = readable::value($result);
110	1	$source = readable::callback($middleware);
111
112	1	throw new LogicException("unexpected middleware result: {$given} returned by: {$source}");
113		}
114
115	1	return $result;
116	1	});
117		}
118
119	1	return new Delegate(function () {
120	1	throw new LogicException("unresolved request: middleware stack exhausted with no result");
121	1	});
122		}
123		}
124

mindplay-dk / middleman

Pull Request — master (#8)

Dispatcher::__construct() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like