Context Navigation

← Previous Change
Next Change →

Requests.php

Timestamp:

11/25/2021 01:10:30 AM (5 years ago)

Author:

SergeyBiryukov

Message:

External Libraries: Update the Requests library to version 2.0.0.

This is a major release and contains breaking changes.

Most important changes to be aware of for this release:

All code is now namespaced. Though there is a full backward compatibility layer available and the old class names are still supported, using them will generate a deprecation notice (which can be silenced by plugins if they'd need to support multiple WP versions). See the upgrade guide for more details.
A lot of classes have been marked final. This should generally not affect userland code as care has been taken to not apply the final keyword to classes which are known to be extended in userland code.
Extensive input validation has been added to Requests. When Requests is used as documented though, this will be unnoticable.
A new WpOrg\Requests\Requests::has_capabilities() method has been introduced which can be used to address #37708.
A new WpOrg\Requests\Response::decode_body() method has been introduced which may be usable to simplify some of the WP native wrapper code.
Remaining PHP 8.0 compatibility fixed (support for named parameters).
PHP 8.1 compatibility.

Release notes: https://github.com/WordPress/Requests/releases/tag/v2.0.0

For a full list of changes in this update, see the Requests GitHub:
https://github.com/WordPress/Requests/compare/v1.8.1...v2.0.0

Follow-up to [50842], [51078].

Props jrf, schlessera, datagutten, wojsmol, dd32, dustinrue, soulseekah, costdev, szepeviktor.
Fixes #54504.

File:

: 1 copied

trunk/src/wp-includes/Requests/Requests.php (copied) (copied from trunk/src/wp-includes/class-requests.php ) (48 diffs)

Legend:

: Unmodified
: Added
: Removed

trunk/src/wp-includes/Requests/Requests.php

-              r52243
+              r52244
  */
+namespace WpOrg\Requests;
+use WpOrg\Requests\Auth\Basic;
+use WpOrg\Requests\Capability;
+use WpOrg\Requests\Cookie\Jar;
+use WpOrg\Requests\Exception;
+use WpOrg\Requests\Exception\InvalidArgument;
+use WpOrg\Requests\Hooks;
+use WpOrg\Requests\IdnaEncoder;
+use WpOrg\Requests\Iri;
+use WpOrg\Requests\Proxy\Http;
+use WpOrg\Requests\Response;
+use WpOrg\Requests\Transport\Curl;
+use WpOrg\Requests\Transport\Fsockopen;
+use WpOrg\Requests\Utility\InputValidator;
 /**
  * Requests for PHP
 …
         /**
+         * Option defaults.
+         *
+         * @see \WpOrg\Requests\Requests::get_default_options()
+         * @see \WpOrg\Requests\Requests::request() for values returned by this method
+         *
+         * @since 2.0.0
+         *
+         * @var array
+         */
+        const OPTION_DEFAULTS = [
+                'timeout'          => 10,
+                'connect_timeout'  => 10,
+                'useragent'        => 'php-requests/' . self::VERSION,
+                'protocol_version' => 1.1,
+                'redirected'       => 0,
+                'redirects'        => 10,
+                'follow_redirects' => true,
+                'blocking'         => true,
+                'type'             => self::GET,
+                'filename'         => false,
+                'auth'             => false,
+                'proxy'            => false,
+                'cookies'          => false,
+                'max_bytes'        => false,
+                'idn'              => true,
+                'hooks'            => null,
+                'transport'        => null,
+                'verify'           => null,
+                'verifyname'       => true,
+        ];
+        /**
+         * Default supported Transport classes.
+         *
+         * @since 2.0.0
+         *
+         * @var array
+         */
+        const DEFAULT_TRANSPORTS = [
+                Curl::class      => Curl::class,
+                Fsockopen::class => Fsockopen::class,
+        ];
+        /**
          * Current version of Requests
+         *
          * @var string
          */
+        const VERSION = '1.8.1';
+        const VERSION = '2.0.0';
+        /**
+         * Selected transport name
+         *
+         * Use {@see \WpOrg\Requests\Requests::get_transport()} instead
+         *
+         * @var array
+         */
+        public static $transport = [];
         /**
 …
          * @var array
          */
+        protected static $transports = array();
+        /**
+         * Selected transport name
+         *
+         * Use {@see get_transport()} instead
+        protected static $transports = [];
+        /**
+         * Default certificate path.
+         *
+         * @see \WpOrg\Requests\Requests::get_certificate_path()
+         * @see \WpOrg\Requests\Requests::set_certificate_path()
+         *
+         * @var string
+         */
+        protected static $certificate_path = __DIR__ . '/../certificates/cacert.pem';
+        /**
+         * All (known) valid deflate, gzip header magic markers.
+         *
+         * These markers relate to different compression levels.
+         *
+         * @link https://stackoverflow.com/a/43170354/482864 Marker source.
+         *
+         * @since 2.0.0
+         *
          * @var array
          */
+        public static $transport = array();
+        /**
+         * Default certificate path.
+         *
+         * @see Requests::get_certificate_path()
+         * @see Requests::set_certificate_path()
+         *
+         * @var string
+         */
+        protected static $certificate_path;
+        private static $magic_compression_headers = [
+                "\x1f\x8b" => true, // Gzip marker.
+                "\x78\x01" => true, // Zlib marker - level 1.
+                "\x78\x5e" => true, // Zlib marker - level 2 to 5.
+                "\x78\x9c" => true, // Zlib marker - level 6.
+                "\x78\xda" => true, // Zlib marker - level 7 to 9.
+        ];
         /**
 …
         /**
-         * Autoloader for Requests
+         *
-         * Register this with {@see register_autoloader()} if you'd like to avoid
-         * having to create your own.
+         *
-         * (You can also use `spl_autoload_register` directly if you'd prefer.)
+         *
-         * @codeCoverageIgnore
+         *
-         * @param string $class Class name to load
-         */
-        public static function autoloader($class) {
-                // Check that the class starts with "Requests"
-                if (strpos($class, 'Requests') !== 0) {
-                        return;
+                }
-                $file = str_replace('_', '/', $class);
-                if (file_exists(dirname(__FILE__) . '/' . $file . '.php')) {
-                        require_once dirname(__FILE__) . '/' . $file . '.php';
+                }
+        }
-        /**
-         * Register the built-in autoloader
+         *
-         * @codeCoverageIgnore
-         */
-        public static function register_autoloader() {
-                spl_autoload_register(array('Requests', 'autoloader'));
+        }
-        /**
          * Register a transport
+         *
          * @param string $transport Transport class to add, must support the Requests_Transport interface
+         * @param string $transport Transport class to add, must support the \WpOrg\Requests\Transport interface
          */
         public static function add_transport($transport) {
                 if (empty(self::$transports)) {
+                        self::$transports = array(
+                                'Requests_Transport_cURL',
+                                'Requests_Transport_fsockopen',
+                        );
+                }
+                self::$transports = array_merge(self::$transports, array($transport));
+        }
+        /**
+         * Get a working transport
+         *
+         * @throws Requests_Exception If no valid transport is found (`notransport`)
+         * @return Requests_Transport
+         */
+        protected static function get_transport($capabilities = array()) {
+                // Caching code, don't bother testing coverage
+                        self::$transports = self::DEFAULT_TRANSPORTS;
+                }
+                self::$transports[$transport] = $transport;
+        }
+        /**
+         * Get the fully qualified class name (FQCN) for a working transport.
+         *
+         * @param array<string, bool> $capabilities Optional. Associative array of capabilities to test against, i.e. `['<capability>' => true]`.
+         * @return string FQCN of the transport to use, or an empty string if no transport was
+         *                found which provided the requested capabilities.
+         */
+        protected static function get_transport_class(array $capabilities = []) {
+                // Caching code, don't bother testing coverage.
                 // @codeCoverageIgnoreStart
                 // array of capabilities as a string to be used as an array key
+                // Array of capabilities as a string to be used as an array key.
                 ksort($capabilities);
                 $cap_string = serialize($capabilities);
+                // Don't search for a transport if it's already been done for these $capabilities
+                if (isset(self::$transport[$cap_string]) && self::$transport[$cap_string] !== null) {
+                        $class = self::$transport[$cap_string];
+                        return new $class();
+                }
+                // Don't search for a transport if it's already been done for these $capabilities.
+                if (isset(self::$transport[$cap_string])) {
+                        return self::$transport[$cap_string];
+                }
+                // Ensure we will not run this same check again later on.
+                self::$transport[$cap_string] = '';
                 // @codeCoverageIgnoreEnd
                 if (empty(self::$transports)) {
+                        self::$transports = array(
+                                'Requests_Transport_cURL',
+                                'Requests_Transport_fsockopen',
+                        );
+                }
+                // Find us a working transport
+                        self::$transports = self::DEFAULT_TRANSPORTS;
+                }
+                // Find us a working transport.
                 foreach (self::$transports as $class) {
                         if (!class_exists($class)) {
 …
+                        }
                         $result = call_user_func(array($class, 'test'), $capabilities);
                         if ($result) {
+                        $result = $class::test($capabilities);
+                        if ($result === true) {
                                 self::$transport[$cap_string] = $class;
                                 break;
+                        }
+                }
+                if (self::$transport[$cap_string] === null) {
+                        throw new Requests_Exception('No working transports found', 'notransport', self::$transports);
+                }
+                $class = self::$transport[$cap_string];
+                return self::$transport[$cap_string];
+        }
+        /**
+         * Get a working transport.
+         *
+         * @param array<string, bool> $capabilities Optional. Associative array of capabilities to test against, i.e. `['<capability>' => true]`.
+         * @return \WpOrg\Requests\Transport
+         * @throws \WpOrg\Requests\Exception If no valid transport is found (`notransport`).
+         */
+        protected static function get_transport(array $capabilities = []) {
+                $class = self::get_transport_class($capabilities);
+                if ($class === '') {
+                        throw new Exception('No working transports found', 'notransport', self::$transports);
+                }
                 return new $class();
+        }
+        /**
+         * Checks to see if we have a transport for the capabilities requested.
+         *
+         * Supported capabilities can be found in the {@see \WpOrg\Requests\Capability}
+         * interface as constants.
+         *
+         * Example usage:
+         * `Requests::has_capabilities([Capability::SSL => true])`.
+         *
+         * @param array<string, bool> $capabilities Optional. Associative array of capabilities to test against, i.e. `['<capability>' => true]`.
+         * @return bool Whether the transport has the requested capabilities.
+         */
+        public static function has_capabilities(array $capabilities = []) {
+                return self::get_transport_class($capabilities) !== '';
+        }
         /**#@+
          * @see request()
+         * @see \WpOrg\Requests\Requests::request()
          * @param string $url
          * @param array $headers
          * @param array $options
          * @return Requests_Response
+         * @return \WpOrg\Requests\Response
          */
         /**
          * Send a GET request
          */
         public static function get($url, $headers = array(), $options = array()) {
+        public static function get($url, $headers = [], $options = []) {
                 return self::request($url, $headers, null, self::GET, $options);
+        }
 …
          * Send a HEAD request
          */
         public static function head($url, $headers = array(), $options = array()) {
+        public static function head($url, $headers = [], $options = []) {
                 return self::request($url, $headers, null, self::HEAD, $options);
+        }
 …
          * Send a DELETE request
          */
         public static function delete($url, $headers = array(), $options = array()) {
+        public static function delete($url, $headers = [], $options = []) {
                 return self::request($url, $headers, null, self::DELETE, $options);
+        }
 …
          * Send a TRACE request
          */
         public static function trace($url, $headers = array(), $options = array()) {
+        public static function trace($url, $headers = [], $options = []) {
                 return self::request($url, $headers, null, self::TRACE, $options);
+        }
 …
         /**#@+
          * @see request()
+         * @see \WpOrg\Requests\Requests::request()
          * @param string $url
          * @param array $headers
          * @param array $data
          * @param array $options
          * @return Requests_Response
+         * @return \WpOrg\Requests\Response
          */
         /**
          * Send a POST request
          */
         public static function post($url, $headers = array(), $data = array(), $options = array()) {
+        public static function post($url, $headers = [], $data = [], $options = []) {
                 return self::request($url, $headers, $data, self::POST, $options);
+        }
 …
          * Send a PUT request
          */
         public static function put($url, $headers = array(), $data = array(), $options = array()) {
+        public static function put($url, $headers = [], $data = [], $options = []) {
                 return self::request($url, $headers, $data, self::PUT, $options);
+        }
 …
          * Send an OPTIONS request
          */
         public static function options($url, $headers = array(), $data = array(), $options = array()) {
+        public static function options($url, $headers = [], $data = [], $options = []) {
                 return self::request($url, $headers, $data, self::OPTIONS, $options);
+        }
 …
          * Send a PATCH request
+         *
          * Note: Unlike {@see post} and {@see put}, `$headers` is required, as the
          * specification recommends that should send an ETag
+         * Note: Unlike {@see \WpOrg\Requests\Requests::post()} and {@see \WpOrg\Requests\Requests::put()},
+         * `$headers` is required, as the specification recommends that should send an ETag
+         *
          * @link https://tools.ietf.org/html/rfc5789
          */
         public static function patch($url, $headers, $data = array(), $options = array()) {
+        public static function patch($url, $headers, $data = [], $options = []) {
                 return self::request($url, $headers, $data, self::PATCH, $options);
+        }
 …
          * - `auth`: Authentication handler or array of user/password details to use
          *    for Basic authentication
          *    (Requests_Auth|array|boolean, default: false)
+         *    (\WpOrg\Requests\Auth|array|boolean, default: false)
          * - `proxy`: Proxy details to use for proxy by-passing and authentication
          *    (Requests_Proxy|array|string|boolean, default: false)
+         *    (\WpOrg\Requests\Proxy|array|string|boolean, default: false)
          * - `max_bytes`: Limit for the response body size.
          *    (integer|boolean, default: false)
 …
          * - `transport`: Custom transport. Either a class name, or a
          *    transport object. Defaults to the first working transport from
          *    {@see getTransport()}
          *    (string|Requests_Transport, default: {@see getTransport()})
+         *    {@see \WpOrg\Requests\Requests::getTransport()}
+         *    (string|\WpOrg\Requests\Transport, default: {@see \WpOrg\Requests\Requests::getTransport()})
          * - `hooks`: Hooks handler.
          *    (Requests_Hooker, default: new Requests_Hooks())
+         *    (\WpOrg\Requests\HookManager, default: new WpOrg\Requests\Hooks())
          * - `verify`: Should we verify SSL certificates? Allows passing in a custom
          *    certificate file as a string. (Using true uses the system-wide root
          *    certificate store instead, but this may have different behaviour
          *    across transports.)
          *    (string|boolean, default: library/Requests/Transport/cacert.pem)
+         *    (string|boolean, default: certificates/cacert.pem)
          * - `verifyname`: Should we verify the common name in the SSL certificate?
          *    (boolean, default: true)
 …
          *    HEAD/GET/DELETE, 'body' for POST/PUT/OPTIONS/PATCH)
+         *
+         * @throws Requests_Exception On invalid URLs (`nonhttp`)
+         *
+         * @param string $url URL to request
+         * @param string|Stringable $url URL to request
          * @param array $headers Extra headers to send with the request
          * @param array|null $data Data to send either as a query string for GET/HEAD requests, or in the body for POST requests
          * @param string $type HTTP request type (use Requests constants)
          * @param array $options Options for the request (see description for more information)
+         * @return Requests_Response
+         */
+        public static function request($url, $headers = array(), $data = array(), $type = self::GET, $options = array()) {
+         * @return \WpOrg\Requests\Response
+         *
+         * @throws \WpOrg\Requests\Exception\InvalidArgument When the passed $url argument is not a string or Stringable.
+         * @throws \WpOrg\Requests\Exception\InvalidArgument When the passed $type argument is not a string.
+         * @throws \WpOrg\Requests\Exception\InvalidArgument When the passed $options argument is not an array.
+         * @throws \WpOrg\Requests\Exception On invalid URLs (`nonhttp`)
+         */
+        public static function request($url, $headers = [], $data = [], $type = self::GET, $options = []) {
+                if (InputValidator::is_string_or_stringable($url) === false) {
+                        throw InvalidArgument::create(1, '$url', 'string|Stringable', gettype($url));
+                }
+                if (is_string($type) === false) {
+                        throw InvalidArgument::create(4, '$type', 'string', gettype($type));
+                }
+                if (is_array($options) === false) {
+                        throw InvalidArgument::create(5, '$options', 'array', gettype($options));
+                }
                 if (empty($options['type'])) {
                         $options['type'] = $type;
 …
                 self::set_defaults($url, $headers, $data, $type, $options);
                 $options['hooks']->dispatch('requests.before_request', array(&$url, &$headers, &$data, &$type, &$options));
+                $options['hooks']->dispatch('requests.before_request', [&$url, &$headers, &$data, &$type, &$options]);
                 if (!empty($options['transport'])) {
 …
                 else {
                         $need_ssl     = (stripos($url, 'https://') === 0);
                         $capabilities = array('ssl' => $need_ssl);
+                        $capabilities = [Capability::SSL => $need_ssl];
                         $transport    = self::get_transport($capabilities);
+                }
                 $response = $transport->request($url, $headers, $data, $options);
                 $options['hooks']->dispatch('requests.before_parse', array(&$response, $url, $headers, $data, $type, $options));
+                $options['hooks']->dispatch('requests.before_parse', [&$response, $url, $headers, $data, $type, $options]);
                 return self::parse_response($response, $url, $headers, $data, $options);
 …
+         *
          * - `url`: Request URL Same as the `$url` parameter to
          *    {@see Requests::request}
+         *    {@see \WpOrg\Requests\Requests::request()}
          *    (string, required)
          * - `headers`: Associative array of header fields. Same as the `$headers`
          *    parameter to {@see Requests::request}
+         *    parameter to {@see \WpOrg\Requests\Requests::request()}
          *    (array, default: `array()`)
          * - `data`: Associative array of data fields or a string. Same as the
          *    `$data` parameter to {@see Requests::request}
+         *    `$data` parameter to {@see \WpOrg\Requests\Requests::request()}
          *    (array|string, default: `array()`)
          * - `type`: HTTP request type (use Requests constants). Same as the `$type`
          *    parameter to {@see Requests::request}
          *    (string, default: `Requests::GET`)
+         * - `type`: HTTP request type (use \WpOrg\Requests\Requests constants). Same as the `$type`
+         *    parameter to {@see \WpOrg\Requests\Requests::request()}
+         *    (string, default: `\WpOrg\Requests\Requests::GET`)
          * - `cookies`: Associative array of cookie name to value, or cookie jar.
          *    (array|Requests_Cookie_Jar)
+         *    (array|\WpOrg\Requests\Cookie\Jar)
+         *
          * If the `$options` parameter is specified, individual requests will
          * inherit options from it. This can be used to use a single hooking system,
          * or set all the types to `Requests::POST`, for example.
+         * or set all the types to `\WpOrg\Requests\Requests::POST`, for example.
+         *
          * In addition, the `$options` parameter takes the following global options:
+         *
          * - `complete`: A callback for when a request is complete. Takes two
          *    parameters, a Requests_Response/Requests_Exception reference, and the
+         *    parameters, a \WpOrg\Requests\Response/\WpOrg\Requests\Exception reference, and the
          *    ID from the request array (Note: this can also be overridden on a
          *    per-request basis, although that's a little silly)
 …
+         *
          * @param array $requests Requests data (see description for more information)
+         * @param array $options Global and default options (see {@see Requests::request})
+         * @return array Responses (either Requests_Response or a Requests_Exception object)
+         */
+        public static function request_multiple($requests, $options = array()) {
+         * @param array $options Global and default options (see {@see \WpOrg\Requests\Requests::request()})
+         * @return array Responses (either \WpOrg\Requests\Response or a \WpOrg\Requests\Exception object)
+         *
+         * @throws \WpOrg\Requests\Exception\InvalidArgument When the passed $requests argument is not an array or iterable object with array access.
+         * @throws \WpOrg\Requests\Exception\InvalidArgument When the passed $options argument is not an array.
+         */
+        public static function request_multiple($requests, $options = []) {
+                if (InputValidator::has_array_access($requests) === false || InputValidator::is_iterable($requests) === false) {
+                        throw InvalidArgument::create(1, '$requests', 'array|ArrayAccess&Traversable', gettype($requests));
+                }
+                if (is_array($options) === false) {
+                        throw InvalidArgument::create(2, '$options', 'array', gettype($options));
+                }
                 $options = array_merge(self::get_default_options(true), $options);
                 if (!empty($options['hooks'])) {
                         $options['hooks']->register('transport.internal.parse_response', array('Requests', 'parse_multiple'));
+                        $options['hooks']->register('transport.internal.parse_response', [static::class, 'parse_multiple']);
                         if (!empty($options['complete'])) {
                                 $options['hooks']->register('multiple.request.complete', $options['complete']);
 …
                 foreach ($requests as $id => &$request) {
                         if (!isset($request['headers'])) {
                                 $request['headers'] = array();
+                                $request['headers'] = [];
+                        }
                         if (!isset($request['data'])) {
                                 $request['data'] = array();
+                                $request['data'] = [];
+                        }
                         if (!isset($request['type'])) {
 …
                         // Ensure we only hook in once
                         if ($request['options']['hooks'] !== $options['hooks']) {
                                 $request['options']['hooks']->register('transport.internal.parse_response', array('Requests', 'parse_multiple'));
+                                $request['options']['hooks']->register('transport.internal.parse_response', [static::class, 'parse_multiple']);
                                 if (!empty($request['options']['complete'])) {
                                         $request['options']['hooks']->register('multiple.request.complete', $request['options']['complete']);
 …
                                 $request = $requests[$id];
                                 self::parse_multiple($response, $request);
                                 $request['options']['hooks']->dispatch('multiple.request.complete', array(&$response, $id));
+                                $request['options']['hooks']->dispatch('multiple.request.complete', [&$response, $id]);
+                        }
+                }
 …
          * Get the default options
+         *
          * @see Requests::request() for values returned by this method
+         * @see \WpOrg\Requests\Requests::request() for values returned by this method
          * @param boolean $multirequest Is this a multirequest?
          * @return array Default option values
          */
         protected static function get_default_options($multirequest = false) {
+                $defaults = array(
+                        'timeout'          => 10,
+                        'connect_timeout'  => 10,
+                        'useragent'        => 'php-requests/' . self::VERSION,
+                        'protocol_version' => 1.1,
+                        'redirected'       => 0,
+                        'redirects'        => 10,
+                        'follow_redirects' => true,
+                        'blocking'         => true,
+                        'type'             => self::GET,
+                        'filename'         => false,
+                        'auth'             => false,
+                        'proxy'            => false,
+                        'cookies'          => false,
+                        'max_bytes'        => false,
+                        'idn'              => true,
+                        'hooks'            => null,
+                        'transport'        => null,
+                        'verify'           => self::get_certificate_path(),
+                        'verifyname'       => true,
+                );
+                $defaults           = static::OPTION_DEFAULTS;
+                $defaults['verify'] = self::$certificate_path;
                 if ($multirequest !== false) {
                         $defaults['complete'] = null;
 …
          */
         public static function get_certificate_path() {
+                if (!empty(self::$certificate_path)) {
+                        return self::$certificate_path;
+                }
+                return dirname(__FILE__) . '/Requests/Transport/cacert.pem';
+                return self::$certificate_path;
+        }
 …
          * Set default certificate path.
+         *
+         * @param string $path Certificate path, pointing to a PEM file.
+         * @param string|Stringable|bool $path Certificate path, pointing to a PEM file.
+         *
+         * @throws \WpOrg\Requests\Exception\InvalidArgument When the passed $url argument is not a string, Stringable or boolean.
          */
         public static function set_certificate_path($path) {
+                if (InputValidator::is_string_or_stringable($path) === false && is_bool($path) === false) {
+                        throw InvalidArgument::create(1, '$path', 'string|Stringable|bool', gettype($path));
+                }
                 self::$certificate_path = $path;
+        }
 …
          * @param string $type HTTP request type
          * @param array $options Options for the request
+         * @return array $options
+         * @return void $options is updated with the results
+         *
+         * @throws \WpOrg\Requests\Exception When the $url is not an http(s) URL.
          */
         protected static function set_defaults(&$url, &$headers, &$data, &$type, &$options) {
                 if (!preg_match('/^http(s)?:\/\//i', $url, $matches)) {
                         throw new Requests_Exception('Only HTTP(S) requests are handled.', 'nonhttp', $url);
+                        throw new Exception('Only HTTP(S) requests are handled.', 'nonhttp', $url);
+                }
                 if (empty($options['hooks'])) {
                         $options['hooks'] = new Requests_Hooks();
+                        $options['hooks'] = new Hooks();
+                }
                 if (is_array($options['auth'])) {
                         $options['auth'] = new Requests_Auth_Basic($options['auth']);
+                        $options['auth'] = new Basic($options['auth']);
+                }
                 if ($options['auth'] !== false) {
 …
                 if (is_string($options['proxy']) || is_array($options['proxy'])) {
                         $options['proxy'] = new Requests_Proxy_HTTP($options['proxy']);
+                        $options['proxy'] = new Http($options['proxy']);
+                }
                 if ($options['proxy'] !== false) {
 …
                 if (is_array($options['cookies'])) {
                         $options['cookies'] = new Requests_Cookie_Jar($options['cookies']);
+                        $options['cookies'] = new Jar($options['cookies']);
+                }
                 elseif (empty($options['cookies'])) {
                         $options['cookies'] = new Requests_Cookie_Jar();
+                        $options['cookies'] = new Jar();
+                }
                 if ($options['cookies'] !== false) {
 …
                 if ($options['idn'] !== false) {
                         $iri       = new Requests_IRI($url);
                         $iri->host = Requests_IDNAEncoder::encode($iri->ihost);
+                        $iri       = new Iri($url);
+                        $iri->host = IdnaEncoder::encode($iri->ihost);
                         $url       = $iri->uri;
+                }
 …
                 if (!isset($options['data_format'])) {
                         if (in_array($type, array(self::HEAD, self::GET, self::DELETE), true)) {
+                        if (in_array($type, [self::HEAD, self::GET, self::DELETE], true)) {
                                 $options['data_format'] = 'query';
+                        }
 …
         /**
          * HTTP response parser
+         *
-         * @throws Requests_Exception On missing head/body separator (`requests.no_crlf_separator`)
-         * @throws Requests_Exception On missing head/body separator (`noversion`)
-         * @throws Requests_Exception On missing head/body separator (`toomanyredirects`)
+         *
          * @param string $headers Full response text including headers and body
 …
          * @param array $req_data Original $data array passed to {@link request()}, in case we need to follow redirects
          * @param array $options Original $options array passed to {@link request()}, in case we need to follow redirects
+         * @return Requests_Response
+         * @return \WpOrg\Requests\Response
+         *
+         * @throws \WpOrg\Requests\Exception On missing head/body separator (`requests.no_crlf_separator`)
+         * @throws \WpOrg\Requests\Exception On missing head/body separator (`noversion`)
+         * @throws \WpOrg\Requests\Exception On missing head/body separator (`toomanyredirects`)
          */
         protected static function parse_response($headers, $url, $req_headers, $req_data, $options) {
                 $return = new Requests_Response();
+                $return = new Response();
                 if (!$options['blocking']) {
                         return $return;
 …
                         if ($pos === false) {
                                 // Crap!
                                 throw new Requests_Exception('Missing header/body separator', 'requests.no_crlf_separator');
+                                throw new Exception('Missing header/body separator', 'requests.no_crlf_separator');
+                        }
 …
                 preg_match('#^HTTP/(1\.\d)[ \t]+(\d+)#i', array_shift($headers), $matches);
                 if (empty($matches)) {
                         throw new Requests_Exception('Response could not be parsed', 'noversion', $headers);
+                        throw new Exception('Response could not be parsed', 'noversion', $headers);
+                }
                 $return->protocol_version = (float) $matches[1];
 …
+                }
                 $options['hooks']->dispatch('requests.before_redirect_check', array(&$return, $req_headers, $req_data, $options));
+                $options['hooks']->dispatch('requests.before_redirect_check', [&$return, $req_headers, $req_data, $options]);
                 if ($return->is_redirect() && $options['follow_redirects'] === true) {
 …
                                 if (strpos($location, 'http://') !== 0 && strpos($location, 'https://') !== 0) {
                                         // relative redirect, for compatibility make it absolute
                                         $location = Requests_IRI::absolutize($url, $location);
+                                        $location = Iri::absolutize($url, $location);
                                         $location = $location->uri;
+                                }
                                 $hook_args = array(
+                                $hook_args = [
                                         &$location,
                                         &$req_headers,
 …
                                         &$options,
                                         $return,
                                 );
+                                ];
                                 $options['hooks']->dispatch('requests.before_redirect', $hook_args);
                                 $redirected            = self::request($location, $req_headers, $req_data, $options['type'], $options);
 …
+                        }
                         elseif ($options['redirected'] >= $options['redirects']) {
                                 throw new Requests_Exception('Too many redirects', 'toomanyredirects', $return);
+                                throw new Exception('Too many redirects', 'toomanyredirects', $return);
+                        }
+                }
 …
                 $return->redirects = $options['redirected'];
                 $options['hooks']->dispatch('requests.after_request', array(&$return, $req_headers, $req_data, $options));
+                $options['hooks']->dispatch('requests.after_request', [&$return, $req_headers, $req_data, $options]);
                 return $return;
+        }
 …
          * Callback for `transport.internal.parse_response`
+         *
          * Internal use only. Converts a raw HTTP response to a Requests_Response
+         * Internal use only. Converts a raw HTTP response to a \WpOrg\Requests\Response
          * while still executing a multiple request.
+         *
          * @param string $response Full response text including headers and body (will be overwritten with Response instance)
          * @param array $request Request data as passed into {@see Requests::request_multiple()}
          * @return null `$response` is either set to a Requests_Response instance, or a Requests_Exception object
+         * @param array $request Request data as passed into {@see \WpOrg\Requests\Requests::request_multiple()}
+         * @return void `$response` is either set to a \WpOrg\Requests\Response instance, or a \WpOrg\Requests\Exception object
          */
         public static function parse_multiple(&$response, $request) {
 …
                         $response = self::parse_response($response, $url, $headers, $data, $options);
+                }
                 catch (Requests_Exception $e) {
+                catch (Exception $e) {
                         $response = $e;
+                }
 …
          * Decoded a chunked body as per RFC 2616
+         *
          * @see https://tools.ietf.org/html/rfc2616#section-3.6.1
+         * @link https://tools.ietf.org/html/rfc2616#section-3.6.1
          * @param string $data Chunked body
          * @return string Decoded body
 …
          * Convert a key => value array to a 'key: value' array for headers
+         *
          * @param array $array Dictionary of header values
+         * @param iterable $dictionary Dictionary of header values
          * @return array List of headers
+         */
+        public static function flatten($array) {
+                $return = array();
+                foreach ($array as $key => $value) {
+         *
+         * @throws \WpOrg\Requests\Exception\InvalidArgument When the passed argument is not iterable.
+         */
+        public static function flatten($dictionary) {
+                if (InputValidator::is_iterable($dictionary) === false) {
+                        throw InvalidArgument::create(1, '$dictionary', 'iterable', gettype($dictionary));
+                }
+                $return = [];
+                foreach ($dictionary as $key => $value) {
                         $return[] = sprintf('%s: %s', $key, $value);
+                }
                 return $return;
+        }
-        /**
-         * Convert a key => value array to a 'key: value' array for headers
+         *
-         * @codeCoverageIgnore
-         * @deprecated Misspelling of {@see Requests::flatten}
-         * @param array $array Dictionary of header values
-         * @return array List of headers
-         */
-        public static function flattern($array) {
-                return self::flatten($array);
+        }
 …
          * @param string $data Compressed data in one of the above formats
          * @return string Decompressed string
+         *
+         * @throws \WpOrg\Requests\Exception\InvalidArgument When the passed argument is not a string.
          */
         public static function decompress($data) {
+                if (substr($data, 0, 2) !== "\x1f\x8b" && substr($data, 0, 2) !== "\x78\x9c") {
+                if (is_string($data) === false) {
+                        throw InvalidArgument::create(1, '$data', 'string', gettype($data));
+                }
+                if (trim($data) === '') {
+                        // Empty body does not need further processing.
+                        return $data;
+                }
+                $marker = substr($data, 0, 2);
+                if (!isset(self::$magic_compression_headers[$marker])) {
                         // Not actually compressed. Probably cURL ruining this for us.
                         return $data;
 …
                 if (function_exists('gzdecode')) {
-                        // phpcs:ignore PHPCompatibility.FunctionUse.NewFunctions.gzdecodeFound -- Wrapped in function_exists() for PHP 5.2.
                         $decoded = @gzdecode($data);
                         if ($decoded !== false) {
 …
          * https://core.trac.wordpress.org/ticket/18273
+         *
          * @since 2.8.1
+         * @since 1.6.0
          * @link https://core.trac.wordpress.org/ticket/18273
          * @link https://secure.php.net/manual/en/function.gzinflate.php#70875
          * @link https://secure.php.net/manual/en/function.gzinflate.php#77336
+         * @link https://www.php.net/gzinflate#70875
+         * @link https://www.php.net/gzinflate#77336
+         *
          * @param string $gz_data String to decompress.
          * @return string|bool False on failure.
+         *
+         * @throws \WpOrg\Requests\Exception\InvalidArgument When the passed argument is not a string.
          */
         public static function compatible_gzinflate($gz_data) {
+                if (is_string($gz_data) === false) {
+                        throw InvalidArgument::create(1, '$gz_data', 'string', gettype($gz_data));
+                }
+                if (trim($gz_data) === '') {
+                        return false;
+                }
                 // Compressed data might contain a full zlib header, if so strip it for
                 // gzinflate()
 …
                 // byte Huffman marker for gzinflate()
                 // The response is Huffman coded by many compressors such as
                 // java.util.zip.Deflater, Ruby’s Zlib::Deflate, and .NET's
+                // java.util.zip.Deflater, Ruby's Zlib::Deflate, and .NET's
                 // System.IO.Compression.DeflateStream.
                 //
 …
                 return false;
+        }
-        public static function match_domain($host, $reference) {
-                // Check for a direct match
-                if ($host === $reference) {
-                        return true;
+                }
-                // Calculate the valid wildcard match if the host is not an IP address
-                // Also validates that the host has 3 parts or more, as per Firefox's
-                // ruleset.
-                $parts = explode('.', $host);
-                if (ip2long($host) === false && count($parts) >= 3) {
-                        $parts[0] = '*';
-                        $wildcard = implode('.', $parts);
-                        if ($wildcard === $reference) {
-                                return true;
+                        }
+                }
-                return false;
+        }
+}

Note: See TracChangeset for help on using the changeset viewer.

Make WordPress Core

Context Navigation

Changeset 52244 for trunk/src/wp-includes/Requests/Requests.php

Legend:

trunk/src/wp-includes/Requests/Requests.php

Download in other formats: