UrlRule::init() - Code Metrics - Inspection of "Consistent behavior of `run()` method in widgets" - yiisoft/yii2 - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — 2.1 ( c952e8...98ed49 )

by Carsten

created 2016-06-20 11:40 UTC

UrlRule::init() D

↳ Parent: UrlRule

Complexity

Conditions	25
Paths	200

Size

Total Lines	91
Code Lines	64

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	69
CRAP Score	25.1027

Importance

Changes

Metric	Value
dl	0
loc	91
rs	4.3198
c	0
b	0
f	0
ccs	69
cts	73
cp	0.9452
cc	25
eloc	64
nc	200
nop	0
crap	25.1027

How to fix Long Method Complexity

<?php
/**
 * @link http://www.yiiframework.com/
 * @copyright Copyright (c) 2008 Yii Software LLC
 * @license http://www.yiiframework.com/license/
 */

namespace yii\web;

use Yii;
use yii\base\Object;
use yii\base\InvalidConfigException;

/**
 * UrlRule represents a rule used by [[UrlManager]] for parsing and generating URLs.
 *
 * To define your own URL parsing and creation logic you can extend from this class
 * and add it to [[UrlManager::rules]] like this:
 *
 * ```php
 * 'rules' => [
 *     ['class' => MyUrlRule::class, 'pattern' => '...', 'route' => 'site/index', ...],
 *     // ...
 * ]
 * ```
 *
 * @author Qiang Xue <[email protected]>
 * @since 2.0
 */
class UrlRule extends Object implements UrlRuleInterface
{
    /**
     * Set [[mode]] with this value to mark that this rule is for URL parsing only
     */
    const PARSING_ONLY = 1;
    /**
     * Set [[mode]] with this value to mark that this rule is for URL creation only
     */
    const CREATION_ONLY = 2;

    /**
     * @var string the name of this rule. If not set, it will use [[pattern]] as the name.
     */
    public $name;
    /**
     * On the rule initialization, the [[pattern]] matching parameters names will be replaced with [[placeholders]].
     * @var string the pattern used to parse and create the path info part of a URL.
     * @see host
     * @see placeholders
     */
    public $pattern;
    /**
     * @var string the pattern used to parse and create the host info part of a URL (e.g. `http://example.com`).
     * @see pattern
     */
    public $host;
    /**
     * @var string the route to the controller action
     */
    public $route;
    /**
     * @var array the default GET parameters (name => value) that this rule provides.
     * When this rule is used to parse the incoming request, the values declared in this property
     * will be injected into $_GET.
     */
    public $defaults = [];
    /**
     * @var string the URL suffix used for this rule.
     * For example, ".html" can be used so that the URL looks like pointing to a static HTML page.
     * If not, the value of [[UrlManager::suffix]] will be used.
     */
    public $suffix;
    /**
     * @var string|array the HTTP verb (e.g. GET, POST, DELETE) that this rule should match.
     * Use array to represent multiple verbs that this rule may match.
     * If this property is not set, the rule can match any verb.
     * Note that this property is only used when parsing a request. It is ignored for URL creation.
     */
    public $verb;
    /**
     * @var integer a value indicating if this rule should be used for both request parsing and URL creation,
     * parsing only, or creation only.
     * If not set or 0, it means the rule is both request parsing and URL creation.
     * If it is [[PARSING_ONLY]], the rule is for request parsing only.
     * If it is [[CREATION_ONLY]], the rule is for URL creation only.
     */
    public $mode;
    /**
     * @var boolean a value indicating if parameters should be url encoded.
     */
    public $encodeParams = true;

    /**
     * @var array list of placeholders for matching parameters names. Used in [[parseRequest()]], [[createUrl()]].
     * On the rule initialization, the [[pattern]] parameters names will be replaced with placeholders.
     * This array contains relations between the original parameters names and their placeholders.
     * The array keys are the placeholders and the values are the original names.
     *
     * @see parseRequest()
     * @see createUrl()
     * @since 2.0.7
     */
    protected $placeholders = [];

    /**
     * @var string the template for generating a new URL. This is derived from [[pattern]] and is used in generating URL.
     */
    private $_template;
    /**
     * @var string the regex for matching the route part. This is used in generating URL.
     */
    private $_routeRule;
    /**
     * @var array list of regex for matching parameters. This is used in generating URL.
     */
    private $_paramRules = [];
    /**
     * @var array list of parameters used in the route.
     */
    private $_routeParams = [];


    /**
     * Initializes this rule.
     */
    public function init()
    {
        if ($this->pattern === null) {
            throw new InvalidConfigException('UrlRule::pattern must be set.');
        }
        if ($this->route === null) {
            throw new InvalidConfigException('UrlRule::route must be set.');
        }
        if ($this->verb !== null) {
            if (is_array($this->verb)) {
                foreach ($this->verb as $i => $verb) {
                    $this->verb[$i] = strtoupper($verb);
                }
            } else {
                $this->verb = [strtoupper($this->verb)];
            }
        }
        if ($this->name === null) {
            $this->name = $this->pattern;
        }

        $this->pattern = trim($this->pattern, '/');
        $this->route = trim($this->route, '/');

        if ($this->host !== null) {
            $this->host = rtrim($this->host, '/');
            $this->pattern = rtrim($this->host . '/' . $this->pattern, '/');
        } elseif ($this->pattern === '') {
            $this->_template = '';
            $this->pattern = '#^$#u';

            return;
        } elseif (($pos = strpos($this->pattern, '://')) !== false) {
            if (($pos2 = strpos($this->pattern, '/', $pos + 3)) !== false) {
                $this->host = substr($this->pattern, 0, $pos2);
            } else {
                $this->host = $this->pattern;
            }
        } else {
            $this->pattern = '/' . $this->pattern . '/';
        }

        if (strpos($this->route, '<') !== false && preg_match_all('/<([\w._-]+)>/', $this->route, $matches)) {
            foreach ($matches[1] as $name) {
                $this->_routeParams[$name] = "<$name>";
            }
        }

        $tr = [
            '.' => '\\.',
            '*' => '\\*',
            '$' => '\\$',
            '[' => '\\[',
            ']' => '\\]',
            '(' => '\\(',
            ')' => '\\)',
        ];

        $tr2 = [];
        if (preg_match_all('/<([\w._-]+):?([^>]+)?>/', $this->pattern, $matches, PREG_OFFSET_CAPTURE | PREG_SET_ORDER)) {
            foreach ($matches as $match) {
                $name = $match[1][0];
                $pattern = isset($match[2][0]) ? $match[2][0] : '[^\/]+';
                $placeholder = 'a' . hash('crc32b', $name); // placeholder must begin with a letter
                $this->placeholders[$placeholder] = $name;
                if (array_key_exists($name, $this->defaults)) {
                    $length = strlen($match[0][0]);
                    $offset = $match[0][1];
                    if ($offset > 1 && $this->pattern[$offset - 1] === '/' && (!isset($this->pattern[$offset + $length]) || $this->pattern[$offset + $length] === '/')) {
                        $tr["/<$name>"] = "(/(?P<$placeholder>$pattern))?";
                    } else {
                        $tr["<$name>"] = "(?P<$placeholder>$pattern)?";
                    }
                } else {
                    $tr["<$name>"] = "(?P<$placeholder>$pattern)";
                }
                if (isset($this->_routeParams[$name])) {
                    $tr2["<$name>"] = "(?P<$placeholder>$pattern)";
                } else {
                    $this->_paramRules[$name] = $pattern === '[^\/]+' ? '' : "#^$pattern$#u";
                }
            }
        }

        $this->_template = preg_replace('/<([\w._-]+):?([^>]+)?>/', '<$1>', $this->pattern);
        $this->pattern = '#^' . trim(strtr($this->_template, $tr), '/') . '$#u';

        if (!empty($this->_routeParams)) {
            $this->_routeRule = '#^' . strtr($this->route, $tr2) . '$#u';
        }
    }

    /**
     * Parses the given request and returns the corresponding route and parameters.
     * @param UrlManager $manager the URL manager
     * @param Request $request the request component
     * @return array|boolean the parsing result. The route and the parameters are returned as an array.
     * If false, it means this rule cannot be used to parse this path info.
     */
    public function parseRequest($manager, $request)
    {
        if ($this->mode === self::CREATION_ONLY) {
            return false;
        }

        if (!empty($this->verb) && !in_array($request->getMethod(), $this->verb, true)) {
            return false;
        }

        $pathInfo = $request->getPathInfo();
        $suffix = (string)($this->suffix === null ? $manager->suffix : $this->suffix);
        if ($suffix !== '' && $pathInfo !== '') {
            $n = strlen($suffix);
            if (substr_compare($pathInfo, $suffix, -$n, $n) === 0) {
                $pathInfo = substr($pathInfo, 0, -$n);
                if ($pathInfo === '') {
                    // suffix alone is not allowed
                    return false;
                }
            } else {
                return false;
            }
        }

        if ($this->host !== null) {
            $pathInfo = strtolower($request->getHostInfo()) . ($pathInfo === '' ? '' : '/' . $pathInfo);
        }

        if (!preg_match($this->pattern, $pathInfo, $matches)) {
            return false;
        }
        $matches = $this->substitutePlaceholderNames($matches);

        foreach ($this->defaults as $name => $value) {
            if (!isset($matches[$name]) || $matches[$name] === '') {
                $matches[$name] = $value;
            }
        }
        $params = $this->defaults;
        $tr = [];
        foreach ($matches as $name => $value) {
            if (isset($this->_routeParams[$name])) {
                $tr[$this->_routeParams[$name]] = $value;
                unset($params[$name]);
            } elseif (isset($this->_paramRules[$name])) {
                $params[$name] = $value;
            }
        }
        if ($this->_routeRule !== null) {
            $route = strtr($this->route, $tr);
        } else {
            $route = $this->route;
        }

        Yii::trace("Request parsed with URL rule: {$this->name}", __METHOD__);

        return [$route, $params];
    }

    /**
     * Creates a URL according to the given route and parameters.
     * @param UrlManager $manager the URL manager
     * @param string $route the route. It should not have slashes at the beginning or the end.
     * @param array $params the parameters
     * @return string|boolean the created URL, or false if this rule cannot be used for creating this URL.
     */
    public function createUrl($manager, $route, $params)
    {
        if ($this->mode === self::PARSING_ONLY) {
            return false;
        }

        $tr = [];

        // match the route part first
        if ($route !== $this->route) {
            if ($this->_routeRule !== null && preg_match($this->_routeRule, $route, $matches)) {
                $matches = $this->substitutePlaceholderNames($matches);
                foreach ($this->_routeParams as $name => $token) {
                    if (isset($this->defaults[$name]) && strcmp($this->defaults[$name], $matches[$name]) === 0) {
                        $tr[$token] = '';
                    } else {
                        $tr[$token] = $matches[$name];
                    }
                }
            } else {
                return false;
            }
        }

        // match default params
        // if a default param is not in the route pattern, its value must also be matched
        foreach ($this->defaults as $name => $value) {
            if (isset($this->_routeParams[$name])) {
                continue;
            }
            if (!isset($params[$name])) {
                return false;
            } elseif (strcmp($params[$name], $value) === 0) { // strcmp will do string conversion automatically
                unset($params[$name]);
                if (isset($this->_paramRules[$name])) {
                    $tr["<$name>"] = '';
                }
            } elseif (!isset($this->_paramRules[$name])) {
                return false;
            }
        }

        // match params in the pattern
        foreach ($this->_paramRules as $name => $rule) {
            if (isset($params[$name]) && !is_array($params[$name]) && ($rule === '' || preg_match($rule, $params[$name]))) {
                $tr["<$name>"] = $this->encodeParams ? urlencode($params[$name]) : $params[$name];
                unset($params[$name]);
            } elseif (!isset($this->defaults[$name]) || isset($params[$name])) {
                return false;
            }
        }

        $url = trim(strtr($this->_template, $tr), '/');
        if ($this->host !== null) {
            $pos = strpos($url, '/', 8);
            if ($pos !== false) {
                $url = substr($url, 0, $pos) . preg_replace('#/+#', '/', substr($url, $pos));
            }
        } elseif (strpos($url, '//') !== false) {
            $url = preg_replace('#/+#', '/', $url);
        }

        if ($url !== '') {
            $url .= ($this->suffix === null ? $manager->suffix : $this->suffix);
        }

        if (!empty($params) && ($query = http_build_query($params)) !== '') {
            $url .= '?' . $query;
        }

        return $url;
    }

    /**
     * Returns list of regex for matching parameter.
     * @return array parameter keys and regexp rules.
     *
     * @since 2.0.6
     */
    protected function getParamRules()
    {
        return $this->_paramRules;
    }

    /**
     * Iterates over [[placeholders]] and checks whether each placeholder exists as a key in $matches array.
     * When found - replaces this placeholder key with a appropriate name of matching parameter.
     * Used in [[parseRequest()]], [[createUrl()]].
     *
     * @param array $matches result of `preg_match()` call
     * @return array input array with replaced placeholder keys
     * @see placeholders
     * @since 2.0.7
     */
    protected function substitutePlaceholderNames(array $matches)
    {
        foreach ($this->placeholders as $placeholder => $name) {
            if (isset($matches[$placeholder])) {
                $matches[$name] = $matches[$placeholder];
                unset($matches[$placeholder]);
            }
        }
        return $matches;
    }
}


1		<?php
2		/**
3		* @link http://www.yiiframework.com/
4		* @copyright Copyright (c) 2008 Yii Software LLC
5		* @license http://www.yiiframework.com/license/
6		*/
7
8		namespace yii\web;
9
10		use Yii;
11		use yii\base\Object;
12		use yii\base\InvalidConfigException;
13
14		/**
15		* UrlRule represents a rule used by [[UrlManager]] for parsing and generating URLs.
16		*
17		* To define your own URL parsing and creation logic you can extend from this class
18		* and add it to [[UrlManager::rules]] like this:
19		*
20		* ```php
21		* 'rules' => [
22		* ['class' => MyUrlRule::class, 'pattern' => '...', 'route' => 'site/index', ...],
23		* // ...
24		* ]
25		* ```
26		*
27		* @author Qiang Xue <[email protected]>
28		* @since 2.0
29		*/
30		class UrlRule extends Object implements UrlRuleInterface
31		{
32		/**
33		* Set [[mode]] with this value to mark that this rule is for URL parsing only
34		*/
35		const PARSING_ONLY = 1;
36		/**
37		* Set [[mode]] with this value to mark that this rule is for URL creation only
38		*/
39		const CREATION_ONLY = 2;
40
41		/**
42		* @var string the name of this rule. If not set, it will use [[pattern]] as the name.
43		*/
44		public $name;
45		/**
46		* On the rule initialization, the [[pattern]] matching parameters names will be replaced with [[placeholders]].
47		* @var string the pattern used to parse and create the path info part of a URL.
48		* @see host
49		* @see placeholders
50		*/
51		public $pattern;
52		/**
53		* @var string the pattern used to parse and create the host info part of a URL (e.g. `http://example.com`).
54		* @see pattern
55		*/
56		public $host;
57		/**
58		* @var string the route to the controller action
59		*/
60		public $route;
61		/**
62		* @var array the default GET parameters (name => value) that this rule provides.
63		* When this rule is used to parse the incoming request, the values declared in this property
64		* will be injected into $_GET.
65		*/
66		public $defaults = [];
67		/**
68		* @var string the URL suffix used for this rule.
69		* For example, ".html" can be used so that the URL looks like pointing to a static HTML page.
70		* If not, the value of [[UrlManager::suffix]] will be used.
71		*/
72		public $suffix;
73		/**
74		* @var string\|array the HTTP verb (e.g. GET, POST, DELETE) that this rule should match.
75		* Use array to represent multiple verbs that this rule may match.
76		* If this property is not set, the rule can match any verb.
77		* Note that this property is only used when parsing a request. It is ignored for URL creation.
78		*/
79		public $verb;
80		/**
81		* @var integer a value indicating if this rule should be used for both request parsing and URL creation,
82		* parsing only, or creation only.
83		* If not set or 0, it means the rule is both request parsing and URL creation.
84		* If it is [[PARSING_ONLY]], the rule is for request parsing only.
85		* If it is [[CREATION_ONLY]], the rule is for URL creation only.
86		*/
87		public $mode;
88		/**
89		* @var boolean a value indicating if parameters should be url encoded.
90		*/
91		public $encodeParams = true;
92
93		/**
94		* @var array list of placeholders for matching parameters names. Used in [[parseRequest()]], [[createUrl()]].
95		* On the rule initialization, the [[pattern]] parameters names will be replaced with placeholders.
96		* This array contains relations between the original parameters names and their placeholders.
97		* The array keys are the placeholders and the values are the original names.
98		*
99		* @see parseRequest()
100		* @see createUrl()
101		* @since 2.0.7
102		*/
103		protected $placeholders = [];
104
105		/**
106		* @var string the template for generating a new URL. This is derived from [[pattern]] and is used in generating URL.
107		*/
108		private $_template;
109		/**
110		* @var string the regex for matching the route part. This is used in generating URL.
111		*/
112		private $_routeRule;
113		/**
114		* @var array list of regex for matching parameters. This is used in generating URL.
115		*/
116		private $_paramRules = [];
117		/**
118		* @var array list of parameters used in the route.
119		*/
120		private $_routeParams = [];
121
122
123		/**
124		* Initializes this rule.
125		*/
126	13	public function init()
127		{
128	13	if ($this->pattern === null) {
129		throw new InvalidConfigException('UrlRule::pattern must be set.');
130		}
131	13	if ($this->route === null) {
132		throw new InvalidConfigException('UrlRule::route must be set.');
133		}
134	13	if ($this->verb !== null) {
135	3	if (is_array($this->verb)) {
136	3	foreach ($this->verb as $i => $verb) {
137	3	$this->verb[$i] = strtoupper($verb);
138	3	}
139	3	} else {
140		$this->verb = [strtoupper($this->verb)];
141		}
142	3	}
143	13	if ($this->name === null) {
144	13	$this->name = $this->pattern;
145	13	}
146
147	13	$this->pattern = trim($this->pattern, '/');
148	13	$this->route = trim($this->route, '/');
149
150	13	if ($this->host !== null) {
151	3	$this->host = rtrim($this->host, '/');
152	3	$this->pattern = rtrim($this->host . '/' . $this->pattern, '/');
153	13	} elseif ($this->pattern === '') {
154	4	$this->_template = '';
155	4	$this->pattern = '#^$#u';
156
157	4	return;
158	12	} elseif (($pos = strpos($this->pattern, '://')) !== false) {
159	3	if (($pos2 = strpos($this->pattern, '/', $pos + 3)) !== false) {
160	3	$this->host = substr($this->pattern, 0, $pos2);
161	3	} else {
162		$this->host = $this->pattern;
163		}
164	3	} else {
165	11	$this->pattern = '/' . $this->pattern . '/';
166		}
167
168	12	if (strpos($this->route, '<') !== false && preg_match_all('/<([\w._-]+)>/', $this->route, $matches)) {
169	2	foreach ($matches[1] as $name) {
170	2	$this->_routeParams[$name] = "<$name>";
171	2	}
172	2	}
173
174		$tr = [
175	12	'.' => '\\.',
176	12	'' => '\\',
177	12	'$' => '\\$',
178	12	'[' => '\\[',
179	12	']' => '\\]',
180	12	'(' => '\\(',
181	12	')' => '\\)',
182	12	];
183
184	12	$tr2 = [];
185	12	if (preg_match_all('/<([\w._-]+):?([^>]+)?>/', $this->pattern, $matches, PREG_OFFSET_CAPTURE \| PREG_SET_ORDER)) {
186	9	foreach ($matches as $match) {
187	9	$name = $match[1][0];
188	9	$pattern = isset($match[2][0]) ? $match[2][0] : '[^\/]+';
189	9	$placeholder = 'a' . hash('crc32b', $name); // placeholder must begin with a letter
190	9	$this->placeholders[$placeholder] = $name;
191	9	if (array_key_exists($name, $this->defaults)) {
192	2	$length = strlen($match[0][0]);
193	2	$offset = $match[0][1];
194	2	if ($offset > 1 && $this->pattern[$offset - 1] === '/' && (!isset($this->pattern[$offset + $length]) \|\| $this->pattern[$offset + $length] === '/')) {
195	2	$tr["/<$name>"] = "(/(?P<$placeholder>$pattern))?";
196	2	} else {
197	2	$tr["<$name>"] = "(?P<$placeholder>$pattern)?";
198		}
199	2	} else {
200	9	$tr["<$name>"] = "(?P<$placeholder>$pattern)";
201		}
202	9	if (isset($this->_routeParams[$name])) {
203	2	$tr2["<$name>"] = "(?P<$placeholder>$pattern)";
204	2	} else {
205	9	$this->_paramRules[$name] = $pattern === '[^\/]+' ? '' : "#^$pattern$#u";
206		}
207	9	}
208	9	}
209
210	12	$this->_template = preg_replace('/<([\w._-]+):?([^>]+)?>/', '<$1>', $this->pattern);
211	12	$this->pattern = '#^' . trim(strtr($this->_template, $tr), '/') . '$#u';
212
213	12	if (!empty($this->_routeParams)) {
214	2	$this->_routeRule = '#^' . strtr($this->route, $tr2) . '$#u';
215	2	}
216	12	}
217
218		/**
219		* Parses the given request and returns the corresponding route and parameters.
220		* @param UrlManager $manager the URL manager
221		* @param Request $request the request component
222		* @return array\|boolean the parsing result. The route and the parameters are returned as an array.
223		* If false, it means this rule cannot be used to parse this path info.
224		*/
225	6	public function parseRequest($manager, $request)
226		{
227	6	if ($this->mode === self::CREATION_ONLY) {
228	1	return false;
229		}
230
231	6	if (!empty($this->verb) && !in_array($request->getMethod(), $this->verb, true)) {
232	2	return false;
233		}
234
235	6	$pathInfo = $request->getPathInfo();
236	6	$suffix = (string)($this->suffix === null ? $manager->suffix : $this->suffix);
237	6	if ($suffix !== '' && $pathInfo !== '') {
238	4	$n = strlen($suffix);
239	4	if (substr_compare($pathInfo, $suffix, -$n, $n) === 0) {
240	4	$pathInfo = substr($pathInfo, 0, -$n);
241	4	if ($pathInfo === '') {
242		// suffix alone is not allowed
243	1	return false;
244		}
245	4	} else {
246	3	return false;
247		}
248	4	}
249
250	6	if ($this->host !== null) {
251	1	$pathInfo = strtolower($request->getHostInfo()) . ($pathInfo === '' ? '' : '/' . $pathInfo);
252	1	}
253
254	6	if (!preg_match($this->pattern, $pathInfo, $matches)) {
255	6	return false;
256		}
257	6	$matches = $this->substitutePlaceholderNames($matches);
258
259	6	foreach ($this->defaults as $name => $value) {
260	1	if (!isset($matches[$name]) \|\| $matches[$name] === '') {
261	1	$matches[$name] = $value;
262	1	}
263	6	}
264	6	$params = $this->defaults;
265	6	$tr = [];
266	6	foreach ($matches as $name => $value) {
267	6	if (isset($this->_routeParams[$name])) {
268	1	$tr[$this->_routeParams[$name]] = $value;
269	1	unset($params[$name]);
270	6	} elseif (isset($this->_paramRules[$name])) {
271	5	$params[$name] = $value;
272	5	}
273	6	}
274	6	if ($this->_routeRule !== null) {
275	1	$route = strtr($this->route, $tr);
276	1	} else {
277	6	$route = $this->route;
278		}
279
280	6	Yii::trace("Request parsed with URL rule: {$this->name}", __METHOD__);
281
282	6	return [$route, $params];
283		}
284
285		/**
286		* Creates a URL according to the given route and parameters.
287		* @param UrlManager $manager the URL manager
288		* @param string $route the route. It should not have slashes at the beginning or the end.
289		* @param array $params the parameters
290		* @return string\|boolean the created URL, or false if this rule cannot be used for creating this URL.
291		*/
292	7	public function createUrl($manager, $route, $params)
293		{
294	7	if ($this->mode === self::PARSING_ONLY) {
295	2	return false;
296		}
297
298	7	$tr = [];
299
300		// match the route part first
301	7	if ($route !== $this->route) {
302	4	if ($this->_routeRule !== null && preg_match($this->_routeRule, $route, $matches)) {
303	1	$matches = $this->substitutePlaceholderNames($matches);
304	1	foreach ($this->_routeParams as $name => $token) {
305	1	if (isset($this->defaults[$name]) && strcmp($this->defaults[$name], $matches[$name]) === 0) {
306	1	$tr[$token] = '';
307	1	} else {
308	1	$tr[$token] = $matches[$name];
309		}
310	1	}
311	1	} else {
312	4	return false;
313		}
314	1	}
315
316		// match default params
317		// if a default param is not in the route pattern, its value must also be matched
318	6	foreach ($this->defaults as $name => $value) {
319	2	if (isset($this->_routeParams[$name])) {
320	1	continue;
321		}
322	2	if (!isset($params[$name])) {
323	1	return false;
324	2	} elseif (strcmp($params[$name], $value) === 0) { // strcmp will do string conversion automatically
325	2	unset($params[$name]);
326	2	if (isset($this->_paramRules[$name])) {
327	1	$tr["<$name>"] = '';
328	1	}
329	2	} elseif (!isset($this->_paramRules[$name])) {
330	2	return false;
331		}
332	6	}
333
334		// match params in the pattern
335	6	foreach ($this->_paramRules as $name => $rule) {
336	3	if (isset($params[$name]) && !is_array($params[$name]) && ($rule === '' \|\| preg_match($rule, $params[$name]))) {
337	3	$tr["<$name>"] = $this->encodeParams ? urlencode($params[$name]) : $params[$name];
338	3	unset($params[$name]);
339	3	} elseif (!isset($this->defaults[$name]) \|\| isset($params[$name])) {
340	2	return false;
341		}
342	6	}
343
344	6	$url = trim(strtr($this->_template, $tr), '/');
345	6	if ($this->host !== null) {
346	3	$pos = strpos($url, '/', 8);
347	3	if ($pos !== false) {
348	3	$url = substr($url, 0, $pos) . preg_replace('#/+#', '/', substr($url, $pos));
349	3	}
350	6	} elseif (strpos($url, '//') !== false) {
351	1	$url = preg_replace('#/+#', '/', $url);
352	1	}
353
354	6	if ($url !== '') {
355	5	$url .= ($this->suffix === null ? $manager->suffix : $this->suffix);
356	5	}
357
358	6	if (!empty($params) && ($query = http_build_query($params)) !== '') {
359	2	$url .= '?' . $query;
360	2	}
361
362	6	return $url;
363		}
364
365		/**
366		* Returns list of regex for matching parameter.
367		* @return array parameter keys and regexp rules.
368		*
369		* @since 2.0.6
370		*/
371		protected function getParamRules()
372		{
373		return $this->_paramRules;
374		}
375
376		/**
377		* Iterates over [[placeholders]] and checks whether each placeholder exists as a key in $matches array.
378		* When found - replaces this placeholder key with a appropriate name of matching parameter.
379		* Used in [[parseRequest()]], [[createUrl()]].
380		*
381		* @param array $matches result of `preg_match()` call
382		* @return array input array with replaced placeholder keys
383		* @see placeholders
384		* @since 2.0.7
385		*/
386	7	protected function substitutePlaceholderNames(array $matches)
387		{
388	7	foreach ($this->placeholders as $placeholder => $name) {
389	6	if (isset($matches[$placeholder])) {
390	6	$matches[$name] = $matches[$placeholder];
391	6	unset($matches[$placeholder]);
392	6	}
393	7	}
394	7	return $matches;
395		}
396		}
397

yiisoft / yii2

Push — 2.1 ( c952e8...98ed49 )

UrlRule::init() D

Complexity

Size

Duplication

Code Coverage

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like