ADDED: PSR related documentation. Other refactoring.

Author: hsehszroc

README.md

@@ -1,23 +1,21 @@
-## Introduction:
+## Introduction
 
 Pipeline follows the Chain of Responsibility Design Pattern to handle the given subject/request using pipes.
 
-## Documentation
-
-### Installation (via Composer)
+## Installation (via Composer)
 
 Install library using composer command:
 ```sh
 $ composer require thewebsolver/pipeline
 ```
 
-### Usage
+## Usage
 
-The main responsibility of the Pipeline class is to pass given subject to all registered pipes and return back the transformed value. The pipeline chain can be initialised following builder pattern as follows:
+The main responsibility of the Pipeline class is to pass given subject to all registered pipes and return back the transformed value. The pipeline chain can be initialized following builder pattern as follows:
 - Initialize the pipeline (`new Pipeline()`).
 - Pass subject to the pipeline using `Pipeline::send()` method.
 - Provide a single handler using `Pipeline::pipe()` method or if multiple pipes (_which obviously should be the case, otherwise what is the intent of using Pipeline anyway_), use `Pipeline::through()` method.
-	> NOTE: `Pipeline::through()` is the main method to provide pipes. If pipes are provided using `Pipeline::pipe()` method and then required pipes are provided using `Pipeline::through()` method, pipes provided using `Pipeline::pipe()` will be defered. Meaning subject will pass through pipes provided using `Pipeline::through()` and then the transformed subject is pass through other pipes provided using `Pipeline::pipe()`.
+	> NOTE: `Pipeline::through()` is the main method to provide pipes. If pipes are provided using `Pipeline::pipe()` method and then required pipes are provided using `Pipeline::through()` method, pipes provided using `Pipeline::pipe()` will be deferred. Meaning subject will pass through pipes provided using `Pipeline::through()` and then the transformed subject is pass through other pipes provided using `Pipeline::pipe()`.
 
 	> In summary, `Pipeline::pipe()` method's intent is to append additional pipes to the pipeline after required pipes are provided using `Pipeline::through()` method.
 
@@ -29,7 +27,7 @@ There are two methods that may be required depending on how subject is being han
 - `Pipeline::use()` method provides additional data to each pipe.
 - `Pipeline::sealWith()` method provides prevention mechanism form script interruption if any pipe throws an exception.
 
-#### Basic Usage
+### Basic Usage
 ```php
 use TheWebSolver\Codegarage\Lib\Pipeline;
 
@@ -43,15 +41,15 @@ class MakeTextUpperCase implements PipeInterface {
 // Pipe as a lambda function.
 $trimCharacters = static fn(string $text, \Closure $next): string => $next( trim( $text ) );
 
-// $finalText will be -> 'WHITESPACED AND MIXED CASED STRING';
+// $finalText will be -> 'WHITESPACE AND MIXED CASED STRING';
 $finalText = (new Pipeline())
-	->send(subject: ' Whitespaced and Mixed cased String\ ')
+	->send(subject: ' Whitespace and Mixed cased String\ ')
 	->through(pipes: array( MakeTextUpperCase::class, $trimCharacters ) )
 	->thenReturn();
 ```
 
 
-#### Advanced Usage
+### Advanced Usage
 ```php
 use Closure;
 use Throwable;
@@ -92,3 +90,52 @@ $transformed = $pipeline->then(
 	static fn(mixed $subject) => array('prefix', ...(is_array($subject) ? $subject : array()))
 );
 ```
+
+## PSR-7 & PSR-15 Bridge
+The `TheWebSolver\Codegarage\Lib\PipelineBridge` seamlessly handles middlewares coming to the Request Handler, piping through the pipeline and getting the response back.
+
+```php
+use Closure;
+use Psr\Http\Message\ResponseInterface;
+use Psr\Http\Server\MiddlewareInterface;
+use Psr\Http\Server\RequestHandlerInterface;
+use Psr\Http\Message\ServerRequestInterface;
+use TheWebSolver\Codegarage\Lib\PipelineBridge;
+
+class RequestHandler implements RequestHandlerInterface {
+	/** @var array<Closure|MiddlewareInterface> */
+	protected array $middlewares;
+
+	public function addMiddleware(Closure|MiddlewareInterface $middleware) {
+		$this->middlewares[] = PipelineBridge::middlewareToPipe($middleware);
+	}
+
+	public function handle( ServerRequestInterface $request ): ResponseInterface {
+		// Concrete that implements "ResponseInterface".
+		$response = new Response();
+
+		// Middleware that uses previous response as required.
+		$middleware = function(
+			ServerRequestInterface $request,
+			RequestHandlerInterface $handler
+		) {
+			$previousResponse = $request->getAttribute(PipelineBridge::MIDDLEWARE_RESPONSE);
+
+			return '/app/route/' !== $request->getRequestTarget()
+				? new Response(status: 404)
+				: $previousResponse->withStatus(code: 200);
+		}
+
+		$middlewares = array(
+			...$this->middlewares,
+			PipelineBridge::middlewareToPipe($middleware)
+		);
+
+		return (new Pipeline())
+			->use($request, $this) // Passed to "MiddlewareInterface::process()" method.
+			->send(subject: $response)
+			->through(pipes: $middlewares)
+			->thenReturn();
+	}
+}
+```