Merge branch 'master' into fix-wasm-compilation

Author: Perseus101

.github/workflows/ci.yaml

@@ -52,11 +52,11 @@ jobs:
     steps:
     - uses: actions/checkout@master
 
-    - name: Install stable toolchain
+    - name: Install nightly toolchain
       uses: actions-rs/toolchain@v1
       with:
         profile: minimal
-        toolchain: stable
+        toolchain: nightly
         override: true
         components: rustfmt
 

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "http-client"
-version = "3.0.0"
+version = "4.0.0"
 license = "MIT OR Apache-2.0"
 repository = "https://github.com/http-rs/http-client"
 documentation = "https://docs.rs/http-client"

src/h1.rs

@@ -1,10 +1,10 @@
 //! http-client implementation for async-h1.
 
-use super::{HttpClient, Request, Response};
+use super::{Error, HttpClient, Request, Response};
 
 use async_h1::client;
 use futures::future::BoxFuture;
-use http_types::{Error, StatusCode};
+use http_types::StatusCode;
 
 /// Async-h1 based HTTP Client.
 #[derive(Debug)]
@@ -30,9 +30,7 @@ impl Clone for H1Client {
 }
 
 impl HttpClient for H1Client {
-    type Error = Error;
-
-    fn send(&self, mut req: Request) -> BoxFuture<'static, Result<Response, Self::Error>> {
+    fn send(&self, mut req: Request) -> BoxFuture<'static, Result<Response, Error>> {
         Box::pin(async move {
             // Insert host
             let host = req

src/isahc.rs

@@ -1,6 +1,6 @@
 //! http-client implementation for isahc
 
-use super::{Body, HttpClient, Request, Response};
+use super::{Body, Error, HttpClient, Request, Response};
 
 use async_std::io::BufReader;
 use futures::future::BoxFuture;
@@ -42,9 +42,7 @@ impl Clone for IsahcClient {
 }
 
 impl HttpClient for IsahcClient {
-    type Error = isahc::Error;
-
-    fn send(&self, mut req: Request) -> BoxFuture<'static, Result<Response, Self::Error>> {
+    fn send(&self, mut req: Request) -> BoxFuture<'static, Result<Response, Error>> {
         let client = self.client.clone();
         Box::pin(async move {
             let mut builder = http::Request::builder()
@@ -65,7 +63,7 @@ impl HttpClient for IsahcClient {
             };
 
             let request = builder.body(body).unwrap();
-            let res = client.send_async(request).await?;
+            let res = client.send_async(request).await.map_err(Error::from)?;
             let (parts, body) = res.into_parts();
             let len = body.len().map(|len| len as usize);
             let body = Body::from_reader(BufReader::new(body), len);

src/lib.rs

@@ -47,19 +47,14 @@ pub use http_types;
 /// trait from there together with all existing HTTP client implementations.__
 ///
 /// ## Spawning new request from middleware
-/// When threading the trait through a layer of middleware, the middleware must be able to perform
-/// new requests. In order to enable this we pass an `HttpClient` instance through the middleware,
-/// with a `Clone` implementation. In order to spawn a new request, `clone` is called, and a new
-/// request is enabled.
 ///
-/// How `Clone` is implemented is up to the implementors, but in an ideal scenario combining this
-/// with the `Client` builder will allow for high connection reuse, improving latency.
-pub trait HttpClient: std::fmt::Debug + Unpin + Send + Sync + Clone + 'static {
-    /// The associated error type.
-    type Error: Send + Sync + Into<Error>;
-
+/// When threading the trait through a layer of middleware, the middleware must be able to perform
+/// new requests. In order to enable this efficiently an `HttpClient` instance may want to be passed
+/// though middleware for one of its own requests, and in order to do so should be wrapped in an
+/// `Rc`/`Arc` to enable reference cloning.
+pub trait HttpClient: std::fmt::Debug + Unpin + Send + Sync + 'static {
     /// Perform a request.
-    fn send(&self, req: Request) -> BoxFuture<'static, Result<Response, Self::Error>>;
+    fn send(&self, req: Request) -> BoxFuture<'static, Result<Response, Error>>;
 }
 
 /// The raw body of an http request or response.

src/wasm.rs

@@ -1,12 +1,11 @@
 //! http-client implementation for fetch
 
-use super::{http_types::Headers, Body, HttpClient, Request, Response};
+use super::{http_types::Headers, Body, Error, HttpClient, Request, Response};
 
 use futures::future::BoxFuture;
 use futures::prelude::*;
 
 use std::convert::TryFrom;
-use std::io;
 use std::pin::Pin;
 use std::task::{Context, Poll};
 
@@ -30,9 +29,7 @@ impl Clone for WasmClient {
 }
 
 impl HttpClient for WasmClient {
-    type Error = std::io::Error;
-
-    fn send(&self, req: Request) -> BoxFuture<'static, Result<Response, Self::Error>> {
+    fn send(&self, req: Request) -> BoxFuture<'static, Result<Response, Error>> {
         let fut = Box::pin(async move {
             let req: fetch::Request = fetch::Request::new(req).await?;
             let mut res = req.send().await?;
@@ -54,15 +51,15 @@ impl HttpClient for WasmClient {
 }
 
 struct InnerFuture {
-    fut: Pin<Box<dyn Future<Output = Result<Response, io::Error>> + 'static>>,
+    fut: Pin<Box<dyn Future<Output = Result<Response, Error>> + 'static>>,
 }
 
 // This is safe because WASM doesn't have threads yet. Once WASM supports threads we should use a
 // thread to park the blocking implementation until it's been completed.
 unsafe impl Send for InnerFuture {}
 
 impl Future for InnerFuture {
-    type Output = Result<Response, io::Error>;
+    type Output = Result<Response, Error>;
 
     fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
         // This is safe because we're only using this future as a pass-through for the inner