Add http. Initially expose shio::http::Method and expose as a facade.

mehcode · mehcode · commit 19ea0818bee4 · 2017-09-15T03:26:54.000-07:00
diff --git a/README.md b/README.md
@@ -36,8 +36,8 @@ fn hello(ctx: Context) -> Response {
 
 fn main() {
     Shio::default()
-        .route((Method::Get, "/", hello_world))
-        .route((Method::Get, "/{name}", hello))
+        .route((Method::GET, "/", hello_world))
+        .route((Method::GET, "/{name}", hello))
         .run(":7878").unwrap();
 }
 ```
diff --git a/examples/hello/src/main.rs b/examples/hello/src/main.rs
@@ -31,8 +31,8 @@ fn main() {
     // Construct a _default_ `Shio` service, mount the `index` handler, and
     // run indefinitely on port `7878` (by default, binds to both `0.0.0.0` and `::0`).
     Shio::default()
-        .route((Method::Get, "/", hello_world))
-        .route((Method::Get, "/{name}", hello))
+        .route((Method::GET, "/", hello_world))
+        .route((Method::GET, "/{name}", hello))
         .run(":7878")
         .unwrap();
 
@@ -46,8 +46,8 @@ fn main() {
 
     let mut router = shio::router::Router::new();
 
-    router.route((Method::Get, "/", hello_world));
-    router.route((Method::Get, "/{name}", hello));
+    router.route((Method::GET, "/", hello_world));
+    router.route((Method::GET, "/{name}", hello));
 
     let mut service = Shio::new(router);
 
diff --git a/examples/json/src/main.rs b/examples/json/src/main.rs
@@ -54,7 +54,7 @@ fn index(ctx: Context) -> BoxFuture<Response, errors::Error> {
 
 fn main() {
     Shio::default()
-        .route((Method::Post, "/", index))
+        .route((Method::POST, "/", index))
         .run(":7878")
         .unwrap();
 }
diff --git a/examples/managed_state/src/main.rs b/examples/managed_state/src/main.rs
@@ -24,7 +24,7 @@ fn hello(context: Context) -> Response {
 fn main() {
     Shio::default()
         .manage::<SharedCounter>(AtomicUsize::default())
-        .route((Method::Get, "/", hello))
+        .route((Method::GET, "/", hello))
         .run(":7878")
         .unwrap();
 }
diff --git a/examples/postgres/src/main.rs b/examples/postgres/src/main.rs
@@ -91,7 +91,7 @@ fn main() {
     pretty_env_logger::init().unwrap();
 
     Shio::default()
-        .route((Method::Get, "/{name}", index))
+        .route((Method::GET, "/{name}", index))
         .run(":7878")
         .unwrap();
 }
diff --git a/examples/redirect/src/main.rs b/examples/redirect/src/main.rs
@@ -20,9 +20,9 @@ fn index(_: Context) -> Response {
 
 fn main() {
     Shio::default()
-        .route((Method::Get, "/", index))
-        .route((Method::Get, "/redirect", redirect_to))
-        .route((Method::Get, "/redirected", redirected))
+        .route((Method::GET, "/", index))
+        .route((Method::GET, "/redirect", redirect_to))
+        .route((Method::GET, "/redirected", redirected))
         .run(":7878")
         .unwrap();
 }
diff --git a/examples/stateful/src/main.rs b/examples/stateful/src/main.rs
@@ -25,7 +25,7 @@ impl shio::Handler for HandlerWithState {
 
 fn main() {
     Shio::default()
-        .route((Method::Get, "/", HandlerWithState::default()))
+        .route((Method::GET, "/", HandlerWithState::default()))
         .run(":7878")
         .unwrap();
 }
diff --git a/examples/templates_askama/src/main.rs b/examples/templates_askama/src/main.rs
@@ -20,7 +20,7 @@ fn hello(ctx: Context) -> Result<Response, askama::Error> {
 
 fn main() {
     Shio::default()
-        .route((Method::Get, "/hello/{name}", hello))
+        .route((Method::GET, "/hello/{name}", hello))
         .run(":7878")
         .unwrap()
 }
diff --git a/lib/Cargo.toml b/lib/Cargo.toml
@@ -20,6 +20,7 @@ tokio-proto = "0.1.1"
 regex = "0.2"
 log = "0.3"
 unsafe-any = "0.4.2"
+http = "0.1"
 
 [features]
 default = []
diff --git a/lib/src/http.rs b/lib/src/http.rs
@@ -2,9 +2,63 @@
 //!
 //! This module exports types that map to HTTP concepts or to the underlying HTTP library
 //! when needed.
+#![allow(non_upper_case_globals)]
 
-// HTTP Methods
-pub use hyper::Method;
+use hyper;
+use http_types;
+
+// NOTE: This facade is only around to not completely break current usage of 0.2.
+//       It will be removed in 0.4.
+
+/// The Request Method (VERB).
+#[derive(Debug, PartialEq, Eq)]
+pub struct Method(http_types::Method);
+
+impl Method {
+    pub const HEAD: Method = Method(http_types::Method::HEAD);
+    pub const OPTIONS: Method = Method(http_types::Method::OPTIONS);
+    pub const GET: Method = Method(http_types::Method::GET);
+    pub const POST: Method = Method(http_types::Method::POST);
+    pub const PUT: Method = Method(http_types::Method::PUT);
+    pub const PATCH: Method = Method(http_types::Method::PATCH);
+    pub const DELETE: Method = Method(http_types::Method::DELETE);
+
+    #[deprecated(since = "0.2.0", note = "use `Method::HEAD` instead")]
+    pub const Head: Method = Method(http_types::Method::HEAD);
+
+    #[deprecated(since = "0.2.0", note = "use `Method::OPTIONS` instead")]
+    pub const Options: Method = Method(http_types::Method::OPTIONS);
+
+    #[deprecated(since = "0.2.0", note = "use `Method::GET` instead")]
+    pub const Get: Method = Method(http_types::Method::GET);
+
+    #[deprecated(since = "0.2.0", note = "use `Method::POST` instead")]
+    pub const Post: Method = Method(http_types::Method::POST);
+
+    #[deprecated(since = "0.2.0", note = "use `Method::PUT` instead")]
+    pub const Put: Method = Method(http_types::Method::PUT);
+
+    #[deprecated(since = "0.2.0", note = "use `Method::PATCH` instead")]
+    pub const Patch: Method = Method(http_types::Method::PATCH);
+
+    #[deprecated(since = "0.2.0", note = "use `Method::DELETE` instead")]
+    pub const Delete: Method = Method(http_types::Method::DELETE);
+
+    // Temporary until Hyper 0.12
+    pub(crate) fn to_hyper_method(&self) -> hyper::Method {
+        match *self {
+            Self::OPTIONS => hyper::Method::Options,
+            Self::HEAD => hyper::Method::Head,
+            Self::GET => hyper::Method::Get,
+            Self::POST => hyper::Method::Post,
+            Self::PUT => hyper::Method::Put,
+            Self::PATCH => hyper::Method::Patch,
+            Self::DELETE => hyper::Method::Delete,
+
+            _ => unimplemented!()
+        }
+    }
+}
 
 // HTTP Headers
 pub use hyper::header;
diff --git a/lib/src/lib.rs b/lib/src/lib.rs
@@ -3,6 +3,7 @@
 #![cfg_attr(feature = "nightly", feature(specialization))]
 
 extern crate futures;
+extern crate http as http_types;
 extern crate hyper;
 #[macro_use]
 extern crate log;
diff --git a/lib/src/router/mod.rs b/lib/src/router/mod.rs
@@ -55,7 +55,7 @@ impl Router {
     /// # use shio::{Method, Response, StatusCode};
     /// # use shio::router::Router;
     /// # let mut router = Router::new();
-    /// router.route((Method::Get, "/users", |_| {
+    /// router.route((Method::GET, "/users", |_| {
     ///     // [...]
     /// # Response::with(StatusCode::NoContent)
     /// }));
@@ -127,8 +127,8 @@ mod tests {
     use hyper;
 
     use super::{Parameters, Router};
-    use {Context, Handler, Response, State, StatusCode};
-    use Method::*;
+    use {Context, Handler, Response, State};
+    use http::{Method, StatusCode};
 
     // Empty handler to use for route tests
     fn empty_handler(_: Context) -> Response {
@@ -139,44 +139,44 @@ mod tests {
     #[test]
     fn test_static_get() {
         let mut router = Router::new();
-        router.add((Get, "/hello", empty_handler));
+        router.add((Method::GET, "/hello", empty_handler));
 
-        assert!(router.find(&Get, "/hello").is_some());
-        assert!(router.find(&Get, "/aa").is_none());
-        assert!(router.find(&Get, "/hello/asfa").is_none());
+        assert!(router.find(&hyper::Method::Get, "/hello").is_some());
+        assert!(router.find(&hyper::Method::Get, "/aa").is_none());
+        assert!(router.find(&hyper::Method::Get, "/hello/asfa").is_none());
     }
 
     /// Test for _some_ match for static in PUT, POST, DELETE
     #[test]
     fn test_static_put_post_del() {
         let mut router = Router::new();
-        router.add((Put, "/hello", empty_handler));
-        router.add((Post, "/hello", empty_handler));
-        router.add((Delete, "/hello", empty_handler));
-
-        assert!(router.find(&Get, "/hello").is_none());
-        assert!(router.find(&Put, "/hello").is_some());
-        assert!(router.find(&Post, "/hello").is_some());
-        assert!(router.find(&Delete, "/hello").is_some());
+        router.add((Method::PUT, "/hello", empty_handler));
+        router.add((Method::POST, "/hello", empty_handler));
+        router.add((Method::DELETE, "/hello", empty_handler));
+
+        assert!(router.find(&hyper::Method::Get, "/hello").is_none());
+        assert!(router.find(&hyper::Method::Put, "/hello").is_some());
+        assert!(router.find(&hyper::Method::Post, "/hello").is_some());
+        assert!(router.find(&hyper::Method::Delete, "/hello").is_some());
     }
 
     /// Test for the correct match for static
     #[test]
     fn test_static_find() {
         // Correct match
         let mut router = Router::new();
-        router.add((Get, "/aa", empty_handler));
-        router.add((Get, "/hello", empty_handler));
+        router.add((Method::GET, "/aa", empty_handler));
+        router.add((Method::GET, "/hello", empty_handler));
 
         // FIXME: This section currently matches against regex
         //        This is an implementation detail; store the source strings and we'll
         //        match against that
         assert_eq!(
-            router.find(&Get, "/hello").unwrap().pattern().as_str(),
+            router.find(&hyper::Method::Get, "/hello").unwrap().pattern().as_str(),
             "^/hello$"
         );
         assert_eq!(
-            router.find(&Get, "/aa").unwrap().pattern().as_str(),
+            router.find(&hyper::Method::Get, "/aa").unwrap().pattern().as_str(),
             "^/aa$"
         );
     }
@@ -185,19 +185,19 @@ mod tests {
     #[test]
     fn test_param_get() {
         let mut router = Router::new();
-        router.add((Get, "/user/{id}", empty_handler));
+        router.add((Method::GET, "/user/{id}", empty_handler));
 
-        assert!(router.find(&Get, "/user/asfa").is_some());
-        assert!(router.find(&Get, "/user/profile").is_some());
-        assert!(router.find(&Get, "/user/3289").is_some());
-        assert!(router.find(&Get, "/user").is_none());
+        assert!(router.find(&hyper::Method::Get, "/user/asfa").is_some());
+        assert!(router.find(&hyper::Method::Get, "/user/profile").is_some());
+        assert!(router.find(&hyper::Method::Get, "/user/3289").is_some());
+        assert!(router.find(&hyper::Method::Get, "/user").is_none());
     }
 
     /// Test for segment parameter value
     #[test]
     fn test_param_get_value() {
         let mut router = Router::new();
-        router.add((Get, "/user/{id}", |context: Context| {
+        router.add((Method::GET, "/user/{id}", |context: Context| {
             // FIXME: We should have an assert that we got here
             assert_eq!(&context.get::<Parameters>()["id"], "3289");
 
@@ -209,7 +209,7 @@ mod tests {
         // TODO: It should much easier to make a test context
         //       Perhaps `Request::build ( .. )` should be a thing?
         //       Proxied as `Context::build ( .. )` ?
-        let (request, data) = ::service::from_hyper_request(hyper::Request::new(Get, "/user/3289".parse().unwrap()));
+        let (request, data) = ::service::from_hyper_request(hyper::Request::new(hyper::Method::Get, "/user/3289".parse().unwrap()));
         let context = Context::new(core.handle(), request, State::default(), data);
 
         let work = router.call(context);
@@ -221,19 +221,19 @@ mod tests {
     #[test]
     fn test_param_custom_get() {
         let mut router = Router::new();
-        router.add((Get, "/static/{file: .+}", empty_handler));
+        router.add((Method::GET, "/static/{file: .+}", empty_handler));
 
-        assert!(router.find(&Get, "/static").is_none());
-        assert!(router.find(&Get, "/static/").is_none());
-        assert!(router.find(&Get, "/static/blah").is_some());
-        assert!(router.find(&Get, "/static/rahrahrah").is_some());
+        assert!(router.find(&hyper::Method::Get, "/static").is_none());
+        assert!(router.find(&hyper::Method::Get, "/static/").is_none());
+        assert!(router.find(&hyper::Method::Get, "/static/blah").is_some());
+        assert!(router.find(&hyper::Method::Get, "/static/rahrahrah").is_some());
     }
 
     /// Test for segment parameter value
     #[test]
     fn test_param_get_custom() {
         let mut router = Router::new();
-        router.add((Get, "/static/{filename: .*}", |context: Context| {
+        router.add((Method::GET, "/static/{filename: .*}", |context: Context| {
             // FIXME: We should have an assert that we got here
             assert_eq!(
                 &context.get::<Parameters>()["filename"],
@@ -245,7 +245,7 @@ mod tests {
 
         let mut core = Core::new().unwrap();
 
-        let (request, data) = ::service::from_hyper_request(hyper::Request::new(Get, "/static/path/to/file/is/here".parse().unwrap()));
+        let (request, data) = ::service::from_hyper_request(hyper::Request::new(hyper::Method::Get, "/static/path/to/file/is/here".parse().unwrap()));
         let context = Context::new(core.handle(), request, State::default(), data);
 
         let work = router.call(context);
diff --git a/lib/src/router/route.rs b/lib/src/router/route.rs
@@ -4,6 +4,7 @@ use hyper::{self, Method};
 use futures::IntoFuture;
 
 use context::Context;
+use http;
 use handler::{BoxHandler, Handler};
 use response::Response;
 use router::pattern::Pattern;
@@ -27,7 +28,7 @@ impl Route {
     /// # Response::new()
     /// });
     /// ```
-    pub fn new<P, H>(method: Method, pattern: P, handler: H) -> Self
+    pub fn new<P, H>(method: http::Method, pattern: P, handler: H) -> Self
     where
         P: Into<Pattern>,
         H: Handler + 'static,
@@ -36,7 +37,7 @@ impl Route {
         Self {
             handler: handler.into_box(),
             pattern: pattern.into(),
-            method,
+            method: method.to_hyper_method(),
         }
     }
 
@@ -56,13 +57,13 @@ impl Route {
     }
 }
 
-impl<P, H> From<(Method, P, H)> for Route
+impl<P, H> From<(http::Method, P, H)> for Route
 where
     P: Into<Pattern>,
     H: Handler + 'static,
     <H::Result as IntoFuture>::Error: fmt::Debug + Send,
 {
-    fn from(arguments: (Method, P, H)) -> Self {
+    fn from(arguments: (http::Method, P, H)) -> Self {
         Self::new(arguments.0, arguments.1, arguments.2)
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -54,7 +54,7 @@ fn index(ctx: Context) -> BoxFuture<Response, errors::Error> {`
`54`	`54`
`55`	`55`	`fn main() {`
`56`	`56`	`Shio::default()`
`57`		`- .route((Method::Post, "/", index))`
	`57`	`+ .route((Method::POST, "/", index))`
`58`	`58`	`.run(":7878")`
`59`	`59`	`.unwrap();`
`60`	`60`	`}`
Original file line number	Diff line number	Diff line change
`@@ -24,7 +24,7 @@ fn hello(context: Context) -> Response {`
`24`	`24`	`fn main() {`
`25`	`25`	`Shio::default()`
`26`	`26`	`.manage::<SharedCounter>(AtomicUsize::default())`
`27`		`- .route((Method::Get, "/", hello))`
	`27`	`+ .route((Method::GET, "/", hello))`
`28`	`28`	`.run(":7878")`
`29`	`29`	`.unwrap();`
`30`	`30`	`}`
Original file line number	Diff line number	Diff line change
`@@ -91,7 +91,7 @@ fn main() {`
`91`	`91`	`pretty_env_logger::init().unwrap();`
`92`	`92`
`93`	`93`	`Shio::default()`
`94`		`- .route((Method::Get, "/{name}", index))`
	`94`	`+ .route((Method::GET, "/{name}", index))`
`95`	`95`	`.run(":7878")`
`96`	`96`	`.unwrap();`
`97`	`97`	`}`
Original file line number	Diff line number	Diff line change
`@@ -25,7 +25,7 @@ impl shio::Handler for HandlerWithState {`
`25`	`25`
`26`	`26`	`fn main() {`
`27`	`27`	`Shio::default()`
`28`		`- .route((Method::Get, "/", HandlerWithState::default()))`
	`28`	`+ .route((Method::GET, "/", HandlerWithState::default()))`
`29`	`29`	`.run(":7878")`
`30`	`30`	`.unwrap();`
`31`	`31`	`}`
Original file line number	Diff line number	Diff line change
`@@ -20,7 +20,7 @@ fn hello(ctx: Context) -> Result<Response, askama::Error> {`
`20`	`20`
`21`	`21`	`fn main() {`
`22`	`22`	`Shio::default()`
`23`		`- .route((Method::Get, "/hello/{name}", hello))`
	`23`	`+ .route((Method::GET, "/hello/{name}", hello))`
`24`	`24`	`.run(":7878")`
`25`	`25`	`.unwrap()`
`26`	`26`	`}`
Original file line number	Diff line number	Diff line change
`@@ -4,6 +4,7 @@ use hyper::{self, Method};`
`4`	`4`	`use futures::IntoFuture;`
`5`	`5`
`6`	`6`	`use context::Context;`
	`7`	`+use http;`
`7`	`8`	`use handler::{BoxHandler, Handler};`
`8`	`9`	`use response::Response;`
`9`	`10`	`use router::pattern::Pattern;`
`@@ -27,7 +28,7 @@ impl Route {`
`27`	`28`	`/// # Response::new()`
`28`	`29`	`/// });`
`29`	`30`	/// ```
`30`		`- pub fn new<P, H>(method: Method, pattern: P, handler: H) -> Self`
	`31`	`+ pub fn new<P, H>(method: http::Method, pattern: P, handler: H) -> Self`
`31`	`32`	`where`
`32`	`33`	`P: Into<Pattern>,`
`33`	`34`	`H: Handler + 'static,`
`@@ -36,7 +37,7 @@ impl Route {`
`36`	`37`	`Self {`
`37`	`38`	`handler: handler.into_box(),`
`38`	`39`	`pattern: pattern.into(),`
`39`		`- method,`
	`40`	`+ method: method.to_hyper_method(),`
`40`	`41`	`}`
`41`	`42`	`}`
`42`	`43`
`@@ -56,13 +57,13 @@ impl Route {`
`56`	`57`	`}`
`57`	`58`	`}`
`58`	`59`
`59`		`-impl<P, H> From<(Method, P, H)> for Route`
	`60`	`+impl<P, H> From<(http::Method, P, H)> for Route`
`60`	`61`	`where`
`61`	`62`	`P: Into<Pattern>,`
`62`	`63`	`H: Handler + 'static,`
`63`	`64`	`<H::Result as IntoFuture>::Error: fmt::Debug + Send,`
`64`	`65`	`{`
`65`		`- fn from(arguments: (Method, P, H)) -> Self {`
	`66`	`+ fn from(arguments: (http::Method, P, H)) -> Self {`
`66`	`67`	`Self::new(arguments.0, arguments.1, arguments.2)`
`67`	`68`	`}`
`68`	`69`	`}`