upgrade hyper to v0.11

src/async_impl/body.rs

@@ -0,0 +1,117 @@
+use std::fmt;
+
+use futures::{Stream, Poll, Async};
+use bytes::Bytes;
+
+/// An asynchronous `Stream`.
+pub struct Body {
+    inner: Inner,
+}
+
+enum Inner {
+    Reusable(Bytes),
+    Hyper(::hyper::Body),
+}
+
+impl Body {
+    fn poll_inner(&mut self) -> &mut ::hyper::Body {
+        match self.inner {
+            Inner::Hyper(ref mut body) => body,
+            Inner::Reusable(_) => unreachable!(),
+        }
+    }
+}
+
+impl Stream for Body {
+    type Item = Chunk;
+    type Error = ::Error;
+
+    #[inline]
+    fn poll(&mut self) -> Poll<Option<Self::Item>, Self::Error> {
+        match try_!(self.poll_inner().poll()) {
+            Async::Ready(opt) => Ok(Async::Ready(opt.map(|chunk| Chunk {
+                inner: chunk,
+            }))),
+            Async::NotReady => Ok(Async::NotReady),
+        }
+    }
+}
+
+
+/// A chunk of bytes for a `Body`.
+///
+/// A `Chunk` can be treated like `&[u8]`.
+#[derive(Default)]
+pub struct Chunk {
+    inner: ::hyper::Chunk,
+}
+
+impl ::std::ops::Deref for Chunk {
+    type Target = [u8];
+    #[inline]
+    fn deref(&self) -> &Self::Target {
+        self.inner.as_ref()
+    }
+}
+
+impl Extend<u8> for Chunk {
+    fn extend<T>(&mut self, iter: T)
+    where T: IntoIterator<Item=u8> {
+        self.inner.extend(iter)
+    }
+}
+
+impl IntoIterator for Chunk {
+    type Item = u8;
+    //XXX: exposing type from hyper!
+    type IntoIter = <::hyper::Chunk as IntoIterator>::IntoIter;
+    fn into_iter(self) -> Self::IntoIter {
+        self.inner.into_iter()
+    }
+}
+
+impl fmt::Debug for Body {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        f.debug_struct("Body")
+            .finish()
+    }
+}
+
+impl fmt::Debug for Chunk {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        fmt::Debug::fmt(&self.inner, f)
+    }
+}
+
+// pub(crate)
+
+#[inline]
+pub fn wrap(body: ::hyper::Body) -> Body {
+    Body {
+        inner: Inner::Hyper(body),
+    }
+}
+
+#[inline]
+pub fn take(body: &mut Body) -> Body {
+    use std::mem;
+    let inner = mem::replace(&mut body.inner, Inner::Hyper(::hyper::Body::empty()));
+    Body {
+        inner: inner,
+    }
+}
+
+#[inline]
+pub fn reusable(chunk: Bytes) -> Body {
+    Body {
+        inner: Inner::Reusable(chunk),
+    }
+}
+
+#[inline]
+pub fn into_hyper(body: Body) -> (Option<Bytes>, ::hyper::Body) {
+    match body.inner {
+        Inner::Reusable(chunk) => (Some(chunk.clone()), chunk.into()),
+        Inner::Hyper(b) => (None, b),
+    }
+}

src/async_impl/client.rs

@@ -0,0 +1,537 @@
+use std::fmt;
+use std::sync::Arc;
+use std::time::Duration;
+
+use bytes::Bytes;
+use futures::{Async, Future, Poll};
+use hyper::client::FutureResponse;
+use hyper::header::{Headers, Location, Referer, UserAgent, Accept, Encoding,
+                    AcceptEncoding, Range, qitem};
+use native_tls::{TlsConnector, TlsConnectorBuilder};
+use tokio_core::reactor::Handle;
+
+
+use super::body;
+use super::request::{self, Request, RequestBuilder};
+use super::response::{self, Response};
+use redirect::{self, RedirectPolicy, check_redirect, remove_sensitive_headers};
+use {Certificate, IntoUrl, Method, StatusCode, Url};
+
+static DEFAULT_USER_AGENT: &'static str =
+    concat!(env!("CARGO_PKG_NAME"), "/", env!("CARGO_PKG_VERSION"));
+
+/// A `Client` to make Requests with.
+///
+/// The Client has various configuration values to tweak, but the defaults
+/// are set to what is usually the most commonly desired value.
+///
+/// The `Client` holds a connection pool internally, so it is advised that
+/// you create one and reuse it.
+///
+/// # Examples
+///
+/// ```rust
+/// # use reqwest::{Error, Client};
+/// #
+/// # fn run() -> Result<(), Error> {
+/// let client = Client::new()?;
+/// let resp = client.get("http://httpbin.org/")?.send()?;
+/// #   drop(resp);
+/// #   Ok(())
+/// # }
+///
+/// ```
+#[derive(Clone)]
+pub struct Client {
+    inner: Arc<ClientRef>,
+}
+
+/// A `ClientBuilder` can be used to create a `Client` with  custom configuration:
+///
+/// - with hostname verification disabled
+/// - with one or multiple custom certificates
+///
+/// # Examples
+///
+/// ```
+/// # use std::fs::File;
+/// # use std::io::Read;
+/// # fn build_client() -> Result<(), Box<std::error::Error>> {
+/// // read a local binary DER encoded certificate
+/// let mut buf = Vec::new();
+/// File::open("my-cert.der")?.read_to_end(&mut buf)?;
+///
+/// // create a certificate
+/// let cert = reqwest::Certificate::from_der(&buf)?;
+///
+/// // get a client builder
+/// let client = reqwest::ClientBuilder::new()?
+///     .add_root_certificate(cert)?
+///     .build()?;
+/// # drop(client);
+/// # Ok(())
+/// # }
+/// ```
+pub struct ClientBuilder {
+    config: Option<Config>,
+}
+
+struct Config {
+    gzip: bool,
+    hostname_verification: bool,
+    redirect_policy: RedirectPolicy,
+    referer: bool,
+    timeout: Option<Duration>,
+    tls: TlsConnectorBuilder,
+}
+
+impl ClientBuilder {
+    /// Constructs a new `ClientBuilder`
+    ///
+    /// # Errors
+    ///
+    /// This method fails if native TLS backend cannot be created.
+    pub fn new() -> ::Result<ClientBuilder> {
+        let tls_connector_builder = try_!(TlsConnector::builder());
+        Ok(ClientBuilder {
+            config: Some(Config {
+                gzip: true,
+                hostname_verification: true,
+                redirect_policy: RedirectPolicy::default(),
+                referer: true,
+                timeout: None,
+                tls: tls_connector_builder,
+            })
+        })
+    }
+
+    /// Returns a `Client` that uses this `ClientBuilder` configuration.
+    ///
+    /// # Errors
+    ///
+    /// This method fails if native TLS backend cannot be initialized.
+    ///
+    /// # Panics
+    ///
+    /// This method consumes the internal state of the builder.
+    /// Trying to use this builder again after calling `build` will panic.
+    pub fn build(&mut self, handle: &Handle) -> ::Result<Client> {
+        let config = self.take_config();
+
+        let tls = try_!(config.tls.build());
+
+        /*
+        let mut tls_client = NativeTlsClient::from(tls_connector);
+        if !config.hostname_verification {
+            tls_client.danger_disable_hostname_verification(true);
+        }
+        */
+
+        let hyper_client = create_hyper_client(tls, handle);
+        //let mut hyper_client = create_hyper_client(tls_client);
+
+        //hyper_client.set_read_timeout(config.timeout);
+        //hyper_client.set_write_timeout(config.timeout);
+
+        Ok(Client {
+            inner: Arc::new(ClientRef {
+                gzip: config.gzip,
+                hyper: hyper_client,
+                redirect_policy: config.redirect_policy,
+                referer: config.referer,
+            }),
+        })
+    }
+
+    /// Add a custom root certificate.
+    ///
+    /// This can be used to connect to a server that has a self-signed
+    /// certificate for example.
+    ///
+    /// # Errors
+    ///
+    /// This method fails if adding root certificate was unsuccessful.
+    pub fn add_root_certificate(&mut self, cert: Certificate) -> ::Result<&mut ClientBuilder> {
+        let cert = ::tls::cert(cert);
+        try_!(self.config_mut().tls.add_root_certificate(cert));
+        Ok(self)
+    }
+
+    /// Disable hostname verification.
+    ///
+    /// # Warning
+    ///
+    /// You should think very carefully before you use this method. If
+    /// hostname verification is not used, any valid certificate for any
+    /// site will be trusted for use from any other. This introduces a
+    /// significant vulnerability to man-in-the-middle attacks.
+    #[inline]
+    pub fn danger_disable_hostname_verification(&mut self) -> &mut ClientBuilder {
+        self.config_mut().hostname_verification = false;
+        self
+    }
+
+    /// Enable hostname verification.
+    #[inline]
+    pub fn enable_hostname_verification(&mut self) -> &mut ClientBuilder {
+        self.config_mut().hostname_verification = true;
+        self
+    }
+
+    /// Enable auto gzip decompression by checking the ContentEncoding response header.
+    ///
+    /// Default is enabled.
+    #[inline]
+    pub fn gzip(&mut self, enable: bool) -> &mut ClientBuilder {
+        self.config_mut().gzip = enable;
+        self
+    }
+
+    /// Set a `RedirectPolicy` for this client.
+    ///
+    /// Default will follow redirects up to a maximum of 10.
+    #[inline]
+    pub fn redirect(&mut self, policy: RedirectPolicy) -> &mut ClientBuilder {
+        self.config_mut().redirect_policy = policy;
+        self
+    }
+
+    /// Enable or disable automatic setting of the `Referer` header.
+    ///
+    /// Default is `true`.
+    #[inline]
+    pub fn referer(&mut self, enable: bool) -> &mut ClientBuilder {
+        self.config_mut().referer = enable;
+        self
+    }
+
+    /// Set a timeout for both the read and write operations of a client.
+    #[inline]
+    pub fn timeout(&mut self, timeout: Duration) -> &mut ClientBuilder {
+        self.config_mut().timeout = Some(timeout);
+        self
+    }
+
+    // private
+    fn config_mut(&mut self) -> &mut Config {
+        self.config
+            .as_mut()
+            .expect("ClientBuilder cannot be reused after building a Client")
+    }
+
+    fn take_config(&mut self) -> Config {
+        self.config
+            .take()
+            .expect("ClientBuilder cannot be reused after building a Client")
+    }
+}
+
+type HyperClient = ::hyper::Client<::hyper_tls::HttpsConnector<::hyper::client::HttpConnector>>;
+
+fn create_hyper_client(tls: TlsConnector, handle: &Handle) -> HyperClient {
+    let mut http = ::hyper::client::HttpConnector::new(4, handle);
+    http.enforce_http(false);
+    let https = ::hyper_tls::HttpsConnector::from((http, tls));
+    ::hyper::Client::configure()
+        .connector(https)
+        .build(handle)
+}
+
+impl Client {
+    /// Constructs a new `Client`.
+    ///
+    /// # Errors
+    ///
+    /// This method fails if native TLS backend cannot be created or initialized.
+    #[inline]
+    pub fn new(handle: &Handle) -> ::Result<Client> {
+        ClientBuilder::new()?.build(handle)
+    }
+
+    /// Creates a `ClientBuilder` to configure a `Client`.
+    ///
+    /// # Errors
+    ///
+    /// This method fails if native TLS backend cannot be created.
+    #[inline]
+    pub fn builder() -> ::Result<ClientBuilder> {
+        ClientBuilder::new()
+    }
+
+    /// Convenience method to make a `GET` request to a URL.
+    ///
+    /// # Errors
+    ///
+    /// This method fails whenever supplied `Url` cannot be parsed.
+    pub fn get<U: IntoUrl>(&self, url: U) -> ::Result<RequestBuilder> {
+        self.request(Method::Get, url)
+    }
+
+    /// Convenience method to make a `POST` request to a URL.
+    ///
+    /// # Errors
+    ///
+    /// This method fails whenever supplied `Url` cannot be parsed.
+    pub fn post<U: IntoUrl>(&self, url: U) -> ::Result<RequestBuilder> {
+        self.request(Method::Post, url)
+    }
+
+    /// Convenience method to make a `PUT` request to a URL.
+    ///
+    /// # Errors
+    ///
+    /// This method fails whenever supplied `Url` cannot be parsed.
+    pub fn put<U: IntoUrl>(&self, url: U) -> ::Result<RequestBuilder> {
+        self.request(Method::Put, url)
+    }
+
+    /// Convenience method to make a `PATCH` request to a URL.
+    ///
+    /// # Errors
+    ///
+    /// This method fails whenever supplied `Url` cannot be parsed.
+    pub fn patch<U: IntoUrl>(&self, url: U) -> ::Result<RequestBuilder> {
+        self.request(Method::Patch, url)
+    }
+
+    /// Convenience method to make a `DELETE` request to a URL.
+    ///
+    /// # Errors
+    ///
+    /// This method fails whenever supplied `Url` cannot be parsed.
+    pub fn delete<U: IntoUrl>(&self, url: U) -> ::Result<RequestBuilder> {
+        self.request(Method::Delete, url)
+    }
+
+    /// Convenience method to make a `HEAD` request to a URL.
+    ///
+    /// # Errors
+    ///
+    /// This method fails whenever supplied `Url` cannot be parsed.
+    pub fn head<U: IntoUrl>(&self, url: U) -> ::Result<RequestBuilder> {
+        self.request(Method::Head, url)
+    }
+
+    /// Start building a `Request` with the `Method` and `Url`.
+    ///
+    /// Returns a `RequestBuilder`, which will allow setting headers and
+    /// request body before sending.
+    ///
+    /// # Errors
+    ///
+    /// This method fails whenever supplied `Url` cannot be parsed.
+    pub fn request<U: IntoUrl>(&self, method: Method, url: U) -> ::Result<RequestBuilder> {
+        let url = try_!(url.into_url());
+        Ok(request::builder(self.clone(), Request::new(method, url)))
+    }
+
+    /// Executes a `Request`.
+    ///
+    /// A `Request` can be built manually with `Request::new()` or obtained
+    /// from a RequestBuilder with `RequestBuilder::build()`.
+    ///
+    /// You should prefer to use the `RequestBuilder` and
+    /// `RequestBuilder::send()`.
+    ///
+    /// # Errors
+    ///
+    /// This method fails if there was an error while sending request,
+    /// redirect loop was detected or redirect limit was exhausted.
+    pub fn execute(&self, request: Request) -> Pending {
+        self.execute_request(request)
+    }
+
+
+    fn execute_request(&self, req: Request) -> Pending {
+        let (
+            method,
+            url,
+            mut headers,
+            body
+        ) = request::pieces(req);
+
+        if !headers.has::<UserAgent>() {
+            headers.set(UserAgent::new(DEFAULT_USER_AGENT));
+        }
+
+        if !headers.has::<Accept>() {
+            headers.set(Accept::star());
+        }
+        if self.inner.gzip &&
+            !headers.has::<AcceptEncoding>() &&
+            !headers.has::<Range>() {
+            headers.set(AcceptEncoding(vec![qitem(Encoding::Gzip)]));
+        }
+
+        let mut req = ::hyper::Request::new(method.clone(), url_to_uri(&url));
+        *req.headers_mut() = headers.clone();
+        let body = body.and_then(|body| {
+            let (resuable, body) = body::into_hyper(body);
+            req.set_body(body);
+            resuable
+        });
+
+        let in_flight = self.inner.hyper.request(req);
+
+        Pending {
+            method: method,
+            url: url,
+            headers: headers,
+            body: body,
+
+            urls: Vec::new(),
+
+            client: self.inner.clone(),
+
+            in_flight: in_flight,
+        }
+    }
+}
+
+impl fmt::Debug for Client {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        f.debug_struct("Client")
+            .field("gzip", &self.inner.gzip)
+            .field("redirect_policy", &self.inner.redirect_policy)
+            .field("referer", &self.inner.referer)
+            .finish()
+    }
+}
+
+impl fmt::Debug for ClientBuilder {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        f.debug_struct("ClientBuilder")
+            .finish()
+    }
+}
+
+struct ClientRef {
+    gzip: bool,
+    hyper: HyperClient,
+    redirect_policy: RedirectPolicy,
+    referer: bool,
+}
+
+pub struct Pending {
+    method: Method,
+    url: Url,
+    headers: Headers,
+    body: Option<Bytes>,
+
+    urls: Vec<Url>,
+
+    client: Arc<ClientRef>,
+
+    in_flight: FutureResponse,
+}
+
+impl Future for Pending {
+    type Item = Response;
+    type Error = ::Error;
+
+    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
+        loop {
+            let res = match try_!(self.in_flight.poll(), &self.url) {
+                Async::Ready(res) => res,
+                Async::NotReady => return Ok(Async::NotReady),
+            };
+            let should_redirect = match res.status() {
+                StatusCode::MovedPermanently |
+                StatusCode::Found |
+                StatusCode::SeeOther => {
+                    self.body = None;
+                    match self.method {
+                        Method::Get | Method::Head => {},
+                        _ => {
+                            self.method = Method::Get;
+                        }
+                    }
+                    true
+                },
+                StatusCode::TemporaryRedirect |
+                StatusCode::PermanentRedirect => {
+                    self.body.is_some()
+                },
+                _ => false,
+            };
+            if should_redirect {
+                let loc = res.headers()
+                    .get::<Location>()
+                    .map(|loc| self.url.join(loc));
+                if let Some(Ok(loc)) = loc {
+                    if self.client.referer {
+                        if let Some(referer) = make_referer(&loc, &self.url) {
+                            self.headers.set(referer);
+                        }
+                    }
+                    self.urls.push(self.url.clone());
+                    let action = check_redirect(&self.client.redirect_policy, &loc, &self.urls);
+
+                    match action {
+                        redirect::Action::Follow => {
+                            self.url = loc;
+
+                            remove_sensitive_headers(&mut self.headers, &self.url, &self.urls);
+                            debug!("redirecting to {:?} '{}'", self.method, self.url);
+                            let mut req = ::hyper::Request::new(
+                                self.method.clone(),
+                                url_to_uri(&self.url)
+                            );
+                            *req.headers_mut() = self.headers.clone();
+                            if let Some(ref body) = self.body {
+                                req.set_body(body.clone());
+                            }
+                            self.in_flight = self.client.hyper.request(req);
+                            continue;
+                        },
+                        redirect::Action::Stop => {
+                            debug!("redirect_policy disallowed redirection to '{}'", loc);
+                        },
+                        redirect::Action::LoopDetected => {
+                            return Err(::error::loop_detected(self.url.clone()));
+                        },
+                        redirect::Action::TooManyRedirects => {
+                            return Err(::error::too_many_redirects(self.url.clone()));
+                        }
+                    }
+                } else if let Some(Err(e)) = loc {
+                    debug!("Location header had invalid URI: {:?}", e);
+                }
+            }
+            let res = response::new(res, self.url.clone(), self.client.gzip);
+            return Ok(Async::Ready(res));
+        }
+    }
+}
+
+impl fmt::Debug for Pending {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        f.debug_struct("Pending")
+            .field("method", &self.method)
+            .field("url", &self.url)
+            .finish()
+    }
+}
+
+fn make_referer(next: &Url, previous: &Url) -> Option<Referer> {
+    if next.scheme() == "http" && previous.scheme() == "https" {
+        return None;
+    }
+
+    let mut referer = previous.clone();
+    let _ = referer.set_username("");
+    let _ = referer.set_password(None);
+    referer.set_fragment(None);
+    Some(Referer::new(referer.into_string()))
+}
+
+fn url_to_uri(url: &Url) -> ::hyper::Uri {
+    url.as_str().parse().expect("a parsed Url should always be a valid Uri")
+}
+
+// pub(crate)
+
+pub fn take_builder(builder: &mut ClientBuilder) -> ClientBuilder {
+    use std::mem;
+    mem::replace(builder, ClientBuilder { config: None })
+}

src/async_impl/mod.rs

@@ -0,0 +1,11 @@
+#![cfg_attr(not(features = "unstable"), allow(unused))]
+
+pub use self::body::{Body, Chunk};
+pub use self::client::{Client, ClientBuilder};
+pub use self::request::{Request, RequestBuilder};
+pub use self::response::Response;
+
+pub mod body;
+pub mod client;
+mod request;
+mod response;

src/async_impl/request.rs

@@ -0,0 +1,410 @@
+use std::fmt;
+
+use serde::Serialize;
+use serde_json;
+use serde_urlencoded;
+
+use super::body::{self, Body};
+use super::client::{Client, Pending};
+use header::{ContentType, Headers};
+use {Method, Url};
+
+/// A request which can be executed with `Client::execute()`.
+pub struct Request {
+    method: Method,
+    url: Url,
+    headers: Headers,
+    body: Option<Body>,
+}
+
+/// A builder to construct the properties of a `Request`.
+pub struct RequestBuilder {
+    client: Client,
+    request: Option<Request>,
+}
+
+impl Request {
+    /// Constructs a new request.
+    #[inline]
+    pub fn new(method: Method, url: Url) -> Self {
+        Request {
+            method,
+            url,
+            headers: Headers::new(),
+            body: None,
+        }
+    }
+
+    /// Get the method.
+    #[inline]
+    pub fn method(&self) -> &Method {
+        &self.method
+    }
+
+    /// Get a mutable reference to the method.
+    #[inline]
+    pub fn method_mut(&mut self) -> &mut Method {
+        &mut self.method
+    }
+
+    /// Get the url.
+    #[inline]
+    pub fn url(&self) -> &Url {
+        &self.url
+    }
+
+    /// Get a mutable reference to the url.
+    #[inline]
+    pub fn url_mut(&mut self) -> &mut Url {
+        &mut self.url
+    }
+
+    /// Get the headers.
+    #[inline]
+    pub fn headers(&self) -> &Headers {
+        &self.headers
+    }
+
+    /// Get a mutable reference to the headers.
+    #[inline]
+    pub fn headers_mut(&mut self) -> &mut Headers {
+        &mut self.headers
+    }
+
+    /// Get the body.
+    #[inline]
+    pub fn body(&self) -> Option<&Body> {
+        self.body.as_ref()
+    }
+
+    /// Get a mutable reference to the body.
+    #[inline]
+    pub fn body_mut(&mut self) -> &mut Option<Body> {
+        &mut self.body
+    }
+}
+
+impl RequestBuilder {
+    /// Add a `Header` to this Request.
+    pub fn header<H>(&mut self, header: H) -> &mut RequestBuilder
+    where
+        H: ::header::Header,
+    {
+        self.request_mut().headers.set(header);
+        self
+    }
+    /// Add a set of Headers to the existing ones on this Request.
+    ///
+    /// The headers will be merged in to any already set.
+    pub fn headers(&mut self, headers: ::header::Headers) -> &mut RequestBuilder {
+        self.request_mut().headers.extend(headers.iter());
+        self
+    }
+
+    /// Enable HTTP basic authentication.
+    pub fn basic_auth<U, P>(&mut self, username: U, password: Option<P>) -> &mut RequestBuilder
+    where
+        U: Into<String>,
+        P: Into<String>,
+    {
+        self.header(::header::Authorization(::header::Basic {
+            username: username.into(),
+            password: password.map(|p| p.into()),
+        }))
+    }
+
+    /// Set the request body.
+    pub fn body<T: Into<Body>>(&mut self, body: T) -> &mut RequestBuilder {
+        self.request_mut().body = Some(body.into());
+        self
+    }
+
+    /// Send a form body.
+    pub fn form<T: Serialize>(&mut self, form: &T) -> ::Result<&mut RequestBuilder> {
+        {
+            // check request_mut() before running serde
+            let mut req = self.request_mut();
+            let body = try_!(serde_urlencoded::to_string(form));
+            req.headers.set(ContentType::form_url_encoded());
+            req.body = Some(body::reusable(body.into()));
+        }
+        Ok(self)
+    }
+
+    /// Send a JSON body.
+    ///
+    /// # Errors
+    ///
+    /// Serialization can fail if `T`'s implementation of `Serialize` decides to
+    /// fail, or if `T` contains a map with non-string keys.
+    pub fn json<T: Serialize>(&mut self, json: &T) -> ::Result<&mut RequestBuilder> {
+        {
+            // check request_mut() before running serde
+            let mut req = self.request_mut();
+            let body = try_!(serde_json::to_vec(json));
+            req.headers.set(ContentType::json());
+            req.body = Some(body::reusable(body.into()));
+        }
+        Ok(self)
+    }
+
+    /// Build a `Request`, which can be inspected, modified and executed with
+    /// `Client::execute()`.
+    ///
+    /// # Panics
+    ///
+    /// This method consumes builder internal state. It panics on an attempt to
+    /// reuse already consumed builder.
+    pub fn build(&mut self) -> Request {
+        self.request
+            .take()
+            .expect("RequestBuilder cannot be reused after builder a Request")
+    }
+
+    /// Constructs the Request and sends it the target URL, returning a Response.
+    ///
+    /// # Errors
+    ///
+    /// This method fails if there was an error while sending request,
+    /// redirect loop was detected or redirect limit was exhausted.
+    pub fn send(&mut self) -> Pending {
+        let request = self.build();
+        self.client.execute(request)
+    }
+
+    // private
+
+    fn request_mut(&mut self) -> &mut Request {
+        self.request
+            .as_mut()
+            .expect("RequestBuilder cannot be reused after builder a Request")
+    }
+}
+
+impl fmt::Debug for Request {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        fmt_request_fields(&mut f.debug_struct("Request"), self)
+            .finish()
+    }
+}
+
+impl fmt::Debug for RequestBuilder {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        if let Some(ref req) = self.request {
+            fmt_request_fields(&mut f.debug_struct("RequestBuilder"), req)
+                .finish()
+        } else {
+            f.debug_tuple("RequestBuilder")
+                .field(&"Consumed")
+                .finish()
+        }
+    }
+}
+
+fn fmt_request_fields<'a, 'b>(f: &'a mut fmt::DebugStruct<'a, 'b>, req: &Request) -> &'a mut fmt::DebugStruct<'a, 'b> {
+    f.field("method", &req.method)
+        .field("url", &req.url)
+        .field("headers", &req.headers)
+}
+
+// pub(crate)
+
+#[inline]
+pub fn builder(client: Client, req: Request) -> RequestBuilder {
+    RequestBuilder {
+        client: client,
+        request: Some(req),
+    }
+}
+
+#[inline]
+pub fn pieces(req: Request) -> (Method, Url, Headers, Option<Body>) {
+    (req.method, req.url, req.headers, req.body)
+}
+
+#[cfg(test)]
+mod tests {
+    /*
+    use {body, Method};
+    use super::Client;
+    use header::{Host, Headers, ContentType};
+    use std::collections::HashMap;
+    use serde_urlencoded;
+    use serde_json;
+
+    #[test]
+    fn basic_get_request() {
+        let client = Client::new().unwrap();
+        let some_url = "https://google.com/";
+        let r = client.get(some_url).unwrap().build();
+
+        assert_eq!(r.method, Method::Get);
+        assert_eq!(r.url.as_str(), some_url);
+    }
+
+    #[test]
+    fn basic_head_request() {
+        let client = Client::new().unwrap();
+        let some_url = "https://google.com/";
+        let r = client.head(some_url).unwrap().build();
+
+        assert_eq!(r.method, Method::Head);
+        assert_eq!(r.url.as_str(), some_url);
+    }
+
+    #[test]
+    fn basic_post_request() {
+        let client = Client::new().unwrap();
+        let some_url = "https://google.com/";
+        let r = client.post(some_url).unwrap().build();
+
+        assert_eq!(r.method, Method::Post);
+        assert_eq!(r.url.as_str(), some_url);
+    }
+
+    #[test]
+    fn basic_put_request() {
+        let client = Client::new().unwrap();
+        let some_url = "https://google.com/";
+        let r = client.put(some_url).unwrap().build();
+
+        assert_eq!(r.method, Method::Put);
+        assert_eq!(r.url.as_str(), some_url);
+    }
+
+    #[test]
+    fn basic_patch_request() {
+        let client = Client::new().unwrap();
+        let some_url = "https://google.com/";
+        let r = client.patch(some_url).unwrap().build();
+
+        assert_eq!(r.method, Method::Patch);
+        assert_eq!(r.url.as_str(), some_url);
+    }
+
+    #[test]
+    fn basic_delete_request() {
+        let client = Client::new().unwrap();
+        let some_url = "https://google.com/";
+        let r = client.delete(some_url).unwrap().build();
+
+        assert_eq!(r.method, Method::Delete);
+        assert_eq!(r.url.as_str(), some_url);
+    }
+
+    #[test]
+    fn add_header() {
+        let client = Client::new().unwrap();
+        let some_url = "https://google.com/";
+        let mut r = client.post(some_url).unwrap();
+
+        let header = Host {
+            hostname: "google.com".to_string(),
+            port: None,
+        };
+
+        // Add a copy of the header to the request builder
+        let r = r.header(header.clone()).build();
+
+        // then check it was actually added
+        assert_eq!(r.headers.get::<Host>(), Some(&header));
+    }
+
+    #[test]
+    fn add_headers() {
+        let client = Client::new().unwrap();
+        let some_url = "https://google.com/";
+        let mut r = client.post(some_url).unwrap();
+
+        let header = Host {
+            hostname: "google.com".to_string(),
+            port: None,
+        };
+
+        let mut headers = Headers::new();
+        headers.set(header);
+
+        // Add a copy of the headers to the request builder
+        let r = r.headers(headers.clone()).build();
+
+        // then make sure they were added correctly
+        assert_eq!(r.headers, headers);
+    }
+
+    #[test]
+    fn add_body() {
+        let client = Client::new().unwrap();
+        let some_url = "https://google.com/";
+        let mut r = client.post(some_url).unwrap();
+
+        let body = "Some interesting content";
+
+        let r = r.body(body).build();
+
+        let buf = body::read_to_string(r.body.unwrap()).unwrap();
+
+        assert_eq!(buf, body);
+    }
+
+    #[test]
+    fn add_form() {
+        let client = Client::new().unwrap();
+        let some_url = "https://google.com/";
+        let mut r = client.post(some_url).unwrap();
+
+        let mut form_data = HashMap::new();
+        form_data.insert("foo", "bar");
+
+        let r = r.form(&form_data).unwrap().build();
+
+        // Make sure the content type was set
+        assert_eq!(r.headers.get::<ContentType>(),
+                   Some(&ContentType::form_url_encoded()));
+
+        let buf = body::read_to_string(r.body.unwrap()).unwrap();
+
+        let body_should_be = serde_urlencoded::to_string(&form_data).unwrap();
+        assert_eq!(buf, body_should_be);
+    }
+
+    #[test]
+    fn add_json() {
+        let client = Client::new().unwrap();
+        let some_url = "https://google.com/";
+        let mut r = client.post(some_url).unwrap();
+
+        let mut json_data = HashMap::new();
+        json_data.insert("foo", "bar");
+
+        let r = r.json(&json_data).unwrap().build();
+
+        // Make sure the content type was set
+        assert_eq!(r.headers.get::<ContentType>(), Some(&ContentType::json()));
+
+        let buf = body::read_to_string(r.body.unwrap()).unwrap();
+
+        let body_should_be = serde_json::to_string(&json_data).unwrap();
+        assert_eq!(buf, body_should_be);
+    }
+
+    #[test]
+    fn add_json_fail() {
+        use serde::{Serialize, Serializer};
+        use serde::ser::Error;
+        struct MyStruct;
+        impl Serialize for MyStruct {
+            fn serialize<S>(&self, _serializer: S) -> Result<S::Ok, S::Error>
+                where S: Serializer
+                {
+                    Err(S::Error::custom("nope"))
+                }
+        }
+
+        let client = Client::new().unwrap();
+        let some_url = "https://google.com/";
+        let mut r = client.post(some_url).unwrap();
+        let json_data = MyStruct{};
+        assert!(r.json(&json_data).unwrap_err().is_serialization());
+    }
+    */
+}

src/async_impl/response.rs

@@ -0,0 +1,112 @@
+use std::fmt;
+use std::marker::PhantomData;
+
+use futures::{Async, Future, Poll, Stream};
+use futures::stream::Concat2;
+use header::Headers;
+use hyper::StatusCode;
+use serde::de::DeserializeOwned;
+use serde_json;
+use url::Url;
+
+use super::{body, Body};
+
+
+/// A Response to a submitted `Request`.
+pub struct Response {
+    status: StatusCode,
+    headers: Headers,
+    url: Url,
+    body: Body,
+}
+
+impl Response {
+    /// Get the final `Url` of this `Response`.
+    #[inline]
+    pub fn url(&self) -> &Url {
+        &self.url
+    }
+
+    /// Get the `StatusCode` of this `Response`.
+    #[inline]
+    pub fn status(&self) -> StatusCode {
+        self.status
+    }
+
+    /// Get the `Headers` of this `Response`.
+    #[inline]
+    pub fn headers(&self) -> &Headers {
+        &self.headers
+    }
+
+    /// Get a mutable reference to the `Headers` of this `Response`.
+    #[inline]
+    pub fn headers_mut(&mut self) -> &mut Headers {
+        &mut self.headers
+    }
+
+    /// Get a mutable reference to the `Body` of this `Response`.
+    #[inline]
+    pub fn body_mut(&mut self) -> &mut Body {
+        &mut self.body
+    }
+
+    /// Try to deserialize the response body as JSON using `serde`.
+    #[inline]
+    pub fn json<T: DeserializeOwned>(&mut self) -> Json<T> {
+        Json {
+            concat: body::take(self.body_mut()).concat2(),
+            _marker: PhantomData,
+        }
+    }
+}
+
+
+impl fmt::Debug for Response {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        f.debug_struct("Response")
+            .field("url", self.url())
+            .field("status", &self.status())
+            .field("headers", self.headers())
+            .finish()
+    }
+}
+
+pub struct Json<T> {
+    concat: Concat2<Body>,
+    _marker: PhantomData<T>,
+}
+
+impl<T: DeserializeOwned> Future for Json<T> {
+    type Item = T;
+    type Error = ::Error;
+    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
+        let bytes = try_ready!(self.concat.poll());
+        let t = try_!(serde_json::from_slice(&bytes));
+        Ok(Async::Ready(t))
+    }
+}
+
+impl<T> fmt::Debug for Json<T> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        f.debug_struct("Json")
+            .finish()
+    }
+}
+
+// pub(crate)
+
+pub fn new(mut res: ::hyper::client::Response, url: Url, _gzip: bool) -> Response {
+    use std::mem;
+
+    let status = res.status();
+    let headers = mem::replace(res.headers_mut(), Headers::new());
+    let body = res.body();
+    info!("Response: '{}' for {}", status, url);
+    Response {
+        status: status,
+        headers: headers,
+        url: url,
+        body: super::body::wrap(body),
+    }
+}