Client::__call() - Code Metrics - Inspection of "Add guzzle via composer" - godbout/alfred-time - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 8d12ff...458df2 )

by Guillaume

created 2017-05-02 09:55 UTC

Client::__call() A

↳ Parent: Client

Complexity

Conditions	4
Paths	5

Size

Total Lines	13
Code Lines	8

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	4
eloc	8
nc	5
nop	2
dl	0
loc	13
rs	9.2
c	0
b	0
f	0

<?php
namespace GuzzleHttp;

use GuzzleHttp\Cookie\CookieJar;
use GuzzleHttp\Promise;
use GuzzleHttp\Psr7;
use Psr\Http\Message\UriInterface;
use Psr\Http\Message\RequestInterface;
use Psr\Http\Message\ResponseInterface;

/**
 * @method ResponseInterface get(string|UriInterface $uri, array $options = [])
 * @method ResponseInterface head(string|UriInterface $uri, array $options = [])
 * @method ResponseInterface put(string|UriInterface $uri, array $options = [])
 * @method ResponseInterface post(string|UriInterface $uri, array $options = [])
 * @method ResponseInterface patch(string|UriInterface $uri, array $options = [])
 * @method ResponseInterface delete(string|UriInterface $uri, array $options = [])
 * @method Promise\PromiseInterface getAsync(string|UriInterface $uri, array $options = [])
 * @method Promise\PromiseInterface headAsync(string|UriInterface $uri, array $options = [])
 * @method Promise\PromiseInterface putAsync(string|UriInterface $uri, array $options = [])
 * @method Promise\PromiseInterface postAsync(string|UriInterface $uri, array $options = [])
 * @method Promise\PromiseInterface patchAsync(string|UriInterface $uri, array $options = [])
 * @method Promise\PromiseInterface deleteAsync(string|UriInterface $uri, array $options = [])
 */
class Client implements ClientInterface
{
    /** @var array Default request options */
    private $config;

    /**
     * Clients accept an array of constructor parameters.
     *
     * Here's an example of creating a client using a base_uri and an array of
     * default request options to apply to each request:
     *
     *     $client = new Client([
     *         'base_uri'        => 'http://www.foo.com/1.0/',
     *         'timeout'         => 0,
     *         'allow_redirects' => false,
     *         'proxy'           => '192.168.16.1:10'
     *     ]);
     *
     * Client configuration settings include the following options:
     *
     * - handler: (callable) Function that transfers HTTP requests over the
     *   wire. The function is called with a Psr7\Http\Message\RequestInterface
     *   and array of transfer options, and must return a
     *   GuzzleHttp\Promise\PromiseInterface that is fulfilled with a
     *   Psr7\Http\Message\ResponseInterface on success. "handler" is a
     *   constructor only option that cannot be overridden in per/request
     *   options. If no handler is provided, a default handler will be created
     *   that enables all of the request options below by attaching all of the
     *   default middleware to the handler.
     * - base_uri: (string|UriInterface) Base URI of the client that is merged
     *   into relative URIs. Can be a string or instance of UriInterface.
     * - **: any request option
     *
     * @param array $config Client configuration settings.
     *
     * @see \GuzzleHttp\RequestOptions for a list of available request options.
     */
    public function __construct(array $config = [])
    {
        if (!isset($config['handler'])) {
            $config['handler'] = HandlerStack::create();
        }

        // Convert the base_uri to a UriInterface
        if (isset($config['base_uri'])) {
            $config['base_uri'] = Psr7\uri_for($config['base_uri']);
        }

        $this->configureDefaults($config);
    }

    public function __call($method, $args)
    {
        if (count($args) < 1) {
            throw new \InvalidArgumentException('Magic request methods require a URI and optional options array');
        }

        $uri = $args[0];
        $opts = isset($args[1]) ? $args[1] : [];

        return substr($method, -5) === 'Async'
            ? $this->requestAsync(substr($method, 0, -5), $uri, $opts)
            : $this->request($method, $uri, $opts);
    }

    public function sendAsync(RequestInterface $request, array $options = [])
    {
        // Merge the base URI into the request URI if needed.
        $options = $this->prepareDefaults($options);

        return $this->transfer(
            $request->withUri($this->buildUri($request->getUri(), $options), $request->hasHeader('Host')),
            $options
        );
    }

    public function send(RequestInterface $request, array $options = [])
    {
        $options[RequestOptions::SYNCHRONOUS] = true;
        return $this->sendAsync($request, $options)->wait();
    }

    public function requestAsync($method, $uri = '', array $options = [])
    {
        $options = $this->prepareDefaults($options);
        // Remove request modifying parameter because it can be done up-front.
        $headers = isset($options['headers']) ? $options['headers'] : [];
        $body = isset($options['body']) ? $options['body'] : null;
        $version = isset($options['version']) ? $options['version'] : '1.1';
        // Merge the URI into the base URI.
        $uri = $this->buildUri($uri, $options);
        if (is_array($body)) {
            $this->invalidBody();
        }
        $request = new Psr7\Request($method, $uri, $headers, $body, $version);
        // Remove the option so that they are not doubly-applied.
        unset($options['headers'], $options['body'], $options['version']);

        return $this->transfer($request, $options);
    }

    public function request($method, $uri = '', array $options = [])
    {
        $options[RequestOptions::SYNCHRONOUS] = true;
        return $this->requestAsync($method, $uri, $options)->wait();
    }

    public function getConfig($option = null)
    {
        return $option === null
            ? $this->config
            : (isset($this->config[$option]) ? $this->config[$option] : null);
    }

    private function buildUri($uri, array $config)
    {
        // for BC we accept null which would otherwise fail in uri_for
        $uri = Psr7\uri_for($uri === null ? '' : $uri);

        if (isset($config['base_uri'])) {
            $uri = Psr7\UriResolver::resolve(Psr7\uri_for($config['base_uri']), $uri);
        }

        return $uri->getScheme() === '' && $uri->getHost() !== '' ? $uri->withScheme('http') : $uri;
    }

    /**
     * Configures the default options for a client.
     *
     * @param array $config
     */
    private function configureDefaults(array $config)
    {
        $defaults = [
            'allow_redirects' => RedirectMiddleware::$defaultSettings,
            'http_errors'     => true,
            'decode_content'  => true,
            'verify'          => true,
            'cookies'         => false
        ];

        // Use the standard Linux HTTP_PROXY and HTTPS_PROXY if set.

        // We can only trust the HTTP_PROXY environment variable in a CLI
        // process due to the fact that PHP has no reliable mechanism to
        // get environment variables that start with "HTTP_".
        if (php_sapi_name() == 'cli' && getenv('HTTP_PROXY')) {
            $defaults['proxy']['http'] = getenv('HTTP_PROXY');
        }

        if ($proxy = getenv('HTTPS_PROXY')) {
            $defaults['proxy']['https'] = $proxy;
        }

        if ($noProxy = getenv('NO_PROXY')) {
            $cleanedNoProxy = str_replace(' ', '', $noProxy);
            $defaults['proxy']['no'] = explode(',', $cleanedNoProxy);
        }

        $this->config = $config + $defaults;

        if (!empty($config['cookies']) && $config['cookies'] === true) {
            $this->config['cookies'] = new CookieJar();
        }

        // Add the default user-agent header.
        if (!isset($this->config['headers'])) {
            $this->config['headers'] = ['User-Agent' => default_user_agent()];
        } else {
            // Add the User-Agent header if one was not already set.
            foreach (array_keys($this->config['headers']) as $name) {
                if (strtolower($name) === 'user-agent') {
                    return;
                }
            }
            $this->config['headers']['User-Agent'] = default_user_agent();
        }
    }

    /**
     * Merges default options into the array.
     *
     * @param array $options Options to modify by reference
     *
     * @return array
     */
    private function prepareDefaults($options)
    {
        $defaults = $this->config;

        if (!empty($defaults['headers'])) {
            // Default headers are only added if they are not present.
            $defaults['_conditional'] = $defaults['headers'];
            unset($defaults['headers']);
        }

        // Special handling for headers is required as they are added as
        // conditional headers and as headers passed to a request ctor.
        if (array_key_exists('headers', $options)) {
            // Allows default headers to be unset.
            if ($options['headers'] === null) {
                $defaults['_conditional'] = null;
                unset($options['headers']);
            } elseif (!is_array($options['headers'])) {
                throw new \InvalidArgumentException('headers must be an array');
            }
        }

        // Shallow merge defaults underneath options.
        $result = $options + $defaults;

        // Remove null values.
        foreach ($result as $k => $v) {
            if ($v === null) {
                unset($result[$k]);
            }
        }

        return $result;
    }

    /**
     * Transfers the given request and applies request options.
     *
     * The URI of the request is not modified and the request options are used
     * as-is without merging in default options.
     *
     * @param RequestInterface $request
     * @param array            $options
     *
     * @return Promise\PromiseInterface
     */
    private function transfer(RequestInterface $request, array $options)
    {
        // save_to -> sink
        if (isset($options['save_to'])) {
            $options['sink'] = $options['save_to'];
            unset($options['save_to']);
        }

        // exceptions -> http_errors
        if (isset($options['exceptions'])) {
            $options['http_errors'] = $options['exceptions'];
            unset($options['exceptions']);
        }

        $request = $this->applyOptions($request, $options);
        $handler = $options['handler'];

        try {
            return Promise\promise_for($handler($request, $options));
        } catch (\Exception $e) {
            return Promise\rejection_for($e);
        }
    }

    /**
     * Applies the array of request options to a request.
     *
     * @param RequestInterface $request
     * @param array            $options
     *
     * @return RequestInterface
     */
    private function applyOptions(RequestInterface $request, array &$options)
    {
        $modify = [];

        if (isset($options['form_params'])) {
            if (isset($options['multipart'])) {
                throw new \InvalidArgumentException('You cannot use '
                    . 'form_params and multipart at the same time. Use the '
                    . 'form_params option if you want to send application/'
                    . 'x-www-form-urlencoded requests, and the multipart '
                    . 'option to send multipart/form-data requests.');
            }
            $options['body'] = http_build_query($options['form_params'], '', '&');
            unset($options['form_params']);
            $options['_conditional']['Content-Type'] = 'application/x-www-form-urlencoded';
        }

        if (isset($options['multipart'])) {
            $options['body'] = new Psr7\MultipartStream($options['multipart']);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
            unset($options['multipart']);
        }

        if (isset($options['json'])) {
            $options['body'] = \GuzzleHttp\json_encode($options['json']);
            unset($options['json']);
            $options['_conditional']['Content-Type'] = 'application/json';
        }

        if (!empty($options['decode_content'])
            && $options['decode_content'] !== true
        ) {
            $modify['set_headers']['Accept-Encoding'] = $options['decode_content'];
        }

        if (isset($options['headers'])) {
            if (isset($modify['set_headers'])) {
                $modify['set_headers'] = $options['headers'] + $modify['set_headers'];
            } else {
                $modify['set_headers'] = $options['headers'];
            }
            unset($options['headers']);
        }

        if (isset($options['body'])) {
            if (is_array($options['body'])) {
                $this->invalidBody();
            }
            $modify['body'] = Psr7\stream_for($options['body']);
            unset($options['body']);
        }

        if (!empty($options['auth']) && is_array($options['auth'])) {
            $value = $options['auth'];
            $type = isset($value[2]) ? strtolower($value[2]) : 'basic';
            switch ($type) {
                case 'basic':
                    $modify['set_headers']['Authorization'] = 'Basic '
                        . base64_encode("$value[0]:$value[1]");
                    break;
                case 'digest':
                    // @todo: Do not rely on curl
                    $options['curl'][CURLOPT_HTTPAUTH] = CURLAUTH_DIGEST;
                    $options['curl'][CURLOPT_USERPWD] = "$value[0]:$value[1]";
                    break;
            }
        }

        if (isset($options['query'])) {
            $value = $options['query'];
            if (is_array($value)) {
                $value = http_build_query($value, null, '&', PHP_QUERY_RFC3986);
            }
            if (!is_string($value)) {
                throw new \InvalidArgumentException('query must be a string or array');
            }
            $modify['query'] = $value;
            unset($options['query']);
        }

        // Ensure that sink is not an invalid value.
        if (isset($options['sink'])) {
            // TODO: Add more sink validation?
            if (is_bool($options['sink'])) {
                throw new \InvalidArgumentException('sink must not be a boolean');
            }
        }

        $request = Psr7\modify_request($request, $modify);
        if ($request->getBody() instanceof Psr7\MultipartStream) {
            // Use a multipart/form-data POST if a Content-Type is not set.
            $options['_conditional']['Content-Type'] = 'multipart/form-data; boundary='
                . $request->getBody()->getBoundary();
        }

        // Merge in conditional headers if they are not present.
        if (isset($options['_conditional'])) {
            // Build up the changes so it's in a single clone of the message.
            $modify = [];
            foreach ($options['_conditional'] as $k => $v) {
                if (!$request->hasHeader($k)) {
                    $modify['set_headers'][$k] = $v;
                }
            }
            $request = Psr7\modify_request($request, $modify);
            // Don't pass this internal value along to middleware/handlers.
            unset($options['_conditional']);
        }

        return $request;
    }

    private function invalidBody()
    {
        throw new \InvalidArgumentException('Passing in the "body" request '
            . 'option as an array to send a POST request has been deprecated. '
            . 'Please use the "form_params" request option to send a '
            . 'application/x-www-form-urlencoded request, or a the "multipart" '
            . 'request option to send a multipart/form-data request.');
    }
}


1			<?php
2			namespace GuzzleHttp;
3
4			use GuzzleHttp\Cookie\CookieJar;
5			use GuzzleHttp\Promise;
6			use GuzzleHttp\Psr7;
7			use Psr\Http\Message\UriInterface;
8			use Psr\Http\Message\RequestInterface;
9			use Psr\Http\Message\ResponseInterface;
10
11			/**
12			* @method ResponseInterface get(string\|UriInterface $uri, array $options = [])
13			* @method ResponseInterface head(string\|UriInterface $uri, array $options = [])
14			* @method ResponseInterface put(string\|UriInterface $uri, array $options = [])
15			* @method ResponseInterface post(string\|UriInterface $uri, array $options = [])
16			* @method ResponseInterface patch(string\|UriInterface $uri, array $options = [])
17			* @method ResponseInterface delete(string\|UriInterface $uri, array $options = [])
18			* @method Promise\PromiseInterface getAsync(string\|UriInterface $uri, array $options = [])
19			* @method Promise\PromiseInterface headAsync(string\|UriInterface $uri, array $options = [])
20			* @method Promise\PromiseInterface putAsync(string\|UriInterface $uri, array $options = [])
21			* @method Promise\PromiseInterface postAsync(string\|UriInterface $uri, array $options = [])
22			* @method Promise\PromiseInterface patchAsync(string\|UriInterface $uri, array $options = [])
23			* @method Promise\PromiseInterface deleteAsync(string\|UriInterface $uri, array $options = [])
24			*/
25			class Client implements ClientInterface
26			{
27			/** @var array Default request options */
28			private $config;
29
30			/**
31			* Clients accept an array of constructor parameters.
32			*
33			* Here's an example of creating a client using a base_uri and an array of
34			* default request options to apply to each request:
35			*
36			* $client = new Client([
37			* 'base_uri' => 'http://www.foo.com/1.0/',
38			* 'timeout' => 0,
39			* 'allow_redirects' => false,
40			* 'proxy' => '192.168.16.1:10'
41			* ]);
42			*
43			* Client configuration settings include the following options:
44			*
45			* - handler: (callable) Function that transfers HTTP requests over the
46			* wire. The function is called with a Psr7\Http\Message\RequestInterface
47			* and array of transfer options, and must return a
48			* GuzzleHttp\Promise\PromiseInterface that is fulfilled with a
49			* Psr7\Http\Message\ResponseInterface on success. "handler" is a
50			* constructor only option that cannot be overridden in per/request
51			* options. If no handler is provided, a default handler will be created
52			* that enables all of the request options below by attaching all of the
53			* default middleware to the handler.
54			* - base_uri: (string\|UriInterface) Base URI of the client that is merged
55			* into relative URIs. Can be a string or instance of UriInterface.
56			* - **: any request option
57			*
58			* @param array $config Client configuration settings.
59			*
60			* @see \GuzzleHttp\RequestOptions for a list of available request options.
61			*/
62			public function __construct(array $config = [])
63			{
64			if (!isset($config['handler'])) {
65			$config['handler'] = HandlerStack::create();
66			}
67
68			// Convert the base_uri to a UriInterface
69			if (isset($config['base_uri'])) {
70			$config['base_uri'] = Psr7\uri_for($config['base_uri']);
71			}
72
73			$this->configureDefaults($config);
74			}
75
76			public function __call($method, $args)
77			{
78			if (count($args) < 1) {
79			throw new \InvalidArgumentException('Magic request methods require a URI and optional options array');
80			}
81
82			$uri = $args[0];
83			$opts = isset($args[1]) ? $args[1] : [];
84
85			return substr($method, -5) === 'Async'
86			? $this->requestAsync(substr($method, 0, -5), $uri, $opts)
87			: $this->request($method, $uri, $opts);
88			}
89
90			public function sendAsync(RequestInterface $request, array $options = [])
91			{
92			// Merge the base URI into the request URI if needed.
93			$options = $this->prepareDefaults($options);
94
95			return $this->transfer(
96			$request->withUri($this->buildUri($request->getUri(), $options), $request->hasHeader('Host')),
97			$options
98			);
99			}
100
101			public function send(RequestInterface $request, array $options = [])
102			{
103			$options[RequestOptions::SYNCHRONOUS] = true;
104			return $this->sendAsync($request, $options)->wait();
105			}
106
107			public function requestAsync($method, $uri = '', array $options = [])
108			{
109			$options = $this->prepareDefaults($options);
110			// Remove request modifying parameter because it can be done up-front.
111			$headers = isset($options['headers']) ? $options['headers'] : [];
112			$body = isset($options['body']) ? $options['body'] : null;
113			$version = isset($options['version']) ? $options['version'] : '1.1';
114			// Merge the URI into the base URI.
115			$uri = $this->buildUri($uri, $options);
116			if (is_array($body)) {
117			$this->invalidBody();
118			}
119			$request = new Psr7\Request($method, $uri, $headers, $body, $version);
120			// Remove the option so that they are not doubly-applied.
121			unset($options['headers'], $options['body'], $options['version']);
122
123			return $this->transfer($request, $options);
124			}
125
126			public function request($method, $uri = '', array $options = [])
127			{
128			$options[RequestOptions::SYNCHRONOUS] = true;
129			return $this->requestAsync($method, $uri, $options)->wait();
130			}
131
132			public function getConfig($option = null)
133			{
134			return $option === null
135			? $this->config
136			: (isset($this->config[$option]) ? $this->config[$option] : null);
137			}
138
139			private function buildUri($uri, array $config)
140			{
141			// for BC we accept null which would otherwise fail in uri_for
142			$uri = Psr7\uri_for($uri === null ? '' : $uri);
143
144			if (isset($config['base_uri'])) {
145			$uri = Psr7\UriResolver::resolve(Psr7\uri_for($config['base_uri']), $uri);
146			}
147
148			return $uri->getScheme() === '' && $uri->getHost() !== '' ? $uri->withScheme('http') : $uri;
149			}
150
151			/**
152			* Configures the default options for a client.
153			*
154			* @param array $config
155			*/
156			private function configureDefaults(array $config)
157			{
158			$defaults = [
159			'allow_redirects' => RedirectMiddleware::$defaultSettings,
160			'http_errors' => true,
161			'decode_content' => true,
162			'verify' => true,
163			'cookies' => false
164			];
165
166			// Use the standard Linux HTTP_PROXY and HTTPS_PROXY if set.
167
168			// We can only trust the HTTP_PROXY environment variable in a CLI
169			// process due to the fact that PHP has no reliable mechanism to
170			// get environment variables that start with "HTTP_".
171			if (php_sapi_name() == 'cli' && getenv('HTTP_PROXY')) {
172			$defaults['proxy']['http'] = getenv('HTTP_PROXY');
173			}
174
175			if ($proxy = getenv('HTTPS_PROXY')) {
176			$defaults['proxy']['https'] = $proxy;
177			}
178
179			if ($noProxy = getenv('NO_PROXY')) {
180			$cleanedNoProxy = str_replace(' ', '', $noProxy);
181			$defaults['proxy']['no'] = explode(',', $cleanedNoProxy);
182			}
183
184			$this->config = $config + $defaults;
185
186			if (!empty($config['cookies']) && $config['cookies'] === true) {
187			$this->config['cookies'] = new CookieJar();
188			}
189
190			// Add the default user-agent header.
191			if (!isset($this->config['headers'])) {
192			$this->config['headers'] = ['User-Agent' => default_user_agent()];
193			} else {
194			// Add the User-Agent header if one was not already set.
195			foreach (array_keys($this->config['headers']) as $name) {
196			if (strtolower($name) === 'user-agent') {
197			return;
198			}
199			}
200			$this->config['headers']['User-Agent'] = default_user_agent();
201			}
202			}
203
204			/**
205			* Merges default options into the array.
206			*
207			* @param array $options Options to modify by reference
208			*
209			* @return array
210			*/
211			private function prepareDefaults($options)
212			{
213			$defaults = $this->config;
214
215			if (!empty($defaults['headers'])) {
216			// Default headers are only added if they are not present.
217			$defaults['_conditional'] = $defaults['headers'];
218			unset($defaults['headers']);
219			}
220
221			// Special handling for headers is required as they are added as
222			// conditional headers and as headers passed to a request ctor.
223			if (array_key_exists('headers', $options)) {
224			// Allows default headers to be unset.
225			if ($options['headers'] === null) {
226			$defaults['_conditional'] = null;
227			unset($options['headers']);
228			} elseif (!is_array($options['headers'])) {
229			throw new \InvalidArgumentException('headers must be an array');
230			}
231			}
232
233			// Shallow merge defaults underneath options.
234			$result = $options + $defaults;
235
236			// Remove null values.
237			foreach ($result as $k => $v) {
238			if ($v === null) {
239			unset($result[$k]);
240			}
241			}
242
243			return $result;
244			}
245
246			/**
247			* Transfers the given request and applies request options.
248			*
249			* The URI of the request is not modified and the request options are used
250			* as-is without merging in default options.
251			*
252			* @param RequestInterface $request
253			* @param array $options
254			*
255			* @return Promise\PromiseInterface
256			*/
257			private function transfer(RequestInterface $request, array $options)
258			{
259			// save_to -> sink
260			if (isset($options['save_to'])) {
261			$options['sink'] = $options['save_to'];
262			unset($options['save_to']);
263			}
264
265			// exceptions -> http_errors
266			if (isset($options['exceptions'])) {
267			$options['http_errors'] = $options['exceptions'];
268			unset($options['exceptions']);
269			}
270
271			$request = $this->applyOptions($request, $options);
272			$handler = $options['handler'];
273
274			try {
275			return Promise\promise_for($handler($request, $options));
276			} catch (\Exception $e) {
277			return Promise\rejection_for($e);
278			}
279			}
280
281			/**
282			* Applies the array of request options to a request.
283			*
284			* @param RequestInterface $request
285			* @param array $options
286			*
287			* @return RequestInterface
288			*/
289			private function applyOptions(RequestInterface $request, array &$options)
290			{
291			$modify = [];
292
293			if (isset($options['form_params'])) {
294			if (isset($options['multipart'])) {
295			throw new \InvalidArgumentException('You cannot use '
296			. 'form_params and multipart at the same time. Use the '
297			. 'form_params option if you want to send application/'
298			. 'x-www-form-urlencoded requests, and the multipart '
299			. 'option to send multipart/form-data requests.');
300			}
301			$options['body'] = http_build_query($options['form_params'], '', '&');
302			unset($options['form_params']);
303			$options['_conditional']['Content-Type'] = 'application/x-www-form-urlencoded';
304			}
305
306			if (isset($options['multipart'])) {
307			$options['body'] = new Psr7\MultipartStream($options['multipart']);
			0 ignored issues – show Documentation introduced 2017-05-02 09:57 UTC by Report Bug Copy Issue Report `$options['multipart']` is of type `string`, but the function expects a `array`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
308			unset($options['multipart']);
309			}
310
311			if (isset($options['json'])) {
312			$options['body'] = \GuzzleHttp\json_encode($options['json']);
313			unset($options['json']);
314			$options['_conditional']['Content-Type'] = 'application/json';
315			}
316
317			if (!empty($options['decode_content'])
318			&& $options['decode_content'] !== true
319			) {
320			$modify['set_headers']['Accept-Encoding'] = $options['decode_content'];
321			}
322
323			if (isset($options['headers'])) {
324			if (isset($modify['set_headers'])) {
325			$modify['set_headers'] = $options['headers'] + $modify['set_headers'];
326			} else {
327			$modify['set_headers'] = $options['headers'];
328			}
329			unset($options['headers']);
330			}
331
332			if (isset($options['body'])) {
333			if (is_array($options['body'])) {
334			$this->invalidBody();
335			}
336			$modify['body'] = Psr7\stream_for($options['body']);
337			unset($options['body']);
338			}
339
340			if (!empty($options['auth']) && is_array($options['auth'])) {
341			$value = $options['auth'];
342			$type = isset($value[2]) ? strtolower($value[2]) : 'basic';
343			switch ($type) {
344			case 'basic':
345			$modify['set_headers']['Authorization'] = 'Basic '
346			. base64_encode("$value[0]:$value[1]");
347			break;
348			case 'digest':
349			// @todo: Do not rely on curl
350			$options['curl'][CURLOPT_HTTPAUTH] = CURLAUTH_DIGEST;
351			$options['curl'][CURLOPT_USERPWD] = "$value[0]:$value[1]";
352			break;
353			}
354			}
355
356			if (isset($options['query'])) {
357			$value = $options['query'];
358			if (is_array($value)) {
359			$value = http_build_query($value, null, '&', PHP_QUERY_RFC3986);
360			}
361			if (!is_string($value)) {
362			throw new \InvalidArgumentException('query must be a string or array');
363			}
364			$modify['query'] = $value;
365			unset($options['query']);
366			}
367
368			// Ensure that sink is not an invalid value.
369			if (isset($options['sink'])) {
370			// TODO: Add more sink validation?
371			if (is_bool($options['sink'])) {
372			throw new \InvalidArgumentException('sink must not be a boolean');
373			}
374			}
375
376			$request = Psr7\modify_request($request, $modify);
377			if ($request->getBody() instanceof Psr7\MultipartStream) {
378			// Use a multipart/form-data POST if a Content-Type is not set.
379			$options['_conditional']['Content-Type'] = 'multipart/form-data; boundary='
380			. $request->getBody()->getBoundary();
381			}
382
383			// Merge in conditional headers if they are not present.
384			if (isset($options['_conditional'])) {
385			// Build up the changes so it's in a single clone of the message.
386			$modify = [];
387			foreach ($options['_conditional'] as $k => $v) {
388			if (!$request->hasHeader($k)) {
389			$modify['set_headers'][$k] = $v;
390			}
391			}
392			$request = Psr7\modify_request($request, $modify);
393			// Don't pass this internal value along to middleware/handlers.
394			unset($options['_conditional']);
395			}
396
397			return $request;
398			}
399
400			private function invalidBody()
401			{
402			throw new \InvalidArgumentException('Passing in the "body" request '
403			. 'option as an array to send a POST request has been deprecated. '
404			. 'Please use the "form_params" request option to send a '
405			. 'application/x-www-form-urlencoded request, or a the "multipart" '
406			. 'request option to send a multipart/form-data request.');
407			}
408			}
409

godbout / alfred-time

Push — master ( 8d12ff...458df2 )

Client::__call() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like