CorsMiddleware::createSettings() - Code Metrics - Inspection of "Merge pull request #5 from sunrise-php/release/v3...." - sunrise-php/awesome-skeleton - Measure and Improve Code Quality continuously with Scrutinizer

Test Failed

Push — master ( 2160b1...e71542 )

by Anatoly

created 2020-02-09 19:20 UTC

CorsMiddleware::createSettings() B

↳ Parent: CorsMiddleware

Complexity

Conditions	8
Paths	128

Size

Total Lines	59
Code Lines	38

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
eloc	38
nc	128
nop	1
dl	0
loc	59
c	0
b	0
f	0
cc	8
rs	7.8808

How to fix Long Method

<?php declare(strict_types=1);

namespace App\Middleware;

/**
 * Import classes
 */
use App\ContainerAwareTrait;
use Arus\Http\Response\ResponseFactoryAwareTrait;
use Neomerx\Cors\Analyzer;
use Neomerx\Cors\Strategies\Settings;
use Psr\Http\Message\ResponseInterface;
use Psr\Http\Message\ServerRequestInterface;
use Psr\Http\Server\MiddlewareInterface;
use Psr\Http\Server\RequestHandlerInterface;

/**
 * Cross Origin Resource Sharing Middleware
 *
 * @see https://github.com/neomerx/cors-psr7
 */
final class CorsMiddleware implements MiddlewareInterface
{
    use ContainerAwareTrait;
    use ResponseFactoryAwareTrait;

    /**
     * {@inheritDoc}
     *
     * @param ServerRequestInterface $request
     * @param RequestHandlerInterface $handler
     *
     * @return ResponseInterface
     */
    public function process(ServerRequestInterface $request, RequestHandlerInterface $handler) : ResponseInterface
    {
        $settings = $this->createSettings(
            $this->container->get('cors.configuration')
        );

        $analyzer = Analyzer::instance($settings);

        if ($this->container->get('cors.debug')) {
            $analyzer->setLogger(
                $this->container->get('logger')
            );
        }

        $cors = $analyzer->analyze($request);

        switch ($cors->getRequestType()) {
            case $cors::ERR_NO_HOST_HEADER:
            case $cors::ERR_ORIGIN_NOT_ALLOWED:
            case $cors::ERR_METHOD_NOT_SUPPORTED:
            case $cors::ERR_HEADERS_NOT_SUPPORTED:
                return $this->createResponse(403);

            case $cors::TYPE_PRE_FLIGHT_REQUEST:
                return $this->injectHeaders(
                    $this->createResponse(200),
                    $cors->getResponseHeaders()
                );

            case $cors::TYPE_REQUEST_OUT_OF_CORS_SCOPE:
                return $handler->handle($request);

            default:
                return $this->injectHeaders(
                    $handler->handle($request),
                    $cors->getResponseHeaders()
                );
        }
    }

    /**
     * @param array $params
     *
     * @return Settings
     */
    private function createSettings(array $params) : Settings
    {
        $settings = new Settings();

        // the object initialization...
        $settings->setAllowedOrigins([]);
        $settings->setAllowedMethods([]);
        $settings->setAllowedHeaders([]);
        $settings->setExposedHeaders([]);

        $settings->setServerOrigin(
            (string) $params['server_origin_scheme'],
            (string) $params['server_origin_host'],
            (int) $params['server_origin_port']
        );

        $settings->setPreFlightCacheMaxAge(
            (int) $params['pre_flight_cache_max_age']
        );

        $params['force_add_methods'] ?
        $settings->enableAddAllowedMethodsToPreFlightResponse() :
        $settings->disableAddAllowedMethodsToPreFlightResponse();

        $params['force_add_headers'] ?
        $settings->enableAddAllowedHeadersToPreFlightResponse() :
        $settings->disableAddAllowedHeadersToPreFlightResponse();

        $params['use_credentials'] ?
        $settings->setCredentialsSupported() :
        $settings->setCredentialsNotSupported();

        $params['all_origins_allowed'] ?
        $settings->enableAllOriginsAllowed() :
        $settings->setAllowedOrigins(
            (array) $params['allowed_origins']
        );

        $params['all_methods_allowed'] ?
        $settings->enableAllMethodsAllowed() :
        $settings->setAllowedMethods(
            (array) $params['allowed_methods']
        );

        $params['all_headers_allowed'] ?
        $settings->enableAllHeadersAllowed() :
        $settings->setAllowedHeaders(
            (array) $params['allowed_headers']
        );

        $settings->setExposedHeaders(
            (array) $params['exposed_headers']
        );

        $params['check_host'] ?
        $settings->enableCheckHost() :
        $settings->disableCheckHost();

        return $settings;
    }

    /**
     * @param ResponseInterface $response
     * @param array $headers
     *
     * @return ResponseInterface
     */
    private function injectHeaders(ResponseInterface $response, array $headers) : ResponseInterface
    {
        foreach ($headers as $name => $value) {
            $response = $response->withHeader($name, $value);
        }

        return $response;
    }
}


1			<?php declare(strict_types=1);
2
3			namespace App\Middleware;
4
5			/**
6			* Import classes
7			*/
8			use App\ContainerAwareTrait;
9			use Arus\Http\Response\ResponseFactoryAwareTrait;
10			use Neomerx\Cors\Analyzer;
11			use Neomerx\Cors\Strategies\Settings;
12			use Psr\Http\Message\ResponseInterface;
13			use Psr\Http\Message\ServerRequestInterface;
14			use Psr\Http\Server\MiddlewareInterface;
15			use Psr\Http\Server\RequestHandlerInterface;
16
17			/**
18			* Cross Origin Resource Sharing Middleware
19			*
20			* @see https://github.com/neomerx/cors-psr7
21			*/
22			final class CorsMiddleware implements MiddlewareInterface
23			{
24			use ContainerAwareTrait;
25			use ResponseFactoryAwareTrait;
26
27			/**
28			* {@inheritDoc}
29			*
30			* @param ServerRequestInterface $request
31			* @param RequestHandlerInterface $handler
32			*
33			* @return ResponseInterface
34			*/
35			public function process(ServerRequestInterface $request, RequestHandlerInterface $handler) : ResponseInterface
36			{
37			$settings = $this->createSettings(
38			$this->container->get('cors.configuration')
39			);
40
41			$analyzer = Analyzer::instance($settings);
42
43			if ($this->container->get('cors.debug')) {
44			$analyzer->setLogger(
45			$this->container->get('logger')
46			);
47			}
48
49			$cors = $analyzer->analyze($request);
50
51			switch ($cors->getRequestType()) {
52			case $cors::ERR_NO_HOST_HEADER:
53			case $cors::ERR_ORIGIN_NOT_ALLOWED:
54			case $cors::ERR_METHOD_NOT_SUPPORTED:
55			case $cors::ERR_HEADERS_NOT_SUPPORTED:
56			return $this->createResponse(403);
57
58			case $cors::TYPE_PRE_FLIGHT_REQUEST:
59			return $this->injectHeaders(
60			$this->createResponse(200),
61			$cors->getResponseHeaders()
62			);
63
64			case $cors::TYPE_REQUEST_OUT_OF_CORS_SCOPE:
65			return $handler->handle($request);
66
67			default:
68			return $this->injectHeaders(
69			$handler->handle($request),
70			$cors->getResponseHeaders()
71			);
72			}
73			}
74
75			/**
76			* @param array $params
77			*
78			* @return Settings
79			*/
80			private function createSettings(array $params) : Settings
81			{
82			$settings = new Settings();
83
84			// the object initialization...
85			$settings->setAllowedOrigins([]);
86			$settings->setAllowedMethods([]);
87			$settings->setAllowedHeaders([]);
88			$settings->setExposedHeaders([]);
89
90			$settings->setServerOrigin(
91			(string) $params['server_origin_scheme'],
92			(string) $params['server_origin_host'],
93			(int) $params['server_origin_port']
94			);
95
96			$settings->setPreFlightCacheMaxAge(
97			(int) $params['pre_flight_cache_max_age']
98			);
99
100			$params['force_add_methods'] ?
101			$settings->enableAddAllowedMethodsToPreFlightResponse() :
102			$settings->disableAddAllowedMethodsToPreFlightResponse();
103
104			$params['force_add_headers'] ?
105			$settings->enableAddAllowedHeadersToPreFlightResponse() :
106			$settings->disableAddAllowedHeadersToPreFlightResponse();
107
108			$params['use_credentials'] ?
109			$settings->setCredentialsSupported() :
110			$settings->setCredentialsNotSupported();
111
112			$params['all_origins_allowed'] ?
113			$settings->enableAllOriginsAllowed() :
114			$settings->setAllowedOrigins(
115			(array) $params['allowed_origins']
116			);
117
118			$params['all_methods_allowed'] ?
119			$settings->enableAllMethodsAllowed() :
120			$settings->setAllowedMethods(
121			(array) $params['allowed_methods']
122			);
123
124			$params['all_headers_allowed'] ?
125			$settings->enableAllHeadersAllowed() :
126			$settings->setAllowedHeaders(
127			(array) $params['allowed_headers']
128			);
129
130			$settings->setExposedHeaders(
131			(array) $params['exposed_headers']
132			);
133
134			$params['check_host'] ?
135			$settings->enableCheckHost() :
136			$settings->disableCheckHost();
137
138			return $settings;
139			}
140
141			/**
142			* @param ResponseInterface $response
143			* @param array $headers
144			*
145			* @return ResponseInterface
146			*/
147			private function injectHeaders(ResponseInterface $response, array $headers) : ResponseInterface
148			{
149			foreach ($headers as $name => $value) {
150			$response = $response->withHeader($name, $value);
151			}
152
153			return $response;
154			}
155			}
156

sunrise-php / awesome-skeleton

Push — master ( 2160b1...e71542 )

CorsMiddleware::createSettings() B

Complexity

Size

Duplication

Importance

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like