Stitcher\Application\Server

Complexity

Total Complexity

22

Size/Duplication

Total Lines	126
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	7

Test Coverage

Coverage

65.31%

Importance

Changes

0

12 Methods

Rating	Name	Duplication	Size	Complexity
	handleStaticRoute()	0	1	?
A	setRouter()	0	6	1
A	run()	0	6	1
A	getRequest()	0	8	2
A	getCurrentPath()	0	6	2
A	handleDynamicRoute()	0	8	2
B	createResponse()	0	25	5
A	setHeaderContainer()	0	6	1
A	setErrorHandler()	0	6	1
A	createRedirectResponse()	0	4	1
A	createErrorResponse()	0	8	2
A	handleResponse()	0	16	4

<?php

namespace Stitcher\Application;

use GuzzleHttp\Psr7\Request;
use GuzzleHttp\Psr7\Response;
use GuzzleHttp\Psr7\ServerRequest;
use Pageon\Http\HeaderContainer;
use Stitcher\Exception\ErrorHandler;
use Stitcher\Exception\Http;
use Stitcher\Exception\StitcherException;

abstract class Server
{
    /** @var Router */
    protected $router;

    /** @var Request */
    protected $request;

    /** @var HeaderContainer */
    protected $headerContainer;

    /** @var \Stitcher\Exception\ErrorHandler */
    protected $errorHandler;

    abstract protected function handleStaticRoute(): ?Response;

    public function setRouter(Router $router): Server
    {
        $this->router = $router;

        return $this;
    }

    public function setHeaderContainer(HeaderContainer $headerContainer): Server
    {
        $this->headerContainer = $headerContainer;

        return $this;
    }

    public function setErrorHandler(ErrorHandler $errorHandler): Server
    {
        $this->errorHandler = $errorHandler;

        return $this;
    }

    public function run(): string
    {
        $response = $this->createResponse();

        return $this->handleResponse($response);
    }

    protected function getRequest(): Request
    {
        if (! $this->request) {
            $this->request = ServerRequest::fromGlobals();

It seems like \GuzzleHttp\Psr7\ServerRequest::fromGlobals() of type object<Psr\Http\Message\ServerRequestInterface> is incompatible with the declared type object<GuzzleHttp\Psr7\Request> of property $request.

        }

        return $this->request;
    }

    protected function getCurrentPath(): string
    {
        $path = $this->getRequest()->getUri()->getPath();

        return $path === '' ? '/' : $path;
    }

    protected function handleDynamicRoute(): ?Response
    {
        if (! $this->router) {
            return null;
        }

        return $this->router->dispatch($this->getRequest());
    }

    protected function createResponse(): Response
    {
        if (
            $this->router
            && $redirectTo = $this->router->getRedirectForUrl($this->getCurrentPath())
        ) {
            return $this->createRedirectResponse($redirectTo);
        }

        try {
            $response = $this->handleStaticRoute();

            if (! $response) {
                $response = $this->handleDynamicRoute();
            }
        } catch (StitcherException $e) {
            $response = $this->createErrorResponse($e);
        }

        return $response ?? $this->createErrorResponse(
                Http::notFound(
                    $this->getCurrentPath()
                )
            );
    }

    protected function createRedirectResponse(string $targetUrl): Response
    {
        return new Response(301, ["Location: {$targetUrl}"]);
    }

    protected function createErrorResponse(StitcherException $exception): Response
    {
        $statusCode = $exception instanceof Http ? $exception->statusCode() : 500;

        $responseBody = $this->errorHandler->handle($statusCode, $exception);

        return new Response($statusCode, [], $responseBody);
    }

    protected function handleResponse(Response $response): string
    {
        foreach ($response->getHeaders() as $headers) {
            header(implode(', ', $headers));
        }

        if ($this->headerContainer) {
            foreach ($this->headerContainer as $header) {
                header((string) $header);
            }
        }

        http_response_code($response->getStatusCode());

        return $response->getBody()->getContents();
    }
}