Host::__toString() - Code Metrics - Inspection of "adding preserve delimiters" - thephpleague/uri - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#58)

by ignace nyamagana

created 2016-05-17 10:27 UTC

Host::__toString() A

↳ Parent: Host

Complexity

Conditions	3
Paths	3

Size

Total Lines	12
Code Lines	6

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	6
CRAP Score	3

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
c	1
b	0
f	0
dl	0
loc	12
ccs	6
cts	6
cp	1
rs	9.4285
cc	3
eloc	6
nc	3
nop	0
crap	3

<?php
/**
 * League.Uri (http://uri.thephpleague.com)
 *
 * @package   League.uri
 * @author    Ignace Nyamagana Butera <[email protected]>
 * @copyright 2013-2015 Ignace Nyamagana Butera
 * @license   https://github.com/thephpleague/uri/blob/master/LICENSE (MIT License)
 * @version   4.2.0
 * @link      https://github.com/thephpleague/uri/
 */
namespace League\Uri\Components;

use InvalidArgumentException;
use League\Uri\Interfaces\Host as HostInterface;

/**
 * Value object representing a URI host component.
 *
 * @package League.uri
 * @author  Ignace Nyamagana Butera <[email protected]>
 * @since   1.0.0
 */
class Host extends AbstractHierarchicalComponent implements HostInterface
{
    use HostIpTrait;

    use HostnameInfoTrait;

    use HostnameTrait;

    /**
     * HierarchicalComponent delimiter
     *
     * @var string
     */
    protected static $separator = '.';

    /**
     * Host literal representation
     *
     * @var string
     */
    protected $host;

    /**
     * New instance
     *
     * @param null|string $host
     */
    public function __construct($host = null)
    {
        if (null !== $host) {
            $host = $this->validateString($host);
            $this->data = $this->validate($host);
            $this->setLiteral();
        }
    }

    /**
     * Returns whether or not the host is an IDN
     *
     * @return bool
     */
    public function isIdn()
    {
        return $this->isIdn;
    }

    /**
     * Returns whether or not the host is an IP address
     *
     * @return bool
     */
    public function isIp()
    {
        return $this->hostAsIpv4 || $this->hostAsIpv6;
    }

    /**
     * Returns whether or not the host is an IPv4 address
     *
     * @return bool
     */
    public function isIpv4()
    {
        return $this->hostAsIpv4;
    }

    /**
     * Returns whether or not the host is an IPv6 address
     *
     * @return bool
     */
    public function isIpv6()
    {
        return $this->hostAsIpv6;
    }

    /**
     * Returns whether or not the host has a ZoneIdentifier
     *
     * @return bool
     *
     * @see http://tools.ietf.org/html/rfc6874#section-4
     */
    public function hasZoneIdentifier()
    {
        return $this->hasZoneIdentifier;
    }

    /**
     * Host literal setter
     */
    protected function setLiteral()
    {
        $this->host = !$this->isIp() ? $this->__toString() : $this->data[0];
    }

    /**
     * Returns the instance literal representation
     * without encoding
     *
     * @return string
     */
    public function getLiteral()
    {
        return $this->host;
    }

    /**
     * validate the submitted data
     *
     * @param string $str
     *
     * @return array
     */
    protected function validate($str)
    {
        $res = $this->validateIpHost($str);
        if (!empty($res)) {
            return $res;
        }

        return $this->validateStringHost($str);
    }

    /**
     * Retrieves a single host label.
     *
     * Retrieves a single host label. If the label offset has not been set,
     * returns the default value provided.
     *
     * @param string $offset  the label offset
     * @param mixed  $default Default value to return if the offset does not exist.
     *
     * @return mixed
     */
    public function getLabel($offset, $default = null)
    {
        if (isset($this->data[$offset])) {
            return $this->isIdn ? $this->data[$offset] : idn_to_ascii($this->data[$offset]);
        }

        return $default;
    }

    /**
     * Returns an array representation of the host
     *
     * @return array
     */
    public function toArray()
    {
        return $this->convertToAscii($this->data, !$this->isIdn);
    }

    /**
     * @inheritdoc
     */
    public function getComponent()
    {
        if ([] === $this->data) {
            return null;
        }

        if ($this->isIp()) {
            return $this->formatIp($this->data[0]);
        }

        return $this->formatComponentString($this->toArray(), $this->isAbsolute);
    }

    /**
     * @inheritdoc
     */
    public function __debugInfo()
    {
        return ['host' => $this->__toString()];
    }

    /**
     * @inheritdoc
     */
    public static function __set_state(array $properties)
    {
        $host = static::createFromArray($properties['data'], $properties['isAbsolute']);
        $host->hostnameInfoLoaded = $properties['hostnameInfoLoaded'];
        $host->hostnameInfo = $properties['hostnameInfo'];

        return $host;
    }

    /**
     * Returns a host in his punycode encoded form
     *
     * This method MUST retain the state of the current instance, and return
     * an instance with the host transcoded using to ascii the RFC 3492 rules
     *
     * @see http://tools.ietf.org/html/rfc3492
     *
     * @return static
     */
    public function toAscii()
    {
        if ($this->isIp() || !$this->isIdn) {
            return $this;
        }

        return $this->modify($this->formatComponentString(
            $this->convertToAscii($this->data, $this->isIdn),
            $this->isAbsolute
        ));
    }

    /**
     * Returns a host in his IDN form
     *
     * This method MUST retain the state of the current instance, and return
     * an instance with the host in its IDN form using RFC 3492 rules
     *
     * @see http://tools.ietf.org/html/rfc3492
     *
     * @return static
     */
    public function toUnicode()
    {
        if ($this->isIp() || $this->isIdn) {
            return $this;
        }

        return $this->modify($this->formatComponentString($this->data, $this->isAbsolute));
    }

    /**
     * @inheritdoc
     */
    protected static function formatComponentString($data, $type)
    {
        $hostname = implode(static::$separator, array_reverse(static::validateIterator($data)));
        if (self::IS_ABSOLUTE == $type) {
            return $hostname.static::$separator;
        }

        return $hostname;
    }

    /**
     * Return an host without its zone identifier according to RFC6874
     *
     * This method MUST retain the state of the current instance, and return
     * an instance without the host zone identifier according to RFC6874
     *
     * @see http://tools.ietf.org/html/rfc6874#section-4
     *
     * @return static
     */
    public function withoutZoneIdentifier()
    {
        if ($this->hasZoneIdentifier) {
            return $this->modify(substr($this->data[0], 0, strpos($this->data[0], '%')));
        }

        return $this;
    }

    /**
     * Validated the Host Label Count
     *
     * @param array $labels Host labels
     *
     * @throws InvalidArgumentException If the validation fails
     */
    protected function assertLabelsCount(array $labels)
    {
        if (127 <= count(array_merge($this->data, $labels))) {
            throw new InvalidArgumentException('Invalid Hostname, verify labels count');
        }
    }

    /**
     * set the FQDN property
     *
     * @param string $str
     *
     * @return string
     */
    protected function setIsAbsolute($str)
    {
        $this->isAbsolute = self::IS_RELATIVE;
        if ('.' == mb_substr($str, -1, 1, 'UTF-8')) {
            $this->isAbsolute = self::IS_ABSOLUTE;
            $str = mb_substr($str, 0, -1, 'UTF-8');
        }

        return $str;
    }

    /**
     * @inheritdoc
     */
    public function append($component)
    {
        return $this->newCollectionInstance(array_merge(
            $this->validateComponent($component)->toArray(),
            $this->toArray()
        ));
    }
}


1		<?php
2		/**
3		* League.Uri (http://uri.thephpleague.com)
4		*
5		* @package League.uri
6		* @author Ignace Nyamagana Butera <[email protected]>
7		* @copyright 2013-2015 Ignace Nyamagana Butera
8		* @license https://github.com/thephpleague/uri/blob/master/LICENSE (MIT License)
9		* @version 4.2.0
10		* @link https://github.com/thephpleague/uri/
11		*/
12		namespace League\Uri\Components;
13
14		use InvalidArgumentException;
15		use League\Uri\Interfaces\Host as HostInterface;
16
17		/**
18		* Value object representing a URI host component.
19		*
20		* @package League.uri
21		* @author Ignace Nyamagana Butera <[email protected]>
22		* @since 1.0.0
23		*/
24		class Host extends AbstractHierarchicalComponent implements HostInterface
25		{
26		use HostIpTrait;
27
28		use HostnameInfoTrait;
29
30		use HostnameTrait;
31
32		/**
33		* HierarchicalComponent delimiter
34		*
35		* @var string
36		*/
37		protected static $separator = '.';
38
39		/**
40		* Host literal representation
41		*
42		* @var string
43		*/
44		protected $host;
45
46		/**
47		* New instance
48		*
49		* @param null\|string $host
50		*/
51	1018	public function __construct($host = null)
52		{
53	1018	if (null !== $host) {
54	910	$host = $this->validateString($host);
55	901	$this->data = $this->validate($host);
56	844	$this->setLiteral();
57	562	}
58	952	}
59
60		/**
61		* Returns whether or not the host is an IDN
62		*
63		* @return bool
64		*/
65	9	public function isIdn()
66		{
67	9	return $this->isIdn;
68		}
69
70		/**
71		* Returns whether or not the host is an IP address
72		*
73		* @return bool
74		*/
75	844	public function isIp()
76		{
77	844	return $this->hostAsIpv4 \|\| $this->hostAsIpv6;
78		}
79
80		/**
81		* Returns whether or not the host is an IPv4 address
82		*
83		* @return bool
84		*/
85	36	public function isIpv4()
86		{
87	36	return $this->hostAsIpv4;
88		}
89
90		/**
91		* Returns whether or not the host is an IPv6 address
92		*
93		* @return bool
94		*/
95	36	public function isIpv6()
96		{
97	36	return $this->hostAsIpv6;
98		}
99
100		/**
101		* Returns whether or not the host has a ZoneIdentifier
102		*
103		* @return bool
104		*
105		* @see http://tools.ietf.org/html/rfc6874#section-4
106		*/
107	12	public function hasZoneIdentifier()
108		{
109	12	return $this->hasZoneIdentifier;
110		}
111
112		/**
113		* Host literal setter
114		*/
115	844	protected function setLiteral()
116		{
117	844	$this->host = !$this->isIp() ? $this->__toString() : $this->data[0];
118	844	}
119
120		/**
121		* Returns the instance literal representation
122		* without encoding
123		*
124		* @return string
125		*/
126	21	public function getLiteral()
127		{
128	21	return $this->host;
129		}
130
131		/**
132		* validate the submitted data
133		*
134		* @param string $str
135		*
136		* @return array
137		*/
138	901	protected function validate($str)
139		{
140	901	$res = $this->validateIpHost($str);
141	901	if (!empty($res)) {
142	120	return $res;
143		}
144
145	814	return $this->validateStringHost($str);
146		}
147
148		/**
149		* Retrieves a single host label.
150		*
151		* Retrieves a single host label. If the label offset has not been set,
152		* returns the default value provided.
153		*
154		* @param string $offset the label offset
155		* @param mixed $default Default value to return if the offset does not exist.
156		*
157		* @return mixed
158		*/
159	3	public function getLabel($offset, $default = null)
160		{
161	3	if (isset($this->data[$offset])) {
162	3	return $this->isIdn ? $this->data[$offset] : idn_to_ascii($this->data[$offset]);
163		}
164
165	3	return $default;
166		}
167
168		/**
169		* Returns an array representation of the host
170		*
171		* @return array
172		*/
173	748	public function toArray()
174		{
175	748	return $this->convertToAscii($this->data, !$this->isIdn);
176		}
177
178		/**
179		* @inheritdoc
180		*/
181	874	public function getComponent()
182		{
183	874	if ([] === $this->data) {
184	207	return null;
185		}
186
187	808	if ($this->isIp()) {
188	75	return $this->formatIp($this->data[0]);
189		}
190
191	739	return $this->formatComponentString($this->toArray(), $this->isAbsolute);
192		}
193
194		/**
195		* @inheritdoc
196		*/
197	2	public function __debugInfo()
198		{
199	2	return ['host' => $this->__toString()];
200		}
201
202		/**
203		* @inheritdoc
204		*/
205	15	public static function __set_state(array $properties)
206		{
207	15	$host = static::createFromArray($properties['data'], $properties['isAbsolute']);
208	15	$host->hostnameInfoLoaded = $properties['hostnameInfoLoaded'];
209	15	$host->hostnameInfo = $properties['hostnameInfo'];
210
211	15	return $host;
212		}
213
214		/**
215		* Returns a host in his punycode encoded form
216		*
217		* This method MUST retain the state of the current instance, and return
218		* an instance with the host transcoded using to ascii the RFC 3492 rules
219		*
220		* @see http://tools.ietf.org/html/rfc3492
221		*
222		* @return static
223		*/
224	108	public function toAscii()
225		{
226	108	if ($this->isIp() \|\| !$this->isIdn) {
227	36	return $this;
228		}
229
230	75	return $this->modify($this->formatComponentString(
231	75	$this->convertToAscii($this->data, $this->isIdn),
232	75	$this->isAbsolute
233	50	));
234		}
235
236		/**
237		* Returns a host in his IDN form
238		*
239		* This method MUST retain the state of the current instance, and return
240		* an instance with the host in its IDN form using RFC 3492 rules
241		*
242		* @see http://tools.ietf.org/html/rfc3492
243		*
244		* @return static
245		*/
246	84	public function toUnicode()
247		{
248	84	if ($this->isIp() \|\| $this->isIdn) {
249	69	return $this;
250		}
251
252	75	return $this->modify($this->formatComponentString($this->data, $this->isAbsolute));
253		}
254
255		/**
256		* @inheritdoc
257		*/
258	781	protected static function formatComponentString($data, $type)
259		{
260	781	$hostname = implode(static::$separator, array_reverse(static::validateIterator($data)));
261	769	if (self::IS_ABSOLUTE == $type) {
262	36	return $hostname.static::$separator;
263		}
264
265	745	return $hostname;
266		}
267
268		/**
269		* Return an host without its zone identifier according to RFC6874
270		*
271		* This method MUST retain the state of the current instance, and return
272		* an instance without the host zone identifier according to RFC6874
273		*
274		* @see http://tools.ietf.org/html/rfc6874#section-4
275		*
276		* @return static
277		*/
278	18	public function withoutZoneIdentifier()
279		{
280	18	if ($this->hasZoneIdentifier) {
281	9	return $this->modify(substr($this->data[0], 0, strpos($this->data[0], '%')));
282		}
283
284	9	return $this;
285		}
286
287		/**
288		* Validated the Host Label Count
289		*
290		* @param array $labels Host labels
291		*
292		* @throws InvalidArgumentException If the validation fails
293		*/
294	781	protected function assertLabelsCount(array $labels)
295		{
296	781	if (127 <= count(array_merge($this->data, $labels))) {
297	3	throw new InvalidArgumentException('Invalid Hostname, verify labels count');
298		}
299	778	}
300
301		/**
302		* set the FQDN property
303		*
304		* @param string $str
305		*
306		* @return string
307		*/
308	796	protected function setIsAbsolute($str)
309		{
310	796	$this->isAbsolute = self::IS_RELATIVE;
311	796	if ('.' == mb_substr($str, -1, 1, 'UTF-8')) {
312	42	$this->isAbsolute = self::IS_ABSOLUTE;
313	42	$str = mb_substr($str, 0, -1, 'UTF-8');
314	28	}
315
316	796	return $str;
317		}
318
319		/**
320		* @inheritdoc
321		*/
322	60	public function append($component)
323		{
324	60	return $this->newCollectionInstance(array_merge(
325	60	$this->validateComponent($component)->toArray(),
326	60	$this->toArray()
327	40	));
328		}
329		}
330

thephpleague / uri

Pull Request — master (#58)

Host::__toString() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like