WebApplication::__construct() - Code Metrics - Inspection of "Fight with Scrutinizer config pt.3" - Gixx/WebHemi - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( d26101...1eb4af )

by Gabor

created 2016-09-26 15:22 UTC

WebApplication::__construct() A

↳ Parent: WebApplication

Complexity

Conditions	1
Paths	1

Size

Total Lines	9
Code Lines	7

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	5
CRAP Score	1

Importance

Changes

Metric	Value
dl	0
loc	9
c	0
b	0
f	0
ccs	5
cts	5
cp	1
rs	9.6666
cc	1
eloc	7
nc	1
nop	3
crap	1

<?php
/**
 * WebHemi.
 *
 * PHP version 5.6
 *
 * @copyright 2012 - 2016 Gixx-web (http://www.gixx-web.com)
 * @license   https://opensource.org/licenses/MIT The MIT License (MIT)
 *
 * @link      http://www.gixx-web.com
 */
namespace WebHemi\Application\Web;

use InvalidArgumentException;
use WebHemi\Adapter\DependencyInjection\DependencyInjectionAdapterInterface;
use WebHemi\Adapter\Http\ResponseInterface;
use WebHemi\Adapter\Http\ServerRequestInterface;
use WebHemi\Adapter\Http\HttpAdapterInterface;
use WebHemi\Adapter\Renderer\RendererAdapterInterface;
use WebHemi\Adapter\Router\RouterAdapterInterface;
use WebHemi\Application\ApplicationInterface;
use WebHemi\Application\EnvironmentManager;
use WebHemi\Middleware\DispatcherMiddleware;
use WebHemi\Middleware\FinalMiddleware;
use WebHemi\Middleware\MiddlewareInterface;
use WebHemi\Middleware\Pipeline\MiddlewarePipelineInterface;

/**
 * Class WebApplication.
 */
class WebApplication implements ApplicationInterface
{
    /** @var DependencyInjectionAdapterInterface */
    private $container;
    /** @var EnvironmentManager */
    private $environmentManager;
    /** @var MiddlewarePipelineInterface */
    private $pipeline;


    /**
     * ApplicationInterface constructor.
     *
     * @param DependencyInjectionAdapterInterface $container
     * @param EnvironmentManager                  $environmentManager
     * @param MiddlewarePipelineInterface         $pipeline
     */
    public function __construct(
        DependencyInjectionAdapterInterface $container,
        EnvironmentManager $environmentManager,
        MiddlewarePipelineInterface $pipeline
    ) {
        $this->container = $container;
        $this->environmentManager = $environmentManager;
        $this->pipeline = $pipeline;
    }

    /**
     * Returns the DI Adapter instance.
     *
     * @return DependencyInjectionAdapterInterface
     */
    public function getContainer()
    {
        return $this->container;
    }

    /**
     * Get ready to run the application: set final data for specific services.
     *
     * @codeCoverageIgnore - Check the EnvironmentManager and Container adapter tests.
     */
    private function prepare()
    {
        $this->container
            ->setServiceArgument(HttpAdapterInterface::class, $this->environmentManager->getEnvironmentData('GET'))
            ->setServiceArgument(HttpAdapterInterface::class, $this->environmentManager->getEnvironmentData('POST'))
            ->setServiceArgument(HttpAdapterInterface::class, $this->environmentManager->getEnvironmentData('SERVER'))
            ->setServiceArgument(HttpAdapterInterface::class, $this->environmentManager->getEnvironmentData('COOKIE'))
            ->setServiceArgument(HttpAdapterInterface::class, $this->environmentManager->getEnvironmentData('FILES'));

        try {
            $theme = $this->environmentManager
                ->getApplicationTemplateSettings($this->environmentManager->getSelectedTheme());
            $themeResourcePath = $this->environmentManager->getResourcePath();
        } catch (InvalidArgumentException $e) {
            $theme = $this->environmentManager->getApplicationTemplateSettings(EnvironmentManager::DEFAULT_THEME);
            $themeResourcePath = EnvironmentManager::DEFAULT_THEME_RESOURCE_PATH;
        }

        $this->container
            ->setServiceArgument(
                RendererAdapterInterface::class,
                $theme
            )
            ->setServiceArgument(
                RendererAdapterInterface::class,
                $themeResourcePath
            )
            ->setServiceArgument(
                RendererAdapterInterface::class,
                $this->environmentManager->getSelectedApplicationUri()
            );

        $this->container
            ->setServiceArgument(
                RouterAdapterInterface::class,
                $this->environmentManager->getModuleRouteSettings()
            )
            ->setServiceArgument(
                RouterAdapterInterface::class,
                $this->environmentManager->getSelectedApplicationUri()
            );
    }

    /**
     * Runs the application. This is where the magic happens.
     * According tho the environment settings this must build up the middleware pipeline and execute it.
     *
     * a Pre-Routing Middleware can be; priority < 0:
     *  - LockCheck - check if the client IP is banned > S102|S403
     *  - Auth - if the user is not logged in, but there's a "Remember me" cookie, then logs in > S102
     *
     * Routing Middleware is fixed (RoutingMiddleware::class); priority = 0:
     *  - A middleware that routes the incoming Request and delegates to the matched middleware. > S102|S404|S405
     *    The RouteResult should be attached to the Request.
     *    If the Routing is not defined explicitly in the pipeline, then it will be injected with priority 0.
     *
     * a Post-Routing Middleware can be; priority between 0 and 100:
     *  - Acl - checks if the given route is available for the client. Also checks the auth > S102|S401|S403
     *  - CacheReader - checks if a suitable response body is cached. > S102|S200
     *
     * Dispatcher Middleware is fixed (DispatcherMiddleware::class); priority = 100:
     *  - A middleware which gets the corresponding Action middleware and applies it > S102
     *    If the Dispatcher is not defined explicitly in the pipeline, then it will be injected with priority 100.
     *    The Dispatcher should not set the response Status Code to 200 to let Post-Dispatchers to be called.
     *
     * a Post-Dispatch Middleware can be; priority > 100:
     *  - CacheWriter - writes response body into DataStorage (DB, File etc.) > S102
     *
     * Final Middleware is fixed (FinalMiddleware:class):
     *  - This middleware behaves a bit differently. It cannot be ordered, it's always the last called middleware:
     *    - when the middleware pipeline reached its end (typically when the Status Code is still 102)
     *    - when one item of the middleware pipeline returns with return response (status code is set to 200|40*|500)
     *    - when during the pipeline process an Exception is thrown.
     *
     * When the middleware pipeline is finished the application prints the header and the output.
     *
     * If a middleware other than the Routing, Dispatcher and Final Middleware has no priority set, it will be
     * considered to have priority = 50.
     *
     * @return void
     */
    public function run()
    {
        $this->prepare();
        /** @var HttpAdapterInterface $httpAdapter */
        $httpAdapter = $this->getContainer()->get(HttpAdapterInterface::class);
        /** @var ServerRequestInterface $request */
        $request = $httpAdapter->getRequest();
        /** @var ResponseInterface $response */
        $response = $httpAdapter->getResponse();
        $middlewareClass = $this->pipeline->start();

        while ($middlewareClass !== null
            && $response->getStatusCode() == ResponseInterface::STATUS_PROCESSING
        ) {
            try {
                /** @var MiddlewareInterface $middleware */
                $middleware = $this->container->get($middlewareClass);
                $requestAttributes = $request->getAttributes();
                // As an extra step if the action middleware is resolved, it is invoked right before the dispatcher.
                // Only the container knows how to instantiate it in the right way, and the container must not be
                // injected into anz other classes. It seems like a hack but it is by purpose.

                if ($middleware instanceof DispatcherMiddleware
                    && isset($requestAttributes[ServerRequestInterface::REQUEST_ATTR_RESOLVED_ACTION_CLASS])
                ) {
                    /** @var MiddlewareInterface $actionMiddleware */
                    $actionMiddleware = $this->container
                        ->get($requestAttributes[ServerRequestInterface::REQUEST_ATTR_RESOLVED_ACTION_CLASS]);
                    $request = $request->withAttribute(
                        ServerRequestInterface::REQUEST_ATTR_ACTION_MIDDLEWARE,
                        $actionMiddleware
                    );
                }
                $response = $middleware($request, $response);
            } catch (\Exception $exception) {
                $response = $response->withStatus(ResponseInterface::STATUS_INTERNAL_SERVER_ERROR);
                $request = $request->withAttribute(
                    ServerRequestInterface::REQUEST_ATTR_MIDDLEWARE_EXCEPTION,
                    $exception
                );
            }

            $middlewareClass = $this->pipeline->next();
        };

        // If there was no error, we mark as ready for output.
        if ($response->getStatusCode() == ResponseInterface::STATUS_PROCESSING) {
            $response = $response->withStatus(ResponseInterface::STATUS_OK);
        }

        /** @var FinalMiddleware $finalMiddleware */
        $finalMiddleware = $this->container->get(FinalMiddleware::class);

        // Send out headers and content.
        $finalMiddleware($request, $response);
    }
}


1		<?php
2		/**
3		* WebHemi.
4		*
5		* PHP version 5.6
6		*
7		* @copyright 2012 - 2016 Gixx-web (http://www.gixx-web.com)
8		* @license https://opensource.org/licenses/MIT The MIT License (MIT)
9		*
10		* @link http://www.gixx-web.com
11		*/
12		namespace WebHemi\Application\Web;
13
14		use InvalidArgumentException;
15		use WebHemi\Adapter\DependencyInjection\DependencyInjectionAdapterInterface;
16		use WebHemi\Adapter\Http\ResponseInterface;
17		use WebHemi\Adapter\Http\ServerRequestInterface;
18		use WebHemi\Adapter\Http\HttpAdapterInterface;
19		use WebHemi\Adapter\Renderer\RendererAdapterInterface;
20		use WebHemi\Adapter\Router\RouterAdapterInterface;
21		use WebHemi\Application\ApplicationInterface;
22		use WebHemi\Application\EnvironmentManager;
23		use WebHemi\Middleware\DispatcherMiddleware;
24		use WebHemi\Middleware\FinalMiddleware;
25		use WebHemi\Middleware\MiddlewareInterface;
26		use WebHemi\Middleware\Pipeline\MiddlewarePipelineInterface;
27
28		/**
29		* Class WebApplication.
30		*/
31		class WebApplication implements ApplicationInterface
32		{
33		/** @var DependencyInjectionAdapterInterface */
34		private $container;
35		/** @var EnvironmentManager */
36		private $environmentManager;
37		/** @var MiddlewarePipelineInterface */
38		private $pipeline;
39
40
41		/**
42		* ApplicationInterface constructor.
43		*
44		* @param DependencyInjectionAdapterInterface $container
45		* @param EnvironmentManager $environmentManager
46		* @param MiddlewarePipelineInterface $pipeline
47		*/
48	5	public function __construct(
49		DependencyInjectionAdapterInterface $container,
50		EnvironmentManager $environmentManager,
51		MiddlewarePipelineInterface $pipeline
52		) {
53	5	$this->container = $container;
54	5	$this->environmentManager = $environmentManager;
55	5	$this->pipeline = $pipeline;
56	5	}
57
58		/**
59		* Returns the DI Adapter instance.
60		*
61		* @return DependencyInjectionAdapterInterface
62		*/
63	5	public function getContainer()
64		{
65	5	return $this->container;
66		}
67
68		/**
69		* Get ready to run the application: set final data for specific services.
70		*
71		* @codeCoverageIgnore - Check the EnvironmentManager and Container adapter tests.
72		*/
73		private function prepare()
74		{
75		$this->container
76		->setServiceArgument(HttpAdapterInterface::class, $this->environmentManager->getEnvironmentData('GET'))
77		->setServiceArgument(HttpAdapterInterface::class, $this->environmentManager->getEnvironmentData('POST'))
78		->setServiceArgument(HttpAdapterInterface::class, $this->environmentManager->getEnvironmentData('SERVER'))
79		->setServiceArgument(HttpAdapterInterface::class, $this->environmentManager->getEnvironmentData('COOKIE'))
80		->setServiceArgument(HttpAdapterInterface::class, $this->environmentManager->getEnvironmentData('FILES'));
81
82		try {
83		$theme = $this->environmentManager
84		->getApplicationTemplateSettings($this->environmentManager->getSelectedTheme());
85		$themeResourcePath = $this->environmentManager->getResourcePath();
86		} catch (InvalidArgumentException $e) {
87		$theme = $this->environmentManager->getApplicationTemplateSettings(EnvironmentManager::DEFAULT_THEME);
88		$themeResourcePath = EnvironmentManager::DEFAULT_THEME_RESOURCE_PATH;
89		}
90
91		$this->container
92		->setServiceArgument(
93		RendererAdapterInterface::class,
94		$theme
95		)
96		->setServiceArgument(
97		RendererAdapterInterface::class,
98		$themeResourcePath
99		)
100		->setServiceArgument(
101		RendererAdapterInterface::class,
102		$this->environmentManager->getSelectedApplicationUri()
103		);
104
105		$this->container
106		->setServiceArgument(
107		RouterAdapterInterface::class,
108		$this->environmentManager->getModuleRouteSettings()
109		)
110		->setServiceArgument(
111		RouterAdapterInterface::class,
112		$this->environmentManager->getSelectedApplicationUri()
113		);
114		}
115
116		/**
117		* Runs the application. This is where the magic happens.
118		* According tho the environment settings this must build up the middleware pipeline and execute it.
119		*
120		* a Pre-Routing Middleware can be; priority < 0:
121		* - LockCheck - check if the client IP is banned > S102\|S403
122		* - Auth - if the user is not logged in, but there's a "Remember me" cookie, then logs in > S102
123		*
124		* Routing Middleware is fixed (RoutingMiddleware::class); priority = 0:
125		* - A middleware that routes the incoming Request and delegates to the matched middleware. > S102\|S404\|S405
126		* The RouteResult should be attached to the Request.
127		* If the Routing is not defined explicitly in the pipeline, then it will be injected with priority 0.
128		*
129		* a Post-Routing Middleware can be; priority between 0 and 100:
130		* - Acl - checks if the given route is available for the client. Also checks the auth > S102\|S401\|S403
131		* - CacheReader - checks if a suitable response body is cached. > S102\|S200
132		*
133		* Dispatcher Middleware is fixed (DispatcherMiddleware::class); priority = 100:
134		* - A middleware which gets the corresponding Action middleware and applies it > S102
135		* If the Dispatcher is not defined explicitly in the pipeline, then it will be injected with priority 100.
136		* The Dispatcher should not set the response Status Code to 200 to let Post-Dispatchers to be called.
137		*
138		* a Post-Dispatch Middleware can be; priority > 100:
139		* - CacheWriter - writes response body into DataStorage (DB, File etc.) > S102
140		*
141		* Final Middleware is fixed (FinalMiddleware:class):
142		* - This middleware behaves a bit differently. It cannot be ordered, it's always the last called middleware:
143		* - when the middleware pipeline reached its end (typically when the Status Code is still 102)
144		* - when one item of the middleware pipeline returns with return response (status code is set to 200\|40*\|500)
145		* - when during the pipeline process an Exception is thrown.
146		*
147		* When the middleware pipeline is finished the application prints the header and the output.
148		*
149		* If a middleware other than the Routing, Dispatcher and Final Middleware has no priority set, it will be
150		* considered to have priority = 50.
151		*
152		* @return void
153		*/
154	4	public function run()
155		{
156	4	$this->prepare();
157		/** @var HttpAdapterInterface $httpAdapter */
158	4	$httpAdapter = $this->getContainer()->get(HttpAdapterInterface::class);
159		/** @var ServerRequestInterface $request */
160	4	$request = $httpAdapter->getRequest();
161		/** @var ResponseInterface $response */
162	4	$response = $httpAdapter->getResponse();
163	4	$middlewareClass = $this->pipeline->start();
164
165		while ($middlewareClass !== null
166	4	&& $response->getStatusCode() == ResponseInterface::STATUS_PROCESSING
167	4	) {
168		try {
169		/** @var MiddlewareInterface $middleware */
170	4	$middleware = $this->container->get($middlewareClass);
171	4	$requestAttributes = $request->getAttributes();
172		// As an extra step if the action middleware is resolved, it is invoked right before the dispatcher.
173		// Only the container knows how to instantiate it in the right way, and the container must not be
174		// injected into anz other classes. It seems like a hack but it is by purpose.
175
176		if ($middleware instanceof DispatcherMiddleware
177	4	&& isset($requestAttributes[ServerRequestInterface::REQUEST_ATTR_RESOLVED_ACTION_CLASS])
178	4	) {
179		/** @var MiddlewareInterface $actionMiddleware */
180	2	$actionMiddleware = $this->container
181	2	->get($requestAttributes[ServerRequestInterface::REQUEST_ATTR_RESOLVED_ACTION_CLASS]);
182	2	$request = $request->withAttribute(
183	2	ServerRequestInterface::REQUEST_ATTR_ACTION_MIDDLEWARE,
184		$actionMiddleware
185	2	);
186	2	}
187	4	$response = $middleware($request, $response);
188	4	} catch (\Exception $exception) {
189	1	$response = $response->withStatus(ResponseInterface::STATUS_INTERNAL_SERVER_ERROR);
190	1	$request = $request->withAttribute(
191	1	ServerRequestInterface::REQUEST_ATTR_MIDDLEWARE_EXCEPTION,
192		$exception
193	1	);
194		}
195
196	4	$middlewareClass = $this->pipeline->next();
197	4	};
198
199		// If there was no error, we mark as ready for output.
200	4	if ($response->getStatusCode() == ResponseInterface::STATUS_PROCESSING) {
201	1	$response = $response->withStatus(ResponseInterface::STATUS_OK);
202	1	}
203
204		/** @var FinalMiddleware $finalMiddleware */
205	4	$finalMiddleware = $this->container->get(FinalMiddleware::class);
206
207		// Send out headers and content.
208	4	$finalMiddleware($request, $response);
209	4	}
210		}
211

Gixx / WebHemi

Push — master ( d26101...1eb4af )

WebApplication::__construct() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like