MiddlewareRunner::orderMiddlewares() - Code Metrics - php-api-clients/middleware - Measure and Improve Code Quality continuously with Scrutinizer

MiddlewareRunner::orderMiddlewares() A
last analyzed 2019-07-01 23:36 UTC

↳ Parent: MiddlewareRunner

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	7
CRAP Score	1

Importance

Changes

Metric	Value
dl	0
loc	11
ccs	7
cts	7
cp	1
rs	9.9
c	0
b	0
f	0
cc	1
nc	1
nop	2
crap	1

<?php declare(strict_types=1);

namespace ApiClients\Foundation\Middleware;

use ApiClients\Foundation\Middleware\Annotation\PriorityInterface;
use Doctrine\Common\Annotations\AnnotationReader;
use Psr\Http\Message\RequestInterface;
use Psr\Http\Message\ResponseInterface;
use React\Promise\CancellablePromiseInterface;
use ReflectionMethod;
use Throwable;
use function React\Promise\reject;
use function React\Promise\resolve;

final class MiddlewareRunner
{
    const TRAITS = [
        'pre'   => PreTrait::class,
        'post'  => PostTrait::class,
        'error' => ErrorTrait::class,
    ];

    /**
     * @var array
     */
    private $options;

    /**
     * @var MiddlewareInterface[]
     */
    private $middlewares;

    /**
     * @var AnnotationReader
     */
    private $annotationReader;

    /**
     * @var string
     */
    private $id;

    /**
     * MiddlewareRunner constructor.
     * @param array                 $options
     * @param MiddlewareInterface[] $middlewares
     */
    public function __construct(array $options, MiddlewareInterface ...$middlewares)
    {
        $this->options = $options;
        $this->id = bin2hex(random_bytes(32));
        $this->middlewares = $middlewares;

        $this->annotationReader = new AnnotationReader();
    }

    /**
     * @param  RequestInterface            $request
     * @return CancellablePromiseInterface
     */
    public function pre(

        RequestInterface $request
    ): CancellablePromiseInterface {
        $promise = resolve($request);

        $middlewares = $this->middlewares;
        $middlewares = $this->orderMiddlewares('pre', ...$middlewares);

        foreach ($middlewares as $middleware) {
            $requestMiddleware = $middleware;
            $promise = $promise->then(function (RequestInterface $request) use ($requestMiddleware) {
                return $requestMiddleware->pre($request, $this->id, $this->options);
            });
        }

        return $promise;
    }

    /**
     * @param  ResponseInterface           $response
     * @return CancellablePromiseInterface
     */
    public function post(

        ResponseInterface $response
    ): CancellablePromiseInterface {
        $promise = resolve($response);

        $middlewares = $this->middlewares;
        $middlewares = $this->orderMiddlewares('post', ...$middlewares);

        foreach ($middlewares as $middleware) {
            $responseMiddleware = $middleware;
            $promise = $promise->then(function (ResponseInterface $response) use ($responseMiddleware) {
                return $responseMiddleware->post($response, $this->id, $this->options);
            });
        }

        return $promise;
    }

    /**
     * @param  Throwable                   $throwable
     * @return CancellablePromiseInterface
     */
    public function error(

        Throwable $throwable
    ): CancellablePromiseInterface {
        $promise = reject($throwable);

        $middlewares = $this->middlewares;
        $middlewares = $this->orderMiddlewares('error', ...$middlewares);

        foreach ($middlewares as $middleware) {
            $errorMiddleware = $middleware;
            $promise = $promise->then(null, function (Throwable $throwable) use ($errorMiddleware) {
                return reject($errorMiddleware->error($throwable, $this->id, $this->options));
            });
        }

        return $promise;
    }

    /**
     * Sort the middlewares by priority.
     *
     * @param  string                $method
     * @param  MiddlewareInterface[] $middlewares
     * @return array
     */
    protected function orderMiddlewares(string $method, MiddlewareInterface ...$middlewares): array
    {
        $middlewares = array_filter($middlewares, function (MiddlewareInterface $middleware) use ($method) {
            return !isset(class_uses($middleware)[self::TRAITS[$method]]);
        });
        usort($middlewares, function (MiddlewareInterface $left, MiddlewareInterface $right) use ($method) {
            return $this->getPriority($method, $right) <=> $this->getPriority($method, $left);
        });

        return $middlewares;
    }

    private function getPriority(string $method, MiddlewareInterface $middleware): int
    {
        $methodReflection = new ReflectionMethod($middleware, $method);
        $annotations = $this->annotationReader->getMethodAnnotations($methodReflection);

        foreach ($annotations as $annotation) {
            if (!is_subclass_of($annotation, PriorityInterface::class)) {

                continue;
            }

            return $annotation->priority();
        }

        return Priority::DEFAULT;
    }
}


1			<?php declare(strict_types=1);
2
3			namespace ApiClients\Foundation\Middleware;
4
5			use ApiClients\Foundation\Middleware\Annotation\PriorityInterface;
6			use Doctrine\Common\Annotations\AnnotationReader;
7			use Psr\Http\Message\RequestInterface;
8			use Psr\Http\Message\ResponseInterface;
9			use React\Promise\CancellablePromiseInterface;
10			use ReflectionMethod;
11			use Throwable;
12			use function React\Promise\reject;
13			use function React\Promise\resolve;
14
15			final class MiddlewareRunner
16			{
17			const TRAITS = [
18			'pre' => PreTrait::class,
19			'post' => PostTrait::class,
20			'error' => ErrorTrait::class,
21			];
22
23			/**
24			* @var array
25			*/
26			private $options;
27
28			/**
29			* @var MiddlewareInterface[]
30			*/
31			private $middlewares;
32
33			/**
34			* @var AnnotationReader
35			*/
36			private $annotationReader;
37
38			/**
39			* @var string
40			*/
41			private $id;
42
43			/**
44			* MiddlewareRunner constructor.
45			* @param array $options
46			* @param MiddlewareInterface[] $middlewares
47			*/
48	2		public function __construct(array $options, MiddlewareInterface ...$middlewares)
49			{
50	2		$this->options = $options;
51	2		$this->id = bin2hex(random_bytes(32));
52	2		$this->middlewares = $middlewares;
			0 ignored issues – show Documentation Bug introduced 2017-06-14 10:32 UTC by Report Bug Copy Issue Report It seems like `$middlewares` of type `array<integer,array<inte...\MiddlewareInterface>>>` is incompatible with the declared type `array<integer,object<Api...e\MiddlewareInterface>>` of property `$middlewares`. Our type inference engine has found an assignment to a property that is incompatible with the declared type of that property. Either this assignment is in error or the assigned type should be added to the documentation/type hint for that property.. Loading history...
53	2		$this->annotationReader = new AnnotationReader();
54	2		}
55
56			/**
57			* @param RequestInterface $request
58			* @return CancellablePromiseInterface
59			*/
60	2	View Code Duplication	public function pre(
			0 ignored issues – show Duplication introduced 2018-07-08 13:59 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
61			RequestInterface $request
62			): CancellablePromiseInterface {
63	2		$promise = resolve($request);
64
65	2		$middlewares = $this->middlewares;
66	2		$middlewares = $this->orderMiddlewares('pre', ...$middlewares);
67
68	2		foreach ($middlewares as $middleware) {
69	2		$requestMiddleware = $middleware;
70	2		$promise = $promise->then(function (RequestInterface $request) use ($requestMiddleware) {
71	2		return $requestMiddleware->pre($request, $this->id, $this->options);
72	2		});
73			}
74
75	2		return $promise;
76			}
77
78			/**
79			* @param ResponseInterface $response
80			* @return CancellablePromiseInterface
81			*/
82	2	View Code Duplication	public function post(
			0 ignored issues – show Duplication introduced 2018-07-08 13:59 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
83			ResponseInterface $response
84			): CancellablePromiseInterface {
85	2		$promise = resolve($response);
86
87	2		$middlewares = $this->middlewares;
88	2		$middlewares = $this->orderMiddlewares('post', ...$middlewares);
89
90	2		foreach ($middlewares as $middleware) {
91	2		$responseMiddleware = $middleware;
92	2		$promise = $promise->then(function (ResponseInterface $response) use ($responseMiddleware) {
93	2		return $responseMiddleware->post($response, $this->id, $this->options);
94	2		});
95			}
96
97	2		return $promise;
98			}
99
100			/**
101			* @param Throwable $throwable
102			* @return CancellablePromiseInterface
103			*/
104	2	View Code Duplication	public function error(
			0 ignored issues – show Duplication introduced 2018-07-08 13:59 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
105			Throwable $throwable
106			): CancellablePromiseInterface {
107	2		$promise = reject($throwable);
108
109	2		$middlewares = $this->middlewares;
110	2		$middlewares = $this->orderMiddlewares('error', ...$middlewares);
111
112	2		foreach ($middlewares as $middleware) {
113	2		$errorMiddleware = $middleware;
114	2		$promise = $promise->then(null, function (Throwable $throwable) use ($errorMiddleware) {
115	2		return reject($errorMiddleware->error($throwable, $this->id, $this->options));
116	2		});
117			}
118
119	2		return $promise;
120			}
121
122			/**
123			* Sort the middlewares by priority.
124			*
125			* @param string $method
126			* @param MiddlewareInterface[] $middlewares
127			* @return array
128			*/
129			protected function orderMiddlewares(string $method, MiddlewareInterface ...$middlewares): array
130			{
131	2		$middlewares = array_filter($middlewares, function (MiddlewareInterface $middleware) use ($method) {
132	2		return !isset(class_uses($middleware)[self::TRAITS[$method]]);
133	2		});
134	2		usort($middlewares, function (MiddlewareInterface $left, MiddlewareInterface $right) use ($method) {
135	2		return $this->getPriority($method, $right) <=> $this->getPriority($method, $left);
136	2		});
137
138	2		return $middlewares;
139			}
140
141	2		private function getPriority(string $method, MiddlewareInterface $middleware): int
142			{
143	2		$methodReflection = new ReflectionMethod($middleware, $method);
144	2		$annotations = $this->annotationReader->getMethodAnnotations($methodReflection);
145
146	2		foreach ($annotations as $annotation) {
147	1		if (!is_subclass_of($annotation, PriorityInterface::class)) {
			0 ignored issues – show Bug introduced 2017-06-19 03:35 UTC by Report Bug Copy Issue Report Due to PHP Bug #53727, `is_subclass_of` might return inconsistent results on some PHP versions if `\ApiClients\Foundation\M...riorityInterface::class` can be an interface. If so, you could instead use `ReflectionClass::implementsInterface`. Loading history...
148			continue;
149			}
150
151	1		return $annotation->priority();
152			}
153
154	2		return Priority::DEFAULT;
155			}
156			}
157

php-api-clients / middleware

GitHub Access Token became invalid

MiddlewareRunner::orderMiddlewares() A last analyzed 2019-07-01 23:36 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

MiddlewareRunner::orderMiddlewares() A
last analyzed 2019-07-01 23:36 UTC