Generic::match() - Code Metrics - DASPRiD/Dash - Measure and Improve Code Quality continuously with Scrutinizer

Generic::match() C
last analyzed 2016-02-10 03:22 UTC

↳ Parent: Generic

Complexity

Conditions	19
Paths	115

Size

Total Lines	65
Code Lines	32

Duplication

Lines	0
Ratio	0 %

Importance

Changes	8
Bugs	1	Features	1

Metric	Value
c	8
b	1
f	1
dl	0
loc	65
rs	5.5016
cc	19
eloc	32
nc	115
nop	2

How to fix Long Method Complexity

<?php
/**
 * Dash
 *
 * @link      http://github.com/DASPRiD/Dash For the canonical source repository
 * @copyright 2013-2015 Ben Scholzen 'DASPRiD'
 * @license   http://opensource.org/licenses/BSD-2-Clause Simplified BSD License
 */

namespace Dash\Route;

use Dash\Exception;
use Dash\MatchResult;
use Dash\Parser\ParserInterface;
use Dash\RouteCollection\RouteCollectionInterface;
use Dash\RouteCollection\RouteCollectionMatcher;
use Psr\Http\Message\ServerRequestInterface;

/**
 * A generic route which takes care of all HTTP aspects.
 */
class Generic implements RouteInterface
{
    /**
     * Allowed methods on this route.
     *
     * @var array|null
     */
    protected $methods;

    /**
     * Whether to force the route to be HTTPS or HTTP.
     *
     * @var bool|null
     */
    protected $secure;

    /**
     * @var int|null
     */
    protected $port;

    /**
     * @var ParserInterface|null
     */
    protected $pathParser;

    /**
     * @var ParserInterface|null
     */
    protected $hostnameParser;

    /**
     * @var array
     */
    protected $defaults = [];

    /**
     * @var RouteCollectionInterface|null
     */
    protected $children;

    /**
     * @param ParserInterface|null          $pathParser
     * @param ParserInterface|null          $hostnameParser
     * @param array|null                    $methods
     * @param bool|null                     $secure
     * @param int|null                      $port
     * @param array                         $defaults
     * @param RouteCollectionInterface|null $children
     */
    public function __construct(
        ParserInterface $pathParser = null,
        ParserInterface $hostnameParser = null,
        array $methods = null,
        $secure = null,
        $port = null,
        array $defaults = [],
        RouteCollectionInterface $children = null
    ) {
        $this->pathParser     = $pathParser;
        $this->hostnameParser = $hostnameParser;
        $this->defaults       = $defaults;
        $this->children       = $children;

        if (null !== $secure) {
            $this->secure = (bool) $secure;
        }

        if (null !== $port) {
            $this->port = (int) $port;
        }

        if (null !== $methods) {
            $this->methods = array_map('strtoupper', array_values($methods));

            if (in_array('GET', $this->methods) ^ in_array('HEAD', $this->methods)) {
                // Implicitly enable HEAD on GET, and vise versa.
                $this->methods['GET']  = true;
                $this->methods['HEAD'] = true;
            }
        }
    }

    /**
     * {@inheritdoc}
     *
     * @throws Exception\UnexpectedValueException
     */
    public function match(ServerRequestInterface $request, $pathOffset)
    {
        $uri    = $request->getUri();
        $params = $this->defaults;

        // Verify scheme first, if set.
        if (true === $this->secure && 'https' !== $uri->getScheme()) {
            return MatchResult::fromSchemeFailure($uri->withScheme('https'));
        } elseif (false === $this->secure && 'http' !== $uri->getScheme()) {
            return MatchResult::fromSchemeFailure($uri->withScheme('http'));
        }

        // Then match hostname, if parser is set.
        if (null !== $this->hostnameParser) {
            $hostnameResult = $this->hostnameParser->parse($uri->getHost(), 0);

            if (null === $hostnameResult || strlen($uri->getHost()) !== $hostnameResult->getMatchLength()) {
                return null;
            }

            $params = $hostnameResult->getParams() + $params;
        }

        // Then match port, if set.
        if (null !== $this->port) {
            $port = $uri->getPort() ?: ('http' === $uri->getScheme() ? 80 : 443);

            if ($port !== $this->port) {
                return null;
            }
        }

        // Next match the path.
        $completePathMatched = false;

        if (null !== $this->pathParser) {
            if (null === ($pathResult = $this->pathParser->parse($uri->getPath(), $pathOffset))) {
                return null;
            }

            $pathOffset += $pathResult->getMatchLength();
            $completePathMatched = ($pathOffset === strlen($uri->getPath()));
            $params = $pathResult->getParams() + $params;
        }

        if ($completePathMatched) {
            if (null === $this->methods || in_array($request->getMethod(), $this->methods)) {
                return MatchResult::fromSuccess($params);
            }

            if (empty($this->methods)) {
                // Special case: when no methods are defined at all, this route may simply not terminate.
                return null;
            }

            return MatchResult::fromMethodFailure($this->methods);
        }

        // The path was not completely matched yet, so we check the children.
        if (null === $this->children) {
            return null;
        }

        return RouteCollectionMatcher::matchRouteCollection($this->children, $request, $pathOffset, $params);
    }

    /**
     * {@inheritdoc}
     *
     * @throws Exception\RuntimeException
     */
    public function assemble(array $params, $childName = null)
    {
        if ($childName !== null) {
            $nameParts  = explode('/', $childName, 2);
            $parentName = $nameParts[0];
            $childName  = isset($nameParts[1]) ? $nameParts[1] : null;

            if ($this->children === null) {
                throw new Exception\RuntimeException('Route has no children to assemble');
            }

            $assemblyResult = $this->children->get($parentName)->assemble($params, $childName);
        } else {
            $assemblyResult = new AssemblyResult();
        }

        if (null !== $this->secure) {
            $assemblyResult->scheme = $this->secure ? 'https' : 'http';
        }

        if (null !== $this->port) {
            $assemblyResult->port = $this->port;
        }

        if ($this->hostnameParser !== null) {
            $assemblyResult->host = $this->hostnameParser->compile($params, $this->defaults);
        }

        if ($this->pathParser !== null) {
            $assemblyResult->path = $this->pathParser->compile($params, $this->defaults) . $assemblyResult->path;
        }

        return $assemblyResult;
    }
}


1			<?php
2			/**
3			* Dash
4			*
5			* @link http://github.com/DASPRiD/Dash For the canonical source repository
6			* @copyright 2013-2015 Ben Scholzen 'DASPRiD'
7			* @license http://opensource.org/licenses/BSD-2-Clause Simplified BSD License
8			*/
9
10			namespace Dash\Route;
11
12			use Dash\Exception;
13			use Dash\MatchResult;
14			use Dash\Parser\ParserInterface;
15			use Dash\RouteCollection\RouteCollectionInterface;
16			use Dash\RouteCollection\RouteCollectionMatcher;
17			use Psr\Http\Message\ServerRequestInterface;
18
19			/**
20			* A generic route which takes care of all HTTP aspects.
21			*/
22			class Generic implements RouteInterface
23			{
24			/**
25			* Allowed methods on this route.
26			*
27			* @var array\|null
28			*/
29			protected $methods;
30
31			/**
32			* Whether to force the route to be HTTPS or HTTP.
33			*
34			* @var bool\|null
35			*/
36			protected $secure;
37
38			/**
39			* @var int\|null
40			*/
41			protected $port;
42
43			/**
44			* @var ParserInterface\|null
45			*/
46			protected $pathParser;
47
48			/**
49			* @var ParserInterface\|null
50			*/
51			protected $hostnameParser;
52
53			/**
54			* @var array
55			*/
56			protected $defaults = [];
57
58			/**
59			* @var RouteCollectionInterface\|null
60			*/
61			protected $children;
62
63			/**
64			* @param ParserInterface\|null $pathParser
65			* @param ParserInterface\|null $hostnameParser
66			* @param array\|null $methods
67			* @param bool\|null $secure
68			* @param int\|null $port
69			* @param array $defaults
70			* @param RouteCollectionInterface\|null $children
71			*/
72			public function __construct(
73			ParserInterface $pathParser = null,
74			ParserInterface $hostnameParser = null,
75			array $methods = null,
76			$secure = null,
77			$port = null,
78			array $defaults = [],
79			RouteCollectionInterface $children = null
80			) {
81			$this->pathParser = $pathParser;
82			$this->hostnameParser = $hostnameParser;
83			$this->defaults = $defaults;
84			$this->children = $children;
85
86			if (null !== $secure) {
87			$this->secure = (bool) $secure;
88			}
89
90			if (null !== $port) {
91			$this->port = (int) $port;
92			}
93
94			if (null !== $methods) {
95			$this->methods = array_map('strtoupper', array_values($methods));
96
97			if (in_array('GET', $this->methods) ^ in_array('HEAD', $this->methods)) {
98			// Implicitly enable HEAD on GET, and vise versa.
99			$this->methods['GET'] = true;
100			$this->methods['HEAD'] = true;
101			}
102			}
103			}
104
105			/**
106			* {@inheritdoc}
107			*
108			* @throws Exception\UnexpectedValueException
109			*/
110			public function match(ServerRequestInterface $request, $pathOffset)
111			{
112			$uri = $request->getUri();
113			$params = $this->defaults;
114
115			// Verify scheme first, if set.
116			if (true === $this->secure && 'https' !== $uri->getScheme()) {
117			return MatchResult::fromSchemeFailure($uri->withScheme('https'));
118			} elseif (false === $this->secure && 'http' !== $uri->getScheme()) {
119			return MatchResult::fromSchemeFailure($uri->withScheme('http'));
120			}
121
122			// Then match hostname, if parser is set.
123			if (null !== $this->hostnameParser) {
124			$hostnameResult = $this->hostnameParser->parse($uri->getHost(), 0);
125
126			if (null === $hostnameResult \|\| strlen($uri->getHost()) !== $hostnameResult->getMatchLength()) {
127			return null;
128			}
129
130			$params = $hostnameResult->getParams() + $params;
131			}
132
133			// Then match port, if set.
134			if (null !== $this->port) {
135			$port = $uri->getPort() ?: ('http' === $uri->getScheme() ? 80 : 443);
136
137			if ($port !== $this->port) {
138			return null;
139			}
140			}
141
142			// Next match the path.
143			$completePathMatched = false;
144
145			if (null !== $this->pathParser) {
146			if (null === ($pathResult = $this->pathParser->parse($uri->getPath(), $pathOffset))) {
147			return null;
148			}
149
150			$pathOffset += $pathResult->getMatchLength();
151			$completePathMatched = ($pathOffset === strlen($uri->getPath()));
152			$params = $pathResult->getParams() + $params;
153			}
154
155			if ($completePathMatched) {
156			if (null === $this->methods \|\| in_array($request->getMethod(), $this->methods)) {
157			return MatchResult::fromSuccess($params);
158			}
159
160			if (empty($this->methods)) {
161			// Special case: when no methods are defined at all, this route may simply not terminate.
162			return null;
163			}
164
165			return MatchResult::fromMethodFailure($this->methods);
166			}
167
168			// The path was not completely matched yet, so we check the children.
169			if (null === $this->children) {
170			return null;
171			}
172
173			return RouteCollectionMatcher::matchRouteCollection($this->children, $request, $pathOffset, $params);
174			}
175
176			/**
177			* {@inheritdoc}
178			*
179			* @throws Exception\RuntimeException
180			*/
181			public function assemble(array $params, $childName = null)
182			{
183			if ($childName !== null) {
184			$nameParts = explode('/', $childName, 2);
185			$parentName = $nameParts[0];
186			$childName = isset($nameParts[1]) ? $nameParts[1] : null;
187
188			if ($this->children === null) {
189			throw new Exception\RuntimeException('Route has no children to assemble');
190			}
191
192			$assemblyResult = $this->children->get($parentName)->assemble($params, $childName);
193			} else {
194			$assemblyResult = new AssemblyResult();
195			}
196
197			if (null !== $this->secure) {
198			$assemblyResult->scheme = $this->secure ? 'https' : 'http';
199			}
200
201			if (null !== $this->port) {
202			$assemblyResult->port = $this->port;
203			}
204
205			if ($this->hostnameParser !== null) {
206			$assemblyResult->host = $this->hostnameParser->compile($params, $this->defaults);
207			}
208
209			if ($this->pathParser !== null) {
210			$assemblyResult->path = $this->pathParser->compile($params, $this->defaults) . $assemblyResult->path;
211			}
212
213			return $assemblyResult;
214			}
215			}
216

DASPRiD / Dash

Generic::match() C last analyzed 2016-02-10 03:22 UTC

Complexity

Size

Duplication

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like

Generic::match() C
last analyzed 2016-02-10 03:22 UTC