4855566680

Build Type

push

github

Committed by Ricardo Boss

Commit Message

Moved namespace iteration to its own iterator

Run Details

1 of 1 new or added line in 1 file covered. (100.0%)

3635 of 5261 relevant lines covered (69.09%)

9.0 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/modules/Web/src/RequestPipelineBuilder.php

<?php
declare(strict_types=1);

namespace Elephox\Web;

use Elephox\Collection\ArrayList;
use Elephox\Collection\EmptySequenceException;
use Elephox\DI\Contract\Resolver;
use Elephox\Support\Contract\ExceptionHandler;
use Elephox\Web\Contract\PipelineEndpoint;
use Elephox\Web\Contract\WebMiddleware;
use InvalidArgumentException;
use LogicException;

class RequestPipelineBuilder
{
        /**
         * @var ArrayList<WebMiddleware|class-string<WebMiddleware>> $middlewares
         */
        private ArrayList $middlewares;

        /**
         * @param PipelineEndpoint|null $endpoint
         * @param class-string<PipelineEndpoint>|null $endpointClass
         */
        public function __construct(
                private ?PipelineEndpoint $endpoint,
                private ?string $endpointClass,
        ) {
                /** @var ArrayList<WebMiddleware|class-string<WebMiddleware>> */
                $this->middlewares = new ArrayList();
        }

        /**
         * @param class-string<WebMiddleware>|WebMiddleware $middleware
         */
        public function push(WebMiddleware|string $middleware): self
        {
                $this->middlewares->add($middleware);

                return $this;
        }

        /**
         * @param class-string<WebMiddleware>|null $className
         *
         * @return WebMiddleware|class-string<WebMiddleware>
         */
        public function pop(?string $className = null): WebMiddleware|string
        {
                $predicate = $className === null ? null : static fn (WebMiddleware|string $middleware): bool => $middleware === $className || $middleware instanceof $className;

                /** @psalm-suppress InvalidArgument */
                return $this->middlewares->pop($predicate);
        }

        public function endpoint(PipelineEndpoint|string $endpoint): self
        {
                if (is_string($endpoint)) {
                        $interfaces = class_implements($endpoint);
                        if ($interfaces === false || !in_array(PipelineEndpoint::class, $interfaces, true)) {
                                throw new InvalidArgumentException('Given class name must implement ' . PipelineEndpoint::class);
                        }

                        /** @var class-string<PipelineEndpoint> $endpoint */
                        $this->endpoint = null;
                        $this->endpointClass = $endpoint;
                } else {
                        $this->endpoint = $endpoint;
                        $this->endpointClass = null;
                }

                return $this;
        }

        public function exceptionHandler(WebMiddleware&ExceptionHandler $exceptionHandler): self
        {
                /** @var int|null $key */
                $key = $this->middlewares->firstKeyOrDefault(null, static fn (string|WebMiddleware $middleware): bool => $middleware instanceof ExceptionHandler);

                if ($key === null) {
                        $this->middlewares->insertAt(0, $exceptionHandler);
                } else {
                        $this->middlewares->put($key, $exceptionHandler);
                }

                return $this;
        }

        public function build(Resolver $resolver): RequestPipeline
        {
                if ($this->endpoint === null && $this->endpointClass !== null) {
                        $this->endpoint = $resolver->instantiate($this->endpointClass);
                } elseif ($this->endpoint === null) {
                        throw new LogicException('Either an endpoint or the class name for an endpoint needs to be set');
                }

                assert($this->endpoint instanceof PipelineEndpoint, 'Invalid endpoint type, expected class implementing ' . PipelineEndpoint::class);

                /** @var ArrayList<WebMiddleware> $concreteMiddlewares */
                $concreteMiddlewares = new ArrayList();

                foreach ($this->middlewares as $middleware) {
                        if (is_string($middleware)) {
                                $concreteMiddleware = $resolver->instantiate($middleware);
                                if (!($concreteMiddleware instanceof WebMiddleware)) {
                                        throw new InvalidArgumentException("Given middleware '$middleware' does not implement " . WebMiddleware::class);
                                }

                                $concreteMiddlewares->add($concreteMiddleware);
                        } else {
                                $concreteMiddlewares->add($middleware);
                        }
                }

                return new RequestPipeline($this->endpoint, $concreteMiddlewares);
        }
}

1	<?php
2	declare(strict_types=1);
3
4	namespace Elephox\Web;
5
6	use Elephox\Collection\ArrayList;
7	use Elephox\Collection\EmptySequenceException;
8	use Elephox\DI\Contract\Resolver;
9	use Elephox\Support\Contract\ExceptionHandler;
10	use Elephox\Web\Contract\PipelineEndpoint;
11	use Elephox\Web\Contract\WebMiddleware;
12	use InvalidArgumentException;
13	use LogicException;
14
15	class RequestPipelineBuilder
16	{
17	/**
18	* @var ArrayList<WebMiddleware\|class-string<WebMiddleware>> $middlewares
19	*/
20	private ArrayList $middlewares;
21
22	/**
23	* @param PipelineEndpoint\|null $endpoint
24	* @param class-string<PipelineEndpoint>\|null $endpointClass
25	*/
26	public function __construct(
27	private ?PipelineEndpoint $endpoint,
28	private ?string $endpointClass,
29	) {
30	/** @var ArrayList<WebMiddleware\|class-string<WebMiddleware>> */
31	$this->middlewares = new ArrayList();	×
32	}
33
34	/**
35	* @param class-string<WebMiddleware>\|WebMiddleware $middleware
36	*/
37	public function push(WebMiddleware\|string $middleware): self
38	{
39	$this->middlewares->add($middleware);	×
40
41	return $this;	×
42	}
43
44	/**
45	* @param class-string<WebMiddleware>\|null $className
46	*
47	* @return WebMiddleware\|class-string<WebMiddleware>
48	*/
49	public function pop(?string $className = null): WebMiddleware\|string
50	{
51	$predicate = $className === null ? null : static fn (WebMiddleware\|string $middleware): bool => $middleware === $className \|\| $middleware instanceof $className;	×
52
53	/** @psalm-suppress InvalidArgument */
54	return $this->middlewares->pop($predicate);	×
55	}
56
57	public function endpoint(PipelineEndpoint\|string $endpoint): self
58	{
59	if (is_string($endpoint)) {	×
60	$interfaces = class_implements($endpoint);	×
61	if ($interfaces === false \|\| !in_array(PipelineEndpoint::class, $interfaces, true)) {	×
62	throw new InvalidArgumentException('Given class name must implement ' . PipelineEndpoint::class);	×
63	}
64
65	/** @var class-string<PipelineEndpoint> $endpoint */
66	$this->endpoint = null;	×
67	$this->endpointClass = $endpoint;	×
68	} else {
69	$this->endpoint = $endpoint;	×
70	$this->endpointClass = null;	×
71	}
72
73	return $this;	×
74	}
75
76	public function exceptionHandler(WebMiddleware&ExceptionHandler $exceptionHandler): self
77	{
78	/** @var int\|null $key */
79	$key = $this->middlewares->firstKeyOrDefault(null, static fn (string\|WebMiddleware $middleware): bool => $middleware instanceof ExceptionHandler);	×
80
81	if ($key === null) {	×
82	$this->middlewares->insertAt(0, $exceptionHandler);	×
83	} else {
84	$this->middlewares->put($key, $exceptionHandler);	×
85	}
86
87	return $this;	×
88	}
89
90	public function build(Resolver $resolver): RequestPipeline
91	{
92	if ($this->endpoint === null && $this->endpointClass !== null) {	×
93	$this->endpoint = $resolver->instantiate($this->endpointClass);	×
94	} elseif ($this->endpoint === null) {	×
95	throw new LogicException('Either an endpoint or the class name for an endpoint needs to be set');	×
96	}
97
98	assert($this->endpoint instanceof PipelineEndpoint, 'Invalid endpoint type, expected class implementing ' . PipelineEndpoint::class);	×
99
100	/** @var ArrayList<WebMiddleware> $concreteMiddlewares */
101	$concreteMiddlewares = new ArrayList();	×
102
103	foreach ($this->middlewares as $middleware) {	×
104	if (is_string($middleware)) {	×
105	$concreteMiddleware = $resolver->instantiate($middleware);	×
106	if (!($concreteMiddleware instanceof WebMiddleware)) {	×
107	throw new InvalidArgumentException("Given middleware '$middleware' does not implement " . WebMiddleware::class);	×
108	}
109
110	$concreteMiddlewares->add($concreteMiddleware);	×
111	} else {
112	$concreteMiddlewares->add($middleware);	×
113	}
114	}
115
116	return new RequestPipeline($this->endpoint, $concreteMiddlewares);	×
117	}
118	}

elephox-dev / framework / 4855566680

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous