feat(lib): replace types with those from http crate

BREAKING CHANGE: `Method`, `Request`, `Response`, `StatusCode`,
  `Version`, and `Uri` have been replaced with types from the `http`
  crate. The `hyper::header` module is gone for now.

  Removed `Client::get`, since it needed to construct a `Request<B>`
  with an empty body. Just use `Client::request` instead.

  Removed `compat` cargo feature, and `compat` related API.

src/proto/mod.rs

@@ -1,16 +1,8 @@
 //! Pieces pertaining to the HTTP message protocol.
-use std::borrow::Cow;
-use std::fmt;
-
 use bytes::BytesMut;
+use http::{HeaderMap, Method, StatusCode, Uri, Version};
 
-use header::{Connection, ConnectionOption, Expect};
-use header::Headers;
-use method::Method;
-use status::StatusCode;
-use uri::Uri;
-use version::HttpVersion;
-use version::HttpVersion::{Http10, Http11};
+use headers;
 
 pub use self::body::Body;
 pub use self::chunk::Chunk;
@@ -20,19 +12,17 @@ mod body;
 mod chunk;
 mod h1;
 //mod h2;
-pub mod request;
-pub mod response;
 
 
 /// An Incoming Message head. Includes request/status line, and headers.
 #[derive(Clone, Debug, Default, PartialEq)]
 pub struct MessageHead<S> {
     /// HTTP version of the message.
-    pub version: HttpVersion,
+    pub version: Version,
     /// Subject (request line or status line) of Incoming message.
     pub subject: S,
     /// Headers of the Incoming message.
-    pub headers: Headers
+    pub headers: HeaderMap,
 }
 
 /// An incoming request message.
@@ -41,14 +31,8 @@ pub type RequestHead = MessageHead<RequestLine>;
 #[derive(Debug, Default, PartialEq)]
 pub struct RequestLine(pub Method, pub Uri);
 
-impl fmt::Display for RequestLine {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "{} {}", self.0, self.1)
-    }
-}
-
 /// An incoming response message.
-pub type ResponseHead = MessageHead<RawStatus>;
+pub type ResponseHead = MessageHead<StatusCode>;
 
 impl<S> MessageHead<S> {
     pub fn should_keep_alive(&self) -> bool {
@@ -60,76 +44,20 @@ impl<S> MessageHead<S> {
     }
 }
 
-impl ResponseHead {
-    /// Converts this head's RawStatus into a StatusCode.
-    #[inline]
-    pub fn status(&self) -> StatusCode {
-        self.subject.status()
-    }
-}
-
-/// The raw status code and reason-phrase.
-#[derive(Clone, PartialEq, Debug)]
-pub struct RawStatus(pub u16, pub Cow<'static, str>);
-
-impl RawStatus {
-    /// Converts this into a StatusCode.
-    #[inline]
-    pub fn status(&self) -> StatusCode {
-        StatusCode::try_from(self.0).unwrap()
-    }
-}
-
-impl fmt::Display for RawStatus {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "{} {}", self.0, self.1)
-    }
-}
-
-impl From<StatusCode> for RawStatus {
-    fn from(status: StatusCode) -> RawStatus {
-        RawStatus(status.into(), Cow::Borrowed(status.canonical_reason().unwrap_or("")))
-    }
-}
-
-impl Default for RawStatus {
-    fn default() -> RawStatus {
-        RawStatus(200, Cow::Borrowed("OK"))
-    }
-}
-
-impl From<MessageHead<::StatusCode>> for MessageHead<RawStatus> {
-    fn from(head: MessageHead<::StatusCode>) -> MessageHead<RawStatus> {
-        MessageHead {
-            subject: head.subject.into(),
-            version: head.version,
-            headers: head.headers,
-        }
-    }
-}
-
 /// Checks if a connection should be kept alive.
 #[inline]
-pub fn should_keep_alive(version: HttpVersion, headers: &Headers) -> bool {
-    let ret = match (version, headers.get::<Connection>()) {
-        (Http10, None) => false,
-        (Http10, Some(conn)) if !conn.contains(&ConnectionOption::KeepAlive) => false,
-        (Http11, Some(conn)) if conn.contains(&ConnectionOption::Close)  => false,
-        _ => true
-    };
-    trace!("should_keep_alive(version={:?}, header={:?}) = {:?}", version, headers.get::<Connection>(), ret);
-    ret
+pub fn should_keep_alive(version: Version, headers: &HeaderMap) -> bool {
+    if version == Version::HTTP_10 {
+        headers::connection_keep_alive(headers)
+    } else {
+        !headers::connection_close(headers)
+    }
 }
 
 /// Checks if a connection is expecting a `100 Continue` before sending its body.
 #[inline]
-pub fn expecting_continue(version: HttpVersion, headers: &Headers) -> bool {
-    let ret = match (version, headers.get::<Expect>()) {
-        (Http11, Some(&Expect::Continue)) => true,
-        _ => false
-    };
-    trace!("expecting_continue(version={:?}, header={:?}) = {:?}", version, headers.get::<Expect>(), ret);
-    ret
+pub fn expecting_continue(version: Version, headers: &HeaderMap) -> bool {
+    version == Version::HTTP_11 && headers::expect_continue(headers)
 }
 
 pub type ServerTransaction = h1::role::Server<h1::role::YesUpgrades>;
@@ -143,7 +71,7 @@ pub trait Http1Transaction {
     type Incoming;
     type Outgoing: Default;
     fn parse(bytes: &mut BytesMut) -> ParseResult<Self::Incoming>;
-    fn decoder(head: &MessageHead<Self::Incoming>, method: &mut Option<::Method>) -> ::Result<Decode>;
+    fn decoder(head: &MessageHead<Self::Incoming>, method: &mut Option<Method>) -> ::Result<Decode>;
     fn encode(head: MessageHead<Self::Outgoing>, has_body: bool, method: &mut Option<Method>, dst: &mut Vec<u8>) -> ::Result<h1::Encoder>;
     fn on_error(err: &::Error) -> Option<MessageHead<Self::Outgoing>>;
 
@@ -165,28 +93,28 @@ pub enum Decode {
 
 #[test]
 fn test_should_keep_alive() {
-    let mut headers = Headers::new();
+    let mut headers = HeaderMap::new();
 
-    assert!(!should_keep_alive(Http10, &headers));
-    assert!(should_keep_alive(Http11, &headers));
+    assert!(!should_keep_alive(Version::HTTP_10, &headers));
+    assert!(should_keep_alive(Version::HTTP_11, &headers));
 
-    headers.set(Connection::close());
-    assert!(!should_keep_alive(Http10, &headers));
-    assert!(!should_keep_alive(Http11, &headers));
+    headers.insert("connection", ::http::header::HeaderValue::from_static("close"));
+    assert!(!should_keep_alive(Version::HTTP_10, &headers));
+    assert!(!should_keep_alive(Version::HTTP_11, &headers));
 
-    headers.set(Connection::keep_alive());
-    assert!(should_keep_alive(Http10, &headers));
-    assert!(should_keep_alive(Http11, &headers));
+    headers.insert("connection", ::http::header::HeaderValue::from_static("keep-alive"));
+    assert!(should_keep_alive(Version::HTTP_10, &headers));
+    assert!(should_keep_alive(Version::HTTP_11, &headers));
 }
 
 #[test]
 fn test_expecting_continue() {
-    let mut headers = Headers::new();
+    let mut headers = HeaderMap::new();
 
-    assert!(!expecting_continue(Http10, &headers));
-    assert!(!expecting_continue(Http11, &headers));
+    assert!(!expecting_continue(Version::HTTP_10, &headers));
+    assert!(!expecting_continue(Version::HTTP_11, &headers));
 
-    headers.set(Expect::Continue);
-    assert!(!expecting_continue(Http10, &headers));
-    assert!(expecting_continue(Http11, &headers));
+    headers.insert("expect", ::http::header::HeaderValue::from_static("100-continue"));
+    assert!(!expecting_continue(Version::HTTP_10, &headers));
+    assert!(expecting_continue(Version::HTTP_11, &headers));
 }