Merge pull request #105 from voodoodrul/patch-2

Don't use CURLOPT_CUSTOMREQUEST for POSTs
Merge pull request #106 from Lozzano/master
2016-04-29 19:54:44 -04:00 · 2016-04-25 10:03:29 -04:00 · 2016-04-25 15:02:42 +02:00 · 2016-04-19 23:05:11 -06:00 · 2016-04-19 22:49:27 -06:00 · 2016-04-14 08:33:01 -04:00
25 changed files with 1879 additions and 934 deletions
--- a/.editorconfig
+++ b/.editorconfig
@@ -0,0 +1,16 @@
 # http://editorconfig.org
 root = true
 [*]
 indent_style = space
 indent_size = 4
 end_of_line = lf
 charset = utf-8
 trim_trailing_whitespace = true
 insert_final_newline = true
 [*.{json,xml,yml}]
 indent_size = 2
 [*.{md,yml}]
 trim_trailing_whitespace = false
--- a/.gitignore
+++ b/.gitignore
@@ -1,4 +1,7 @@
 .DS_Store
-/vendor
+.idea
 build
 composer.lock
-composer.phar
+composer.phar
 coverage
 vendor
--- a/.travis.yml
+++ b/.travis.yml
@@ -1,11 +1,39 @@
 sudo: false
 language: php
 php:
-  - 5.3
+  - '5.4'
-  - 5.4
+  - '5.5'
-  - 5.5
+  - '5.6'
  - '7.0'
  - hhvm
 before_script:
-  - sh -c "if [ '$TRAVIS_PHP_VERSION' = '5.2' ]; then wget http://iweb.dl.sourceforge.net/project/simpletest/simpletest/simpletest_1.1/simpletest_1.1.0.tar.gz; tar xf simpletest_1.1.0.tar.gz -C test; else composer install --dev --prefer-source; fi"
+  - composer selfupdate
  - composer install
-script: php test/Unirest.php
+after_script:
  - vendor/bin/test-reporter --stdout > codeclimate.json
  - "curl -X POST -d @codeclimate.json -H 'Content-Type: application/json' -H 'User-Agent: Code Climate (PHP Test Reporter v0.1.1)' https://codeclimate.com/test_reports"
 notifications:
  webhooks:
    urls:
      - https://webhooks.gitter.im/e/802f417bb6e3e1e8b20d
    on_success: always
    on_failure: always
    on_start: false
 matrix:
  fast_finish: true
  allow_failures:
    - php: hhvm
 notifications:
  webhooks:
    urls:
      - https://webhooks.gitter.im/e/d4319553d0aecfd5b9ac
    on_success: always
    on_failure: always
    on_start: false
--- a/2
+++ b/2
@@ -1,6 +1,6 @@
 The MIT License
-Copyright (c) 2013 Mashape (http://mashape.com)
+Copyright (c) 2013-2015 Mashape (https://www.mashape.com)
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the
--- a/README.md
+++ b/README.md
@@ -1,118 +1,279 @@
-<hr>
+# Unirest for PHP [![Build Status][travis-image]][travis-url] [![version][packagist-version]][packagist-url]
 **To the community**: At this time Unirest-PHP only support syncronous requests, and I would really love to implement  asynchronous support. If you guys have any feedback or ideas please comment on issue <a href="https://github.com/Mashape/unirest-php/issues/23">#23</a>.
 <hr>
-# Unirest for PHP [![Build Status](https://api.travis-ci.org/Mashape/unirest-php.png)](https://travis-ci.org/Mashape/unirest-php)
+[![Downloads][packagist-downloads]][packagist-url]
 [![Code Climate][codeclimate-quality]][codeclimate-url]
 [![Coverage Status][codeclimate-coverage]][codeclimate-url]
 [![Dependencies][versioneye-image]][versioneye-url]
 [![Gitter][gitter-image]][gitter-url]
 [![License][packagist-license]][license-url]
-Unirest is a set of lightweight HTTP libraries available in multiple languages, ideal for most applications:
+![][unirest-logo]
-* Make `GET`, `POST`, `PUT`, `PATCH`, `DELETE` requests
+
-* It supports form parameters, file uploads and custom body entities
+[Unirest](http://unirest.io) is a set of lightweight HTTP libraries available in multiple languages, built and maintained by [Mashape](https://github.com/Mashape), who also maintain the open-source API Gateway [Kong](https://github.com/Mashape/kong). 
 ## Features
 * Utility methods to call `GET`, `HEAD`, `POST`, `PUT`, `DELETE`, `CONNECT`, `OPTIONS`, `TRACE`, `PATCH` requests
 * Supports form parameters, file uploads and custom body entities
 * Supports gzip
-* Supports Basic Authentication natively
+* Supports Basic, Digest, Negotiate, NTLM Authentication natively
 * Customizable timeout
 * Customizable default headers for every request (DRY)
 * Automatic JSON parsing into a native object for JSON responses
-Created with love by [thefosk](https://github.com/thefosk) @ [mashape.com](https://mashape.com)
+## Requirements
-### Install with Composer
+- [cURL](http://php.net/manual/en/book.curl.php)
-If you're using [Composer](https://github.com/composer/composer) to manage
+- PHP 5.4+
 dependencies, you can add Unirest with it.
-```javascript
+## Installation
 ### Using [Composer](https://getcomposer.org)
 To install unirest-php with Composer, just add the following to your `composer.json` file:
 ```json
 {
-  "require" : {
+    "require-dev": {
-    "mashape/unirest-php" : "dev-master"
+        "mashape/unirest-php": "3.*"
-  },
+    }
  "autoload": {
    "psr-0": {"Unirest": "lib/"}
  }
 }
 ```
-### Install source from GitHub
+or by running the following command:
 Unirest-PHP requires PHP `v5.3+`. Download the PHP library from Github, and require in your script like so:
-To install the source code:
+```shell
-
+composer require mashape/unirest-php
 ```bash
 $ git clone git@github.com:Mashape/unirest-php.git 
 ```
-And include it in your scripts:
+This will get you the latest version of the reporter and install it. If you do want the master, untagged, version you may use the command below:
-```bash
+```shell
-require_once '/path/to/unirest-php/lib/Unirest.php';
+composer require mashape/php-test-reporter dev-master
 ```
-## Creating Request
+Composer installs autoloader at `./vendor/autoloader.php`. to include the library in your script, add:
 ```php
 require_once 'vendor/autoload.php';
 ```
 If you use Symfony2, autoloader has to be detected automatically.
 *You can see this library on [Packagist](https://packagist.org/packages/mashape/unirest-php).*
 ### Install from source
 Download the PHP library from Github, then include `Unirest.php` in your script:
 ```shell
 git clone git@github.com:Mashape/unirest-php.git 
 ```
 ```php
 require_once '/path/to/unirest-php/src/Unirest.php';
 ```
 ## Usage
 ### Creating a Request
 So you're probably wondering how using Unirest makes creating requests in PHP easier, let's look at a working example:
 ```php
-$response = Unirest::post("http://httpbin.org/post", array( "Accept" => "application/json" ),
+$headers = array('Accept' => 'application/json');
-  array(
+$query = array('foo' => 'hello', 'bar' => 'world');
    "parameter" => 23,
    "foo" => "bar"
  )
 );
-$response->code; // HTTP Status code
+$response = Unirest\Request::post('http://mockbin.com/request', $headers, $query);
-$response->headers; // Headers
+
-$response->body; // Parsed body
+$response->code;        // HTTP Status code
-$response->raw_body; // Unparsed body
+$response->headers;     // Headers
 $response->body;        // Parsed body
 $response->raw_body;    // Unparsed body
 ```
-### File Uploads
+### JSON Requests *(`application/json`)*
-To upload files in a multipart form representation use the return value of `Unirest::file($path)` as the value of a parameter:
+A JSON Request can be constructed using the `Unirest\Request\Body::Json` helper:
 ```php
-$response = Unirest::post("http://httpbin.org/post", array( "Accept" => "application/json" ),
+$headers = array('Accept' => 'application/json');
-  array(
+$data = array('name' => 'ahmad', 'company' => 'mashape');
-    "file" => Unirest::file("/tmp/file.txt") // Tells Unirest where the file is located
+
-  )
+$body = Unirest\Request\Body::json($data);
-);
+
 $response = Unirest\Request::post('http://mockbin.com/request', $headers, $body);
 ```
 **Notes:**
 - `Content-Type` headers will be automatically set to `application/json` 
 - the data variable will be processed through [`json_encode`](http://php.net/manual/en/function.json-encode.php) with default values for arguments.
 - an error will be thrown if the [JSON Extension](http://php.net/manual/en/book.json.php) is not available.
 ### Form Requests *(`application/x-www-form-urlencoded`)*
 A typical Form Request can be constructed using the `Unirest\Request\Body::Form` helper:
 ```php
 $headers = array('Accept' => 'application/json');
 $data = array('name' => 'ahmad', 'company' => 'mashape');
 $body = Unirest\Request\Body::form($data);
 $response = Unirest\Request::post('http://mockbin.com/request', $headers, $body);
 ```
 **Notes:** 
 - `Content-Type` headers will be automatically set to `application/x-www-form-urlencoded`
 - the final data array will be processed through [`http_build_query`](http://php.net/manual/en/function.http-build-query.php) with default values for arguments.
 ### Multipart Requests *(`multipart/form-data`)*
 A Multipart Request can be constructed using the `Unirest\Request\Body::Multipart` helper:
 ```php
 $headers = array('Accept' => 'application/json');
 $data = array('name' => 'ahmad', 'company' => 'mashape');
 $body = Unirest\Request\Body::multipart($data);
 $response = Unirest\Request::post('http://mockbin.com/request', $headers, $body);
 ```
 **Notes:** 
 - `Content-Type` headers will be automatically set to `multipart/form-data`.
 - an auto-generated `--boundary` will be set.
 ### Multipart File Upload
 simply add an array of files as the second argument to to the `Multipart` helper:
 ```php
 $headers = array('Accept' => 'application/json');
 $data = array('name' => 'ahmad', 'company' => 'mashape');
 $files = array('bio' => '/path/to/bio.txt', 'avatar' => '/path/to/avatar.jpg');
 $body = Unirest\Request\Body::multipart($data, $files);
 $response = Unirest\Request::post('http://mockbin.com/request', $headers, $body);
 ```
- 
+
-### Custom Entity Body
+If you wish to further customize the properties of files uploaded you can do so with the `Unirest\Request\Body::File` helper:
-Sending a custom body such as a JSON Object rather than a string or form style parameters we utilize json_encode for the body:
+
 ```php
-$response = Unirest::post("http://httpbin.org/post", array( "Accept" => "application/json" ),
+$headers = array('Accept' => 'application/json');
-  json_encode(
+$body = array(
-    array(
+    'name' => 'ahmad', 
-      "parameter" => "value",
+    'company' => 'mashape'
-      "foo" => "bar"
+    'bio' => Unirest\Request\Body::file('/path/to/bio.txt', 'text/plain'),
-    )
+    'avatar' => Unirest\Request\Body::file('/path/to/my_avatar.jpg', 'text/plain', 'avatar.jpg')
  )
 );
 ```
-### Basic Authentication
+$response = Unirest\Request::post('http://mockbin.com/request', $headers, $body);
 ```
-Authenticating the request with basic authentication can be done by providing the `username` and `password` arguments:
+**Note**: we did not use the `Unirest\Request\Body::multipart` helper in this example, it is not needed when manually adding files.
 ### Custom Body
 Sending a custom body such rather than using the `Unirest\Request\Body` helpers is also possible, for example, using a [`serialize`](http://php.net/manual/en/function.serialize.php) body string with a custom `Content-Type`:
 ```php
-$response = Unirest::get("http://httpbin.org/get", null, null, "username", "password");
+$headers = array('Accept' => 'application/json', 'Content-Type' => 'application/x-php-serialized');
 $body = serialize((array('foo' => 'hello', 'bar' => 'world'));
 $response = Unirest\Request::post('http://mockbin.com/request', $headers, $body);
 ```
-# Request
+### Authentication
 First, if you are using [Mashape][mashape-url]:
 ```php
-Unirest::get($url, $headers = array(), $parameters = NULL, $username = NULL, $password = NULL)
+// Mashape auth
-Unirest::post($url, $headers = array(), $body = NULL, $username = NULL, $password = NULL)
+Unirest\Request::setMashapeKey('<mashape_key>');
-Unirest::put($url, $headers = array(), $body = NULL, $username = NULL, $password = NULL)
+```
-Unirest::patch($url, $headers = array(), $body = NULL, $username = NULL, $password = NULL)
+
-Unirest::delete($url, $headers = array(), $body = NULL, $username = NULL, $password = NULL)
+Otherwise, passing a username, password *(optional)*, defaults to Basic Authentication:
 ```php
 // basic auth
 Unirest\Request::auth('username', 'password');
 ```
 The third parameter, which is a bitmask, will Unirest which HTTP authentication method(s) you want it to use for your proxy authentication.
 If more than one bit is set, Unirest *(at PHP's libcurl level)* will first query the site to see what authentication methods it supports and then pick the best one you allow it to use. *For some methods, this will induce an extra network round-trip.*
 **Supported Methods**
 | Method               | Description                                                                                                                                                                                                     |
 | -------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
 | `CURLAUTH_BASIC`     | HTTP Basic authentication. This is the default choice                                                                                                                                                           | 
 | `CURLAUTH_DIGEST`    | HTTP Digest authentication. as defined in [RFC 2617](http://www.ietf.org/rfc/rfc2617.txt)                                                                                                                       | 
 | `CURLAUTH_DIGEST_IE` | HTTP Digest authentication with an IE flavor. *The IE flavor is simply that libcurl will use a special "quirk" that IE is known to have used before version 7 and that some servers require the client to use.* | 
 | `CURLAUTH_NEGOTIATE` | HTTP Negotiate (SPNEGO) authentication. as defined in [RFC 4559](http://www.ietf.org/rfc/rfc4559.txt)                                                                                                           |
 | `CURLAUTH_NTLM`      | HTTP NTLM authentication. A proprietary protocol invented and used by Microsoft.                                                                                                                                |
 | `CURLAUTH_NTLM_WB`   | NTLM delegating to winbind helper. Authentication is performed by a separate binary application. *see [libcurl docs](http://curl.haxx.se/libcurl/c/CURLOPT_HTTPAUTH.html) for more info*                        | 
 | `CURLAUTH_ANY`       | This is a convenience macro that sets all bits and thus makes libcurl pick any it finds suitable. libcurl will automatically select the one it finds most secure.                                               |
 | `CURLAUTH_ANYSAFE`   | This is a convenience macro that sets all bits except Basic and thus makes libcurl pick any it finds suitable. libcurl will automatically select the one it finds most secure.                                  |
 | `CURLAUTH_ONLY`      | This is a meta symbol. OR this value together with a single specific auth value to force libcurl to probe for un-restricted auth and if not, only that single auth algorithm is acceptable.                     |
 ```php
 // custom auth method
 Unirest\Request::proxyAuth('username', 'password', CURLAUTH_DIGEST);
 ```
 Previous versions of **Unirest** support *Basic Authentication* by providing the `username` and `password` arguments:
 ```php
 $response = Unirest\Request::get('http://mockbin.com/request', null, null, 'username', 'password');
 ```
 **This has been deprecated, and will be completely removed in `v.3.0.0` please use the `Unirest\Request::auth()` method instead**
 ### Cookies
 Set a cookie string to specify the contents of a cookie header. Multiple cookies are separated with a semicolon followed by a space (e.g., "fruit=apple; colour=red")
 ```php
 Unirest\Request::cookie($cookie)
 ```
 Set a cookie file path for enabling cookie reading and storing cookies across multiple sequence of requests.
 ```php
 Unirest\Request::cookieFile($cookieFile)
 ```
 `$cookieFile` must be a correct path with write permission.
 ### Request Object
 ```php
 Unirest\Request::get($url, $headers = array(), $parameters = null)
 Unirest\Request::post($url, $headers = array(), $body = null)
 Unirest\Request::put($url, $headers = array(), $body = null)
 Unirest\Request::patch($url, $headers = array(), $body = null)
 Unirest\Request::delete($url, $headers = array(), $body = null)
 ```
 - `url` - Endpoint, address, or uri to be acted upon and requested information from.
 - `headers` - Request Headers as associative array or object
 - `body` - Request Body as associative array or object
 - `username` - Basic Authentication username
 - `password` - Basic Authentication password
-# Response
+You can send a request with any [standard](http://www.iana.org/assignments/http-methods/http-methods.xhtml) or custom HTTP Method:
 ```php
 Unirest\Request::send(Unirest\Method::LINK, $url, $headers = array(), $body);
 Unirest\Request::send('CHECKOUT', $url, $headers = array(), $body);
 ```
 ### Response Object
 Upon recieving a response Unirest returns the result in the form of an Object, this object should always have the same keys for each language regarding to the response details.
 - `code` - HTTP Response Status Code (Example `200`)
@@ -120,39 +281,159 @@ Upon recieving a response Unirest returns the result in the form of an Object, t
 - `body` - Parsed response body where applicable, for example JSON responses are parsed to Objects / Associative Arrays.
 - `raw_body` - Un-parsed response body
-# Advanced Configuration
+### Advanced Configuration
 You can set some advanced configuration to tune Unirest-PHP:
-### Timeout
+#### Custom JSON Decode Flags
 Unirest uses PHP's [JSON Extension](http://php.net/manual/en/book.json.php) for automatically decoding JSON responses.
 sometime you may want to return associative arrays, limit the depth of recursion, or use any of the [customization flags](http://php.net/manual/en/json.constants.php).
 To do so, simply set the desired options using the `jsonOpts` request method:
 ```php
 Unirest\Request::jsonOpts(true, 512, JSON_NUMERIC_CHECK & JSON_FORCE_OBJECT & JSON_UNESCAPED_SLASHES);
 ```
 #### Timeout
 You can set a custom timeout value (in **seconds**):
 ```php
-Unirest::timeout(5); // 5s timeout
+Unirest\Request::timeout(5); // 5s timeout
 ```
-### Default Request Headers
+#### Proxy
 Set the proxy to use for the upcoming request.
 you can also set the proxy type to be one of `CURLPROXY_HTTP`, `CURLPROXY_HTTP_1_0`, `CURLPROXY_SOCKS4`, `CURLPROXY_SOCKS5`, `CURLPROXY_SOCKS4A`, and `CURLPROXY_SOCKS5_HOSTNAME`.
 *check the [cURL docs](http://curl.haxx.se/libcurl/c/CURLOPT_PROXYTYPE.html) for more info*.
 ```php
 // quick setup with default port: 1080
 Unirest\Request::proxy('10.10.10.1');
 // custom port and proxy type
 Unirest\Request::proxy('10.10.10.1', 8080, CURLPROXY_HTTP);
 // enable tunneling
 Unirest\Request::proxy('10.10.10.1', 8080, CURLPROXY_HTTP, true);
 ```
 ##### Proxy Authenticaton
 Passing a username, password *(optional)*, defaults to Basic Authentication:
 ```php
 // basic auth
 Unirest\Request::proxyAuth('username', 'password');
 ```
 The third parameter, which is a bitmask, will Unirest which HTTP authentication method(s) you want it to use for your proxy authentication. 
 If more than one bit is set, Unirest *(at PHP's libcurl level)* will first query the site to see what authentication methods it supports and then pick the best one you allow it to use. *For some methods, this will induce an extra network round-trip.*
 See [Authentication](#authentication) for more details on methods supported.
 ```php
 // basic auth
 Unirest\Request::proxyAuth('username', 'password', CURLAUTH_DIGEST);
 ```
 #### Default Request Headers
 You can set default headers that will be sent on every request:
 ```php
-Unirest::defaultHeader("Header1", "Value1");
+Unirest\Request::defaultHeader('Header1', 'Value1');
-Unirest::defaultHeader("Header2", "Value2");
+Unirest\Request::defaultHeader('Header2', 'Value2');
 ```
 You can set default headers in bulk by passing an array:
 ```php
 Unirest\Request::defaultHeaders(array(
    'Header1' => 'Value1',
    'Header2' => 'Value2'
 ));
 ```
 You can clear the default headers anytime with:
 ```php
-Unirest::clearDefaultHeaders();
+Unirest\Request::clearDefaultHeaders();
 ```
-### SSL validation
+#### Default cURL Options
 You can set default [cURL options](http://php.net/manual/en/function.curl-setopt.php) that will be sent on every request:
 ```php
 Unirest\Request::curlOpt(CURLOPT_COOKIE, 'foo=bar');
 ```
 You can set options bulk by passing an array:
 ```php
 Unirest\Request::curlOpts(array(
    CURLOPT_COOKIE => 'foo=bar'
 ));
 ```
 You can clear the default options anytime with:
 ```php
 Unirest\Request::clearCurlOpts();
 ```
 #### SSL validation
 You can explicitly enable or disable SSL certificate validation when consuming an SSL protected endpoint:
 ```php
-Unirest::verifyPeer(false); // Disables SSL cert validation
+Unirest\Request::verifyPeer(false); // Disables SSL cert validation
 ```
 By default is `true`.
 #### Utility Methods
 ```php
 // alias for `curl_getinfo`
 Unirest\Request::getInfo()
 // returns internal cURL handle
 Unirest\Request::getCurlHandle()
 ```
 ----
 Made with &#9829; from the [Mashape][mashape-url] team
 [unirest-logo]: http://cl.ly/image/2P373Y090s2O/Image%202015-10-12%20at%209.48.06%20PM.png
 [mashape-url]: https://www.mashape.com/
 [license-url]: https://github.com/Mashape/unirest-php/blob/master/LICENSE
 [gitter-url]: https://gitter.im/Mashape/unirest-php
 [gitter-image]: https://img.shields.io/badge/Gitter-Join%20Chat-blue.svg?style=flat
 [travis-url]: https://travis-ci.org/Mashape/unirest-php
 [travis-image]: https://img.shields.io/travis/Mashape/unirest-php.svg?style=flat
 [packagist-url]: https://packagist.org/packages/Mashape/unirest-php
 [packagist-license]: https://img.shields.io/packagist/l/Mashape/unirest-php.svg?style=flat
 [packagist-version]: https://img.shields.io/packagist/v/Mashape/unirest-php.svg?style=flat
 [packagist-downloads]: https://img.shields.io/packagist/dm/Mashape/unirest-php.svg?style=flat
 [codeclimate-url]: https://codeclimate.com/github/Mashape/unirest-php
 [codeclimate-quality]: https://img.shields.io/codeclimate/github/Mashape/unirest-php.svg?style=flat
 [codeclimate-coverage]: https://img.shields.io/codeclimate/coverage/github/Mashape/unirest-php.svg?style=flat
 [versioneye-url]: https://www.versioneye.com/user/projects/54b82450050646ca5c0001f3
 [versioneye-image]: https://img.shields.io/versioneye/d/php/mashape:unirest-php.svg?style=flat
--- a/composer.json
+++ b/composer.json
@@ -1,31 +1,28 @@
 {
-    "name" : "mashape/unirest-php",
+  "name": "mashape/unirest-php",
-    "description" : "Unirest PHP",
+  "description": "Unirest PHP",
-    "keywords" : ["rest", "curl", "http", "client"],
+  "keywords": ["rest", "curl", "http", "https", "client"],
-    "type" : "library",
+  "type": "library",
-    "homepage" : "https://github.com/Mashape/unirest-php",
+  "homepage": "https://github.com/Mashape/unirest-php",
-    "license" : "MIT",
+  "license": "MIT",
-    "authors" : [
+  "author": "Mashape <opensource@mashape.com> (https://www.mashape.com)",
-        {
+  "require": {
-            "name" : "Mashape",
+    "php": ">=5.4.0",
-            "email" : "support@mashape.com",
+    "ext-curl": "*"
-            "homepage" : "http://mashape.com"
+  },
-        }
+  "suggest": {
-    ],
+    "ext-json": "Allows using JSON Bodies for sending and parsing requests"
-    "require" : {
+  },
-        "php" : ">=5.3.0",
+  "require-dev": {
-        "ext-curl" : "*",
+    "phpunit/phpunit": "~4.4",
-        "ext-json" : "*"
+    "codeclimate/php-test-reporter": "0.1.*"
-    },
+  },
-    "require-dev": {
+  "autoload": {
-        "vierbergenlars/simpletest": "*"
+    "psr-0": {
-    },
+      "Unirest": "src"
    "autoload" : {
        "psr-0" : {
            "Unirest" : "lib"
        }
    },
    "support" : {
        "email" : "support@mashape.com"
    }
-}
+  },
  "support": {
    "email": "opensource@mashape.com"
  }
 }
--- a/lib/Unirest.php
+++ b/lib/Unirest.php
@@ -1,7 +0,0 @@
 <?php
 require(dirname(__FILE__) . '/Unirest/HttpMethod.php');
 require(dirname(__FILE__) . '/Unirest/HttpResponse.php');
 require(dirname(__FILE__) . '/Unirest/Unirest.php');
 ?>
--- a/lib/Unirest/HttpMethod.php
+++ b/lib/Unirest/HttpMethod.php
@@ -1,14 +0,0 @@
 <?php
 namespace Unirest;
 interface HttpMethod
 {
    const DELETE = "DELETE";
    const GET = "GET";
    const POST = "POST";
    const PUT = "PUT";
    const PATCH = "PATCH";
 }
--- a/lib/Unirest/HttpResponse.php
+++ b/lib/Unirest/HttpResponse.php
@@ -1,77 +0,0 @@
 <?php
 namespace Unirest;
 class HttpResponse
 {
    private $code;
    private $raw_body;
    private $body;
    private $headers;
    /**
     * @param int $code response code of the cURL request
     * @param string $raw_body the raw body of the cURL response
     * @param string $headers raw header string from cURL response
     */
    public function __construct($code, $raw_body, $headers)
    {
        $this->code     = $code;
        $this->headers  = $this->get_headers_from_curl_response($headers);
        $this->raw_body = $raw_body;
        $this->body     = $raw_body;
        $json           = json_decode($raw_body);
        if (json_last_error() == JSON_ERROR_NONE) {
            $this->body = $json;
        }
    }
    /**
     * Return a property of the response if it exists.
     * Possibilities include: code, raw_body, headers, body (if the response is json-decodable)
     * @return mixed
     */
    public function __get($property)
    {
        if (property_exists($this, $property)) {
            return $this->$property;
        }
    }
    /**
     * Set the properties of this object
     * @param string $property the property name
     * @param mixed $value the property value
     */
    public function __set($property, $value)
    {
        if (property_exists($this, $property)) {
            $this->$property = $value;
        }
        return $this;
    }
    /**
     * Retrieve the cURL response headers from the
     * header string and convert it into an array
     * @param  string $headers header string from cURL response
     * @return array
     */
    private function get_headers_from_curl_response($headers)
    {
        $headers = explode("\r\n", $headers);
        array_shift($headers);
        foreach ($headers as $line) {
            if (strstr($line, ': ')) {
                list($key, $value) = explode(': ', $line);
                $result[$key] = $value;
            }
        }
        return $result;
    }
 }
--- a/lib/Unirest/Unirest.php
+++ b/lib/Unirest/Unirest.php
@@ -1,319 +0,0 @@
 <?php
 use Unirest\HttpMethod;
 use Unirest\HttpResponse;
 class Unirest
 {
    private static $verifyPeer = true;
    private static $socketTimeout = null;
    private static $defaultHeaders = array();
    /**
     * Verify SSL peer
     * @param bool $enabled enable SSL verification, by default is true
     */
    public static function verifyPeer($enabled)
    {
        Unirest::$verifyPeer = $enabled;
    }
    /**
     * Set a timeout
     * @param integer $seconds timeout value in seconds
     */
    public static function timeout($seconds)
    {
        Unirest::$socketTimeout = $seconds;
    }
    /**
     * Set a new default header to send on every request
     * @param string $name header name
     * @param string $value header value
     */
    public static function defaultHeader($name, $value)
    {
        Unirest::$defaultHeaders[$name] = $value;
    }
    /**
     * Clear all the default headers
     */
    public static function clearDefaultHeaders()
    {
        Unirest::$defaultHeaders = array();
    }
    /**
     * Send a GET request to a URL
     * @param string $url URL to send the GET request to
     * @param array $headers additional headers to send
     * @param mixed $parameters parameters to send in the querystring
     * @param string $username Basic Authentication username
     * @param string $password Basic Authentication password
     * @return string|stdObj response string or stdObj if response is json-decodable
     */
    public static function get($url, $headers = array(), $parameters = NULL, $username = NULL, $password = NULL)
    {
        return Unirest::request(HttpMethod::GET, $url, $parameters, $headers, $username, $password);
    }
    /**
     * Send POST request to a URL
     * @param string $url URL to send the POST request to
     * @param array $headers additional headers to send
     * @param mixed $body POST body data
     * @param string $username Basic Authentication username
     * @param string $password Basic Authentication password
     * @return string|stdObj response string or stdObj if response is json-decodable
     */
    public static function post($url, $headers = array(), $body = NULL, $username = NULL, $password = NULL)
    {
        return Unirest::request(HttpMethod::POST, $url, $body, $headers, $username, $password);
    }
    /**
     * Send DELETE request to a URL
     * @param string $url URL to send the DELETE request to
     * @param array $headers additional headers to send
     * @param mixed $body DELETE body data
     * @param string $username Basic Authentication username
     * @param string $password Basic Authentication password
     * @return string|stdObj response string or stdObj if response is json-decodable
     */
    public static function delete($url, $headers = array(), $body = NULL, $username = NULL, $password = NULL)
    {
        return Unirest::request(HttpMethod::DELETE, $url, $body, $headers, $username, $password);
    }
    /**
     * Send PUT request to a URL
     * @param string $url URL to send the PUT request to
     * @param array $headers additional headers to send
     * @param mixed $body PUT body data
     * @param string $username Basic Authentication username
     * @param string $password Basic Authentication password
     * @return string|stdObj response string or stdObj if response is json-decodable
     */
    public static function put($url, $headers = array(), $body = NULL, $username = NULL, $password = NULL)
    {
        return Unirest::request(HttpMethod::PUT, $url, $body, $headers, $username, $password);
    }
    /**
     * Send PATCH request to a URL
     * @param string $url URL to send the PATCH request to
     * @param array $headers additional headers to send
     * @param mixed $body PATCH body data
     * @param string $username Basic Authentication username
     * @param string $password Basic Authentication password
     * @return string|stdObj response string or stdObj if response is json-decodable
     */
    public static function patch($url, $headers = array(), $body = NULL, $username = NULL, $password = NULL)
    {
        return Unirest::request(HttpMethod::PATCH, $url, $body, $headers, $username, $password);
    }
    /**
     * Prepares a file for upload. To be used inside the parameters declaration for a request.
     * @param string $path The file path
     */
    public static function file($path)
    {
        if (function_exists("curl_file_create")) {
            return curl_file_create($path);
        } else {
            return "@" . $path;
        }
    }
    /**
     * This function is useful for serializing multidimensional arrays, and avoid getting
     * the "Array to string conversion" notice
     */
    public static function http_build_query_for_curl($arrays, &$new = array(), $prefix = null)
    {
        if (is_object($arrays)) {
            $arrays = get_object_vars($arrays);
        }
        foreach ($arrays AS $key => $value) {
            $k = isset($prefix) ? $prefix . '[' . $key . ']' : $key;
            if (!$value instanceof \CURLFile AND (is_array($value) OR is_object($value))) {
                Unirest::http_build_query_for_curl($value, $new, $k);
            } else {
                $new[$k] = $value;
            }
        }
    }
    /**
     * Send a cURL request
     * @param string $httpMethod HTTP method to use (based off \Unirest\HttpMethod constants)
     * @param string $url URL to send the request to
     * @param mixed $body request body
     * @param array $headers additional headers to send
     * @param string $username  Basic Authentication username
     * @param string $password  Basic Authentication password
     * @throws Exception if a cURL error occurs
     * @return HttpResponse
     */
    private static function request($httpMethod, $url, $body = NULL, $headers = array(), $username = NULL, $password = NULL)
    {
        if ($headers == NULL)
            $headers = array();
        $lowercaseHeaders = array();
        $finalHeaders = array_merge($headers, Unirest::$defaultHeaders);
        foreach ($finalHeaders as $key => $val) {
            $lowercaseHeaders[] = Unirest::getHeader($key, $val);
        }
        $lowerCaseFinalHeaders = array_change_key_case($finalHeaders);
        if (!array_key_exists("user-agent", $lowerCaseFinalHeaders)) {
            $lowercaseHeaders[] = "user-agent: unirest-php/1.1";
        }
        if (!array_key_exists("expect", $lowerCaseFinalHeaders)) {
            $lowercaseHeaders[] = "expect:";
        }
        $ch = curl_init();
        if ($httpMethod != HttpMethod::GET) {
            curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $httpMethod);
            if (is_array($body) || $body instanceof Traversable) {
                Unirest::http_build_query_for_curl($body, $postBody);
                curl_setopt($ch, CURLOPT_POSTFIELDS, $postBody);
            } else {
                curl_setopt($ch, CURLOPT_POSTFIELDS, $body);
            }
        } else if (is_array($body)) {
            if (strpos($url, '?') !== false) {
                $url .= "&";
            } else {
                $url .= "?";
            }
            Unirest::http_build_query_for_curl($body, $postBody);
            $url .= urldecode(http_build_query($postBody));
        }
        curl_setopt($ch, CURLOPT_URL, Unirest::encodeUrl($url));
        curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
        curl_setopt($ch, CURLOPT_FOLLOWLOCATION, true);
        curl_setopt($ch, CURLOPT_MAXREDIRS, 10);
        curl_setopt($ch, CURLOPT_HTTPHEADER, $lowercaseHeaders);
        curl_setopt($ch, CURLOPT_HEADER, true);
        curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, Unirest::$verifyPeer);
        curl_setopt($ch, CURLOPT_ENCODING, ""); // If an empty string, "", is set, a header containing all supported encoding types is sent.
        if (Unirest::$socketTimeout != null) {
            curl_setopt($ch, CURLOPT_TIMEOUT, Unirest::$socketTimeout);
        }
        if (!empty($username)) {
            curl_setopt($ch, CURLOPT_USERPWD, $username . ":" . ((empty($password)) ? "" : $password));
        }
        $response = curl_exec($ch);
        $error    = curl_error($ch);
        if ($error) {
            throw new Exception($error);
        }
        // Split the full response in its headers and body
        $curl_info   = curl_getinfo($ch);
        $header_size = $curl_info["header_size"];
        $header      = substr($response, 0, $header_size);
        $body        = substr($response, $header_size);
        $httpCode    = $curl_info["http_code"];
        return new HttpResponse($httpCode, $body, $header);
    }
    private static function getArrayFromQuerystring($querystring)
    {
        $pairs = explode("&", $querystring);
        $vars  = array();
        foreach ($pairs as $pair) {
            $nv          = explode("=", $pair, 2);
            $name        = $nv[0];
            $value       = $nv[1];
            $vars[$name] = $value;
        }
        return $vars;
    }
    /**
     * Ensure that a URL is encoded and safe to use with cURL
     * @param  string $url URL to encode
     * @return string
     */
    private static function encodeUrl($url)
    {
        $url_parsed = parse_url($url);
        $scheme = $url_parsed['scheme'] . '://';
        $host   = $url_parsed['host'];
        $port   = (isset($url_parsed['port']) ? $url_parsed['port'] : null);
        $path   = (isset($url_parsed['path']) ? $url_parsed['path'] : null);
        $query  = (isset($url_parsed['query']) ? $url_parsed['query'] : null);
        if ($query != null) {
            $query = '?' . http_build_query(Unirest::getArrayFromQuerystring($url_parsed['query']));
        }
        if ($port && $port[0] != ":")
            $port = ":" . $port;
        $result = $scheme . $host . $port . $path . $query;
        return $result;
    }
    private static function getHeader($key, $val)
    {
        $key = trim(strtolower($key));
        return $key . ": " . $val;
    }
 }
 if (!function_exists('http_chunked_decode')) {
    /**
     * Dechunk an http 'transfer-encoding: chunked' message 
     * @param string $chunk the encoded message 
     * @return string the decoded message
     */
    function http_chunked_decode($chunk)
    {
        $pos     = 0;
        $len     = strlen($chunk);
        $dechunk = null;
        while (($pos < $len) && ($chunkLenHex = substr($chunk, $pos, ($newlineAt = strpos($chunk, "\n", $pos + 1)) - $pos))) {
            if (!is_hex($chunkLenHex)) {
                trigger_error('Value is not properly chunk encoded', E_USER_WARNING);
                return $chunk;
            }
            $pos      = $newlineAt + 1;
            $chunkLen = hexdec(rtrim($chunkLenHex, "\r\n"));
            $dechunk .= substr($chunk, $pos, $chunkLen);
            $pos = strpos($chunk, "\n", $pos + $chunkLen) + 1;
        }
        return $dechunk;
    }
 }
 /**
 * determine if a string can represent a number in hexadecimal 
 * @link http://uk1.php.net/ctype_xdigit
 * @param string $hex 
 * @return boolean true if the string is a hex, otherwise false 
 */
 function is_hex($hex)
 {
    return ctype_xdigit($hex);
 }
 ?>
--- a/phpunit.xml
+++ b/phpunit.xml
@@ -0,0 +1,16 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <phpunit bootstrap="tests/bootstrap.php" colors="true">
  <logging>
    <log type="coverage-clover" target="build/logs/clover.xml"/>
  </logging>
  <testsuites>
    <testsuite name="Unirest Test Suite">
      <directory>./tests</directory>
    </testsuite>
  </testsuites>
  <php>
    <ini name="date.timezone" value="UTC"/>
  </php>
 </phpunit>
--- a/src/Unirest.php
+++ b/src/Unirest.php
@@ -0,0 +1,7 @@
 <?php
 require_once dirname(__FILE__) . '/Unirest/Exception.php';
 require_once dirname(__FILE__) . '/Unirest/Method.php';
 require_once dirname(__FILE__) . '/Unirest/Response.php';
 require_once dirname(__FILE__) . '/Unirest/Request.php';
 require_once dirname(__FILE__) . '/Unirest/Request/Body.php';
--- a/src/Unirest/Exception.php
+++ b/src/Unirest/Exception.php
@@ -0,0 +1,5 @@
 <?php
 namespace Unirest;
 class Exception extends \Exception {}
--- a/src/Unirest/Method.php
+++ b/src/Unirest/Method.php
@@ -0,0 +1,75 @@
 <?php
 /**
 * Hypertext Transfer Protocol (HTTP) Method Registry
 *
 * http://www.iana.org/assignments/http-methods/http-methods.xhtml
 */
 namespace Unirest;
 interface Method
 {
    // RFC7231
    const GET = 'GET';
    const HEAD = 'HEAD';
    const POST = 'POST';
    const PUT = 'PUT';
    const DELETE = 'DELETE';
    const CONNECT = 'CONNECT';
    const OPTIONS = 'OPTIONS';
    const TRACE = 'TRACE';
    // RFC3253
    const BASELINE = 'BASELINE';
    // RFC2068
    const LINK = 'LINK';
    const UNLINK = 'UNLINK';
    // RFC3253
    const MERGE = 'MERGE';
    const BASELINECONTROL = 'BASELINE-CONTROL';
    const MKACTIVITY = 'MKACTIVITY';
    const VERSIONCONTROL = 'VERSION-CONTROL';
    const REPORT = 'REPORT';
    const CHECKOUT = 'CHECKOUT';
    const CHECKIN = 'CHECKIN';
    const UNCHECKOUT = 'UNCHECKOUT';
    const MKWORKSPACE = 'MKWORKSPACE';
    const UPDATE = 'UPDATE';
    const LABEL = 'LABEL';
    // RFC3648
    const ORDERPATCH = 'ORDERPATCH';
    // RFC3744
    const ACL = 'ACL';
    // RFC4437
    const MKREDIRECTREF = 'MKREDIRECTREF';
    const UPDATEREDIRECTREF = 'UPDATEREDIRECTREF';
    // RFC4791
    const MKCALENDAR = 'MKCALENDAR';
    // RFC4918
    const PROPFIND = 'PROPFIND';
    const LOCK = 'LOCK';
    const UNLOCK = 'UNLOCK';
    const PROPPATCH = 'PROPPATCH';
    const MKCOL = 'MKCOL';
    const COPY = 'COPY';
    const MOVE = 'MOVE';
    // RFC5323
    const SEARCH = 'SEARCH';
    // RFC5789
    const PATCH = 'PATCH';
    // RFC5842
    const BIND = 'BIND';
    const UNBIND = 'UNBIND';
    const REBIND = 'REBIND';
 }
--- a/src/Unirest/Request.php
+++ b/src/Unirest/Request.php
@@ -0,0 +1,582 @@
 <?php
 namespace Unirest;
 use Unirest\Method as Method;
 use Unirest\Response as Response;
 use Unirest\Exception as Exception;
 class Request
 {
    private static $cookie = null;
    private static $cookieFile = null;
    private static $curlOpts = array();
    private static $defaultHeaders = array();
    private static $handle = null;
    private static $jsonOpts = array();
    private static $socketTimeout = null;
    private static $verifyPeer = true;
    private static $verifyHost = true;
    private static $auth = array (
        'user' => '',
        'pass' => '',
        'method' => CURLAUTH_BASIC
    );
    private static $proxy = array(
        'port' => false,
        'tunnel' => false,
        'address' => false,
        'type' => CURLPROXY_HTTP,
        'auth' => array (
            'user' => '',
            'pass' => '',
            'method' => CURLAUTH_BASIC
        )
    );
    /**
     * Set JSON decode mode
     *
     * @param bool $assoc When TRUE, returned objects will be converted into associative arrays.
     * @param integer $depth User specified recursion depth.
     * @param integer $options Bitmask of JSON decode options. Currently only JSON_BIGINT_AS_STRING is supported (default is to cast large integers as floats)
     * @return array
     */
    public static function jsonOpts($assoc = false, $depth = 512, $options = 0)
    {
        return self::$jsonOpts = array($assoc, $depth, $options);
    }
    /**
     * Verify SSL peer
     *
     * @param bool $enabled enable SSL verification, by default is true
     * @return bool
     */
    public static function verifyPeer($enabled)
    {
        return self::$verifyPeer = $enabled;
    }
    /**
     * Verify SSL host
     *
     * @param bool $enabled enable SSL host verification, by default is true
     * @return bool
     */
    public static function verifyHost($enabled)
    {
        return self::$verifyHost = $enabled;
    }
    /**
     * Set a timeout
     *
     * @param integer $seconds timeout value in seconds
     * @return integer
     */
    public static function timeout($seconds)
    {
        return self::$socketTimeout = $seconds;
    }
    /**
     * Set default headers to send on every request
     *
     * @param array $headers headers array
     */
    public static function defaultHeaders($headers)
    {
        return self::$defaultHeaders = array_merge(self::$defaultHeaders, $headers);
    }
    /**
     * Set a new default header to send on every request
     *
     * @param string $name header name
     * @param string $value header value
     * @return string
     */
    public static function defaultHeader($name, $value)
    {
        return self::$defaultHeaders[$name] = $value;
    }
    /**
     * Clear all the default headers
     */
    public static function clearDefaultHeaders()
    {
        return self::$defaultHeaders = array();
    }
    /**
     * Set curl options to send on every request
     *
     * @param array $options options array
     * @return array
     */
    public static function curlOpts($options)
    {
        return self::mergeCurlOptions(self::$curlOpts, $options);
    }
    /**
     * Set a new default header to send on every request
     *
     * @param string $name header name
     * @param string $value header value
     * @return string
     */
    public static function curlOpt($name, $value)
    {
        return self::$curlOpts[$name] = $value;
    }
    /**
     * Clear all the default headers
     */
    public static function clearCurlOpts()
    {
        return self::$curlOpts = array();
    }
    /**
     * Set a Mashape key to send on every request as a header
     * Obtain your Mashape key by browsing one of your Mashape applications on https://www.mashape.com
     *
     * Note: Mashape provides 2 keys for each application: a 'Testing' and a 'Production' one.
     *       Be aware of which key you are using and do not share your Production key.
     *
     * @param string $key Mashape key
     * @return string
     */
    public static function setMashapeKey($key)
    {
        return self::defaultHeader('X-Mashape-Key', $key);
    }
    /**
     * Set a cookie string for enabling cookie handling
     *
     * @param string $cookie
     */
    public static function cookie($cookie)
    {
        self::$cookie = $cookie;
    }
    /**
     * Set a cookie file path for enabling cookie handling
     *
     * $cookieFile must be a correct path with write permission
     *
     * @param string $cookieFile - path to file for saving cookie
     */
    public static function cookieFile($cookieFile)
    {
        self::$cookieFile = $cookieFile;
    }
    /**
     * Set authentication method to use
     *
     * @param string $username authentication username
     * @param string $password authentication password
     * @param integer $method authentication method
     */
    public static function auth($username = '', $password = '', $method = CURLAUTH_BASIC)
    {
        self::$auth['user'] = $username;
        self::$auth['pass'] = $password;
        self::$auth['method'] = $method;
    }
    /**
     * Set proxy to use
     *
     * @param string $address proxy address
     * @param integer $port proxy port
     * @param integer $type (Available options for this are CURLPROXY_HTTP, CURLPROXY_HTTP_1_0 CURLPROXY_SOCKS4, CURLPROXY_SOCKS5, CURLPROXY_SOCKS4A and CURLPROXY_SOCKS5_HOSTNAME)
     * @param bool $tunnel enable/disable tunneling
     */
    public static function proxy($address, $port = 1080, $type = CURLPROXY_HTTP, $tunnel = false)
    {
        self::$proxy['type'] = $type;
        self::$proxy['port'] = $port;
        self::$proxy['tunnel'] = $tunnel;
        self::$proxy['address'] = $address;
    }
    /**
     * Set proxy authentication method to use
     *
     * @param string $username authentication username
     * @param string $password authentication password
     * @param integer $method authentication method
     */
    public static function proxyAuth($username = '', $password = '', $method = CURLAUTH_BASIC)
    {
        self::$proxy['auth']['user'] = $username;
        self::$proxy['auth']['pass'] = $password;
        self::$proxy['auth']['method'] = $method;
    }
    /**
     * Send a GET request to a URL
     *
     * @param string $url URL to send the GET request to
     * @param array $headers additional headers to send
     * @param mixed $parameters parameters to send in the querystring
     * @param string $username Authentication username (deprecated)
     * @param string $password Authentication password (deprecated)
     * @return Unirest\Response
     */
    public static function get($url, $headers = array(), $parameters = null, $username = null, $password = null)
    {
        return self::send(Method::GET, $url, $parameters, $headers, $username, $password);
    }
    /**
     * Send a HEAD request to a URL
     * @param string $url URL to send the HEAD request to
     * @param array $headers additional headers to send
     * @param mixed $parameters parameters to send in the querystring
     * @param string $username Basic Authentication username (deprecated)
     * @param string $password Basic Authentication password (deprecated)
     * @return Unirest\Response
     */
    public static function head($url, $headers = array(), $parameters = null, $username = null, $password = null)
    {
        return self::send(Method::HEAD, $url, $parameters, $headers, $username, $password);
    }
    /**
     * Send a OPTIONS request to a URL
     * @param string $url URL to send the OPTIONS request to
     * @param array $headers additional headers to send
     * @param mixed $parameters parameters to send in the querystring
     * @param string $username Basic Authentication username
     * @param string $password Basic Authentication password
     * @return Unirest\Response
     */
    public static function options($url, $headers = array(), $parameters = null, $username = null, $password = null)
    {
        return self::send(Method::OPTIONS, $url, $parameters, $headers, $username, $password);
    }
    /**
     * Send a CONNECT request to a URL
     * @param string $url URL to send the CONNECT request to
     * @param array $headers additional headers to send
     * @param mixed $parameters parameters to send in the querystring
     * @param string $username Basic Authentication username (deprecated)
     * @param string $password Basic Authentication password (deprecated)
     * @return Unirest\Response
     */
    public static function connect($url, $headers = array(), $parameters = null, $username = null, $password = null)
    {
        return self::send(Method::CONNECT, $url, $parameters, $headers, $username, $password);
    }
    /**
     * Send POST request to a URL
     * @param string $url URL to send the POST request to
     * @param array $headers additional headers to send
     * @param mixed $body POST body data
     * @param string $username Basic Authentication username (deprecated)
     * @param string $password Basic Authentication password (deprecated)
     * @return Unirest\Response response
     */
    public static function post($url, $headers = array(), $body = null, $username = null, $password = null)
    {
        return self::send(Method::POST, $url, $body, $headers, $username, $password);
    }
    /**
     * Send DELETE request to a URL
     * @param string $url URL to send the DELETE request to
     * @param array $headers additional headers to send
     * @param mixed $body DELETE body data
     * @param string $username Basic Authentication username (deprecated)
     * @param string $password Basic Authentication password (deprecated)
     * @return Unirest\Response
     */
    public static function delete($url, $headers = array(), $body = null, $username = null, $password = null)
    {
        return self::send(Method::DELETE, $url, $body, $headers, $username, $password);
    }
    /**
     * Send PUT request to a URL
     * @param string $url URL to send the PUT request to
     * @param array $headers additional headers to send
     * @param mixed $body PUT body data
     * @param string $username Basic Authentication username (deprecated)
     * @param string $password Basic Authentication password (deprecated)
     * @return Unirest\Response
     */
    public static function put($url, $headers = array(), $body = null, $username = null, $password = null)
    {
        return self::send(Method::PUT, $url, $body, $headers, $username, $password);
    }
    /**
     * Send PATCH request to a URL
     * @param string $url URL to send the PATCH request to
     * @param array $headers additional headers to send
     * @param mixed $body PATCH body data
     * @param string $username Basic Authentication username (deprecated)
     * @param string $password Basic Authentication password (deprecated)
     * @return Unirest\Response
     */
    public static function patch($url, $headers = array(), $body = null, $username = null, $password = null)
    {
        return self::send(Method::PATCH, $url, $body, $headers, $username, $password);
    }
    /**
     * Send TRACE request to a URL
     * @param string $url URL to send the TRACE request to
     * @param array $headers additional headers to send
     * @param mixed $body TRACE body data
     * @param string $username Basic Authentication username (deprecated)
     * @param string $password Basic Authentication password (deprecated)
     * @return Unirest\Response
     */
    public static function trace($url, $headers = array(), $body = null, $username = null, $password = null)
    {
        return self::send(Method::TRACE, $url, $body, $headers, $username, $password);
    }
    /**
     * This function is useful for serializing multidimensional arrays, and avoid getting
     * the 'Array to string conversion' notice
     * @param array|object $data array to flatten.
     * @param bool|string $parent parent key or false if no parent
     * @return array
     */
    public static function buildHTTPCurlQuery($data, $parent = false)
    {
        $result = array();
        if (is_object($data)) {
            $data = get_object_vars($data);
        }
        foreach ($data as $key => $value) {
            if ($parent) {
                $new_key = sprintf('%s[%s]', $parent, $key);
            } else {
                $new_key = $key;
            }
            if (!$value instanceof \CURLFile and (is_array($value) or is_object($value))) {
                $result = array_merge($result, self::buildHTTPCurlQuery($value, $new_key));
            } else {
                $result[$new_key] = $value;
            }
        }
        return $result;
    }
    /**
     * Send a cURL request
     * @param Unirest\Method|string $method HTTP method to use
     * @param string $url URL to send the request to
     * @param mixed $body request body
     * @param array $headers additional headers to send
     * @param string $username Authentication username (deprecated)
     * @param string $password Authentication password (deprecated)
     * @throws Unirest\Exception if a cURL error occurs
     * @return Unirest\Response
     */
    public static function send($method, $url, $body = null, $headers = array(), $username = null, $password = null)
    {
        self::$handle = curl_init();
        if ($method !== Method::GET) {
 			if ($method === Method::POST) {
 				curl_setopt(self::$handle, CURLOPT_POST, true);
 			} else {
 				curl_setopt(self::$handle, CURLOPT_CUSTOMREQUEST, $method);
 			}
            curl_setopt(self::$handle, CURLOPT_POSTFIELDS, $body);
        } elseif (is_array($body)) {
            if (strpos($url, '?') !== false) {
                $url .= '&';
            } else {
                $url .= '?';
            }
            $url .= urldecode(http_build_query(self::buildHTTPCurlQuery($body)));
        }
        $curl_base_options = [
            CURLOPT_URL => self::encodeUrl($url),
            CURLOPT_RETURNTRANSFER => true,
            CURLOPT_FOLLOWLOCATION => true,
            CURLOPT_MAXREDIRS => 10,
            CURLOPT_HTTPHEADER => self::getFormattedHeaders($headers),
            CURLOPT_HEADER => true,
            CURLOPT_SSL_VERIFYPEER => self::$verifyPeer,
            //CURLOPT_SSL_VERIFYHOST accepts only 0 (false) or 2 (true). Future versions of libcurl will treat values 1 and 2 as equals
            CURLOPT_SSL_VERIFYHOST => self::$verifyHost === false ? 0 : 2,
            // If an empty string, '', is set, a header containing all supported encoding types is sent
            CURLOPT_ENCODING => ''
        ];
        curl_setopt_array(self::$handle, self::mergeCurlOptions($curl_base_options, self::$curlOpts));
        if (self::$socketTimeout !== null) {
            curl_setopt(self::$handle, CURLOPT_TIMEOUT, self::$socketTimeout);
        }
        if (self::$cookie) {
            curl_setopt(self::$handle, CURLOPT_COOKIE, self::$cookie);
        }
        if (self::$cookieFile) {
            curl_setopt(self::$handle, CURLOPT_COOKIEFILE, self::$cookieFile);
            curl_setopt(self::$handle, CURLOPT_COOKIEJAR, self::$cookieFile);
        }
        // supporting deprecated http auth method
        if (!empty($username)) {
            curl_setopt_array(self::$handle, array(
                CURLOPT_HTTPAUTH => CURLAUTH_BASIC,
                CURLOPT_USERPWD => $username . ':' . $password
            ));
        }
        if (!empty(self::$auth['user'])) {
            curl_setopt_array(self::$handle, array(
                CURLOPT_HTTPAUTH    => self::$auth['method'],
                CURLOPT_USERPWD     => self::$auth['user'] . ':' . self::$auth['pass']
            ));
        }
        if (self::$proxy['address'] !== false) {
            curl_setopt_array(self::$handle, array(
                CURLOPT_PROXYTYPE       => self::$proxy['type'],
                CURLOPT_PROXY           => self::$proxy['address'],
                CURLOPT_PROXYPORT       => self::$proxy['port'],
                CURLOPT_HTTPPROXYTUNNEL => self::$proxy['tunnel'],
                CURLOPT_PROXYAUTH       => self::$proxy['auth']['method'],
                CURLOPT_PROXYUSERPWD    => self::$proxy['auth']['user'] . ':' . self::$proxy['auth']['pass']
            ));
        }
        $response   = curl_exec(self::$handle);
        $error      = curl_error(self::$handle);
        $info       = self::getInfo();
        if ($error) {
            throw new Exception($error);
        }
        // Split the full response in its headers and body
        $header_size = $info['header_size'];
        $header      = substr($response, 0, $header_size);
        $body        = substr($response, $header_size);
        $httpCode    = $info['http_code'];
        return new Response($httpCode, $body, $header, self::$jsonOpts);
    }
    public static function getInfo($opt = false)
    {
        if ($opt) {
            $info = curl_getinfo(self::$handle, $opt);
        } else {
            $info = curl_getinfo(self::$handle);
        }
        return $info;
    }
    public static function getCurlHandle()
    {
        return self::$handle;
    }
    public static function getFormattedHeaders($headers)
    {
        $formattedHeaders = array();
        $combinedHeaders = array_change_key_case(array_merge(self::$defaultHeaders, (array) $headers));
        foreach ($combinedHeaders as $key => $val) {
            $formattedHeaders[] = self::getHeaderString($key, $val);
        }
        if (!array_key_exists('user-agent', $combinedHeaders)) {
            $formattedHeaders[] = 'user-agent: unirest-php/2.0';
        }
        if (!array_key_exists('expect', $combinedHeaders)) {
            $formattedHeaders[] = 'expect:';
        }
        return $formattedHeaders;
    }
    private static function getArrayFromQuerystring($query)
    {
        $query = preg_replace_callback('/(?:^|(?<=&))[^=[]+/', function ($match) {
            return bin2hex(urldecode($match[0]));
        }, $query);
        parse_str($query, $values);
        return array_combine(array_map('hex2bin', array_keys($values)), $values);
    }
    /**
     * Ensure that a URL is encoded and safe to use with cURL
     * @param  string $url URL to encode
     * @return string
     */
    private static function encodeUrl($url)
    {
        $url_parsed = parse_url($url);
        $scheme = $url_parsed['scheme'] . '://';
        $host   = $url_parsed['host'];
        $port   = (isset($url_parsed['port']) ? $url_parsed['port'] : null);
        $path   = (isset($url_parsed['path']) ? $url_parsed['path'] : null);
        $query  = (isset($url_parsed['query']) ? $url_parsed['query'] : null);
        if ($query !== null) {
            $query = '?' . http_build_query(self::getArrayFromQuerystring($query));
        }
        if ($port && $port[0] !== ':') {
            $port = ':' . $port;
        }
        $result = $scheme . $host . $port . $path . $query;
        return $result;
    }
    private static function getHeaderString($key, $val)
    {
        $key = trim(strtolower($key));
        return $key . ': ' . $val;
    }
    /**
     * @param array $existing_options
     * @param array $new_options
     * @return array
     */
    private static function mergeCurlOptions(&$existing_options, $new_options)
    {
        $existing_options = $new_options + $existing_options;
        return $existing_options;
    }
 }
--- a/src/Unirest/Request/Body.php
+++ b/src/Unirest/Request/Body.php
@@ -0,0 +1,66 @@
 <?php
 namespace Unirest\Request;
 use Unirest\Request as Request;
 use Unirest\Exception as Exception;
 class Body
 {
    /**
     * Prepares a file for upload. To be used inside the parameters declaration for a request.
     * @param string $filename The file path
     * @param string $mimetype MIME type
     * @param string $postname the file name
     * @return string|\CURLFile
     */
    public static function File($filename, $mimetype = '', $postname = '')
    {
        if (class_exists('CURLFile')) {
            return new \CURLFile($filename, $mimetype, $postname);
        }
        if (function_exists('curl_file_create')) {
            return curl_file_create($filename, $mimetype, $postname);
        }
        return sprintf('@%s;filename=%s;type=%s', $filename, $postname ?: basename($filename), $mimetype);
    }
    public static function Json($data)
    {
        if (!function_exists('json_encode')) {
            throw new Exception('JSON Extension not available');
        }
        return json_encode($data);
    }
    public static function Form($data)
    {
        if (is_array($data) || is_object($data) || $data instanceof \Traversable) {
            return http_build_query(Request::buildHTTPCurlQuery($data));
        }
        return $data;
    }
    public static function Multipart($data, $files = false)
    {
        if (is_object($data)) {
            return get_object_vars($data);
        }
        if (!is_array($data)) {
            return array($data);
        }
        if ($files !== false) {
            foreach ($files as $name => $file) {
                $data[$name] = call_user_func(array(__CLASS__, 'File'), $file);
            }
        }
        return $data;
    }
 }
--- a/src/Unirest/Response.php
+++ b/src/Unirest/Response.php
@@ -0,0 +1,78 @@
 <?php
 namespace Unirest;
 class Response
 {
    public $code;
    public $raw_body;
    public $body;
    public $headers;
    /**
     * @param int $code response code of the cURL request
     * @param string $raw_body the raw body of the cURL response
     * @param string $headers raw header string from cURL response
     * @param array $json_args arguments to pass to json_decode function
     */
    public function __construct($code, $raw_body, $headers, $json_args = array())
    {
        $this->code     = $code;
        $this->headers  = $this->parseHeaders($headers);
        $this->raw_body = $raw_body;
        $this->body     = $raw_body;
        // make sure raw_body is the first argument
        array_unshift($json_args, $raw_body);
        if (function_exists('json_decode')) {
            $json = call_user_func_array('json_decode', $json_args);
            if (json_last_error() === JSON_ERROR_NONE) {
                $this->body = $json;
            }
        }
    }
    /**
     * if PECL_HTTP is not available use a fall back function
     *
     * thanks to ricardovermeltfoort@gmail.com
     * http://php.net/manual/en/function.http-parse-headers.php#112986
     * @param string $raw_headers raw headers
     * @return array
     */
    private function parseHeaders($raw_headers)
    {
        if (function_exists('http_parse_headers')) {
            return http_parse_headers($raw_headers);
        } else {
            $key = '';
            $headers = array();
            foreach (explode("\n", $raw_headers) as $i => $h) {
                $h = explode(':', $h, 2);
                if (isset($h[1])) {
                    if (!isset($headers[$h[0]])) {
                        $headers[$h[0]] = trim($h[1]);
                    } elseif (is_array($headers[$h[0]])) {
                        $headers[$h[0]] = array_merge($headers[$h[0]], array(trim($h[1])));
                    } else {
                        $headers[$h[0]] = array_merge(array($headers[$h[0]]), array(trim($h[1])));
                    }
                    $key = $h[0];
                } else {
                    if (substr($h[0], 0, 1) == "\t") {
                        $headers[$key] .= "\r\n\t".trim($h[0]);
                    } elseif (!$key) {
                        $headers[0] = trim($h[0]);
                    }
                }
            }
            return $headers;
        }
    }
 }
--- a/test/.gitignore
+++ b/test/.gitignore
@@ -1 +0,0 @@
 simpletest
--- a/test/Unirest.php
+++ b/test/Unirest.php
@@ -1,27 +0,0 @@
 <?php
 echo "Running the Unirest-PHP bindings test suite.\n" . "If you're trying to use the Unirest-PHP bindings you'll probably want " . "to require('lib/Unirest.php'); instead of this file\n";
 $ok = @include_once(dirname(__FILE__) . '/simpletest/autorun.php');
 if (!$ok) {
    $ok = @include_once(dirname(__FILE__) . '/../vendor/vierbergenlars/simpletest/autorun.php');
 }
 if (!$ok) {
    echo "MISSING DEPENDENCY: The Unirest-PHP test cases depend on SimpleTest. " . "Download it at <http://www.simpletest.org/>, and either install it " . "in your PHP include_path or put it in the test/ directory.\n";
    exit(1);
 }
 // Throw an exception on any error
 function exception_error_handler($errno, $errstr, $errfile, $errline)
 {
    throw new ErrorException($errstr, $errno, 0, $errfile, $errline);
 }
 set_error_handler('exception_error_handler');
 error_reporting(E_ALL | E_STRICT);
 require_once(dirname(__FILE__) . '/../lib/Unirest.php');
 require_once(dirname(__FILE__) . '/Unirest/UnirestTest.php');
 ?>
--- a/test/Unirest/UnirestTest.php
+++ b/test/Unirest/UnirestTest.php
@@ -1,374 +0,0 @@
 <?php
 class UnirestTest extends UnitTestCase
 {
    public function testGet()
    {
        $response = Unirest::get("http://httpbin.org/get?name=Mark", array(
            "Accept" => "application/json"
        ), array(
            "nick" => "thefosk"
        ));
        $this->assertEqual(200, $response->code);
        $args = $response->body->args;
        $this->assertEqual("Mark", $args->name);
        $this->assertEqual("thefosk", $args->nick);
    }
    public function testGetMultidimensionalArray()
    {
        $response = Unirest::get("http://httpbin.org/get", array(
            "Accept" => "application/json"
        ), array(
            'key' => 'value',
            'items' => array(
                'item1',
                'item2'
            )
        ));
        $this->assertEqual(200, $response->code);
        $args = $response->body->args;
        $this->assertEqual("value", $args->key);
        $this->assertEqual("item1", $args->{"items[0]"});
        $this->assertEqual("item2", $args->{"items[1]"});
    }
    public function testGetWithDots()
    {
        $response = Unirest::get("http://httpbin.org/get", array(
            "Accept" => "application/json"
        ), array(
            "user.name" => "Mark",
            "nick" => "thefosk"
        ));
        $this->assertEqual(200, $response->code);
        $args = $response->body->args;
        $this->assertEqual("Mark", $args->{"user.name"});
        $this->assertEqual("thefosk", $args->nick);
    }
    public function testGetWithDots2()
    {
        $response = Unirest::get("http://httpbin.org/get", array(
            "Accept" => "application/json"
        ), array(
            "user.name" => "Mark Bond",
            "nick" => "thefosk"
        ));
        $this->assertEqual(200, $response->code);
        $args = $response->body->args;
        $this->assertEqual("Mark Bond", $args->{"user.name"});
        $this->assertEqual("thefosk", $args->nick);
    }
    public function testPost()
    {
        $response = Unirest::post("http://httpbin.org/post", array(
            "Accept" => "application/json"
        ), array(
            "name" => "Mark",
            "nick" => "thefosk"
        ));
        $this->assertEqual(200, $response->code);
        $form = $response->body->form;
        $this->assertEqual("Mark", $form->name);
        $this->assertEqual("thefosk", $form->nick);
    }
    public function testPostWithEqualSign()
    {
        $response = Unirest::post("http://httpbin.org/post", array(
            "Accept" => "application/json"
        ), array(
            "name" => "Mark=Hello"
        ));
        $this->assertEqual(200, $response->code);
        $form = $response->body->form;
        $this->assertEqual("Mark=Hello", $form->name);
    }
    public function testGetWithEqualSign()
    {
        $response = Unirest::get("http://httpbin.org/get", array(
            "Accept" => "application/json"
        ), array(
            "name" => "Mark=Hello"
        ));
        $this->assertEqual(200, $response->code);
        $args = $response->body->args;
        $this->assertEqual("Mark=Hello", $args->name);
        $response = Unirest::get("http://httpbin.org/get", array(
            "Accept" => "application/json"
        ), array(
            "name" => "Mark=Hello=John"
        ));
        $this->assertEqual(200, $response->code);
        $args = $response->body->args;
        $this->assertEqual("Mark=Hello=John", $args->name);
    }
    public function testPostArray()
    {
        $response = Unirest::post("http://httpbin.org/post", array(
            "Accept" => "application/json"
        ), array(
            "name[0]" => "Mark",
            "name[1]" => "John"
        ));
        $this->assertEqual(200, $response->code);
        $form = $response->body->form;
        $this->assertEqual("Mark", $form->{"name[0]"});
        $this->assertEqual("John", $form->{"name[1]"});
    }
    public function testGetArray()
    {
        $response = Unirest::get("http://httpbin.org/get", array(), array(
            "name[0]" => "Mark",
            "name[1]" => "John"
        ));
        $this->assertEqual(200, $response->code);
        $args = $response->body->args;
        $this->assertEqual("Mark", $args->{"name[0]"});
        $this->assertEqual("John", $args->{"name[1]"});
    }
    public function testPostWithDots()
    {
        $response = Unirest::post("http://httpbin.org/post", array(
            "Accept" => "application/json"
        ), array(
            "user.name" => "Mark",
            "nick" => "thefosk"
        ));
        $this->assertEqual(200, $response->code);
        $form = $response->body->form;
        $this->assertEqual("Mark", $form->{"user.name"});
        $this->assertEqual("thefosk", $form->nick);
    }
    public function testRawPost()
    {
        $response = Unirest::post("http://httpbin.org/post", array(
            "Accept" => "application/json"
        ), json_encode(array(
            "author" => "Sam Sullivan"
        )));
        $this->assertEqual(200, $response->code);
        $json = $response->body->json;
        $this->assertEqual("Sam Sullivan", $json->author);
    }
    public function testUpload()
    {  
        $response = Unirest::post("http://httpbin.org/post", array(
            "Accept" => "application/json"
        ), array(
            "name" => "Mark",
            "file" => Unirest::file(dirname(__FILE__) . "/test_upload.txt")
        ));
        $this->assertEqual(200, $response->code);
        $files = $response->body->files;
        $this->assertEqual("This is a test", $files->file);
        $form = $response->body->form;
        $this->assertEqual("Mark", $form->name);
    }
    public function testUploadIfFilePartOfData()
    {  
        $response = Unirest::post("http://httpbin.org/post", array(
            "Accept" => "application/json"
        ), array(
            "name" => "Mark",
            "files[owl.gif]" => Unirest::file(dirname(__FILE__) . "/test_upload.txt")
        ));
        $this->assertEqual(200, $response->code);
        //$files = $response->body->files;
        //$this->assertEqual("This is a test", $files->file);
        $form = $response->body->form;
        $this->assertEqual("Mark", $form->name);
    }
    public function testPostMultidimensionalArray()
    {
        $response = Unirest::post("http://httpbin.org/post", array(
            "Accept" => "application/json"
        ), array(
            'key' => 'value',
            'items' => array(
                'item1',
                'item2'
            )
        ));
        $this->assertEqual(200, $response->code);
        $form = $response->body->form;
        $this->assertEqual("value", $form->key);
        $this->assertEqual("item1", $form->{"items[0]"});
        $this->assertEqual("item2", $form->{"items[1]"});
    }
    public function testPut()
    {
        $response = Unirest::put("http://httpbin.org/put", array(
            "Accept" => "application/json"
        ), array(
            "name" => "Mark",
            "nick" => "thefosk"
        ));
        $this->assertEqual(200, $response->code);
        $form = $response->body->form;
        $this->assertEqual("Mark", $form->name);
        $this->assertEqual("thefosk", $form->nick);
    }
    public function testPatch()
    {
        $response = Unirest::patch("http://httpbin.org/patch", array(
            "Accept" => "application/json"
        ), array(
            "name" => "Mark",
            "nick" => "thefosk"
        ));
        $this->assertEqual(200, $response->code);
        $form = $response->body->form;
        $this->assertEqual("Mark", $form->name);
        $this->assertEqual("thefosk", $form->nick);
    }
    public function testDelete()
    {
        $response = Unirest::delete("http://httpbin.org/delete", array(
            "Accept" => "application/json",
            "Content-Type" => "application/x-www-form-urlencoded"
        ), array(
            "name" => "Mark",
            "nick" => "thefosk"
        ));
        $this->assertEqual(200, $response->code);
        $data = $response->body->data;
        $this->assertFalse(empty($data));
    }
    public function testTimeoutFail()
    {
        Unirest::timeout(1);
        $this->expectException();
        $response = Unirest::get("http://httpbin.org/delay/3");
        Unirest::timeout(null); // Cleaning timeout for the other tests
    }
    public function testTimeoutSuccess()
    {
        Unirest::timeout(3);
        $response = Unirest::get("http://httpbin.org/delay/1");
        $this->assertEqual(200, $response->code);
        Unirest::timeout(null); // Cleaning timeout for the other tests
    }
    public function testDefaultHeader()
    {
        Unirest::defaultHeader("Hello", "custom");
        $response = Unirest::get("http://httpbin.org/get");
        $this->assertEqual(200, $response->code);
        $headers    = $response->body->headers;
        $properties = get_object_vars($headers);
        $this->assertTrue(array_key_exists("Hello", $properties));
        $this->assertEqual("custom", $headers->Hello);
        $response = Unirest::get("http://httpbin.org/get");
        $this->assertEqual(200, $response->code);
        $headers    = $response->body->headers;
        $properties = get_object_vars($headers);
        $this->assertTrue(array_key_exists("Hello", $properties));
        $this->assertEqual("custom", $headers->Hello);
        Unirest::clearDefaultHeaders();
        $response = Unirest::get("http://httpbin.org/get");
        $this->assertEqual(200, $response->code);
        $headers    = $response->body->headers;
        $properties = get_object_vars($headers);
        $this->assertFalse(array_key_exists("Hello", $properties));
    }
    public function testGzip()
    {
        $response = Unirest::get("http://httpbin.org/gzip");
        $args     = $response->body;
        $this->assertEqual(true, $args->gzipped);
    }
    public function testBasicAuthentication()
    {
        $response = Unirest::get("http://httpbin.org/get", null, null, "user", "password");
        $headers  = $response->body->headers;
        $this->assertEqual("Basic dXNlcjpwYXNzd29yZA==", $headers->Authorization);
    }
    public function testCustomHeaders() 
    {
        $response = Unirest::get('http://httpbin.org/get', array(
            'user-agent' => 'ciao',
        ));
        $this->assertEqual(200, $response->code);
        $headers    = $response->body->headers;
        $this->assertEqual("ciao", $headers->{'User-Agent'});
    }
    public function testHttpBuildQueryWhenCurlFile()
    {
      $file = Unirest::file(dirname(__FILE__) . "/test_upload.txt");
      $body = array(
        "to" => "mail@mailinator.com",
        "from" => "mail@mailinator.com",
        "file" => $file 
      );
      Unirest::http_build_query_for_curl($body, $postBody);
      $this->assertEqual($postBody['file'], $file);
    }
 }
--- a/tests/Unirest/BodyTest.php
+++ b/tests/Unirest/BodyTest.php
@@ -0,0 +1,89 @@
 <?php
 namespace Unirest\Request\Body\Test;
 use Unirest\Request as Request;
 use Unirest\Request\Body as Body;
 require_once __DIR__ . '/../../src/Unirest.php';
 class BodyTest extends \PHPUnit_Framework_TestCase
 {
    public function testCURLFile()
    {
        $fixture = __DIR__ . '/fixtures/upload.txt';
        $file = Body::File($fixture);
        if (PHP_MAJOR_VERSION === 5 && PHP_MINOR_VERSION === 4) {
            $this->assertEquals($file, sprintf('@%s;filename=%s;type=', $fixture, basename($fixture)));
        } else {
            $this->assertTrue($file instanceof \CURLFile);
        }
    }
    public function testHttpBuildQueryWithCurlFile()
    {
        $fixture = __DIR__ . '/fixtures/upload.txt';
        $file = Body::File($fixture);
        $body = array(
            'to' => 'mail@mailinator.com',
            'from' => 'mail@mailinator.com',
            'file' => $file
        );
        $result = Request::buildHTTPCurlQuery($body);
        $this->assertEquals($result['file'], $file);
    }
    public function testJson()
    {
        $body = Body::Json(array('foo', 'bar'));
        $this->assertEquals($body, '["foo","bar"]');
    }
    public function testForm()
    {
        $body = Body::Form(array('foo' => 'bar', 'bar' => 'baz'));
        $this->assertEquals($body, 'foo=bar&bar=baz');
        // try again with a string
        $body = Body::Form($body);
        $this->assertEquals($body, 'foo=bar&bar=baz');
    }
    public function testMultipart()
    {
        $arr = array('foo' => 'bar', 'bar' => 'baz');
        $body = Body::Multipart((object) $arr);
        $this->assertEquals($body, $arr);
        $body = Body::Multipart('flat');
        $this->assertEquals($body, array('flat'));
    }
    public function testMultipartFiles()
    {
        $fixture = __DIR__ . '/fixtures/upload.txt';
        $data = array('foo' => 'bar', 'bar' => 'baz');
        $files = array('test' => $fixture);
        $body = Body::Multipart($data, $files);
        // echo $body;
        $this->assertEquals($body, array(
            'foo' => 'bar',
            'bar' => 'baz',
            'test' => Body::File($fixture)
        ));
    }
 }
--- a/tests/Unirest/RequestTest.php
+++ b/tests/Unirest/RequestTest.php
@@ -0,0 +1,485 @@
 <?php
 namespace Unirest\Request\Test;
 use Unirest\Request as Request;
 require __DIR__ . '/../../src/Unirest.php';
 class UnirestRequestTest extends \PHPUnit_Framework_TestCase
 {
    // Generic
    public function testCurlOpts()
    {
        Request::curlOpt(CURLOPT_COOKIE, 'foo=bar');
        $response = Request::get('http://mockbin.com/request');
        $this->assertTrue(property_exists($response->body->cookies, 'foo'));
        Request::clearCurlOpts();
    }
    /**
     * @expectedException \Unirest\Exception
     */
    public function testTimeoutFail()
    {
        Request::timeout(1);
        Request::get('http://mockbin.com/delay/1000');
        Request::timeout(null); // Cleaning timeout for the other tests
    }
    public function testDefaultHeaders()
    {
        $defaultHeaders = array(
            'header1' => 'Hello',
            'header2' => 'world'
        );
        Request::defaultHeaders($defaultHeaders);
        $response = Request::get('http://mockbin.com/request');
        $this->assertEquals(200, $response->code);
        $this->assertObjectHasAttribute('header1', $response->body->headers);
        $this->assertEquals('Hello', $response->body->headers->header1);
        $this->assertObjectHasAttribute('header2', $response->body->headers);
        $this->assertEquals('world', $response->body->headers->header2);
        $response = Request::get('http://mockbin.com/request', ['header1' => 'Custom value']);
        $this->assertEquals(200, $response->code);
        $this->assertObjectHasAttribute('header1', $response->body->headers);
        $this->assertEquals('Custom value', $response->body->headers->header1);
        Request::clearDefaultHeaders();
        $response = Request::get('http://mockbin.com/request');
        $this->assertEquals(200, $response->code);
        $this->assertObjectNotHasAttribute('header1', $response->body->headers);
        $this->assertObjectNotHasAttribute('header2', $response->body->headers);
    }
    public function testDefaultHeader()
    {
        Request::defaultHeader('Hello', 'custom');
        $response = Request::get('http://mockbin.com/request');
        $this->assertEquals(200, $response->code);
        $this->assertTrue(property_exists($response->body->headers, 'hello'));
        $this->assertEquals('custom', $response->body->headers->hello);
        Request::clearDefaultHeaders();
        $response = Request::get('http://mockbin.com/request');
        $this->assertEquals(200, $response->code);
        $this->assertFalse(property_exists($response->body->headers, 'hello'));
    }
    public function testSetMashapeKey()
    {
        Request::setMashapeKey('abcd');
        $response = Request::get('http://mockbin.com/request');
        $this->assertEquals(200, $response->code);
        $this->assertTrue(property_exists($response->body->headers, 'x-mashape-key'));
        $this->assertEquals('abcd', $response->body->headers->{'x-mashape-key'});
        // send another request
        $response = Request::get('http://mockbin.com/request');
        $this->assertEquals(200, $response->code);
        $this->assertTrue(property_exists($response->body->headers, 'x-mashape-key'));
        $this->assertEquals('abcd', $response->body->headers->{'x-mashape-key'});
        Request::clearDefaultHeaders();
        $response = Request::get('http://mockbin.com/request');
        $this->assertEquals(200, $response->code);
        $this->assertFalse(property_exists($response->body->headers, 'x-mashape-key'));
    }
    public function testGzip()
    {
        $response = Request::get('http://mockbin.com/gzip/request');
        $this->assertEquals('gzip', $response->headers['Content-Encoding']);
    }
    public function testBasicAuthenticationDeprecated()
    {
        $response = Request::get('http://mockbin.com/request', array(), array(), 'user', 'password');
        $this->assertEquals('Basic dXNlcjpwYXNzd29yZA==', $response->body->headers->authorization);
    }
    public function testBasicAuthentication()
    {
        Request::auth('user', 'password');
        $response = Request::get('http://mockbin.com/request');
        $this->assertEquals('Basic dXNlcjpwYXNzd29yZA==', $response->body->headers->authorization);
    }
    public function testCustomHeaders()
    {
        $response = Request::get('http://mockbin.com/request', array(
            'user-agent' => 'unirest-php',
        ));
        $this->assertEquals(200, $response->code);
        $this->assertEquals('unirest-php', $response->body->headers->{'user-agent'});
    }
    // GET
    public function testGet()
    {
        $response = Request::get('http://mockbin.com/request?name=Mark', array(
            'Accept' => 'application/json'
        ), array(
            'nick' => 'thefosk'
        ));
        $this->assertEquals(200, $response->code);
        $this->assertEquals('GET', $response->body->method);
        $this->assertEquals('Mark', $response->body->queryString->name);
        $this->assertEquals('thefosk', $response->body->queryString->nick);
    }
    public function testGetMultidimensionalArray()
    {
        $response = Request::get('http://mockbin.com/request', array(
            'Accept' => 'application/json'
        ), array(
            'key' => 'value',
            'items' => array(
                'item1',
                'item2'
            )
        ));
        $this->assertEquals(200, $response->code);
        $this->assertEquals('GET', $response->body->method);
        $this->assertEquals('value', $response->body->queryString->key);
        $this->assertEquals('item1', $response->body->queryString->items[0]);
        $this->assertEquals('item2', $response->body->queryString->items[1]);
    }
    public function testGetWithDots()
    {
        $response = Request::get('http://mockbin.com/request', array(
            'Accept' => 'application/json'
        ), array(
            'user.name' => 'Mark',
            'nick' => 'thefosk'
        ));
        $this->assertEquals(200, $response->code);
        $this->assertEquals('GET', $response->body->method);
        $this->assertEquals('Mark', $response->body->queryString->{'user.name'});
        $this->assertEquals('thefosk', $response->body->queryString->nick);
    }
    public function testGetWithDotsAlt()
    {
        $response = Request::get('http://mockbin.com/request', array(
            'Accept' => 'application/json'
        ), array(
            'user.name' => 'Mark Bond',
            'nick' => 'thefosk'
        ));
        $this->assertEquals(200, $response->code);
        $this->assertEquals('GET', $response->body->method);
        $this->assertEquals('Mark Bond', $response->body->queryString->{'user.name'});
        $this->assertEquals('thefosk', $response->body->queryString->nick);
    }
    public function testGetWithEqualSign()
    {
        $response = Request::get('http://mockbin.com/request', array(
            'Accept' => 'application/json'
        ), array(
            'name' => 'Mark=Hello'
        ));
        $this->assertEquals(200, $response->code);
        $this->assertEquals('GET', $response->body->method);
        $this->assertEquals('Mark=Hello', $response->body->queryString->name);
    }
    public function testGetWithEqualSignAlt()
    {
        $response = Request::get('http://mockbin.com/request', array(
            'Accept' => 'application/json'
        ), array(
            'name' => 'Mark=Hello=John'
        ));
        $this->assertEquals(200, $response->code);
        $this->assertEquals('GET', $response->body->method);
        $this->assertEquals('Mark=Hello=John', $response->body->queryString->name);
    }
    public function testGetWithComplexQuery()
    {
        $response = Request::get('http://mockbin.com/request?query=[{"type":"/music/album","name":null,"artist":{"id":"/en/bob_dylan"},"limit":3}]&cursor');
        $this->assertEquals(200, $response->code);
        $this->assertEquals('GET', $response->body->method);
        $this->assertEquals('', $response->body->queryString->cursor);
        $this->assertEquals('[{"type":"/music/album","name":null,"artist":{"id":"/en/bob_dylan"},"limit":3}]', $response->body->queryString->query);
    }
    public function testGetArray()
    {
        $response = Request::get('http://mockbin.com/request', array(), array(
            'name[0]' => 'Mark',
            'name[1]' => 'John'
        ));
        $this->assertEquals(200, $response->code);
        $this->assertEquals('GET', $response->body->method);
        $this->assertEquals('Mark', $response->body->queryString->name[0]);
        $this->assertEquals('John', $response->body->queryString->name[1]);
    }
    // POST
    public function testPost()
    {
        $response = Request::post('http://mockbin.com/request', array(
            'Accept' => 'application/json'
        ), array(
            'name' => 'Mark',
            'nick' => 'thefosk'
        ));
        $this->assertEquals(200, $response->code);
        $this->assertEquals('POST', $response->body->method);
        $this->assertEquals('Mark', $response->body->postData->params->name);
        $this->assertEquals('thefosk', $response->body->postData->params->nick);
    }
    public function testPostForm()
    {
        $body = Request\Body::Form(array(
            'name' => 'Mark',
            'nick' => 'thefosk'
        ));
        $response = Request::post('http://mockbin.com/request', array(
            'Accept' => 'application/json'
        ), $body);
        $this->assertEquals('POST', $response->body->method);
        $this->assertEquals('application/x-www-form-urlencoded', $response->body->headers->{'content-type'});
        $this->assertEquals('application/x-www-form-urlencoded', $response->body->postData->mimeType);
        $this->assertEquals('Mark', $response->body->postData->params->name);
        $this->assertEquals('thefosk', $response->body->postData->params->nick);
    }
    public function testPostMultipart()
    {
        $body = Request\Body::Multipart(array(
            'name' => 'Mark',
            'nick' => 'thefosk'
        ));
        $response = Request::post('http://mockbin.com/request', (object) array(
            'Accept' => 'application/json',
        ), $body);
        $this->assertEquals('POST', $response->body->method);
        $this->assertEquals('multipart/form-data', explode(';', $response->body->headers->{'content-type'})[0]);
        $this->assertEquals('multipart/form-data', $response->body->postData->mimeType);
        $this->assertEquals('Mark', $response->body->postData->params->name);
        $this->assertEquals('thefosk', $response->body->postData->params->nick);
    }
    public function testPostWithEqualSign()
    {
        $body = Request\Body::Form(array(
            'name' => 'Mark=Hello'
        ));
        $response = Request::post('http://mockbin.com/request', array(
            'Accept' => 'application/json'
        ), $body);
        $this->assertEquals(200, $response->code);
        $this->assertEquals('POST', $response->body->method);
        $this->assertEquals('Mark=Hello', $response->body->postData->params->name);
    }
    public function testPostArray()
    {
        $response = Request::post('http://mockbin.com/request', array(
            'Accept' => 'application/json'
        ), array(
            'name[0]' => 'Mark',
            'name[1]' => 'John'
        ));
        $this->assertEquals(200, $response->code);
        $this->assertEquals('POST', $response->body->method);
        $this->assertEquals('Mark', $response->body->postData->params->{'name[0]'});
        $this->assertEquals('John', $response->body->postData->params->{'name[1]'});
    }
    public function testPostWithDots()
    {
        $response = Request::post('http://mockbin.com/request', array(
            'Accept' => 'application/json'
        ), array(
            'user.name' => 'Mark',
            'nick' => 'thefosk'
        ));
        $this->assertEquals(200, $response->code);
        $this->assertEquals('POST', $response->body->method);
        $this->assertEquals('Mark', $response->body->postData->params->{'user.name'});
        $this->assertEquals('thefosk', $response->body->postData->params->nick);
    }
    public function testRawPost()
    {
        $response = Request::post('http://mockbin.com/request', array(
            'Accept' => 'application/json',
            'Content-Type' => 'application/json'
        ), json_encode(array(
            'author' => 'Sam Sullivan'
        )));
        $this->assertEquals(200, $response->code);
        $this->assertEquals('POST', $response->body->method);
        $this->assertEquals('Sam Sullivan', json_decode($response->body->postData->text)->author);
    }
    public function testPostMultidimensionalArray()
    {
        $body = Request\Body::Form(array(
            'key' => 'value',
            'items' => array(
                'item1',
                'item2'
            )
        ));
        $response = Request::post('http://mockbin.com/request', array(
            'Accept' => 'application/json'
        ), $body);
        $this->assertEquals(200, $response->code);
        $this->assertEquals('POST', $response->body->method);
        $this->assertEquals('value', $response->body->postData->params->key);
        $this->assertEquals('item1', $response->body->postData->params->{'items[0]'});
        $this->assertEquals('item2', $response->body->postData->params->{'items[1]'});
    }
    // PUT
    public function testPut()
    {
        $response = Request::put('http://mockbin.com/request', array(
            'Accept' => 'application/json'
        ), array(
            'name' => 'Mark',
            'nick' => 'thefosk'
        ));
        $this->assertEquals(200, $response->code);
        $this->assertEquals('PUT', $response->body->method);
        $this->assertEquals('Mark', $response->body->postData->params->name);
        $this->assertEquals('thefosk', $response->body->postData->params->nick);
    }
    // PATCH
    public function testPatch()
    {
        $response = Request::patch('http://mockbin.com/request', array(
            'Accept' => 'application/json'
        ), array(
            'name' => 'Mark',
            'nick' => 'thefosk'
        ));
        $this->assertEquals(200, $response->code);
        $this->assertEquals('PATCH', $response->body->method);
        $this->assertEquals('Mark', $response->body->postData->params->name);
        $this->assertEquals('thefosk', $response->body->postData->params->nick);
    }
    // DELETE
    public function testDelete()
    {
        $response = Request::delete('http://mockbin.com/request', array(
            'Accept' => 'application/json',
            'Content-Type' => 'application/x-www-form-urlencoded'
        ), array(
            'name' => 'Mark',
            'nick' => 'thefosk'
        ));
        $this->assertEquals(200, $response->code);
        $this->assertEquals('DELETE', $response->body->method);
    }
    // Upload
    public function testUpload()
    {
        $fixture = __DIR__ . '/../fixtures/upload.txt';
        $headers = array('Accept' => 'application/json');
        $files = array('file' => $fixture);
        $data = array('name' => 'ahmad');
        $body = Request\Body::Multipart($data, $files);
        $response = Request::post('http://mockbin.com/request', $headers, $body);
        $this->assertEquals(200, $response->code);
        $this->assertEquals('POST', $response->body->method);
        $this->assertEquals('ahmad', $response->body->postData->params->name);
        $this->assertEquals('This is a test', $response->body->postData->params->file);
    }
    public function testUploadWithoutHelper()
    {
        $fixture = __DIR__ . '/../fixtures/upload.txt';
        $response = Request::post('http://mockbin.com/request', array(
            'Accept' => 'application/json'
        ), array(
            'name' => 'Mark',
            'file' => Request\Body::File($fixture)
        ));
        $this->assertEquals(200, $response->code);
        $this->assertEquals('POST', $response->body->method);
        $this->assertEquals('Mark', $response->body->postData->params->name);
        $this->assertEquals('This is a test', $response->body->postData->params->file);
    }
    public function testUploadIfFilePartOfData()
    {
        $fixture = __DIR__ . '/../fixtures/upload.txt';
        $response = Request::post('http://mockbin.com/request', array(
            'Accept' => 'application/json'
        ), array(
            'name' => 'Mark',
            'files[owl.gif]' => Request\Body::File($fixture)
        ));
        $this->assertEquals(200, $response->code);
        $this->assertEquals('POST', $response->body->method);
        $this->assertEquals('Mark', $response->body->postData->params->name);
        $this->assertEquals('This is a test', $response->body->postData->params->{'files[owl.gif]'});
    }
 }
--- a/tests/Unirest/ResponseTest.php
+++ b/tests/Unirest/ResponseTest.php
@@ -0,0 +1,35 @@
 <?php
 namespace Unirest\Response\Test;
 use Unirest\Request as Request;
 use Unirest\Response as Response;
 require __DIR__ . '/../../src/Unirest.php';
 class UnirestResponseTest extends \PHPUnit_Framework_TestCase
 {
    public function testJSONAssociativeArrays()
    {
        $opts = Request::jsonOpts(true);
        $response = new Response(200, '{"a":1,"b":2,"c":3,"d":4,"e":5}', '', $opts);
        $this->assertEquals($response->body['a'], 1);
    }
    public function testJSONAObjects()
    {
        $opts = Request::jsonOpts(false);
        $response = new Response(200, '{"a":1,"b":2,"c":3,"d":4,"e":5}', '', $opts);
        $this->assertEquals($response->body->a, 1);
    }
    public function testJSONOpts()
    {
        $opts = Request::jsonOpts(false, 512, JSON_NUMERIC_CHECK);
        $response = new Response(200, '{"number": 1234567890}', '', $opts);
        $this->assertSame($response->body->number, 1234567890);
    }
 }
--- a/tests/bootstrap.php
+++ b/tests/bootstrap.php
@@ -0,0 +1 @@
 <?php ?>
--- a/test/Unirest/test_upload.txt
+++ b/test/Unirest/test_upload.txt
Author	SHA1	Message	Date
Ahmad Nassri	53656bf519	Merge pull request #105 from voodoodrul/patch-2 Don't use CURLOPT_CUSTOMREQUEST for POSTs	2016-04-29 19:54:44 -04:00
Ahmad Nassri	889ca14f5f	Merge pull request #106 from Lozzano/master Fixing current version in README.	2016-04-25 10:03:29 -04:00
André Valentin	45274fd536	Fixing current version in README. The current version wasn't showed as the one people should add in their composer files. Updated from 2.* to 3.*.	2016-04-25 15:02:42 +02:00
Jesse Skrivseth	a3446f6d99	Update Request.php Remove curl_setopt(self::$handle, CURLOPT_POSTREDIR, 3); in favor of the caller being well-behaved and setting this option as needed	2016-04-19 23:05:11 -06:00
Jesse Skrivseth	e9ea4dbee2	Don't use CURLOPT_CUSTOMREQUEST for POSTs I think the current usage of CURLOPT_CUSTOMREQUEST is wrong. As far as I can tell CURLOPT_CUSTOMREQUEST = Method::POST is not the same thing as CURLOPT_POST = true. I struggled for hours with POSTed data not being accepted by IIS. First IIS threw an HTTP 411 due to curl not sending a Content-Length header. That is solved by replacing CURLOPT_CUSTOMREQUEST with CURLOPT_POST in the case of actual POSTs. Also, IIS in my case returns an HTTP 301 redirect, which I need Unirest to follow, so I set the CURLOPT_POSTREDIR = 3 in order to let the POST follow on redirect via 301 or 302. Notice this: https://curl.haxx.se/libcurl/c/CURLOPT_CUSTOMREQUEST.html - "Many people have wrongly used this option to replace the entire request with their own, including multiple headers and POST contents. While that might work in many cases, it will cause libcurl to send invalid requests and it could possibly confuse the remote server badly. Use CURLOPT_POST and CURLOPT_POSTFIELDS to set POST data. Use CURLOPT_HTTPHEADER to replace or extend the set of headers sent by libcurl. Use CURLOPT_HTTP_VERSION to change HTTP version." In any case, I know that the CURLOPT_POSTREDIR option probably shouldn't go here and should be client configurable, but I can't find a good place for it. It would be nice to have one-shot $curlOpts passed in with the send method, or curlOpts() that otherwise live for only one curl_exec().	2016-04-19 22:49:27 -06:00
Colin Hutchinson	d71cd15d4a	Merge pull request #102 from xcopy/master Typofix	2016-04-14 08:33:01 -04:00
Kairat Jenishev	2d0cd4c8d9	Typofix	2016-04-14 17:01:32 +06:00
Ahmad Nassri	c01f685e3b	Merge pull request #98 from RusinovIG/master Issue with priority of headers	2016-03-23 00:18:08 -04:00
Igor Rusinov	28080c975c	Fixedissue with priority of headers	2016-03-20 20:53:52 +03:00
Ahmad Nassri	2bedcf05ac	docs(readme): fix content-types in labels [ci skip]	2016-02-24 23:27:05 -05:00
Ahmad Nassri	b6328f270f	chore(travis): fix namespacing issues	2016-02-24 23:23:54 -05:00
Ahmad Nassri	1e86cc751f	chore(travis): move to container mode in travis	2016-02-24 23:13:33 -05:00
Ahmad Nassri	825cee7dc7	chore(travis): fix namespacing issues	2016-02-24 23:12:45 -05:00
Ahmad Nassri	eb470e929c	chore(travis): test on all current PHP versions	2016-02-24 23:02:39 -05:00
Ahmad Nassri	d23cdc5593	refactor(request): request body management is now externalized to helper methods	2016-02-24 23:01:21 -05:00
Ahmad Nassri	0f3a22d63e	feat(json): json pecl extension may be available all the time	2016-02-24 22:07:25 -05:00
Ahmad Nassri	f7f13bd940	Merge pull request #91 from Furgas/fix-curlfile Fix creating CURLFile	2016-02-16 14:25:22 -05:00
Tomasz Sawicki	d950a88257	Fix creating CURLFile	2016-02-16 19:54:45 +01:00
Ahmad Nassri	73c2d90323	Merge pull request #90 from Furgas/fix-phpdoc Fix PHPDoc	2016-02-16 11:45:52 -05:00
Tomasz Sawicki	d0fc831a00	Fix PHPDoc	2016-02-16 10:49:00 +01:00
Ahmad Nassri	4a480b156b	Merge pull request #89 from RusinovIG/master Fixed setting of default headers array	2016-01-20 14:41:35 -05:00
Igor Rusinov	ca6a3b1daf	Fixed setting of default headers array	2016-01-18 23:24:14 +03:00
Ahmad Nassri	da71f063cf	Merge pull request #88 from frankdee/master improved solution to override cURL options …	2015-12-15 17:22:11 -05:00
frankdee	be5ee63ad1	shortened cURL options array merging	2015-12-14 19:17:31 +01:00
frankdee	32334a6bfa	improved solution to override cURL options, that preserves the right indices in cURL option arrays (Note: PHP seems to not override all options when calling 'curl_setopt_array(..)' several times after another)	2015-12-14 13:55:49 +01:00
Ahmad Nassri	e11c54d29c	Merge pull request #86 from Mashape/curlopts-override-fix allow to override curlopts	2015-12-11 18:41:55 -05:00
Ahmad Nassri	a3312a0ecd	allow to override curlopts	2015-12-11 18:38:09 -05:00
Augusto Marietti	fde6f41733	Update README.md	2015-10-16 19:40:03 -07:00
Ahmad Nassri	75258a2024	Merge pull request #83 from mircobabini/patch-1 fix composer command	2015-09-03 11:12:21 -04:00
Mirco Babini	b330685820	fix composer command	2015-09-03 15:39:52 +02:00
Augusto Marietti	2f7aea9f63	Update README.md	2015-07-28 00:27:17 -07:00
Ahmad Nassri	f04b42e75e	Merge pull request #81 from gabrielzerbib/master phpdoc return type for ::post	2015-07-27 12:17:35 -07:00
Gabriel Zerbib	32c1a9fef0	Merge branch 'master' of https://github.com/gabrielzerbib/unirest-php	2015-07-27 22:07:56 +03:00
Gabriel	2b5b349036	phpdoc return type for ::post	2015-07-27 22:07:05 +03:00
Gabriel	1017f14ef5	phpdoc return type for ::post	2015-07-27 14:57:24 +03:00
Ahmad Nassri	99c6975f23	Merge pull request #79 from voodoodrul/patch-1 Allow disabling of CURLOPT_SSL_VERIFYHOST	2015-06-08 13:29:31 -04:00
Jesse Skrivseth	f257217434	Fix CURLOPT_SSL_VERIFYHOST issue libcurl's CURLOPT_SSL_VERIFYHOST option accepts only values 0 and 2. This fix is fail-secure in that SSL host verification will be enabled regardless of what a caller passes to Request::verifyHost($bool) unless $bool === false.	2015-06-08 08:50:58 -06:00
Jesse Skrivseth	c9c0a85250	Allow disabling of CURLOPT_SSL_VERIFYHOST Useful when the SSL cert has an invalid or non-resolvable hostname	2015-06-05 19:50:11 -06:00
Ahmad Nassri	3e375515fe	Update README.md	2015-04-22 11:40:44 -04:00
Ahmad Nassri	b6fb76ce12	oops, forgot notifications	2015-04-09 12:29:10 -04:00
Ahmad Nassri	5926846300	events are required for gitter hook?	2015-04-09 12:02:12 -04:00
Ahmad Nassri	feae18f980	add gitter webhook	2015-04-09 11:22:15 -04:00
Ahmad Nassri	b0df287d64	README fix	2015-04-08 17:36:02 -04:00
Ahmad Nassri	4221ee5138	setting custom curl options - `Unirest\Request::curlOpt()` - `Unirest\Request::curlOpts()` - `Unirest\Request::clearCurlOpts()` fixes #78	2015-04-08 17:35:14 -04:00
Ahmad Nassri	ec5828c8aa	Merge pull request #77 from cristianp6/master Fixed "Undefined variable: ch" and add cookie string support	2015-04-03 13:08:41 -04:00
cristianp6	0293eb258c	Add cookie string support, aka CURLOPT_COOKIE	2015-04-03 12:04:49 +02:00
cristianp6	a1ed45be55	Fixed "Notice: Undefined variable: ch" on curl_setopt cookieFile	2015-04-03 11:16:17 +02:00
Ahmad Nassri	8da79e7898	updating README and fixing typo	2015-04-02 14:22:32 -04:00
Ahmad Nassri	217b436124	manually applying PR by @daydiff due to complex merge issues, closes #67	2015-04-02 14:11:23 -04:00
Ahmad Nassri	d508bd9628	Merge pull request #76 from vlakarados/master Add PHP version to readme.md's requirements	2015-03-30 03:40:31 -04:00
Sergey Telshevsky	7116894dad	Add PHP version to readme.md's requirements	2015-03-30 10:33:46 +03:00
Ahmad Nassri	f31ce371a0	updating all tests and docs to mockbins.com	2015-03-07 06:00:42 -05:00
Ahmad Nassri	530905c7c9	switch to using curl_setopt_array for better readability, added utility methods Fixes #66	2015-03-01 02:48:16 -05:00
Ahmad Nassri	139b58019c	Merge pull request #68 from thibaultCha/feature/set-mashape-key Native 'setMashapeKey' method for X-Mashape-Key header	2015-02-10 20:16:30 -08:00
thibaultCha	8b47e051ba	Set Mashape Key by calling setDefaultHeader	2015-02-05 23:02:12 -08:00
thibaultCha	491064f40b	Add test for setMashapeKey	2015-02-05 21:09:01 -08:00
thibaultCha	fb241f6898	Native 'setMashapeKey' method for X-Mashape-Key header	2015-02-05 20:49:06 -08:00
Ahmad Nassri	f6fc64103f	Update README.md	2015-02-05 14:31:38 -05:00
Ahmad Nassri	11cf1eaa9f	Update README.md	2015-02-05 14:04:02 -05:00
Ahmad Nassri	d5a7ad40bd	fix to deprecated method + more tests	2015-02-05 13:00:49 -05:00
Ahmad Nassri	8af870ff69	fix depreicated method as well!	2015-02-05 12:53:30 -05:00
Ahmad Nassri	ae01978eb3	php 5.4 cURL does not support setting username and password separately	2015-02-05 12:48:56 -05:00
Ahmad Nassri	2074abf904	keeping deprecated auth method functional	2015-02-05 12:22:46 -05:00
Ahmad Nassri	96cdf61101	allowing all native libcurl authentication methods	2015-02-05 12:19:47 -05:00
Ahmad Nassri	002c175cd1	typo fix	2015-02-05 11:41:42 -05:00
Ahmad Nassri	c5be546d1b	Proxies! closes #47	2015-02-05 11:33:59 -05:00
Ahmad Nassri	5fa02336f9	rounded corners for badges	2015-01-15 17:31:04 -05:00
Ahmad Nassri	23c3cb5b00	fix badge + unified description	2015-01-15 17:15:37 -05:00
Ahmad Nassri	8ce5204c37	updates to badges and text	2015-01-15 15:25:45 -05:00
Ahmad Nassri	90be29ced4	typo	2015-01-15 01:47:58 -05:00
Ahmad Nassri	8dcb11e0a6	updating README with new info	2015-01-15 01:46:21 -05:00
Ahmad Nassri	3591292c3e	eliminating code smells and converting Unirest\Request::send into a public method	2015-01-15 01:42:43 -05:00
Ahmad Nassri	3ec25a5d17	adjusting requirements	2015-01-15 01:32:53 -05:00
Ahmad Nassri	fbe66400fc	allow hhvm to fail	2015-01-15 01:30:10 -05:00
Ahmad Nassri	f68939375b	closing code	2015-01-15 01:25:30 -05:00
Ahmad Nassri	ba25e0304a	JSON Decoding options - users can now specify all the json_decode params to be used - additional method added: `Unirest\Request::defaultHeaders`	2015-01-15 01:22:23 -05:00
Ahmad Nassri	3bb82974cc	codeclimate seems to have a self-signed ssl, which causes errors in travis	2015-01-15 00:33:18 -05:00
Ahmad Nassri	3eb8536d3d	new test to validate #58	2015-01-15 00:30:47 -05:00
Ahmad Nassri	4762858017	fixing ext-json dependency for older php	2015-01-15 00:16:40 -05:00
Ahmad Nassri	7404fca828	minor update to README & Travis fix	2015-01-15 00:12:52 -05:00
Ahmad Nassri	1dfcade505	Update README.md	2015-01-14 21:47:33 -05:00
Ahmad Nassri	976247358b	Update README.md	2015-01-14 21:45:22 -05:00
Ahmad Nassri	a58c5592d5	Update README.md	2015-01-14 21:45:01 -05:00
Ahmad Nassri	3ffe191c1c	Merge pull request #63 from Mashape/cleanup removing github image-url	2015-01-14 20:11:11 -05:00
Ahmad Nassri	d7d9c35696	removing github image-url	2015-01-14 20:10:46 -05:00
Ahmad Nassri	9461d6664c	Merge pull request #60 from Mashape/cleanup v2.0.0	2015-01-14 20:08:48 -05:00
Ahmad Nassri	d188bcbd15	fix typo	2015-01-14 20:06:10 -05:00
Ahmad Nassri	1ad47092de	PHP 5.4 test	2015-01-14 20:01:38 -05:00
Ahmad Nassri	bcc2a3bc19	adding mashape logo	2015-01-14 19:53:33 -05:00
Ahmad Nassri	aff17227d4	typo	2015-01-14 19:48:14 -05:00
Ahmad Nassri	eaaca57797	gitter integration	2015-01-14 19:45:07 -05:00
Ahmad Nassri	e6f9dc1d01	updating README	2015-01-14 19:38:48 -05:00
Ahmad Nassri	9a67f24f34	removing scruitinizer	2015-01-14 19:25:37 -05:00
Ahmad Nassri	2a07cffe54	travis to send coverage reports	2015-01-14 19:25:18 -05:00
Ahmad Nassri	0b29426d7f	adding codeclimate and updating README	2015-01-14 19:24:20 -05:00
Ahmad Nassri	c1018cc344	just some ordering	2015-01-14 18:44:05 -05:00
Ahmad Nassri	4f156e59fd	improving tests	2015-01-14 18:40:21 -05:00
Ahmad Nassri	be9bca1d5a	splitting out Unirest\File and updating README	2015-01-14 18:31:21 -05:00
Ahmad Nassri	ed2a2df982	updating Request utility methods to match all of RFC7231	2015-01-14 18:15:13 -05:00
Ahmad Nassri	7a6df4cb82	adding the full scope of the HTTP Methods registery	2015-01-14 18:07:10 -05:00
Ahmad Nassri	34db4e958f	spacing cleanup	2015-01-14 17:47:20 -05:00
Ahmad Nassri	2bbafd950d	updating editorconfig settings	2015-01-14 17:46:52 -05:00
Ahmad Nassri	601c20c6ca	updating mashape url and email	2015-01-14 17:38:04 -05:00
Ahmad Nassri	b4b4b85a69	updating copyright year	2015-01-13 16:22:03 -05:00
Ahmad Nassri	f0b84f49ca	proper mashape url	2015-01-13 16:21:23 -05:00
Ahmad Nassri	2279d98f6a	two whitespaces	2015-01-13 16:21:06 -05:00
Ahmad Nassri	fe8591361b	proper json formating	2015-01-13 16:20:38 -05:00
Ahmad Nassri	87f5c54308	fixing travis build	2014-12-18 01:19:38 -05:00
Ahmad Nassri	eccbc76469	improving curl post body flattening for multidimensional arrays	2014-12-18 01:16:40 -05:00
Ahmad Nassri	d004129842	more scrutinizer-ci	2014-12-18 00:08:12 -05:00
Ahmad Nassri	97f51e1269	fixes from scrutinizer-ci	2014-12-18 00:05:49 -05:00
Ahmad Nassri	ed76b17884	test fixes	2014-12-17 23:57:27 -05:00
Ahmad Nassri	8ee4ba0753	adding a better query string parser that can handle arrays	2014-12-17 23:57:06 -05:00
Ahmad Nassri	dd9edca044	fixing phpunit test directory	2014-12-17 23:56:17 -05:00
Ahmad Nassri	814cee98fc	removing php5.3	2014-12-17 23:56:06 -05:00
Ahmad Nassri	07aa7ab19f	removing redundant setter/getter + adding PECL_HTTP like header parsing	2014-12-17 23:03:20 -05:00
Ahmad Nassri	c7b73c8316	identation fix	2014-12-17 22:45:58 -05:00
Ahmad Nassri	b6efa7e1cc	PSR compliance	2014-12-17 22:44:33 -05:00
Ahmad Nassri	6347fa33ee	modifying directory name to standard usage	2014-12-17 22:38:46 -05:00
Ahmad Nassri	cda471ebdb	removing extra dependency	2014-12-17 22:33:07 -05:00
Ahmad Nassri	61eb281692	massive cleanups - renamed classes - updated to phpunit - more PSR compliance	2014-12-17 22:29:03 -05:00
Ahmad Nassri	ea3995225c	PSR: PHP keywords in proper lower case + more camelCasing	2014-12-17 21:06:53 -05:00
Ahmad Nassri	4e68b0efab	PSR: CamelCaps	2014-12-17 21:00:47 -05:00
Ahmad Nassri	9465a4656a	specifying PSR-2 level checks	2014-12-17 20:57:23 -05:00
Ahmad Nassri	2d4f23af38	various cleanups - added Scrutinizer - added EditorConfig - removed closing php tags - proper usage of require_once - cleaned extra spacing	2014-12-17 20:47:57 -05:00
Ahmad Nassri	2bd214f2d9	pass additional params to request method to ask for associative json objects	2014-12-17 18:54:05 -05:00
Ahmad Nassri	6e615557cc	fixes #24 allows for an extra param to decode json objects into associative arrays	2014-12-17 18:51:36 -05:00
Nijiko Yonskai	e362fe01ec	Update README.md	2014-05-01 12:54:50 -07:00
Marco Palladino	461060202c	Merge pull request #40 from tsnyder91/master file attachments/uploads assumes always in root namespace	2014-04-05 19:38:31 -07:00
Tony Snyder	8020af6f71	fixes assumption of being in root namespace.	2014-04-04 12:12:12 -05:00