Url::parseSuffix() - Code Metrics - Inspection of "改进Url生成伪静态后缀设置false的情况" - top-think/framework - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — 6.0 ( 6bb9cc...7f945e )

by liu

created 2019-11-14 13:52 UTC

Url::parseSuffix() B

↳ Parent: Url

Complexity

Conditions	7
Paths	20

Size

Total Lines	11
Code Lines	5

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	56

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	7
eloc	5
c	1
b	0
f	0
nc	20
nop	1
dl	0
loc	11
ccs	0
cts	6
cp	0
crap	56
rs	8.8333

<?php
// +----------------------------------------------------------------------
// | ThinkPHP [ WE CAN DO IT JUST THINK ]
// +----------------------------------------------------------------------
// | Copyright (c) 2006~2019 http://thinkphp.cn All rights reserved.
// +----------------------------------------------------------------------
// | Licensed ( http://www.apache.org/licenses/LICENSE-2.0 )
// +----------------------------------------------------------------------
// | Author: liu21st <[email protected]>
// +----------------------------------------------------------------------
declare (strict_types = 1);

namespace think\route;

use think\App;
use think\Route;

/**
 * 路由地址生成
 */
class Url
{
    /**
     * 应用对象
     * @var App
     */
    protected $app;

    /**
     * 路由对象
     * @var Route
     */
    protected $route;

    /**
     * URL变量
     * @var array
     */
    protected $vars = [];

    /**
     * 路由URL
     * @var string
     */
    protected $url;

    /**
     * URL 根地址
     * @var string
     */
    protected $root = '';

    /**
     * HTTPS
     * @var bool
     */
    protected $https;

    /**
     * URL后缀
     * @var string|bool
     */
    protected $suffix = true;

    /**
     * URL域名
     * @var string|bool
     */
    protected $domain = false;

    /**

     * 架构函数
     * @access public
     * @param  string $url URL地址

     * @param  array  $vars 参数

     */
    public function __construct(Route $route, App $app, string $url = '', array $vars = [])
    {
        $this->route = $route;
        $this->app   = $app;
        $this->url   = $url;
        $this->vars  = $vars;
    }

    /**
     * 设置URL参数
     * @access public
     * @param  array $vars URL参数
     * @return $this
     */
    public function vars(array $vars = [])
    {
        $this->vars = $vars;
        return $this;
    }

    /**
     * 设置URL后缀
     * @access public
     * @param  string|bool $suffix URL后缀
     * @return $this
     */
    public function suffix($suffix)
    {
        $this->suffix = $suffix;
        return $this;
    }

    /**
     * 设置URL域名（或者子域名）
     * @access public
     * @param  string|bool $domain URL域名
     * @return $this
     */
    public function domain($domain)
    {
        $this->domain = $domain;
        return $this;
    }

    /**
     * 设置URL 根地址
     * @access public
     * @param  string $root URL root
     * @return $this
     */
    public function root(string $root)
    {
        $this->root = $root;
        return $this;
    }

    /**
     * 设置是否使用HTTPS
     * @access public
     * @param  bool $https

     * @return $this
     */
    public function https(bool $https = true)
    {
        $this->https = $https;
        return $this;
    }

    /**
     * 检测域名
     * @access protected
     * @param  string      $url URL

     * @param  string|true $domain 域名
     * @return string
     */
    protected function parseDomain(string &$url, $domain): string
    {
        if (!$domain) {
            return '';
        }

        $request    = $this->app->request;
        $rootDomain = $request->rootDomain();

        if (true === $domain) {
            // 自动判断域名
            $domain  = $request->host();
            $domains = $this->route->getDomains();

            if (!empty($domains)) {
                $route_domain = array_keys($domains);
                foreach ($route_domain as $domain_prefix) {
                    if (0 === strpos($domain_prefix, '*.') && strpos($domain, ltrim($domain_prefix, '*.')) !== false) {
                        foreach ($domains as $key => $rule) {
                            $rule = is_array($rule) ? $rule[0] : $rule;
                            if (is_string($rule) && false === strpos($key, '*') && 0 === strpos($url, $rule)) {
                                $url    = ltrim($url, $rule);
                                $domain = $key;

                                // 生成对应子域名
                                if (!empty($rootDomain)) {
                                    $domain .= $rootDomain;
                                }
                                break;
                            } elseif (false !== strpos($key, '*')) {
                                if (!empty($rootDomain)) {
                                    $domain .= $rootDomain;
                                }

                                break;
                            }
                        }
                    }
                }
            }
        } elseif (false === strpos($domain, '.') && 0 !== strpos($domain, $rootDomain)) {
            $domain .= '.' . $rootDomain;
        }

        if (false !== strpos($domain, '://')) {
            $scheme = '';
        } else {
            $scheme = $this->https || $request->isSsl() ? 'https://' : 'http://';
        }

        return $scheme . $domain;
    }

    /**
     * 解析URL后缀
     * @access protected
     * @param  string|bool $suffix 后缀
     * @return string
     */
    protected function parseSuffix($suffix): string
    {
        if ($suffix) {
            $suffix = true === $suffix ? $this->route->config('url_html_suffix') : $suffix;

            if (is_string($suffix) && $pos = strpos($suffix, '|')) {
                $suffix = substr($suffix, 0, $pos);
            }
        }

        return (empty($suffix) || 0 === strpos($suffix, '.')) ? (string) $suffix : '.' . $suffix;
    }

    /**
     * 直接解析URL地址
     * @access protected
     * @param  string      $url URL

     * @param  string|bool $domain Domain
     * @return string
     */
    protected function parseUrl(string $url, &$domain): string
    {
        $request = $this->app->request;

        if (0 === strpos($url, '/')) {
            // 直接作为路由地址解析
            $url = substr($url, 1);
        } elseif (false !== strpos($url, '\\')) {
            // 解析到类
            $url = ltrim(str_replace('\\', '/', $url), '/');
        } elseif (0 === strpos($url, '@')) {
            // 解析到控制器
            $url = substr($url, 1);
        } elseif ('' === $url) {
            $url = $request->controller() . '/' . $request->action();
        } else {
            $controller = $request->controller();

            $path       = explode('/', $url);
            $action     = array_pop($path);
            $controller = empty($path) ? $controller : array_pop($path);

            $url = $controller . '/' . $action;
        }

        return $url;
    }

    /**
     * 分析路由规则中的变量
     * @access protected
     * @param  string $rule 路由规则
     * @return array
     */
    protected function parseVar(string $rule): array
    {
        // 提取路由规则中的变量
        $var = [];

        if (preg_match_all('/<\w+\??>/', $rule, $matches)) {
            foreach ($matches[0] as $name) {
                $optional = false;

                if (strpos($name, '?')) {
                    $name     = substr($name, 1, -2);
                    $optional = true;
                } else {
                    $name = substr($name, 1, -1);
                }

                $var[$name] = $optional ? 2 : 1;
            }
        }

        return $var;
    }

    /**
     * 匹配路由地址
     * @access protected
     * @param  array $rule 路由规则

     * @param  array $vars 路由变量

     * @param  mixed $allowDomain 允许域名
     * @return array
     */
    protected function getRuleUrl(array $rule, array &$vars = [], $allowDomain = ''): array
    {
        $request = $this->app->request;
        if (is_string($allowDomain) && false === strpos($allowDomain, '.')) {
            $allowDomain .= '.' . $request->rootDomain();
        }
        $port = $request->port();

        foreach ($rule as $item) {
            $url     = $item->getRule();
            $pattern = $this->parseVar($url);
            $domain  = $item->getDomain();
            $suffix  = $item->getSuffix();

            if ('-' == $domain) {
                $domain = is_string($allowDomain) ? $allowDomain : $request->host(true);
            }

            if (is_string($allowDomain) && $domain != $allowDomain) {
                continue;
            }

            if ($port && !in_array($port, [80, 443])) {
                $domain .= ':' . $port;
            }

            if (empty($pattern)) {
                return [rtrim($url, '?/-'), $domain, $suffix];
            }

            $type = $this->route->config('url_common_param');
            $keys = [];

            foreach ($pattern as $key => $val) {
                if (isset($vars[$key])) {
                    $url    = str_replace(['[:' . $key . ']', '<' . $key . '?>', ':' . $key, '<' . $key . '>'], $type ? $vars[$key] : urlencode((string) $vars[$key]), $url);
                    $keys[] = $key;
                    $url    = str_replace(['/?', '-?'], ['/', '-'], $url);
                    $result = [rtrim($url, '?/-'), $domain, $suffix];
                } elseif (2 == $val) {
                    $url    = str_replace(['/[:' . $key . ']', '[:' . $key . ']', '<' . $key . '?>'], '', $url);
                    $url    = str_replace(['/?', '-?'], ['/', '-'], $url);
                    $result = [rtrim($url, '?/-'), $domain, $suffix];
                } else {
                    $result = null;
                    $keys   = [];
                    break;
                }
            }

            $vars = array_diff_key($vars, array_flip($keys));

            if (isset($result)) {
                return $result;
            }
        }

        return [];
    }

    public function build()

    {
        // 解析URL
        $url     = $this->url;
        $suffix  = $this->suffix;
        $domain  = $this->domain;
        $request = $this->app->request;
        $vars    = $this->vars;

        if (0 === strpos($url, '[') && $pos = strpos($url, ']')) {
            // [name] 表示使用路由命名标识生成URL
            $name = substr($url, 1, $pos - 1);
            $url  = 'name' . substr($url, $pos + 1);
        }

        if (false === strpos($url, '://') && 0 !== strpos($url, '/')) {
            $info = parse_url($url);
            $url  = !empty($info['path']) ? $info['path'] : '';

            if (isset($info['fragment'])) {
                // 解析锚点
                $anchor = $info['fragment'];

                if (false !== strpos($anchor, '?')) {
                    // 解析参数
                    [$anchor, $info['query']] = explode('?', $anchor, 2);
                }

                if (false !== strpos($anchor, '@')) {
                    // 解析域名
                    [$anchor, $domain] = explode('@', $anchor, 2);
                }
            } elseif (strpos($url, '@') && false === strpos($url, '\\')) {
                // 解析域名
                [$url, $domain] = explode('@', $url, 2);
            }
        }

        if ($url) {
            $checkName   = isset($name) ? $name : $url . (isset($info['query']) ? '?' . $info['query'] : '');
            $checkDomain = $domain && is_string($domain) ? $domain : null;

            $rule = $this->route->getName($checkName, $checkDomain);

            if (empty($rule) && isset($info['query'])) {
                $rule = $this->route->getName($url, $checkDomain);
                // 解析地址里面参数 合并到vars
                parse_str($info['query'], $params);
                $vars = array_merge($params, $vars);
                unset($info['query']);
            }
        }

        if (!empty($rule) && $match = $this->getRuleUrl($rule, $vars, $domain)) {
            // 匹配路由命名标识
            $url = $match[0];

            if ($domain && !empty($match[1])) {
                $domain = $match[1];
            }

            if (!is_null($match[2])) {
                $suffix = $match[2];
            }
        } elseif (!empty($rule) && isset($name)) {
            throw new \InvalidArgumentException('route name not exists:' . $name);
        } else {
            // 检测URL绑定
            $bind = $this->route->getDomainBind($domain && is_string($domain) ? $domain : null);

            if ($bind && 0 === strpos($url, $bind)) {
                $url = substr($url, strlen($bind) + 1);
            } else {
                $binds = $this->route->getBind();

                foreach ($binds as $key => $val) {
                    if (is_string($val) && 0 === strpos($url, $val) && substr_count($val, '/') > 1) {
                        $url    = substr($url, strlen($val) + 1);
                        $domain = $key;
                        break;
                    }
                }
            }

            // 路由标识不存在 直接解析
            $url = $this->parseUrl($url, $domain);

            if (isset($info['query'])) {
                // 解析地址里面参数 合并到vars
                parse_str($info['query'], $params);
                $vars = array_merge($params, $vars);
            }
        }

        // 还原URL分隔符
        $depr = $this->route->config('pathinfo_depr');
        $url  = str_replace('/', $depr, $url);

        $file = $request->baseFile();
        if ($file && 0 !== strpos($request->url(), $file)) {
            $file = str_replace('\\', '/', dirname($file));
        }

        $url = rtrim($file, '/') . '/' . $url;

        // URL后缀
        if ('/' == substr($url, -1) || '' == $url) {
            $suffix = '';
        } else {
            $suffix = $this->parseSuffix($suffix);
        }

        // 锚点
        $anchor = !empty($anchor) ? '#' . $anchor : '';

        // 参数组装
        if (!empty($vars)) {
            // 添加参数
            if ($this->route->config('url_common_param')) {
                $vars = http_build_query($vars);
                $url .= $suffix . '?' . $vars . $anchor;
            } else {
                foreach ($vars as $var => $val) {
                    $val = (string) $val;
                    if ('' !== $val) {
                        $url .= $depr . $var . $depr . urlencode($val);
                    }
                }

                $url .= $suffix . $anchor;
            }
        } else {
            $url .= $suffix . $anchor;
        }

        // 检测域名
        $domain = $this->parseDomain($url, $domain);

        // URL组装
        return $domain . rtrim($this->root, '/') . '/' . ltrim($url, '/');
    }

    public function __toString()

    {
        return $this->build();
    }

    public function __debugInfo()

    {
        return [
            'url'    => $this->url,
            'vars'   => $this->vars,
            'suffix' => $this->suffix,
            'domain' => $this->domain,
        ];
    }
}


1			<?php
2			// +----------------------------------------------------------------------
3			// \| ThinkPHP [ WE CAN DO IT JUST THINK ]
4			// +----------------------------------------------------------------------
5			// \| Copyright (c) 2006~2019 http://thinkphp.cn All rights reserved.
6			// +----------------------------------------------------------------------
7			// \| Licensed ( http://www.apache.org/licenses/LICENSE-2.0 )
8			// +----------------------------------------------------------------------
9			// \| Author: liu21st <[email protected]>
10			// +----------------------------------------------------------------------
11			declare (strict_types = 1);
12
13			namespace think\route;
14
15			use think\App;
16			use think\Route;
17
18			/**
19			* 路由地址生成
20			*/
21			class Url
22			{
23			/**
24			* 应用对象
25			* @var App
26			*/
27			protected $app;
28
29			/**
30			* 路由对象
31			* @var Route
32			*/
33			protected $route;
34
35			/**
36			* URL变量
37			* @var array
38			*/
39			protected $vars = [];
40
41			/**
42			* 路由URL
43			* @var string
44			*/
45			protected $url;
46
47			/**
48			* URL 根地址
49			* @var string
50			*/
51			protected $root = '';
52
53			/**
54			* HTTPS
55			* @var bool
56			*/
57			protected $https;
58
59			/**
60			* URL后缀
61			* @var string\|bool
62			*/
63			protected $suffix = true;
64
65			/**
66			* URL域名
67			* @var string\|bool
68			*/
69			protected $domain = false;
70
71			/**
			0 ignored issues – show Coding Style introduced 2019-05-28 11:02 UTC by Report Bug Copy Issue Report Parameter `$route` should have a doc-comment as per coding-style. Loading history... Coding Style introduced 2019-04-05 02:29 UTC by Report Bug Copy Issue Report Parameter `$app` should have a doc-comment as per coding-style. Loading history...
72			* 架构函数
73			* @access public
74			* @param string $url URL地址
			0 ignored issues – show Coding Style introduced 2019-05-28 11:02 UTC by Report Bug Copy Issue Report Doc comment for parameter $url does not match actual variable name $route Loading history... Coding Style introduced 2019-05-28 11:02 UTC by Report Bug Copy Issue Report Expected 2 spaces after parameter name; 1 found Loading history...
75			* @param array $vars 参数
			0 ignored issues – show Coding Style introduced 2019-05-28 11:02 UTC by Report Bug Copy Issue Report Doc comment for parameter $vars does not match actual variable name $app Loading history...
76			*/
77			public function __construct(Route $route, App $app, string $url = '', array $vars = [])
78			{
79			$this->route = $route;
80			$this->app = $app;
81			$this->url = $url;
82			$this->vars = $vars;
83			}
84
85			/**
86			* 设置URL参数
87			* @access public
88			* @param array $vars URL参数
89			* @return $this
90			*/
91			public function vars(array $vars = [])
92			{
93			$this->vars = $vars;
94			return $this;
95			}
96
97			/**
98			* 设置URL后缀
99			* @access public
100			* @param string\|bool $suffix URL后缀
101			* @return $this
102			*/
103			public function suffix($suffix)
104			{
105			$this->suffix = $suffix;
106			return $this;
107			}
108
109			/**
110			* 设置URL域名（或者子域名）
111			* @access public
112			* @param string\|bool $domain URL域名
113			* @return $this
114			*/
115			public function domain($domain)
116			{
117			$this->domain = $domain;
118			return $this;
119			}
120
121			/**
122			* 设置URL 根地址
123			* @access public
124			* @param string $root URL root
125			* @return $this
126			*/
127			public function root(string $root)
128			{
129			$this->root = $root;
130			return $this;
131			}
132
133			/**
134			* 设置是否使用HTTPS
135			* @access public
136			* @param bool $https
			0 ignored issues – show Coding Style introduced 2019-02-27 06:16 UTC by Report Bug Copy Issue Report Missing parameter comment Loading history...
137			* @return $this
138			*/
139			public function https(bool $https = true)
140			{
141			$this->https = $https;
142			return $this;
143			}
144
145			/**
146			* 检测域名
147			* @access protected
148			* @param string $url URL
			0 ignored issues – show Coding Style introduced 2019-03-05 11:27 UTC by Report Bug Copy Issue Report Expected 4 spaces after parameter name; 1 found Loading history...
149			* @param string\|true $domain 域名
150			* @return string
151			*/
152			protected function parseDomain(string &$url, $domain): string
153			{
154			if (!$domain) {
155			return '';
156			}
157
158			$request = $this->app->request;
159			$rootDomain = $request->rootDomain();
160
161			if (true === $domain) {
162			// 自动判断域名
163			$domain = $request->host();
164			$domains = $this->route->getDomains();
165
166			if (!empty($domains)) {
167			$route_domain = array_keys($domains);
168			foreach ($route_domain as $domain_prefix) {
169			if (0 === strpos($domain_prefix, '.') && strpos($domain, ltrim($domain_prefix, '.')) !== false) {
170			foreach ($domains as $key => $rule) {
171			$rule = is_array($rule) ? $rule[0] : $rule;
172			if (is_string($rule) && false === strpos($key, '*') && 0 === strpos($url, $rule)) {
173			$url = ltrim($url, $rule);
174			$domain = $key;
175
176			// 生成对应子域名
177			if (!empty($rootDomain)) {
178			$domain .= $rootDomain;
179			}
180			break;
181			} elseif (false !== strpos($key, '*')) {
182			if (!empty($rootDomain)) {
183			$domain .= $rootDomain;
184			}
185
186			break;
187			}
188			}
189			}
190			}
191			}
192			} elseif (false === strpos($domain, '.') && 0 !== strpos($domain, $rootDomain)) {
193			$domain .= '.' . $rootDomain;
194			}
195
196			if (false !== strpos($domain, '://')) {
197			$scheme = '';
198			} else {
199			$scheme = $this->https \|\| $request->isSsl() ? 'https://' : 'http://';
200			}
201
202			return $scheme . $domain;
203			}
204
205			/**
206			* 解析URL后缀
207			* @access protected
208			* @param string\|bool $suffix 后缀
209			* @return string
210			*/
211			protected function parseSuffix($suffix): string
212			{
213			if ($suffix) {
214			$suffix = true === $suffix ? $this->route->config('url_html_suffix') : $suffix;
215
216			if (is_string($suffix) && $pos = strpos($suffix, '\|')) {
217			$suffix = substr($suffix, 0, $pos);
218			}
219			}
220
221			return (empty($suffix) \|\| 0 === strpos($suffix, '.')) ? (string) $suffix : '.' . $suffix;
222			}
223
224			/**
225			* 直接解析URL地址
226			* @access protected
227			* @param string $url URL
			0 ignored issues – show Coding Style introduced 2019-05-28 11:02 UTC by Report Bug Copy Issue Report Expected 4 spaces after parameter name; 1 found Loading history...
228			* @param string\|bool $domain Domain
229			* @return string
230			*/
231			protected function parseUrl(string $url, &$domain): string
232			{
233			$request = $this->app->request;
234
235			if (0 === strpos($url, '/')) {
236			// 直接作为路由地址解析
237			$url = substr($url, 1);
238			} elseif (false !== strpos($url, '\\')) {
239			// 解析到类
240			$url = ltrim(str_replace('\\', '/', $url), '/');
241			} elseif (0 === strpos($url, '@')) {
242			// 解析到控制器
243			$url = substr($url, 1);
244			} elseif ('' === $url) {
245			$url = $request->controller() . '/' . $request->action();
246			} else {
247			$controller = $request->controller();
248
249			$path = explode('/', $url);
250			$action = array_pop($path);
251			$controller = empty($path) ? $controller : array_pop($path);
252
253			$url = $controller . '/' . $action;
254			}
255
256			return $url;
257			}
258
259			/**
260			* 分析路由规则中的变量
261			* @access protected
262			* @param string $rule 路由规则
263			* @return array
264			*/
265			protected function parseVar(string $rule): array
266			{
267			// 提取路由规则中的变量
268			$var = [];
269
270			if (preg_match_all('/<\w+\??>/', $rule, $matches)) {
271			foreach ($matches[0] as $name) {
272			$optional = false;
273
274			if (strpos($name, '?')) {
275			$name = substr($name, 1, -2);
276			$optional = true;
277			} else {
278			$name = substr($name, 1, -1);
279			}
280
281			$var[$name] = $optional ? 2 : 1;
282			}
283			}
284
285			return $var;
286			}
287
288			/**
289			* 匹配路由地址
290			* @access protected
291			* @param array $rule 路由规则
			0 ignored issues – show Coding Style introduced 2019-03-05 11:27 UTC by Report Bug Copy Issue Report Expected 8 spaces after parameter name; 1 found Loading history...
292			* @param array $vars 路由变量
			0 ignored issues – show Coding Style introduced 2019-03-05 11:27 UTC by Report Bug Copy Issue Report Expected 8 spaces after parameter name; 1 found Loading history...
293			* @param mixed $allowDomain 允许域名
294			* @return array
295			*/
296			protected function getRuleUrl(array $rule, array &$vars = [], $allowDomain = ''): array
297			{
298			$request = $this->app->request;
299			if (is_string($allowDomain) && false === strpos($allowDomain, '.')) {
300			$allowDomain .= '.' . $request->rootDomain();
301			}
302			$port = $request->port();
303
304			foreach ($rule as $item) {
305			$url = $item->getRule();
306			$pattern = $this->parseVar($url);
307			$domain = $item->getDomain();
308			$suffix = $item->getSuffix();
309
310			if ('-' == $domain) {
311			$domain = is_string($allowDomain) ? $allowDomain : $request->host(true);
312			}
313
314			if (is_string($allowDomain) && $domain != $allowDomain) {
315			continue;
316			}
317
318			if ($port && !in_array($port, [80, 443])) {
319			$domain .= ':' . $port;
320			}
321
322			if (empty($pattern)) {
323			return [rtrim($url, '?/-'), $domain, $suffix];
324			}
325
326			$type = $this->route->config('url_common_param');
327			$keys = [];
328
329			foreach ($pattern as $key => $val) {
330			if (isset($vars[$key])) {
331			$url = str_replace(['[:' . $key . ']', '<' . $key . '?>', ':' . $key, '<' . $key . '>'], $type ? $vars[$key] : urlencode((string) $vars[$key]), $url);
332			$keys[] = $key;
333			$url = str_replace(['/?', '-?'], ['/', '-'], $url);
334			$result = [rtrim($url, '?/-'), $domain, $suffix];
335			} elseif (2 == $val) {
336			$url = str_replace(['/[:' . $key . ']', '[:' . $key . ']', '<' . $key . '?>'], '', $url);
337			$url = str_replace(['/?', '-?'], ['/', '-'], $url);
338			$result = [rtrim($url, '?/-'), $domain, $suffix];
339			} else {
340			$result = null;
341			$keys = [];
342			break;
343			}
344			}
345
346			$vars = array_diff_key($vars, array_flip($keys));
347
348			if (isset($result)) {
349			return $result;
350			}
351			}
352
353			return [];
354			}
355
356			public function build()
			0 ignored issues – show Coding Style introduced 2019-05-28 11:02 UTC by Report Bug Copy Issue Report Missing doc comment for function build() Loading history...
357			{
358			// 解析URL
359			$url = $this->url;
360			$suffix = $this->suffix;
361			$domain = $this->domain;
362			$request = $this->app->request;
363			$vars = $this->vars;
364
365			if (0 === strpos($url, '[') && $pos = strpos($url, ']')) {
366			// [name] 表示使用路由命名标识生成URL
367			$name = substr($url, 1, $pos - 1);
368			$url = 'name' . substr($url, $pos + 1);
369			}
370
371			if (false === strpos($url, '://') && 0 !== strpos($url, '/')) {
372			$info = parse_url($url);
373			$url = !empty($info['path']) ? $info['path'] : '';
374
375			if (isset($info['fragment'])) {
376			// 解析锚点
377			$anchor = $info['fragment'];
378
379			if (false !== strpos($anchor, '?')) {
380			// 解析参数
381			[$anchor, $info['query']] = explode('?', $anchor, 2);
382			}
383
384			if (false !== strpos($anchor, '@')) {
385			// 解析域名
386			[$anchor, $domain] = explode('@', $anchor, 2);
387			}
388			} elseif (strpos($url, '@') && false === strpos($url, '\\')) {
389			// 解析域名
390			[$url, $domain] = explode('@', $url, 2);
391			}
392			}
393
394			if ($url) {
395			$checkName = isset($name) ? $name : $url . (isset($info['query']) ? '?' . $info['query'] : '');
396			$checkDomain = $domain && is_string($domain) ? $domain : null;
397
398			$rule = $this->route->getName($checkName, $checkDomain);
399
400			if (empty($rule) && isset($info['query'])) {
401			$rule = $this->route->getName($url, $checkDomain);
402			// 解析地址里面参数合并到vars
403			parse_str($info['query'], $params);
404			$vars = array_merge($params, $vars);
405			unset($info['query']);
406			}
407			}
408
409			if (!empty($rule) && $match = $this->getRuleUrl($rule, $vars, $domain)) {
410			// 匹配路由命名标识
411			$url = $match[0];
412
413			if ($domain && !empty($match[1])) {
414			$domain = $match[1];
415			}
416
417			if (!is_null($match[2])) {
418			$suffix = $match[2];
419			}
420			} elseif (!empty($rule) && isset($name)) {
421			throw new \InvalidArgumentException('route name not exists:' . $name);
422			} else {
423			// 检测URL绑定
424			$bind = $this->route->getDomainBind($domain && is_string($domain) ? $domain : null);
425
426			if ($bind && 0 === strpos($url, $bind)) {
427			$url = substr($url, strlen($bind) + 1);
428			} else {
429			$binds = $this->route->getBind();
430
431			foreach ($binds as $key => $val) {
432			if (is_string($val) && 0 === strpos($url, $val) && substr_count($val, '/') > 1) {
433			$url = substr($url, strlen($val) + 1);
434			$domain = $key;
435			break;
436			}
437			}
438			}
439
440			// 路由标识不存在直接解析
441			$url = $this->parseUrl($url, $domain);
442
443			if (isset($info['query'])) {
444			// 解析地址里面参数合并到vars
445			parse_str($info['query'], $params);
446			$vars = array_merge($params, $vars);
447			}
448			}
449
450			// 还原URL分隔符
451			$depr = $this->route->config('pathinfo_depr');
452			$url = str_replace('/', $depr, $url);
453
454			$file = $request->baseFile();
455			if ($file && 0 !== strpos($request->url(), $file)) {
456			$file = str_replace('\\', '/', dirname($file));
457			}
458
459			$url = rtrim($file, '/') . '/' . $url;
460
461			// URL后缀
462			if ('/' == substr($url, -1) \|\| '' == $url) {
463			$suffix = '';
464			} else {
465			$suffix = $this->parseSuffix($suffix);
466			}
467
468			// 锚点
469			$anchor = !empty($anchor) ? '#' . $anchor : '';
470
471			// 参数组装
472			if (!empty($vars)) {
473			// 添加参数
474			if ($this->route->config('url_common_param')) {
475			$vars = http_build_query($vars);
476			$url .= $suffix . '?' . $vars . $anchor;
477			} else {
478			foreach ($vars as $var => $val) {
479			$val = (string) $val;
480			if ('' !== $val) {
481			$url .= $depr . $var . $depr . urlencode($val);
482			}
483			}
484
485			$url .= $suffix . $anchor;
486			}
487			} else {
488			$url .= $suffix . $anchor;
489			}
490
491			// 检测域名
492			$domain = $this->parseDomain($url, $domain);
493
494			// URL组装
495			return $domain . rtrim($this->root, '/') . '/' . ltrim($url, '/');
496			}
497
498			public function __toString()
			0 ignored issues – show Coding Style introduced 2019-05-28 11:02 UTC by Report Bug Copy Issue Report Missing doc comment for function __toString() Loading history...
499			{
500			return $this->build();
501			}
502
503			public function __debugInfo()
			0 ignored issues – show Coding Style introduced 2019-05-29 01:06 UTC by Report Bug Copy Issue Report Missing doc comment for function __debugInfo() Loading history...
504			{
505			return [
506			'url' => $this->url,
507			'vars' => $this->vars,
508			'suffix' => $this->suffix,
509			'domain' => $this->domain,
510			];
511			}
512			}
513

top-think / framework

Push — 6.0 ( 6bb9cc...7f945e )

Url::parseSuffix() B

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like