Uri::__construct() - Code Metrics - Riimu/Kit-UrlParser - Measure and Improve Code Quality continuously with Scrutinizer

Uri::__construct() A
last analyzed 2022-12-13 18:53 UTC

↳ Parent: Uri

Complexity

Conditions	3
Paths	3

Size

Total Lines	16
Code Lines	10

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	3
eloc	10
c	1
b	0
f	0
nc	3
nop	2
dl	0
loc	16
rs	9.9332

<?php

namespace Riimu\Kit\UrlParser;

use Psr\Http\Message\UriInterface;

/**
 * Immutable value object that represents a RFC3986 compliant URI.
 * @author Riikka Kalliomäki <[email protected]>
 * @copyright Copyright (c) 2015-2017 Riikka Kalliomäki
 * @license http://opensource.org/licenses/mit-license.php MIT License
 */
class Uri implements UriInterface
{
    use ExtendedUriTrait;

    /** @var string The scheme component of the URI */
    private $scheme = '';

    /** @var string The user information component of the URI */
    private $userInfo = '';

    /** @var string The host component of the URI */
    private $host = '';

    /** @var int|null The port component of the URI or null for none */
    private $port = null;

    /** @var string The path component of the URI */
    private $path = '';

    /** @var string The query component of the URI */
    private $query = '';

    /** @var string The fragment component of the URI */
    private $fragment = '';

    /**
     * Creates a new instance of Uri.
     * @param string $uri The URI provided as a string or empty string for none
     * @param int $mode The parser mode used to parse the provided URI
     * @throws \InvalidArgumentException If the provided URI is invalid
     */
    public function __construct($uri = '', $mode = UriParser::MODE_RFC3986)
    {
        $uri = (string) $uri;

        if ($uri !== '') {
            $parser = new UriParser();
            $parser->setMode($mode);
            $parsed = $parser->parse($uri);

            if (!$parsed instanceof self) {
                throw new \InvalidArgumentException("Invalid URI '$uri'");
            }

            $properties = get_object_vars($parsed);
            array_walk($properties, function ($value, $name) {
                $this->$name = $value;
            });
        }
    }

    /**
     * Returns the scheme component of the URI.
     *
     * Note that the returned value will always be normalized to lowercase,
     * as per RFC 3986 Section 3.1. If no scheme has been provided, an empty
     * string will be returned instead.
     *
     * @see https://tools.ietf.org/html/rfc3986#section-3.1
     * @return string The URI scheme or an empty string if no scheme has been provided
     */
    public function getScheme()
    {
        return $this->scheme;
    }

    /**
     * Returns the authority component of the URI.
     *
     * If no authority information has been provided, an empty string will be
     * returned instead. Note that the host component in the authority component
     * will always be normalized to lowercase as per RFC 3986 Section 3.2.2.
     *
     * Also note that even if a port has been provided, but it is the standard port
     * for the current scheme, the port will not be included in the returned value.
     *
     * The format of the returned value is `[user-info@]host[:port]`
     *
     * @see https://tools.ietf.org/html/rfc3986#section-3.2
     * @return string The URI authority or an empty string if no authority information has been provided
     */
    public function getAuthority()
    {
        return $this->constructString([
            '%s%s@' => $this->getUserInfo(),
            '%s%s' => $this->getHost(),
            '%s:%s' => $this->getPort(),
        ]);
    }

    /**
     * Returns the user information component of the URI.
     *
     * The user information component contains the username and password in the
     * URI separated by a colon. If no username has been provided, an empty
     * string will be returned instead. If no password has been provided, the returned
     * value will only contain the username without the delimiting colon.
     *
     * @see http://tools.ietf.org/html/rfc3986#section-3.2.1
     * @return string The URI user information or an empty string if no username has been provided
     */
    public function getUserInfo()
    {
        return $this->userInfo;
    }

    /**
     * Returns the host component of the URI.
     *
     * Note that the returned value will always be normalized to lowercase,
     * as per RFC 3986 Section 3.2.2. If no host has been provided, an empty
     * string will be returned instead.
     *
     * @see http://tools.ietf.org/html/rfc3986#section-3.2.2
     * @return string The URI host or an empty string if no host has been provided
     */
    public function getHost()
    {
        return $this->host;
    }

    /**
     * Returns the port component of the URI.
     *
     * If no port has been provided, this method will return a null instead.
     * Note that this method will also return a null, if the provided port is
     * the standard port for the current scheme.
     *
     * @see http://tools.ietf.org/html/rfc3986#section-3.2.3
     * @return int|null The URI port or null if no port has been provided
     */
    public function getPort()
    {
        if ($this->port === $this->getStandardPort()) {
            return null;
        }

        return $this->port;
    }

    /**
     * Returns the path component of the URI.
     * @see https://tools.ietf.org/html/rfc3986#section-3.3
     * @return string The URI path or an empty string if no path has been provided
     */
    public function getPath()
    {
        return $this->path;
    }

    /**
     * Returns the query string of the URI.
     * @see https://tools.ietf.org/html/rfc3986#section-3.4
     * @return string The URI query string or an empty string if no query has been provided
     */
    public function getQuery()
    {
        return $this->query;
    }

    /**
     * Returns the fragment component of the URI.
     * @see https://tools.ietf.org/html/rfc3986#section-3.5
     * @return string The URI fragment or an empty string if no fragment has been provided
     */
    public function getFragment()
    {
        return $this->fragment;
    }

    /**
     * Returns a URI instance with the specified scheme.
     *
     * This method allows all different kinds of schemes. Note, however, that
     * the different components are only validated based on the generic URI
     * syntax. No additional validation is performed based on the scheme. An
     * empty string can be used to remove the scheme. Note that the provided
     * scheme will be normalized to lowercase.
     *
     * @param string $scheme The scheme to use with the new instance
     * @return static A new instance with the specified scheme
     * @throws \InvalidArgumentException If the scheme is invalid
     */
    public function withScheme($scheme)
    {
        $scheme = strtolower($scheme);
        $pattern = new UriPattern();

        if (strlen($scheme) === 0 || $pattern->matchScheme($scheme)) {
            return $this->with('scheme', $scheme);
        }

        throw new \InvalidArgumentException("Invalid scheme '$scheme'");
    }

    /**
     * Returns a URI instance with the specified user information.
     *
     * Note that the password is optional, but unless an username is provided,
     * the password will be ignored. Note that this method assumes that neither
     * the username nor the password contains encoded characters. Thus, all
     * encoded characters will be double encoded, if present. An empty username
     * can be used to remove the user information.
     *
     * @param string $user The username to use for the authority component
     * @param string|null $password The password associated with the user
     * @return static A new instance with the specified user information
     */
    public function withUserInfo($user, $password = null)
    {
        $username = rawurlencode($user);

        if (strlen($username) > 0) {
            return $this->with('userInfo', $this->constructString([
                '%s%s' => $username,
                '%s:%s' => rawurlencode((string) $password),
            ]));
        }

        return $this->with('userInfo', '');
    }

    /**
     * Returns a URI instance with the specified host.
     *
     * An empty host can be used to remove the host. Note that since host names
     * are treated in a case insensitive manner, the host will be normalized
     * to lowercase. This method does not support international domain names and
     * hosts with non ascii characters are considered invalid.
     *
     * @param string $host The hostname to use with the new instance
     * @return static A new instance with the specified host
     * @throws \InvalidArgumentException If the hostname is invalid
     */
    public function withHost($host)
    {
        $pattern = new UriPattern();

        if ($pattern->matchHost($host)) {
            return $this->with('host', $this->normalize(strtolower($host)));
        }

        throw new \InvalidArgumentException("Invalid host '$host'");
    }

    /**
     * Returns a URI instance with the specified port.
     *
     * A null value can be used to remove the port number. Note that if an
     * invalid port number is provided (a number less than 0 or more than
     * 65535), an exception will be thrown.
     *
     * @param int|null $port The port to use with the new instance
     * @return static A new instance with the specified port
     * @throws \InvalidArgumentException If the port is invalid
     */
    public function withPort($port)
    {
        if ($port !== null) {
            $port = (int) $port;

            if (max(0, min(65535, $port)) !== $port) {
                throw new \InvalidArgumentException("Invalid port number '$port'");
            }
        }

        return $this->with('port', $port);
    }

    /**
     * Returns a URI instance with the specified path.
     *
     * The provided path may or may not begin with a forward slash. The path
     * will be automatically normalized with the appropriate number of slashes
     * once the string is generated from the Uri instance. An empty string can
     * be used to remove the path. The path may also contain percent encoded
     * characters as these characters will not be double encoded.
     *
     * @param string $path The path to use with the new instance
     * @return static A new instance with the specified path
     */
    public function withPath($path)
    {
        return $this->with('path', $this->encode($path, '@/'));
    }

    /**
     * Returns a URI instance with the specified query string.
     *
     * An empty string can be used to remove the query string. The provided
     * value may contain both encoded and unencoded characters. Encoded
     * characters will not be double encoded.
     *
     * @param string $query The query string to use with the new instance
     * @return static A new instance with the specified query string
     */
    public function withQuery($query)
    {
        return $this->with('query', $this->encode($query, ':@/?'));
    }

    /**
     * Returns a URI instance with the specified URI fragment.
     *
     * An empty string can be used to remove the fragment. The provided value
     * may contain both encoded and unencoded characters. Encoded characters
     * will not be double encoded.
     *
     * @param string $fragment The fragment to use with the new instance
     * @return static A new instance with the specified fragment
     */
    public function withFragment($fragment)
    {
        return $this->with('fragment', $this->encode($fragment, ':@/?'));
    }

    /**
     * Returns an Uri instance with the given value.
     * @param string $variable Name of the variable to change
     * @param mixed $value New value for the variable
     * @return static A new or the same instance depending on if the value changed
     */
    private function with($variable, $value)
    {
        if ($value === $this->$variable) {
            return $this;
        }

        $uri = clone $this;
        $uri->$variable = $value;

        return $uri;
    }

    /**
     * Percent encodes the value without double encoding.
     * @param string $string The value to encode
     * @param string $extra Additional allowed characters in the value
     * @return string The encoded string
     */
    private function encode($string, $extra = '')
    {
        $pattern = sprintf(
            '/[^0-9a-zA-Z%s]|%%(?![0-9A-F]{2})/',
            preg_quote("%-._~!$&'()*+,;=" . $extra, '/')
        );

        return preg_replace_callback($pattern, function ($match) {
            return sprintf('%%%02X', ord($match[0]));
        }, $this->normalize($string));
    }

    /**
     * Normalizes the percent encoded characters to upper case.
     * @param string $string The string to normalize
     * @return string String with percent encodings normalized to upper case
     */
    private function normalize($string)
    {
        return preg_replace_callback(
            '/%(?=.?[a-f])[0-9a-fA-F]{2}/',
            function ($match) {
                return strtoupper($match[0]);
            },
            (string) $string
        );
    }

    /**
     * Returns the string representation of the URI.
     *
     * The resulting URI will be composed of the provided components. All
     * components that have not been provided will be omitted from the generated
     * URI. The provided path will be normalized based on whether the authority
     * is included in the URI or not.
     *
     * @return string The string representation of the URI
     */
    public function __toString()
    {
        return $this->constructString([
            '%s%s:' => $this->getScheme(),
            '%s//%s' => $this->getAuthority(),
            '%s%s' => $this->getNormalizedUriPath(),
            '%s?%s' => $this->getQuery(),
            '%s#%s' => $this->getFragment(),
        ]);
    }

    /**
     * Constructs the string from the non empty parts with specific formats.
     * @param array $components Associative array of formats and values
     * @return string The constructed string
     */
    private function constructString(array $components)
    {
        $formats = array_keys($components);
        $values = array_values($components);
        $keys = array_keys(array_filter($values, function ($value) {
            return $value !== null && $value !== '';
        }));

        return array_reduce($keys, function ($string, $key) use ($formats, $values) {
            return sprintf($formats[$key], $string, $values[$key]);
        }, '');
    }

    /**
     * Returns the path normalized for the string representation.
     * @return string The normalized path for the string representation
     */
    private function getNormalizedUriPath()
    {
        $path = $this->getPath();

        if ($this->getAuthority() === '') {
            return preg_replace('#^/+#', '/', $path);
        } elseif ($path === '' || $path[0] === '/') {
            return $path;
        }

        return '/' . $path;
    }
}


1			<?php
2
3			namespace Riimu\Kit\UrlParser;
4
5			use Psr\Http\Message\UriInterface;
6
7			/**
8			* Immutable value object that represents a RFC3986 compliant URI.
9			* @author Riikka Kalliomäki <[email protected]>
10			* @copyright Copyright (c) 2015-2017 Riikka Kalliomäki
11			* @license http://opensource.org/licenses/mit-license.php MIT License
12			*/
13			class Uri implements UriInterface
14			{
15			use ExtendedUriTrait;
16
17			/** @var string The scheme component of the URI */
18			private $scheme = '';
19
20			/** @var string The user information component of the URI */
21			private $userInfo = '';
22
23			/** @var string The host component of the URI */
24			private $host = '';
25
26			/** @var int\|null The port component of the URI or null for none */
27			private $port = null;
28
29			/** @var string The path component of the URI */
30			private $path = '';
31
32			/** @var string The query component of the URI */
33			private $query = '';
34
35			/** @var string The fragment component of the URI */
36			private $fragment = '';
37
38			/**
39			* Creates a new instance of Uri.
40			* @param string $uri The URI provided as a string or empty string for none
41			* @param int $mode The parser mode used to parse the provided URI
42			* @throws \InvalidArgumentException If the provided URI is invalid
43			*/
44			public function __construct($uri = '', $mode = UriParser::MODE_RFC3986)
45			{
46			$uri = (string) $uri;
47
48			if ($uri !== '') {
49			$parser = new UriParser();
50			$parser->setMode($mode);
51			$parsed = $parser->parse($uri);
52
53			if (!$parsed instanceof self) {
54			throw new \InvalidArgumentException("Invalid URI '$uri'");
55			}
56
57			$properties = get_object_vars($parsed);
58			array_walk($properties, function ($value, $name) {
59			$this->$name = $value;
60			});
61			}
62			}
63
64			/**
65			* Returns the scheme component of the URI.
66			*
67			* Note that the returned value will always be normalized to lowercase,
68			* as per RFC 3986 Section 3.1. If no scheme has been provided, an empty
69			* string will be returned instead.
70			*
71			* @see https://tools.ietf.org/html/rfc3986#section-3.1
72			* @return string The URI scheme or an empty string if no scheme has been provided
73			*/
74			public function getScheme()
75			{
76			return $this->scheme;
77			}
78
79			/**
80			* Returns the authority component of the URI.
81			*
82			* If no authority information has been provided, an empty string will be
83			* returned instead. Note that the host component in the authority component
84			* will always be normalized to lowercase as per RFC 3986 Section 3.2.2.
85			*
86			* Also note that even if a port has been provided, but it is the standard port
87			* for the current scheme, the port will not be included in the returned value.
88			*
89			* The format of the returned value is `[user-info@]host[:port]`
90			*
91			* @see https://tools.ietf.org/html/rfc3986#section-3.2
92			* @return string The URI authority or an empty string if no authority information has been provided
93			*/
94			public function getAuthority()
95			{
96			return $this->constructString([
97			'%s%s@' => $this->getUserInfo(),
98			'%s%s' => $this->getHost(),
99			'%s:%s' => $this->getPort(),
100			]);
101			}
102
103			/**
104			* Returns the user information component of the URI.
105			*
106			* The user information component contains the username and password in the
107			* URI separated by a colon. If no username has been provided, an empty
108			* string will be returned instead. If no password has been provided, the returned
109			* value will only contain the username without the delimiting colon.
110			*
111			* @see http://tools.ietf.org/html/rfc3986#section-3.2.1
112			* @return string The URI user information or an empty string if no username has been provided
113			*/
114			public function getUserInfo()
115			{
116			return $this->userInfo;
117			}
118
119			/**
120			* Returns the host component of the URI.
121			*
122			* Note that the returned value will always be normalized to lowercase,
123			* as per RFC 3986 Section 3.2.2. If no host has been provided, an empty
124			* string will be returned instead.
125			*
126			* @see http://tools.ietf.org/html/rfc3986#section-3.2.2
127			* @return string The URI host or an empty string if no host has been provided
128			*/
129			public function getHost()
130			{
131			return $this->host;
132			}
133
134			/**
135			* Returns the port component of the URI.
136			*
137			* If no port has been provided, this method will return a null instead.
138			* Note that this method will also return a null, if the provided port is
139			* the standard port for the current scheme.
140			*
141			* @see http://tools.ietf.org/html/rfc3986#section-3.2.3
142			* @return int\|null The URI port or null if no port has been provided
143			*/
144			public function getPort()
145			{
146			if ($this->port === $this->getStandardPort()) {
147			return null;
148			}
149
150			return $this->port;
151			}
152
153			/**
154			* Returns the path component of the URI.
155			* @see https://tools.ietf.org/html/rfc3986#section-3.3
156			* @return string The URI path or an empty string if no path has been provided
157			*/
158			public function getPath()
159			{
160			return $this->path;
161			}
162
163			/**
164			* Returns the query string of the URI.
165			* @see https://tools.ietf.org/html/rfc3986#section-3.4
166			* @return string The URI query string or an empty string if no query has been provided
167			*/
168			public function getQuery()
169			{
170			return $this->query;
171			}
172
173			/**
174			* Returns the fragment component of the URI.
175			* @see https://tools.ietf.org/html/rfc3986#section-3.5
176			* @return string The URI fragment or an empty string if no fragment has been provided
177			*/
178			public function getFragment()
179			{
180			return $this->fragment;
181			}
182
183			/**
184			* Returns a URI instance with the specified scheme.
185			*
186			* This method allows all different kinds of schemes. Note, however, that
187			* the different components are only validated based on the generic URI
188			* syntax. No additional validation is performed based on the scheme. An
189			* empty string can be used to remove the scheme. Note that the provided
190			* scheme will be normalized to lowercase.
191			*
192			* @param string $scheme The scheme to use with the new instance
193			* @return static A new instance with the specified scheme
194			* @throws \InvalidArgumentException If the scheme is invalid
195			*/
196			public function withScheme($scheme)
197			{
198			$scheme = strtolower($scheme);
199			$pattern = new UriPattern();
200
201			if (strlen($scheme) === 0 \|\| $pattern->matchScheme($scheme)) {
202			return $this->with('scheme', $scheme);
203			}
204
205			throw new \InvalidArgumentException("Invalid scheme '$scheme'");
206			}
207
208			/**
209			* Returns a URI instance with the specified user information.
210			*
211			* Note that the password is optional, but unless an username is provided,
212			* the password will be ignored. Note that this method assumes that neither
213			* the username nor the password contains encoded characters. Thus, all
214			* encoded characters will be double encoded, if present. An empty username
215			* can be used to remove the user information.
216			*
217			* @param string $user The username to use for the authority component
218			* @param string\|null $password The password associated with the user
219			* @return static A new instance with the specified user information
220			*/
221			public function withUserInfo($user, $password = null)
222			{
223			$username = rawurlencode($user);
224
225			if (strlen($username) > 0) {
226			return $this->with('userInfo', $this->constructString([
227			'%s%s' => $username,
228			'%s:%s' => rawurlencode((string) $password),
229			]));
230			}
231
232			return $this->with('userInfo', '');
233			}
234
235			/**
236			* Returns a URI instance with the specified host.
237			*
238			* An empty host can be used to remove the host. Note that since host names
239			* are treated in a case insensitive manner, the host will be normalized
240			* to lowercase. This method does not support international domain names and
241			* hosts with non ascii characters are considered invalid.
242			*
243			* @param string $host The hostname to use with the new instance
244			* @return static A new instance with the specified host
245			* @throws \InvalidArgumentException If the hostname is invalid
246			*/
247			public function withHost($host)
248			{
249			$pattern = new UriPattern();
250
251			if ($pattern->matchHost($host)) {
252			return $this->with('host', $this->normalize(strtolower($host)));
253			}
254
255			throw new \InvalidArgumentException("Invalid host '$host'");
256			}
257
258			/**
259			* Returns a URI instance with the specified port.
260			*
261			* A null value can be used to remove the port number. Note that if an
262			* invalid port number is provided (a number less than 0 or more than
263			* 65535), an exception will be thrown.
264			*
265			* @param int\|null $port The port to use with the new instance
266			* @return static A new instance with the specified port
267			* @throws \InvalidArgumentException If the port is invalid
268			*/
269			public function withPort($port)
270			{
271			if ($port !== null) {
272			$port = (int) $port;
273
274			if (max(0, min(65535, $port)) !== $port) {
275			throw new \InvalidArgumentException("Invalid port number '$port'");
276			}
277			}
278
279			return $this->with('port', $port);
280			}
281
282			/**
283			* Returns a URI instance with the specified path.
284			*
285			* The provided path may or may not begin with a forward slash. The path
286			* will be automatically normalized with the appropriate number of slashes
287			* once the string is generated from the Uri instance. An empty string can
288			* be used to remove the path. The path may also contain percent encoded
289			* characters as these characters will not be double encoded.
290			*
291			* @param string $path The path to use with the new instance
292			* @return static A new instance with the specified path
293			*/
294			public function withPath($path)
295			{
296			return $this->with('path', $this->encode($path, '@/'));
297			}
298
299			/**
300			* Returns a URI instance with the specified query string.
301			*
302			* An empty string can be used to remove the query string. The provided
303			* value may contain both encoded and unencoded characters. Encoded
304			* characters will not be double encoded.
305			*
306			* @param string $query The query string to use with the new instance
307			* @return static A new instance with the specified query string
308			*/
309			public function withQuery($query)
310			{
311			return $this->with('query', $this->encode($query, ':@/?'));
312			}
313
314			/**
315			* Returns a URI instance with the specified URI fragment.
316			*
317			* An empty string can be used to remove the fragment. The provided value
318			* may contain both encoded and unencoded characters. Encoded characters
319			* will not be double encoded.
320			*
321			* @param string $fragment The fragment to use with the new instance
322			* @return static A new instance with the specified fragment
323			*/
324			public function withFragment($fragment)
325			{
326			return $this->with('fragment', $this->encode($fragment, ':@/?'));
327			}
328
329			/**
330			* Returns an Uri instance with the given value.
331			* @param string $variable Name of the variable to change
332			* @param mixed $value New value for the variable
333			* @return static A new or the same instance depending on if the value changed
334			*/
335			private function with($variable, $value)
336			{
337			if ($value === $this->$variable) {
338			return $this;
339			}
340
341			$uri = clone $this;
342			$uri->$variable = $value;
343
344			return $uri;
345			}
346
347			/**
348			* Percent encodes the value without double encoding.
349			* @param string $string The value to encode
350			* @param string $extra Additional allowed characters in the value
351			* @return string The encoded string
352			*/
353			private function encode($string, $extra = '')
354			{
355			$pattern = sprintf(
356			'/[^0-9a-zA-Z%s]\|%%(?![0-9A-F]{2})/',
357			preg_quote("%-._~!$&'()*+,;=" . $extra, '/')
358			);
359
360			return preg_replace_callback($pattern, function ($match) {
361			return sprintf('%%%02X', ord($match[0]));
362			}, $this->normalize($string));
363			}
364
365			/**
366			* Normalizes the percent encoded characters to upper case.
367			* @param string $string The string to normalize
368			* @return string String with percent encodings normalized to upper case
369			*/
370			private function normalize($string)
371			{
372			return preg_replace_callback(
373			'/%(?=.?[a-f])[0-9a-fA-F]{2}/',
374			function ($match) {
375			return strtoupper($match[0]);
376			},
377			(string) $string
378			);
379			}
380
381			/**
382			* Returns the string representation of the URI.
383			*
384			* The resulting URI will be composed of the provided components. All
385			* components that have not been provided will be omitted from the generated
386			* URI. The provided path will be normalized based on whether the authority
387			* is included in the URI or not.
388			*
389			* @return string The string representation of the URI
390			*/
391			public function __toString()
392			{
393			return $this->constructString([
394			'%s%s:' => $this->getScheme(),
395			'%s//%s' => $this->getAuthority(),
396			'%s%s' => $this->getNormalizedUriPath(),
397			'%s?%s' => $this->getQuery(),
398			'%s#%s' => $this->getFragment(),
399			]);
400			}
401
402			/**
403			* Constructs the string from the non empty parts with specific formats.
404			* @param array $components Associative array of formats and values
405			* @return string The constructed string
406			*/
407			private function constructString(array $components)
408			{
409			$formats = array_keys($components);
410			$values = array_values($components);
411			$keys = array_keys(array_filter($values, function ($value) {
412			return $value !== null && $value !== '';
413			}));
414
415			return array_reduce($keys, function ($string, $key) use ($formats, $values) {
416			return sprintf($formats[$key], $string, $values[$key]);
417			}, '');
418			}
419
420			/**
421			* Returns the path normalized for the string representation.
422			* @return string The normalized path for the string representation
423			*/
424			private function getNormalizedUriPath()
425			{
426			$path = $this->getPath();
427
428			if ($this->getAuthority() === '') {
429			return preg_replace('#^/+#', '/', $path);
430			} elseif ($path === '' \|\| $path[0] === '/') {
431			return $path;
432			}
433
434			return '/' . $path;
435			}
436			}
437

Riimu / Kit-UrlParser

Uri::__construct() A last analyzed 2022-12-13 18:53 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

Uri::__construct() A
last analyzed 2022-12-13 18:53 UTC