AuraRouterAdapter::createDefaultRoute() - Code Metrics - Inspection of "Added default route registration" - apparat/server - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( a4ea0b...5e2812 )

by Joschi

created 2016-06-01 22:22 UTC

AuraRouterAdapter::createDefaultRoute() A

↳ Parent: AuraRouterAdapter

Complexity

Conditions	1
Paths	1

Size

Total Lines	8
Code Lines	5

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	2

Importance

Changes	1
Bugs	0	Features	1

Metric	Value
c	1
b	0
f	1
dl	0
loc	8
ccs	0
cts	7
cp	0
rs	9.4285
cc	1
eloc	5
nc	1
nop	1
crap	2

<?php

/**
 * apparat-server
 *
 * @category    Apparat
 * @package     Apparat\Server
 * @subpackage  Apparat\Server\Infrastructure
 * @author      Joschi Kuphal <[email protected]> / @jkphl
 * @copyright   Copyright © 2016 Joschi Kuphal <[email protected]> / @jkphl
 * @license     http://opensource.org/licenses/MIT The MIT License (MIT)
 */

/***********************************************************************************
 *  The MIT License (MIT)
 *
 *  Copyright © 2016 Joschi Kuphal <[email protected]> / @jkphl
 *
 *  Permission is hereby granted, free of charge, to any person obtaining a copy of
 *  this software and associated documentation files (the "Software"), to deal in
 *  the Software without restriction, including without limitation the rights to
 *  use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
 *  the Software, and to permit persons to whom the Software is furnished to do so,
 *  subject to the following conditions:
 *
 *  The above copyright notice and this permission notice shall be included in all
 *  copies or substantial portions of the Software.
 *
 *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
 *  FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
 *  COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
 *  IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 *  CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 ***********************************************************************************/

namespace Apparat\Server\Infrastructure;

use Apparat\Kernel\Ports\Kernel;
use Apparat\Server\Domain\Contract\RouteInterface;
use Apparat\Server\Domain\Contract\RouterContainerInterface;
use Apparat\Server\Ports\Action\ActionInterface;
use Aura\Router\Matcher;
use Aura\Router\Route;
use Aura\Router\RouterContainer;
use Psr\Http\Message\ResponseInterface;
use Psr\Http\Message\ServerRequestInterface;

/**
 * Aura.Router adapter
 *
 * @package Apparat\Server
 * @subpackage Apparat\Server\Infrastructure
 */
class AuraRouterAdapter implements RouterContainerInterface
{
    /**
     * Aura.Router container
     *
     * @var RouterContainer
     */
    protected $routerContainer;

    /**
     * Constructor
     *
     * @param RouterContainer $routerContainer Router container
     */
    public function __construct(RouterContainer $routerContainer)
    {
        $this->routerContainer = $routerContainer;
    }

    /**
     * Register a route
     *
     * @param RouteInterface $route Route
     * @return RouterContainerInterface Self reference
     */
    public function registerRoute(RouteInterface $route)
    {
        $auraRoute = $route->isDefault() ?
            $this->createDefaultRoute($route) :
            $this->routerContainer->getMap()->route($route->getName(), $route->getPath(), $route->getAction());

        $auraRoute->allows($route->getVerbs())
            ->tokens($route->getTokens())
            ->defaults($route->getDefaults())
            ->wildcard($route->getWildcard())
            ->host($route->getHost())
            ->accepts($route->getAccepts())
            ->auth($route->getAuth())
            ->secure($route->getSecure())
            ->extras($route->getExtras());
        return $this;
    }

    /**
     * Create a default route
     *
     * @param RouteInterface $route Route
     * @return AuraDefaultRoute Default route
     */
    protected function createDefaultRoute(RouteInterface $route)
    {
        /** @var AuraDefaultRoute $auraRoute */
        $auraRoute = Kernel::create(AuraDefaultRoute::class);
        $auraRoute->name($route->getName())->path($route->getPath())->handler($route->getAction());
        $this->routerContainer->getMap()->addRoute($auraRoute);
        return $auraRoute;
    }

    /**
     * Dispatch a request
     *
     * @param ServerRequestInterface $request
     * @return ResponseInterface $response
     */
    public function dispatchRequest(ServerRequestInterface $request)
    {
        $matcher = $this->routerContainer->getMatcher();
        $route = $matcher->match($request);

        // If a registered Route could be matched
        if ($route instanceof Route) {
            return $this->handleRequestRoute($request, $route);
        }

        // Handle the request mismatch
        return $this->handleRequestMismatch($request, $matcher);
    }

    /**
     * Handle a matched route request
     *
     * @param ServerRequestInterface $request Server request
     * @param Route $route Matched route
     * @return ResponseInterface $response
     */
    protected function handleRequestRoute(ServerRequestInterface $request, Route $route)
    {
        // If this is a default route: Preprocess the matched attributes
        if ($route instanceof AuraDefaultRoute) {
            $route->preprocessAttributes();
        }

        // Copy all route attributes to the server request
        foreach ($route->attributes as $key => $val) {
            $request = $request->withAttribute($key, $val);
        }

        $handler = $route->handler;

        // If the handler is a callable
        if (is_callable($handler)) {
            return $handler($request);
        }

        /** @var ActionInterface $handler */
        $handler = Kernel::create($handler, [$request]);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        return $handler();
    }

    /**
     * Handle a mismatched request
     *
     * @param ServerRequestInterface $request Server request
     * @param Matcher $matcher Matcher
     * @return ResponseInterface Response
     */
    protected function handleRequestMismatch(ServerRequestInterface $request, Matcher $matcher)

    {
        // TODO Error responder
//        // Instantiate a response
//        $response = Kernel::create(ResponseInterface::class);
//
//        // Get the first of the best-available non-matched routes
//        $failedRoute = $matcher->getFailedRoute();
//
//        // Which matching rule failed?
//        switch ($failedRoute->failedRule) {
//            case 'Aura\Router\Rule\Allows':
//                // 405 METHOD NOT ALLOWED
//                // Send the $failedRoute->allows as 'Allow:'
//                break;
//            case 'Aura\Router\Rule\Accepts':
//                // 406 NOT ACCEPTABLE
//                break;
//            default:
//                // 404 NOT FOUND
//                break;
//        }
//
//        return $response;
    }
}


1			<?php
2
3			/**
4			* apparat-server
5			*
6			* @category Apparat
7			* @package Apparat\Server
8			* @subpackage Apparat\Server\Infrastructure
9			* @author Joschi Kuphal <[email protected]> / @jkphl
10			* @copyright Copyright © 2016 Joschi Kuphal <[email protected]> / @jkphl
11			* @license http://opensource.org/licenses/MIT The MIT License (MIT)
12			*/
13
14			/***********************************************************************************
15			* The MIT License (MIT)
16			*
17			* Copyright © 2016 Joschi Kuphal <[email protected]> / @jkphl
18			*
19			* Permission is hereby granted, free of charge, to any person obtaining a copy of
20			* this software and associated documentation files (the "Software"), to deal in
21			* the Software without restriction, including without limitation the rights to
22			* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
23			* the Software, and to permit persons to whom the Software is furnished to do so,
24			* subject to the following conditions:
25			*
26			* The above copyright notice and this permission notice shall be included in all
27			* copies or substantial portions of the Software.
28			*
29			* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
30			* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
31			* FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
32			* COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
33			* IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
34			* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
35			***********************************************************************************/
36
37			namespace Apparat\Server\Infrastructure;
38
39			use Apparat\Kernel\Ports\Kernel;
40			use Apparat\Server\Domain\Contract\RouteInterface;
41			use Apparat\Server\Domain\Contract\RouterContainerInterface;
42			use Apparat\Server\Ports\Action\ActionInterface;
43			use Aura\Router\Matcher;
44			use Aura\Router\Route;
45			use Aura\Router\RouterContainer;
46			use Psr\Http\Message\ResponseInterface;
47			use Psr\Http\Message\ServerRequestInterface;
48
49			/**
50			* Aura.Router adapter
51			*
52			* @package Apparat\Server
53			* @subpackage Apparat\Server\Infrastructure
54			*/
55			class AuraRouterAdapter implements RouterContainerInterface
56			{
57			/**
58			* Aura.Router container
59			*
60			* @var RouterContainer
61			*/
62			protected $routerContainer;
63
64			/**
65			* Constructor
66			*
67			* @param RouterContainer $routerContainer Router container
68			*/
69			public function __construct(RouterContainer $routerContainer)
70			{
71			$this->routerContainer = $routerContainer;
72			}
73
74			/**
75			* Register a route
76			*
77			* @param RouteInterface $route Route
78			* @return RouterContainerInterface Self reference
79			*/
80			public function registerRoute(RouteInterface $route)
81			{
82			$auraRoute = $route->isDefault() ?
83			$this->createDefaultRoute($route) :
84			$this->routerContainer->getMap()->route($route->getName(), $route->getPath(), $route->getAction());
85
86			$auraRoute->allows($route->getVerbs())
87			->tokens($route->getTokens())
88			->defaults($route->getDefaults())
89			->wildcard($route->getWildcard())
90			->host($route->getHost())
91			->accepts($route->getAccepts())
92			->auth($route->getAuth())
93			->secure($route->getSecure())
94			->extras($route->getExtras());
95			return $this;
96			}
97
98			/**
99			* Create a default route
100			*
101			* @param RouteInterface $route Route
102			* @return AuraDefaultRoute Default route
103			*/
104			protected function createDefaultRoute(RouteInterface $route)
105			{
106			/** @var AuraDefaultRoute $auraRoute */
107			$auraRoute = Kernel::create(AuraDefaultRoute::class);
108			$auraRoute->name($route->getName())->path($route->getPath())->handler($route->getAction());
109			$this->routerContainer->getMap()->addRoute($auraRoute);
110			return $auraRoute;
111			}
112
113			/**
114			* Dispatch a request
115			*
116			* @param ServerRequestInterface $request
117			* @return ResponseInterface $response
118			*/
119			public function dispatchRequest(ServerRequestInterface $request)
120			{
121			$matcher = $this->routerContainer->getMatcher();
122			$route = $matcher->match($request);
123
124			// If a registered Route could be matched
125			if ($route instanceof Route) {
126			return $this->handleRequestRoute($request, $route);
127			}
128
129			// Handle the request mismatch
130			return $this->handleRequestMismatch($request, $matcher);
131			}
132
133			/**
134			* Handle a matched route request
135			*
136			* @param ServerRequestInterface $request Server request
137			* @param Route $route Matched route
138			* @return ResponseInterface $response
139			*/
140			protected function handleRequestRoute(ServerRequestInterface $request, Route $route)
141			{
142			// If this is a default route: Preprocess the matched attributes
143			if ($route instanceof AuraDefaultRoute) {
144			$route->preprocessAttributes();
145			}
146
147			// Copy all route attributes to the server request
148			foreach ($route->attributes as $key => $val) {
149			$request = $request->withAttribute($key, $val);
150			}
151
152			$handler = $route->handler;
153
154			// If the handler is a callable
155			if (is_callable($handler)) {
156			return $handler($request);
157			}
158
159			/** @var ActionInterface $handler */
160			$handler = Kernel::create($handler, [$request]);
			0 ignored issues – show Documentation introduced 2016-05-30 22:17 UTC by Report Bug Copy Issue Report `$handler` is of type `object<Apparat\Server\Po...Action\ActionInterface>`, but the function expects a `string`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
161			return $handler();
162			}
163
164			/**
165			* Handle a mismatched request
166			*
167			* @param ServerRequestInterface $request Server request
168			* @param Matcher $matcher Matcher
169			* @return ResponseInterface Response
170			*/
171			protected function handleRequestMismatch(ServerRequestInterface $request, Matcher $matcher)
			0 ignored issues – show Unused Code introduced 2016-05-29 22:10 UTC by Report Bug Copy Issue Report The parameter `$request` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history... Unused Code introduced 2016-05-29 22:10 UTC by Report Bug Copy Issue Report The parameter `$matcher` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history...
172			{
173			// TODO Error responder
174			// // Instantiate a response
175			// $response = Kernel::create(ResponseInterface::class);
176			//
177			// // Get the first of the best-available non-matched routes
178			// $failedRoute = $matcher->getFailedRoute();
179			//
180			// // Which matching rule failed?
181			// switch ($failedRoute->failedRule) {
182			// case 'Aura\Router\Rule\Allows':
183			// // 405 METHOD NOT ALLOWED
184			// // Send the $failedRoute->allows as 'Allow:'
185			// break;
186			// case 'Aura\Router\Rule\Accepts':
187			// // 406 NOT ACCEPTABLE
188			// break;
189			// default:
190			// // 404 NOT FOUND
191			// break;
192			// }
193			//
194			// return $response;
195			}
196			}
197

apparat / server

Push — master ( a4ea0b...5e2812 )

AuraRouterAdapter::createDefaultRoute() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like