HttpGetRequest::processRFSOption() - Code Metrics - Inspection of "Removed unused code" - hirak/prestissimo - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#84)

by Hiraku

created 2016-05-03 05:18 UTC

HttpGetRequest::processRFSOption() A

↳ Parent: HttpGetRequest

Complexity

Conditions	2
Paths	2

Size

Total Lines	6
Code Lines	3

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	5
CRAP Score	2

Importance

Changes	1
Bugs	0	Features	0

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

<?php
/*
 * hirak/prestissimo
 * @author Hiraku NAKANO
 * @license MIT https://github.com/hirak/prestissimo
 */
namespace Hirak\Prestissimo;

use Composer\IO;
use Composer\Composer;
use Composer\Downloader;
use Composer\Util\NoProxyPattern;

/**
 * Simple Container for http-get request
 */
class HttpGetRequest
{
    public $origin;
    public $scheme = 'http';
    public $host = 'example.com';
    public $port = 80;
    public $path = '/';

    public $query = array();
    public $headers = array();

    public $curlOpts = array();

    public $username = null;
    public $password = null;

    public $maybePublic = false;
    public $verbose = false;

    /** @internal */
    const TOKEN_LABEL = 'access_token';

    /**
     * normalize url and authentication info
     * @param string $origin domain text
     * @param string $url
     * @param IO\IOInterface $io
     */
    public function __construct($origin, $url, IO\IOInterface $io)
    {
        $this->origin = $origin;
        $this->importURL($url);
        $this->setupProxy();

        if ($this->username && $this->password) {
            $io->setAuthentication($origin, $this->username, $this->password);
        } elseif ($io->hasAuthentication($origin)) {
            $auth = $io->getAuthentication($origin);
            $this->username = $auth['username'];
            $this->password = $auth['password'];
        }
    }

    private function setupProxy()
// Bad
class Router
{
    public function generate($path)
    {
        return $_SERVER['HOST'].$path;
    }
}

// Better
class Router
{
    private $host;

    public function __construct($host)
    {
        $this->host = $host;
    }

    public function generate($path)
    {
        return $this->host.$path;
    }
}

class Controller
{
    public function myAction(Request $request)
    {
        // Instead of
        $page = isset($_GET['page']) ? intval($_GET['page']) : 1;

        // Better (assuming you use the Symfony2 request)
        $page = $request->query->get('page', 1);
    }
}
    {
        // no_proxy skip
        if (isset($_SERVER['no_proxy'])) {
            $pattern = new NoProxyPattern($_SERVER['no_proxy']);
            if ($pattern->test($this->getURL())) {
                unset($this->curlOpts[CURLOPT_PROXY]);
                return;
            }
        }

        $httpProxy = self::issetOr($_SERVER, 'http_proxy', 'HTTP_PROXY');
        if ($httpProxy && $this->scheme === 'http') {
            $this->curlOpts[CURLOPT_PROXY] = $httpProxy;
            return;
        }

        $httpsProxy = self::issetOr($_SERVER, 'https_proxy', 'HTTPS_PROXY');
        if ($httpsProxy && $this->scheme === 'https') {
            $this->curlOpts[CURLOPT_PROXY] = $httpsProxy;
            return;
        }

        unset($this->curlOpts[CURLOPT_PROXY]);
        unset($this->curlOpts[CURLOPT_PROXYUSERPWD]);
    }

    private static function issetOr(array $arr, $key1, $key2)
    {
        if (isset($arr[$key1])) {
            return $arr[$key1];
        }
        if (isset($arr[$key2])) {
            return $arr[$key2];
        }
        return null;
    }

    /**
     * @param string $url
     */
    public function importURL($url)
    {
        $struct = parse_url($url);
        // @codeCoverageIgnoreStart
        if (!$struct) {
            throw new \InvalidArgumentException("$url is not valid URL");
        }
        // @codeCoverageIgnoreEnd

        $this->scheme = self::setOr($struct, 'scheme');
        $this->host = self::setOr($struct, 'host');
        $this->port = self::setOr($struct, 'port');
        $this->path = self::setOr($struct, 'path');
        $this->username = self::setOr($struct, 'user');
        $this->password = self::setOr($struct, 'pass');

        if (!empty($struct['query'])) {
            parse_str($struct['query'], $this->query);
        }
    }


    /**
     * @param array $struct
     * @param string $key
     * @param string $default
     * @return mixed
     */
    private static function setOr(array $struct, $key, $default = null)
    {
        if (!empty($struct[$key])) {
            return $struct[$key];
        }

        return $default;
    }

    /**
     * process option for RemortFileSystem
     * @param array $options
     * @return void
     */
    public function processRFSOption(array $options)
    {
        if (isset($options[static::TOKEN_LABEL])) {
            $this->query['access_token'] = $options[static::TOKEN_LABEL];
        }
    }

    /**
     * @return array
     */
    public function getCurlOpts()
    {
        $headers = $this->headers;
        if ($this->username && $this->password) {
            foreach ($headers as $i => $header) {
                if (0 === strpos($header, 'Authorization:')) {
                    unset($headers[$i]);
                }
            }
            $headers[] = 'Authorization: Basic ' . base64_encode("$this->username:$this->password");
        }

        $curlOpts = $this->curlOpts + array(
            CURLOPT_HTTPGET => true,
            CURLOPT_FOLLOWLOCATION => true,
            CURLOPT_MAXREDIRS => 20,
            CURLOPT_ENCODING => 'gzip',
            CURLOPT_HTTPHEADER => $headers,
            CURLOPT_USERAGENT => $this->genUA(),
            CURLOPT_VERBOSE => (bool)$this->verbose,
            CURLOPT_URL => $this->getUrl(),
        );
        unset($curlOpts[CURLOPT_USERPWD]);

        if ($ciphers = $this->nssCiphers()) {
            $curlOpts[CURLOPT_SSL_CIPHER_LIST] = $ciphers;
        }

        return $curlOpts;
    }

    /**
     * enable ECC cipher suites in cURL/NSS
     */
    public function nssCiphers()
    {
        static $cache;
        if (isset($cache)) {
            return $cache;
        }
        $ver = curl_version();
        if (preg_match('/^NSS.*Basic ECC$/', $ver['ssl_version'])) {
            $ciphers = file(__DIR__ . '/../res/nss_ciphers.txt', \FILE_IGNORE_NEW_LINES | \FILE_SKIP_EMPTY_LINES);
            return $cache = implode(',', $ciphers);
        }
        return $cache = false;
    }

    public function getURL()
    {
        $url = '';
        if ($this->scheme) {
            $url .= "$this->scheme://";
        }
        $url .= $this->host;

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

        $url .= $this->path;

        if ($this->query) {

            $url .= '?' . http_build_query($this->query);
        }

        return $url;
    }

    /**
     * @return string
     */
    public static function genUA()
    {
        static $ua;
        if ($ua) {
            return $ua;
        }
        $phpVersion = defined('HHVM_VERSION') ? 'HHVM ' . HHVM_VERSION : 'PHP ' . PHP_VERSION;

        return $ua = sprintf(
            'Composer/%s (%s; %s; %s)',
            str_replace('@package_version@', 'source', Composer::VERSION),
            php_uname('s'),
            php_uname('r'),
            $phpVersion
        );
    }
}


1		<?php
2		/*
3		* hirak/prestissimo
4		* @author Hiraku NAKANO
5		* @license MIT https://github.com/hirak/prestissimo
6		*/
7		namespace Hirak\Prestissimo;
8
9		use Composer\IO;
10		use Composer\Composer;
11		use Composer\Downloader;
12		use Composer\Util\NoProxyPattern;
13
14		/**
15		* Simple Container for http-get request
16		*/
17		class HttpGetRequest
18		{
19		public $origin;
20		public $scheme = 'http';
21		public $host = 'example.com';
22		public $port = 80;
23		public $path = '/';
24
25		public $query = array();
26		public $headers = array();
27
28		public $curlOpts = array();
29
30		public $username = null;
31		public $password = null;
32
33		public $maybePublic = false;
34		public $verbose = false;
35
36		/** @internal */
37		const TOKEN_LABEL = 'access_token';
38
39		/**
40		* normalize url and authentication info
41		* @param string $origin domain text
42		* @param string $url
43		* @param IO\IOInterface $io
44		*/
45	15	public function __construct($origin, $url, IO\IOInterface $io)
46		{
47	15	$this->origin = $origin;
48	15	$this->importURL($url);
49	15	$this->setupProxy();
50
51	15	if ($this->username && $this->password) {
52	3	$io->setAuthentication($origin, $this->username, $this->password);
53	15	} elseif ($io->hasAuthentication($origin)) {
54	1	$auth = $io->getAuthentication($origin);
55	1	$this->username = $auth['username'];
56	1	$this->password = $auth['password'];
57	1	}
58	15	}
59
60	15	private function setupProxy()
		0 ignored issues – show Coding Style introduced 2016-04-25 16:25 UTC by Report Bug Copy Issue Report `setupProxy` uses the super-global variable `$_SERVER` which is generally not recommended. Instead of super-globals, we recommend to explicitly inject the dependencies of your class. This makes your code less dependent on global state and it becomes generally more testable: // Bad class Router { public function generate($path) { return $_SERVER['HOST'].$path; } } // Better class Router { private $host; public function __construct($host) { $this->host = $host; } public function generate($path) { return $this->host.$path; } } class Controller { public function myAction(Request $request) { // Instead of $page = isset($_GET['page']) ? intval($_GET['page']) : 1; // Better (assuming you use the Symfony2 request) $page = $request->query->get('page', 1); } } Loading history...
61		{
62		// no_proxy skip
63	15	if (isset($_SERVER['no_proxy'])) {
64		$pattern = new NoProxyPattern($_SERVER['no_proxy']);
65		if ($pattern->test($this->getURL())) {
66		unset($this->curlOpts[CURLOPT_PROXY]);
67		return;
68		}
69		}
70
71	15	$httpProxy = self::issetOr($_SERVER, 'http_proxy', 'HTTP_PROXY');
72	15	if ($httpProxy && $this->scheme === 'http') {
73	1	$this->curlOpts[CURLOPT_PROXY] = $httpProxy;
74	1	return;
75		}
76
77	14	$httpsProxy = self::issetOr($_SERVER, 'https_proxy', 'HTTPS_PROXY');
78	14	if ($httpsProxy && $this->scheme === 'https') {
79	1	$this->curlOpts[CURLOPT_PROXY] = $httpsProxy;
80	1	return;
81		}
82
83	13	unset($this->curlOpts[CURLOPT_PROXY]);
84	13	unset($this->curlOpts[CURLOPT_PROXYUSERPWD]);
85	13	}
86
87	15	private static function issetOr(array $arr, $key1, $key2)
88		{
89	15	if (isset($arr[$key1])) {
90	2	return $arr[$key1];
91		}
92	15	if (isset($arr[$key2])) {
93	2	return $arr[$key2];
94		}
95	14	return null;
96		}
97
98		/**
99		* @param string $url
100		*/
101	15	public function importURL($url)
102		{
103	15	$struct = parse_url($url);
104		// @codeCoverageIgnoreStart
105		if (!$struct) {
106		throw new \InvalidArgumentException("$url is not valid URL");
107		}
108		// @codeCoverageIgnoreEnd
109
110	15	$this->scheme = self::setOr($struct, 'scheme');
111	15	$this->host = self::setOr($struct, 'host');
112	15	$this->port = self::setOr($struct, 'port');
113	15	$this->path = self::setOr($struct, 'path');
114	15	$this->username = self::setOr($struct, 'user');
115	15	$this->password = self::setOr($struct, 'pass');
116
117	15	if (!empty($struct['query'])) {
118	3	parse_str($struct['query'], $this->query);
119	3	}
120	15	}
121
122
123		/**
124		* @param array $struct
125		* @param string $key
126		* @param string $default
127		* @return mixed
128		*/
129	15	private static function setOr(array $struct, $key, $default = null)
130		{
131	15	if (!empty($struct[$key])) {
132	15	return $struct[$key];
133		}
134
135	15	return $default;
136		}
137
138		/**
139		* process option for RemortFileSystem
140		* @param array $options
141		* @return void
142		*/
143	2	public function processRFSOption(array $options)
144		{
145	2	if (isset($options[static::TOKEN_LABEL])) {
146	2	$this->query['access_token'] = $options[static::TOKEN_LABEL];
147	2	}
148	2	}
149
150		/**
151		* @return array
152		*/
153	4	public function getCurlOpts()
154		{
155	4	$headers = $this->headers;
156	4	if ($this->username && $this->password) {
157	1	foreach ($headers as $i => $header) {
158		if (0 === strpos($header, 'Authorization:')) {
159		unset($headers[$i]);
160		}
161	1	}
162	1	$headers[] = 'Authorization: Basic ' . base64_encode("$this->username:$this->password");
163	1	}
164
165	4	$curlOpts = $this->curlOpts + array(
166	4	CURLOPT_HTTPGET => true,
167	4	CURLOPT_FOLLOWLOCATION => true,
168	4	CURLOPT_MAXREDIRS => 20,
169	4	CURLOPT_ENCODING => 'gzip',
170	4	CURLOPT_HTTPHEADER => $headers,
171	4	CURLOPT_USERAGENT => $this->genUA(),
172	4	CURLOPT_VERBOSE => (bool)$this->verbose,
173	4	CURLOPT_URL => $this->getUrl(),
174	4	);
175	4	unset($curlOpts[CURLOPT_USERPWD]);
176
177	4	if ($ciphers = $this->nssCiphers()) {
178		$curlOpts[CURLOPT_SSL_CIPHER_LIST] = $ciphers;
179		}
180
181	4	return $curlOpts;
182		}
183
184		/**
185		* enable ECC cipher suites in cURL/NSS
186		*/
187	4	public function nssCiphers()
188		{
189	4	static $cache;
190	4	if (isset($cache)) {
191	3	return $cache;
192		}
193	2	$ver = curl_version();
194	2	if (preg_match('/^NSS.*Basic ECC$/', $ver['ssl_version'])) {
195		$ciphers = file(__DIR__ . '/../res/nss_ciphers.txt', \FILE_IGNORE_NEW_LINES \| \FILE_SKIP_EMPTY_LINES);
196		return $cache = implode(',', $ciphers);
197		}
198	2	return $cache = false;
199		}
200
201	7	public function getURL()
202		{
203	7	$url = '';
204	7	if ($this->scheme) {
205	7	$url .= "$this->scheme://";
206	7	}
207	7	$url .= $this->host;
208
209	7	if ($this->port) {
210	3	$url .= ":$this->port";
211	3	}
212
213	7	$url .= $this->path;
214
215	7	if ($this->query) {
		0 ignored issues – show Bug Best Practice introduced 2016-01-24 02:37 UTC by Report Bug Copy Issue Report The expression `$this->query` of type `array` is implicitly converted to a boolean; are you sure this is intended? If so, consider using `! empty($expr)` instead to make it clear that you intend to check for an array without elements. This check marks implicit conversions of arrays to boolean values in a comparison. While in PHP an empty array is considered to be equal (but not identical) to false, this is not always apparent. Consider making the comparison explicit by using `empty(..)` or `! empty(...)` instead. Loading history...
216	3	$url .= '?' . http_build_query($this->query);
217	3	}
218
219	7	return $url;
220		}
221
222		/**
223		* @return string
224		*/
225	4	public static function genUA()
226		{
227	4	static $ua;
228	4	if ($ua) {
229	3	return $ua;
230		}
231	2	$phpVersion = defined('HHVM_VERSION') ? 'HHVM ' . HHVM_VERSION : 'PHP ' . PHP_VERSION;
232
233	2	return $ua = sprintf(
234	2	'Composer/%s (%s; %s; %s)',
235	2	str_replace('@package_version@', 'source', Composer::VERSION),
236	2	php_uname('s'),
237	2	php_uname('r'),
238		$phpVersion
239	2	);
240		}
241		}
242

hirak / prestissimo

Pull Request — master (#84)

HttpGetRequest::processRFSOption() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like