Limoncello\Core\Application\Application

Complexity

Total Complexity

30

Size/Duplication

Total Lines	325
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	6

Test Coverage

Coverage

100%

Importance

Changes	2
Bugs	0	Features	0

21 Methods

Rating	Name	Duplication	Size	Complexity
	createContainer()	0	1	?
	getRoutesData()	0	1	?
	getGlobalMiddleware()	0	1	?
	setUpExceptionHandler()	0	1	?
A	setSapi()	0	6	1
D	run()	0	43	9
A	getDefaultRequestFactory()	0	4	1
A	defaultRequestFactory()	0	14	1
A	createEmptyResponse()	0	6	1
A	getRouter()	0	9	2
A	getCoreConfig()	0	7	1
A	createRouter()	0	19	1
A	configureUserContainer()	0	6	2
A	createRequest()	0	13	2
A	createOrdinaryTerminalHandler()	0	9	1
A	createMethodNotAllowedTerminalHandler()	0	7	1
A	createNotFoundTerminalHandler()	0	7	1
A	createMiddlewareChain()	0	11	1
A	createMiddlewareChainImpl()	0	11	2
A	createMiddlewareChainLink()	0	6	1
A	getValue()	0	6	2

<?php namespace Limoncello\Core\Application;

/**
 * Copyright 2015-2016 info@neomerx.com (www.neomerx.com)
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

use Closure;
use FastRoute\DataGenerator\GroupCountBased as GroupCountBasedGenerator;
use Interop\Container\ContainerInterface;
use Limoncello\Core\Contracts\Application\ApplicationInterface;
use Limoncello\Core\Contracts\Application\SapiInterface;
use Limoncello\Core\Contracts\Config\ConfigInterface;
use Limoncello\Core\Contracts\Routing\RouterInterface;
use Limoncello\Core\Routing\Dispatcher\GroupCountBased as GroupCountBasedDispatcher;
use Limoncello\Core\Routing\Router;
use LogicException;
use Psr\Http\Message\ResponseInterface;
use Psr\Http\Message\ServerRequestInterface;
use Zend\Diactoros\Response;
use Zend\Diactoros\Response\EmptyResponse;
use Zend\Diactoros\ServerRequest;

/**
 * @package Limoncello\Core
 *
 * @SuppressWarnings(PHPMD.CouplingBetweenObjects)
 */
abstract class Application implements ApplicationInterface
{
    /** Method name for default request factory. */
    const FACTORY_METHOD = 'defaultRequestFactory';

    /**
     * @var SapiInterface|null
     */
    private $sapi;

    /**
     * @var RouterInterface
     */
    private $router;

    /**
     * @return ContainerInterface
     */
    abstract protected function createContainer();

    /**
     * @return array
     */
    abstract protected function getRoutesData();

    /**
     * @return callable[]
     */
    abstract protected function getGlobalMiddleware();

    /**
     * @param SapiInterface      $sapi
     * @param ContainerInterface $container
     *
     * @return void
     */
    abstract protected function setUpExceptionHandler(SapiInterface $sapi, ContainerInterface $container);

    /**
     * @inheritdoc
     */
    public function setSapi(SapiInterface $sapi)
    {
        $this->sapi = $sapi;

        return $this;
    }

    /**
     * @inheritdoc
     */
    public function run()
    {
        if ($this->sapi === null) {
            throw new LogicException('SAPI not set.');
        }

        $userContainer = $this->createContainer();

        $this->setUpExceptionHandler($this->sapi, $userContainer);

        list($matchCode, $allowedMethods, $handlerParams, $handler, $routeMiddleware, $configurators, $requestFactory) =
            $this->getRouter()->match($this->sapi->getMethod(), $this->sapi->getUri()->getPath());

        if (empty($configurators) === false) {
            $this->configureUserContainer($userContainer, $configurators);
        }

        switch ($matchCode) {
            case RouterInterface::MATCH_FOUND:
                $handler = $this->createOrdinaryTerminalHandler($handler, $handlerParams, $userContainer);
                break;
            case RouterInterface::MATCH_METHOD_NOT_ALLOWED:
                $handler = $this->createMethodNotAllowedTerminalHandler($allowedMethods);
                break;
            default:
                $handler = $this->createNotFoundTerminalHandler();
                break;
        }

        $globalMiddleware = $this->getGlobalMiddleware();
        $handler = $this->createMiddlewareChain($handler, $userContainer, $globalMiddleware, $routeMiddleware);

        // if handler consists only from Controller and user didn't asked for Request creation
        $requestNotNeeded = $requestFactory === null && empty($globalMiddleware) === true && empty($routeMiddleware) &&
            $matchCode === RouterInterface::MATCH_FOUND;
        $request = $requestNotNeeded === true ?
            null : $this->createRequest($this->sapi, $userContainer, $requestFactory);

        // send Request down all middleware (global then route's) and call terminal handler in Controller
        $response = $handler($request);

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

    /**
     * @return callable

Consider making the return type a bit more specific; maybe use string[].

     */
    public static function getDefaultRequestFactory()
    {
        return [static::class, static::FACTORY_METHOD];
    }

    /**
     * @param SapiInterface $sapi
     *
     * @return ServerRequestInterface
     */
    public static function defaultRequestFactory(SapiInterface $sapi)
    {
        return new ServerRequest(
            $sapi->getServer(),
            $sapi->getFiles(),
            $sapi->getUri(),
            $sapi->getMethod(),
            $sapi->getRequestBody(),
            $sapi->getHeaders(),
            $sapi->getCookies(),
            $sapi->getQueryParams(),
            $sapi->getParsedBody()
        );
    }

    /**
     * @param int   $status
     * @param array $headers
     *
     * @return ResponseInterface
     */
    protected function createEmptyResponse($status = 204, array $headers = [])
    {
        $response = new EmptyResponse($status, $headers);

        return $response;
    }

    /**
     * @return RouterInterface
     */
    protected function getRouter()
    {
        if ($this->router === null) {
            $this->router = $this->createRouter();
            $this->router->loadCachedRoutes($this->getRoutesData());
        }

        return $this->router;
    }

    /**
     * @return array
     */
    protected function getCoreConfig()
    {
        return [
            ConfigInterface::KEY_ROUTING_GENERATOR  => GroupCountBasedGenerator::class,
            ConfigInterface::KEY_ROUTING_DISPATCHER => GroupCountBasedDispatcher::class,
        ];
    }

    /**
     * @return RouterInterface
     */
    private function createRouter()
    {
        $config = $this->getCoreConfig();

        $generatorClass = $this->getValue(
            $config,
            ConfigInterface::KEY_ROUTING_GENERATOR,
            GroupCountBasedGenerator::class
        );
        $dispatcherClass = $this->getValue(
            $config,
            ConfigInterface::KEY_ROUTING_DISPATCHER,
            GroupCountBasedDispatcher::class
        );

        $router = new Router($generatorClass, $dispatcherClass);

        return $router;
    }

    /**
     * @param ContainerInterface $container
     * @param callable[]         $configurators
     *
     * @return void
     */
    private function configureUserContainer(ContainerInterface $container, array $configurators)
    {
        foreach ($configurators as $configurator) {
            call_user_func($configurator, $container);
        }
    }

    /**
     * @param SapiInterface      $sapi
     * @param ContainerInterface $userContainer
     * @param callable|null      $requestFactory
     *
     * @return ServerRequestInterface
     */
    private function createRequest(
        SapiInterface $sapi,
        ContainerInterface $userContainer,
        callable $requestFactory = null
    ) {
        $request = call_user_func(
            $requestFactory === null ? self::getDefaultRequestFactory() : $requestFactory,
            $sapi,
            $userContainer
        );

        return $request;
    }

    /**
     * @param callable           $handler
     * @param array              $handlerParams
     * @param ContainerInterface $container
     *
     * @return Closure
     */
    private function createOrdinaryTerminalHandler(
        callable $handler,
        array $handlerParams,
        ContainerInterface $container
    ) {
        return function (ServerRequestInterface $request = null) use ($handler, $handlerParams, $container) {
            return call_user_func($handler, $handlerParams, $container, $request);
        };
    }

    /**
     * @param array $allowedMethods
     *
     * @return Closure
     */
    private function createMethodNotAllowedTerminalHandler(array $allowedMethods)
    {
        // 405 Method Not Allowed
        return function () use ($allowedMethods) {
            return $this->createEmptyResponse(405, ['Accept' => implode(',', $allowedMethods)]);
        };
    }

    /**
     * @return Closure
     */
    private function createNotFoundTerminalHandler()
    {
        // 404 Not Found
        return function () {
            return $this->createEmptyResponse(404);
        };
    }

    /**
     * @param Closure            $handler
     * @param ContainerInterface $userContainer
     * @param array|null         $globalMiddleware
     * @param array|null         $routeMiddleware
     *
     * @return Closure
     */
    private function createMiddlewareChain(
        Closure $handler,
        ContainerInterface $userContainer,
        array $globalMiddleware,
        array $routeMiddleware = null
    ) {
        $handler = $this->createMiddlewareChainImpl($handler, $userContainer, $routeMiddleware);
        $handler = $this->createMiddlewareChainImpl($handler, $userContainer, $globalMiddleware);

        return $handler;
    }

    /**
     * @param Closure            $handler
     * @param ContainerInterface $userContainer
     * @param array|null         $middleware
     *
     * @return Closure
     */
    private function createMiddlewareChainImpl(
        Closure $handler,
        ContainerInterface $userContainer,
        array $middleware = null
    ) {
        for ($index = count($middleware) - 1; $index >= 0; $index--) {
            $handler = $this->createMiddlewareChainLink($handler, $middleware[$index], $userContainer);
        }

        return $handler;
    }

    /**
     * @param Closure            $next
     * @param callable           $middleware
     * @param ContainerInterface $userContainer
     *
     * @return Closure
     */
    private function createMiddlewareChainLink(Closure $next, callable $middleware, ContainerInterface $userContainer)
    {
        return function (ServerRequestInterface $request) use ($next, $middleware, $userContainer) {
            return call_user_func($middleware, $request, $next, $userContainer);
        };
    }

    /**
     * @param array      $config
     * @param int|string $key
     * @param mixed      $default
     *
     * @return mixed
     */
    private function getValue(array $config, $key, $default)
    {
        $value = array_key_exists($key, $config) === true ? $config[$key] : $default;

        return $value;
    }
}