Philae\DefaultServiceProvider

Complexity

Total Complexity

11

Size/Duplication

Total Lines	169
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	13

Test Coverage

Coverage

90.41%

Importance

Changes

0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	register()	0	12	1
A	addCallableResolver()	0	14	1
A	addRouteCollector()	0	14	1
A	addOriginalRequest()	0	11	1
A	addRequest()	0	11	2
A	addUriResolver()	0	11	1
A	addResponse()	0	11	1
A	addMiddlewareDispatcher()	0	15	1
A	addResponseEmitter()	0	16	1

<?php

namespace Philae;

use FastRoute\DataGenerator\GroupCountBased as GroupCountBasedDataGenerator;
use FastRoute\RouteCollector;
use FastRoute\RouteParser\Std as StdRouteParser;
use League\Container\ServiceProvider\AbstractServiceProvider;
use Middlewares\Utils\CallableResolver\ReflectionResolver;
use Middlewares\Utils\Dispatcher;
use Philae\Utils\CallableResolver;
use Philae\Utils\UriResolver;
use Psr\Http\Message\ResponseInterface;
use Psr\Http\Message\ServerRequestInterface;
use Zend\Diactoros\Response;
use Zend\Diactoros\Response\SapiEmitter;
use Zend\Diactoros\ServerRequestFactory;

/**
 * Service provider that registers the default core dependencies in a container
 */
class DefaultServiceProvider extends AbstractServiceProvider
{
    const SERVICE_REQUEST               = 'request';
    const SERVICE_ORIGINAL_REQUEST      = 'original_request';
    const SERVICE_URI_RESOLVER          = 'uri_resolver';
    const SERVICE_RESPONSE              = 'response';
    const SERVICE_RESPONSE_EMITTER      = 'response_emitter';
    const SERVICE_ROUTE_COLLECTOR       = 'route_collector';
    const SERVICE_MIDDLEWARE_DISPATCHER = 'middleware_dispatcher';
    const SERVICE_CALLABLE_RESOLVER     = 'callable_resolver';

    public function __construct()
    {
        $this->provides = array_values((new \ReflectionClass(static::class))->getConstants());
    }

    public function register()
    {
        $this
            ->addCallableResolver()
            ->addRouteCollector()
            ->addOriginalRequest()
            ->addRequest()
            ->addResponse()
            ->addResponseEmitter()
            ->addMiddlewareDispatcher()
            ->addUriResolver();
    }

    /**
     * @return $this
     */
    protected function addCallableResolver()
    {
        $this->getContainer()->share(
            self::SERVICE_CALLABLE_RESOLVER,
            function () {
                $callableResolver = new CallableResolver(new ReflectionResolver());
                $callableResolver->setContainer($this->getContainer());

                return $callableResolver;
            }
        );

        return $this;
    }

    /**
     * @return $this
     */
    protected function addRouteCollector()
    {
        $this->getContainer()->share(
            self::SERVICE_ROUTE_COLLECTOR,
            function () {
                return new RouteCollector(
                    new StdRouteParser(),
                    new GroupCountBasedDataGenerator()
                );
            }
        );

        return $this;
    }

    /**
     * @return $this
     */
    protected function addOriginalRequest()
    {
        $this->getContainer()->share(
            self::SERVICE_ORIGINAL_REQUEST,
            function () {
                return ServerRequestFactory::fromGlobals();
            }
        );

        return $this;
    }

    /**
     * @return $this
     */
    protected function addRequest()
    {
        $this->getContainer()->share(
            self::SERVICE_REQUEST,
            function (ServerRequestInterface $originalRequest = null) {
                return $originalRequest ?: ServerRequestFactory::fromGlobals();
            }
        )->withArgument(self::SERVICE_ORIGINAL_REQUEST);

        return $this;
    }

    /**
     * @return $this
     */
    protected function addUriResolver()
    {
        $this->getContainer()->share(
            self::SERVICE_URI_RESOLVER,
            function (ServerRequestInterface $request) {
                return new UriResolver($request);
            }
        )->withArgument(self::SERVICE_REQUEST);

        return $this;
    }

    /**
     * @return $this
     */
    protected function addResponse()
    {
        $this->getContainer()->add(
            self::SERVICE_RESPONSE,
            function () {
                return new Response();
            }
        );

        return $this;
    }

    /**
     * Should return a callable that accepts a ServerRequestInterface as a parameter
     *
     * @return $this
     */
    protected function addMiddlewareDispatcher()
    {
        $this->getContainer()->add(
            self::SERVICE_MIDDLEWARE_DISPATCHER,
            function (array $middlewares) {
                $dispatcher = (new Dispatcher($middlewares));

                return function (ServerRequestInterface $request) use ($dispatcher) {
                    return $dispatcher->dispatch($request);
                };
            }
        );

        return $this;
    }

    /**
     * Should return a callable that accepts a ResponseInterface as a parameter
     * and returns a ResponseInterface as a result.
     *
     * @return $this
     */
    protected function addResponseEmitter()
    {
        $this->getContainer()->share(
            self::SERVICE_RESPONSE_EMITTER,
            function () {
                $emitter = new SapiEmitter();

                return function (ResponseInterface $response) use ($emitter) {
                    $maxBufferLevel = 10;
                    $emitter->emit($response, $maxBufferLevel);
                };
            }
        );

        return $this;
    }
}