Uri::fragment() - Code Metrics - JustSteveKing/uri-builder - Measure and Improve Code Quality continuously with Scrutinizer

Uri::fragment() A
last analyzed 2022-07-15 12:21 UTC

↳ Parent: Uri

Complexity

Conditions	1
Paths	1

Size

Total Lines	3
Code Lines	1

Duplication

Lines	0
Ratio	0 %

Importance

Changes

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

<?php

declare(strict_types=1);

namespace JustSteveKing\UriBuilder;

use InvalidArgumentException;
use JustSteveKing\ParameterBag\ParameterBag;

use Safe\Exceptions\UrlException;

use function Safe\parse_url;

final class Uri
{
    /**
     * @param ParameterBag $query
     * @param string $scheme
     * @param string $host
     * @param int|null $port
     * @param string|null $path
     * @param string|null $fragment
     * @return void
     */
    private function __construct(
        private ParameterBag $query,
        private string $scheme = '',
        private string $host = '',
        private null|int $port = null,
        private null|string $path = null,
        private null|string $fragment = null,
    ) {
    }

    /**
     * @return Uri
     */
    public static function build(): Uri
    {
        return new Uri(
            query: new ParameterBag(),
        );
    }

    /**
     * @param string $uri
     * @return Uri
     * @throws UrlException
     * @throws InvalidArgumentException
     */
    public static function fromString(string $uri): Uri
    {
        $original = $uri;

        $uri = parse_url($uri);

        if (
            ! is_array($uri)

            || ! isset($uri['scheme'], $uri['host'])
        ) {
            throw new InvalidArgumentException(
                message: "URI failed to parse using parse_url, please ensure is valid URL. Passed in [$uri]",
            );
        }

        $url = Uri::build()
            ->addScheme(
                scheme: $uri['scheme'],
            )->addHost(
                host: $uri['host'],
            );

        if (isset($uri['port'])) {
            $url->addPort(
                port: $uri['port'],
            );
        }

        if (isset($uri['path'])) {
            $url->addPath(
                path: $uri['path'],
            );
        }

        if (isset($uri['query'])) {
            $url->addQuery(
                query: $uri['query'],
            );
        }

        $fragment = parse_url($original, PHP_URL_FRAGMENT);

        if (! is_null($fragment)) {
            $url->addFragment(
                fragment: $fragment,
            );
        }

        return $url;
    }

    /**
     * @param  string $scheme
     * @return Uri
     */
    public function addScheme(string $scheme): Uri
    {
        $this->scheme = $scheme;

        return $this;
    }

    /**
     * @return string
     */
    public function scheme(): string
    {
        return $this->scheme;
    }

    /**
     * @param  string $host
     * @return Uri
     */
    public function addHost(string $host): Uri
    {
        $this->host = $host;

        return $this;
    }

    /**
     * @return string
     */
    public function host(): string
    {
        return $this->host;
    }

    /**
     * @param null|int $port
     * @throws InvalidArgumentException
     * @return Uri
     */
    public function addPort(null|int $port = null): Uri
    {
        if (is_null($port)) {
            throw new InvalidArgumentException(
                message: 'Cannot set port to a null value.',
            );
        }

        $this->port = $port;

        return $this;
    }

    /**
     * @return null|int
     */
    public function port(): null|int
    {
        return $this->port;
    }

    /**
     * @param  null|string $path
     * @return Uri
     */
    public function addPath(null|string $path = null): Uri
    {
        if (is_null($path)) {
            return $this;
        }

        $this->path = str_starts_with(
            haystack: $path,
            needle: '/',
        ) ? $path : "/$path";

        return $this;
    }

    /**
     * @return null|string
     */
    public function path(): null|string
    {
        return $this->path;
    }

    /**
     * @param  null|string $query
     * @throws InvalidArgumentException
     * @return Uri
     */
    public function addQuery(null|string $query = null): Uri
    {
        if (is_null($query)) {
            throw new InvalidArgumentException(
                message: 'Cannot set query to a null value.',
            );
        }

        $this->query = ParameterBag::fromString(
            attributes: $query,
        );

        return $this;
    }

    /**
     * @return ParameterBag
     */
    public function query(): ParameterBag
    {
        return $this->query;
    }

    /**
     * @param  string $key
     * @param  int|string|bool|null|array  $value
     * @param  bool   $covertBoolToString
     * @throws InvalidArgumentException
     * @return Uri
     */
    public function addQueryParam(string $key, int|string|bool|null|array $value, bool $covertBoolToString = false): Uri
    {
        if (! in_array(gettype($value), ['string', 'array', 'int', 'float', 'boolean'])) {
            throw new InvalidArgumentException(
                message:'Cannot set Query Parameter to: ' . gettype($value),
            );
        }

        if ($covertBoolToString && is_bool($value)) {

            $value = ($value) ? 'true' : 'false';
        }

        $this->query->set(
            key: $key,
            value: $value,
        );

        return $this;
    }

    /**
     * @return array<string,mixed>
     */
    public function queryParams(): array
    {
        return $this->query->all();
    }

    /**
     * @param  string $fragment
     * @return Uri
     */
    public function addFragment(string $fragment): Uri
    {
        if ($fragment === '') {
            return $this;
        }

        $this->fragment = str_starts_with(
            haystack: $fragment,
            needle:'#',
        ) ? $fragment : "#{$fragment}";

        return $this;
    }

    /**
     * @return null|string
     */
    public function fragment(): null|string
    {
        return $this->fragment;
    }

    /**
     * @return string
     */
    public function __toString(): string
    {
        return $this->toString();
    }

    /**
     * @param bool $encode
     * @return string
     */
    public function toString(bool $encode = false): string
    {
        $url = "$this->scheme://$this->host";

        if (! is_null($this->port)) {
            $url .= ":$this->port";
        }

        if (! is_null($this->path)) {
            $url .= "$this->path";
        }

        if (! empty($this->query->all())) {
            $collection = [];
            foreach ($this->query->all() as $key => $value) {
                $collection[] = "$key=$value";
            }

            $queryParamString = implode('&', $collection);

            if ($encode) {
                $queryParamString = urlencode($queryParamString);
            }

            $url .= "?$queryParamString";
        }

        if (! is_null($this->fragment)) {
            $url .= "$this->fragment";
        }

        return $url;
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			namespace JustSteveKing\UriBuilder;
6
7			use InvalidArgumentException;
8			use JustSteveKing\ParameterBag\ParameterBag;
9
10			use Safe\Exceptions\UrlException;
11
12			use function Safe\parse_url;
13
14			final class Uri
15			{
16			/**
17			* @param ParameterBag $query
18			* @param string $scheme
19			* @param string $host
20			* @param int\|null $port
21			* @param string\|null $path
22			* @param string\|null $fragment
23			* @return void
24			*/
25			private function __construct(
26			private ParameterBag $query,
27			private string $scheme = '',
28			private string $host = '',
29			private null\|int $port = null,
30			private null\|string $path = null,
31			private null\|string $fragment = null,
32			) {
33			}
34
35			/**
36			* @return Uri
37			*/
38			public static function build(): Uri
39			{
40			return new Uri(
41			query: new ParameterBag(),
42			);
43			}
44
45			/**
46			* @param string $uri
47			* @return Uri
48			* @throws UrlException
49			* @throws InvalidArgumentException
50			*/
51			public static function fromString(string $uri): Uri
52			{
53			$original = $uri;
54
55			$uri = parse_url($uri);
56
57			if (
58			! is_array($uri)
			0 ignored issues – show introduced 2022-07-15 11:51 UTC by Report Bug Copy Issue Report The condition `is_array($uri)` is always `false`. Loading history...
59			\|\| ! isset($uri['scheme'], $uri['host'])
60			) {
61			throw new InvalidArgumentException(
62			message: "URI failed to parse using parse_url, please ensure is valid URL. Passed in [$uri]",
63			);
64			}
65
66			$url = Uri::build()
67			->addScheme(
68			scheme: $uri['scheme'],
69			)->addHost(
70			host: $uri['host'],
71			);
72
73			if (isset($uri['port'])) {
74			$url->addPort(
75			port: $uri['port'],
76			);
77			}
78
79			if (isset($uri['path'])) {
80			$url->addPath(
81			path: $uri['path'],
82			);
83			}
84
85			if (isset($uri['query'])) {
86			$url->addQuery(
87			query: $uri['query'],
88			);
89			}
90
91			$fragment = parse_url($original, PHP_URL_FRAGMENT);
92
93			if (! is_null($fragment)) {
94			$url->addFragment(
95			fragment: $fragment,
96			);
97			}
98
99			return $url;
100			}
101
102			/**
103			* @param string $scheme
104			* @return Uri
105			*/
106			public function addScheme(string $scheme): Uri
107			{
108			$this->scheme = $scheme;
109
110			return $this;
111			}
112
113			/**
114			* @return string
115			*/
116			public function scheme(): string
117			{
118			return $this->scheme;
119			}
120
121			/**
122			* @param string $host
123			* @return Uri
124			*/
125			public function addHost(string $host): Uri
126			{
127			$this->host = $host;
128
129			return $this;
130			}
131
132			/**
133			* @return string
134			*/
135			public function host(): string
136			{
137			return $this->host;
138			}
139
140			/**
141			* @param null\|int $port
142			* @throws InvalidArgumentException
143			* @return Uri
144			*/
145			public function addPort(null\|int $port = null): Uri
146			{
147			if (is_null($port)) {
148			throw new InvalidArgumentException(
149			message: 'Cannot set port to a null value.',
150			);
151			}
152
153			$this->port = $port;
154
155			return $this;
156			}
157
158			/**
159			* @return null\|int
160			*/
161			public function port(): null\|int
162			{
163			return $this->port;
164			}
165
166			/**
167			* @param null\|string $path
168			* @return Uri
169			*/
170			public function addPath(null\|string $path = null): Uri
171			{
172			if (is_null($path)) {
173			return $this;
174			}
175
176			$this->path = str_starts_with(
177			haystack: $path,
178			needle: '/',
179			) ? $path : "/$path";
180
181			return $this;
182			}
183
184			/**
185			* @return null\|string
186			*/
187			public function path(): null\|string
188			{
189			return $this->path;
190			}
191
192			/**
193			* @param null\|string $query
194			* @throws InvalidArgumentException
195			* @return Uri
196			*/
197			public function addQuery(null\|string $query = null): Uri
198			{
199			if (is_null($query)) {
200			throw new InvalidArgumentException(
201			message: 'Cannot set query to a null value.',
202			);
203			}
204
205			$this->query = ParameterBag::fromString(
206			attributes: $query,
207			);
208
209			return $this;
210			}
211
212			/**
213			* @return ParameterBag
214			*/
215			public function query(): ParameterBag
216			{
217			return $this->query;
218			}
219
220			/**
221			* @param string $key
222			* @param int\|string\|bool\|null\|array $value
223			* @param bool $covertBoolToString
224			* @throws InvalidArgumentException
225			* @return Uri
226			*/
227			public function addQueryParam(string $key, int\|string\|bool\|null\|array $value, bool $covertBoolToString = false): Uri
228			{
229			if (! in_array(gettype($value), ['string', 'array', 'int', 'float', 'boolean'])) {
230			throw new InvalidArgumentException(
231			message:'Cannot set Query Parameter to: ' . gettype($value),
232			);
233			}
234
235			if ($covertBoolToString && is_bool($value)) {
			0 ignored issues – show introduced 2022-07-15 11:51 UTC by Report Bug Copy Issue Report The condition `is_bool($value)` is always `false`. Loading history...
236			$value = ($value) ? 'true' : 'false';
237			}
238
239			$this->query->set(
240			key: $key,
241			value: $value,
242			);
243
244			return $this;
245			}
246
247			/**
248			* @return array<string,mixed>
249			*/
250			public function queryParams(): array
251			{
252			return $this->query->all();
253			}
254
255			/**
256			* @param string $fragment
257			* @return Uri
258			*/
259			public function addFragment(string $fragment): Uri
260			{
261			if ($fragment === '') {
262			return $this;
263			}
264
265			$this->fragment = str_starts_with(
266			haystack: $fragment,
267			needle:'#',
268			) ? $fragment : "#{$fragment}";
269
270			return $this;
271			}
272
273			/**
274			* @return null\|string
275			*/
276			public function fragment(): null\|string
277			{
278			return $this->fragment;
279			}
280
281			/**
282			* @return string
283			*/
284			public function __toString(): string
285			{
286			return $this->toString();
287			}
288
289			/**
290			* @param bool $encode
291			* @return string
292			*/
293			public function toString(bool $encode = false): string
294			{
295			$url = "$this->scheme://$this->host";
296
297			if (! is_null($this->port)) {
298			$url .= ":$this->port";
299			}
300
301			if (! is_null($this->path)) {
302			$url .= "$this->path";
303			}
304
305			if (! empty($this->query->all())) {
306			$collection = [];
307			foreach ($this->query->all() as $key => $value) {
308			$collection[] = "$key=$value";
309			}
310
311			$queryParamString = implode('&', $collection);
312
313			if ($encode) {
314			$queryParamString = urlencode($queryParamString);
315			}
316
317			$url .= "?$queryParamString";
318			}
319
320			if (! is_null($this->fragment)) {
321			$url .= "$this->fragment";
322			}
323
324			return $url;
325			}
326			}
327

JustSteveKing / uri-builder

Uri::fragment() A last analyzed 2022-07-15 12:21 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

Uri::fragment() A
last analyzed 2022-07-15 12:21 UTC