Url::getPassword() - Code Metrics - Inspection of "Merge branch 'master' of github.com:skolodyazhnyy/..." - skolodyazhnyy/butter-amqplib - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 680f50...da2635 )

by Sergey

created 2016-09-14 22:59 UTC

Url::getPassword() A

↳ Parent: Url

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	2
CRAP Score	1

Importance

Changes

Metric	Value
dl	0
loc	4
ccs	2
cts	2
cp	1
rs	10
c	0
b	0
f	0
cc	1
eloc	2
nc	1
nop	0
crap	1

<?php

namespace ButterAMQP;

class Url
{
    const DEFAULT_SCHEMA = 'amqp';
    const DEFAULT_HOST = 'localhost';
    const DEFAULT_PORT = 5672;
    const DEFAULT_SECURE_PORT = 5671;
    const DEFAULT_USER = 'guest';
    const DEFAULT_VHOST = '/';

    /**
     * @var string
     */
    private $scheme;

    /**
     * @var string
     */
    private $host;

    /**
     * @var int
     */
    private $port;

    /**
     * @var string
     */
    private $user;

    /**
     * @var string
     */
    private $password;

    /**
     * @var string
     */
    private $vhost;

    /**
     * @var array
     */
    private $query = [];

    /**
     * @param string $scheme
     * @param string $host
     * @param int    $port
     * @param string $user
     * @param string $password
     * @param string $vhost
     * @param array  $query
     */
    public function __construct(
        $scheme = null,
        $host = null,
        $port = null,
        $user = null,
        $password = null,
        $vhost = null,
        array $query = []
    ) {
        $this->scheme = $scheme;
        $this->host = $host;
        $this->port = $port;
        $this->user = $user;
        $this->password = $password;
        $this->vhost = $vhost;
        $this->query = $query;
    }

    /**
     * @param string $url
     *
     * @return Url
     *
     * @throws \Exception
     */
    public static function parse($url)
    {
        if (($parts = parse_url($url)) === false) {
            throw new \InvalidArgumentException(sprintf('Invalid URL "%s"', $url));
        }

        $parts = array_merge(self::getParseDefaults(), $parts);

        parse_str($parts['query'], $query);

        return new self(
            urldecode($parts['scheme']),
            urldecode($parts['host']),
            $parts['port'],
            urldecode($parts['user']),
            urldecode($parts['pass']),
            urldecode(substr($parts['path'], 1)),
            $query ?: []
        );
    }

    /**
     * @return array
     */
    private static function getParseDefaults()
    {
        return [
            'scheme' => null,
            'host' => null,
            'port' => null,
            'user' => null,
            'pass' => null,
            'path' => null,
            'query' => '',
        ];
    }

    /**
     * Import URL from an array.
     *
     * @param array $data
     *
     * @return Url
     */
    public static function import(array $data)
    {
        $data = array_merge(self::getImportDefaults(), $data);

        return new self(
            $data['scheme'],
            $data['host'],
            (int) $data['port'],
            $data['user'],
            $data['password'],
            $data['vhost'],
            (array) $data['parameters']
        );
    }

    /**
     * @return array
     */
    private static function getImportDefaults()
    {
        return [
            'scheme' => null,
            'host' => null,
            'port' => null,
            'user' => null,
            'password' => null,
            'vhost' => null,
            'parameters' => [],
        ];
    }

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

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

    /**
     * @return int
     */
    public function getPort()
    {
        if (empty($this->port)) {
            return strcasecmp($this->getScheme(), 'amqps') == 0 ? self::DEFAULT_SECURE_PORT : self::DEFAULT_PORT;
        }

        return $this->port;
    }

    /**
     * @return string
     */
    public function getUser()
    {
        return $this->user === null ? self::DEFAULT_USER : $this->user;
    }

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

    /**
     * @return string
     */
    public function getVhost()
    {
        return $this->vhost ?: self::DEFAULT_VHOST;
    }

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

    /**
     * @param string $key
     * @param mixed  $default
     *
     * @return mixed
     */
    public function getQueryParameter($key, $default = null)
    {
        return isset($this->query[$key]) ? $this->query[$key] : $default;
    }

    /**
     * @param bool $maskPassword
     *
     * @return string
     */
    public function compose($maskPassword = true)
    {
        return sprintf(
            '%s://%s:%s@%s:%d/%s%s',
            urlencode($this->scheme),
            urlencode($this->user),
            $maskPassword ? '******' : urlencode($this->password),
            urlencode($this->host),
            $this->port,
            urlencode($this->vhost),
            $this->query ? '?'.http_build_query($this->query) : ''
        );
    }

    /**
     * Export URL to an array.
     *
     * @return array
     */
    public function export()
    {
        return [
            'scheme' => $this->scheme,
            'host' => $this->host,
            'port' => $this->port,
            'user' => $this->user,
            'password' => $this->password,
            'vhost' => $this->vhost,
            'parameters' => $this->query,
        ];
    }

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


1		<?php
2
3		namespace ButterAMQP;
4
5		class Url
6		{
7		const DEFAULT_SCHEMA = 'amqp';
8		const DEFAULT_HOST = 'localhost';
9		const DEFAULT_PORT = 5672;
10		const DEFAULT_SECURE_PORT = 5671;
11		const DEFAULT_USER = 'guest';
12		const DEFAULT_VHOST = '/';
13
14		/**
15		* @var string
16		*/
17		private $scheme;
18
19		/**
20		* @var string
21		*/
22		private $host;
23
24		/**
25		* @var int
26		*/
27		private $port;
28
29		/**
30		* @var string
31		*/
32		private $user;
33
34		/**
35		* @var string
36		*/
37		private $password;
38
39		/**
40		* @var string
41		*/
42		private $vhost;
43
44		/**
45		* @var array
46		*/
47		private $query = [];
48
49		/**
50		* @param string $scheme
51		* @param string $host
52		* @param int $port
53		* @param string $user
54		* @param string $password
55		* @param string $vhost
56		* @param array $query
57		*/
58	36	public function __construct(
59		$scheme = null,
60		$host = null,
61		$port = null,
62		$user = null,
63		$password = null,
64		$vhost = null,
65		array $query = []
66		) {
67	36	$this->scheme = $scheme;
68	36	$this->host = $host;
69	36	$this->port = $port;
70	36	$this->user = $user;
71	36	$this->password = $password;
72	36	$this->vhost = $vhost;
73	36	$this->query = $query;
74	36	}
75
76		/**
77		* @param string $url
78		*
79	21	* @return Url
80		*
81	21	* @throws \Exception
82		*/
83		public static function parse($url)
84		{
85		if (($parts = parse_url($url)) === false) {
86		throw new \InvalidArgumentException(sprintf('Invalid URL "%s"', $url));
87	21	}
88
89	21	$parts = array_merge(self::getParseDefaults(), $parts);
90
91		parse_str($parts['query'], $query);
92
93		return new self(
94		urldecode($parts['scheme']),
95	21	urldecode($parts['host']),
96		$parts['port'],
97	21	urldecode($parts['user']),
98	18	urldecode($parts['pass']),
99		urldecode(substr($parts['path'], 1)),
100		$query ?: []
101	4	);
102		}
103
104		/**
105		* @return array
106		*/
107	22	private static function getParseDefaults()
108		{
109	22	return [
110		'scheme' => null,
111		'host' => null,
112		'port' => null,
113		'user' => null,
114		'pass' => null,
115	22	'path' => null,
116		'query' => '',
117	22	];
118		}
119
120		/**
121		* Import URL from an array.
122		*
123	21	* @param array $data
124		*
125	21	* @return Url
126		*/
127		public static function import(array $data)
128		{
129		$data = array_merge(self::getImportDefaults(), $data);
130
131	21	return new self(
132		$data['scheme'],
133	21	$data['host'],
134		(int) $data['port'],
135		$data['user'],
136		$data['password'],
137		$data['vhost'],
138		(array) $data['parameters']
139		);
140		}
141
142	19	/**
143		* @return array
144	19	*/
145		private static function getImportDefaults()
146		{
147		return [
148		'scheme' => null,
149		'host' => null,
150		'port' => null,
151		'user' => null,
152		'password' => null,
153		'vhost' => null,
154	35	'parameters' => [],
155		];
156	35	}
157	1
158		/**
159		* @return string
160	34	*/
161		public function getScheme()
162	34	{
163	34	return $this->scheme ?: self::DEFAULT_SCHEMA;
164	34	}
165	34
166	34	/**
167	34	* @return string
168	34	*/
169	34	public function getHost()
170		{
171	34	return $this->host ?: self::DEFAULT_HOST;
172		}
173	34
174		/**
175	34	* @return int
176	34	*/
177	34	public function getPort()
178	34	{
179	34	if (empty($this->port)) {
180	34	return strcasecmp($this->getScheme(), 'amqps') == 0 ? self::DEFAULT_SECURE_PORT : self::DEFAULT_PORT;
181	34	}
182	32
183	34	return $this->port;
184		}
185
186		/**
187		* @return string
188		*/
189		public function getUser()
190		{
191	1	return $this->user === null ? self::DEFAULT_USER : $this->user;
192		}
193	1
194	1	/**
195	1	* @return string
196	1	*/
197	1	public function getPassword()
198	1	{
199	1	return $this->password;
200	1	}
201	1
202	1	/**
203		* @return string
204		*/
205		public function getVhost()
206		{
207		return $this->vhost ?: self::DEFAULT_VHOST;
208		}
209
210		/**
211		* @return array
212	1	*/
213		public function getQuery()
214	1	{
215		return $this->query;
216	1	}
217	1
218	1	/**
219	1	* @param string $key
220	1	* @param mixed $default
221	1	*
222	1	* @return mixed
223	1	*/
224		public function getQueryParameter($key, $default = null)
225	1	{
226		return isset($this->query[$key]) ? $this->query[$key] : $default;
227	1	}
228	1
229	1	/**
230	1	* @param bool $maskPassword
231	1	*
232	1	* @return string
233	1	*/
234	1	public function compose($maskPassword = true)
235	1	{
236		return sprintf(
237		'%s://%s:%s@%s:%d/%s%s',
238		urlencode($this->scheme),
239		urlencode($this->user),
240		$maskPassword ? '******' : urlencode($this->password),
241		urlencode($this->host),
242		$this->port,
243	1	urlencode($this->vhost),
244		$this->query ? '?'.http_build_query($this->query) : ''
245		);
246	1	}
247	1
248	1	/**
249	1	* Export URL to an array.
250	1	*
251	1	* @return array
252	1	*/
253	1	public function export()
254		{
255		return [
256		'scheme' => $this->scheme,
257		'host' => $this->host,
258		'port' => $this->port,
259	1	'user' => $this->user,
260		'password' => $this->password,
261	1	'vhost' => $this->vhost,
262		'parameters' => $this->query,
263		];
264		}
265
266		/**
267		* @return string
268		*/
269		public function __toString()
270		{
271		return $this->compose();
272		}
273		}
274

skolodyazhnyy / butter-amqplib

Push — master ( 680f50...da2635 )

Url::getPassword() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like