Revamp Tide, dropping Extractors and simplifying the framework

Cargo.toml

@@ -15,10 +15,11 @@ version = "0.0.5"
 [dependencies]
 cookie = "0.11"
 futures-preview = "0.3.0-alpha.13"
+fnv = "1.0.6"
 http = "0.1"
 http-service = "0.1.4"
-path-table = "1.0.0"
 pin-utils = "0.1.0-alpha.4"
+route-recognizer = "0.1.12"
 serde = "1.0.80"
 serde_derive = "1.0.80"
 serde_json = "1.0.32"
@@ -46,3 +47,5 @@ basic-cookies = "0.1.3"
 juniper = "0.10.0"
 structopt = "0.2.14"
 http-service-mock = "0.1.0"
+serde = "1.0.80"
+serde_derive = "1.0.80"

examples/body_types.rs

@@ -1,56 +1,51 @@
-#![feature(async_await, futures_api)]
+#![feature(async_await, futures_api, await_macro)]
 
 #[macro_use]
 extern crate serde_derive;
-use tide::body;
+
+use tide::{
+    error::ResultExt,
+    forms::{self, ExtractForms},
+    response, App, Context, EndpointResult,
+};
 
 #[derive(Serialize, Deserialize, Clone, Debug)]
 struct Message {
     author: Option<String>,
     contents: String,
 }
 
-async fn echo_string(msg: body::Str) -> String {
-    println!("String: {}", *msg);
-    format!("{}", *msg)
-}
-
-async fn echo_string_lossy(msg: body::StrLossy) -> String {
-    println!("String: {}", *msg);
-    format!("{}", *msg)
-}
-
-async fn echo_vec(msg: body::Bytes) -> Vec<u8> {
-    println!("Vec<u8>: {:?}", *msg);
-    msg.to_vec()
-}
-
-async fn echo_bytes(msg: body::Bytes) -> body::Bytes {
-    println!("Bytes: {:?}", *msg);
+async fn echo_string(mut cx: Context<()>) -> String {
+    let msg = await!(cx.body_string()).unwrap();
+    println!("String: {}", msg);
     msg
 }
 
-async fn echo_json(msg: body::Json<Message>) -> body::Json<Message> {
-    println!("JSON: {:?}", *msg);
-
+async fn echo_bytes(mut cx: Context<()>) -> Vec<u8> {
+    let msg = await!(cx.body_bytes()).unwrap();
+    println!("Bytes: {:?}", msg);
     msg
 }
 
-async fn echo_form(msg: body::Form<Message>) -> body::Form<Message> {
-    println!("Form: {:?}", *msg);
+async fn echo_json(mut cx: Context<()>) -> EndpointResult {
+    let msg = await!(cx.body_json()).client_err()?;
+    println!("JSON: {:?}", msg);
+    Ok(response::json(msg))
+}
 
-    msg
+async fn echo_form(mut cx: Context<()>) -> EndpointResult {
+    let msg = await!(cx.body_form())?;
+    println!("Form: {:?}", msg);
+    Ok(forms::form(msg))
 }
 
 fn main() {
-    let mut app = tide::App::new(());
+    let mut app = App::new(());
 
     app.at("/echo/string").post(echo_string);
-    app.at("/echo/string_lossy").post(echo_string_lossy);
-    app.at("/echo/vec").post(echo_vec);
     app.at("/echo/bytes").post(echo_bytes);
     app.at("/echo/json").post(echo_json);
     app.at("/echo/form").post(echo_form);
 
-    app.serve();
+    app.serve("127.0.0.1:8000").unwrap();
 }

examples/catch_all.rs

@@ -1,14 +1,14 @@
 #![feature(async_await, futures_api)]
 
-async fn echo_path(path: tide::head::Path<String>) -> String {
-    format!("Your path is: {}", *path)
+use tide::Context;
+
+async fn echo_path(cx: Context<()>) -> String {
+    let path: String = cx.param("path").unwrap();
+    format!("Your path is: {}", path)
 }
 
 fn main() {
     let mut app = tide::App::new(());
-    app.at("/echo_path").nest(|router| {
-        router.at("*").get(echo_path);
-    });
-
-    app.serve();
+    app.at("/echo_path/:path*").get(echo_path);
+    app.serve("127.0.0.1:8000").unwrap();
 }

examples/cookie_extractor.rs

@@ -1,18 +1,15 @@
 #![feature(async_await, futures_api)]
 
-use tide::Cookies;
+use tide::{cookies::ExtractCookies, Context};
 
 /// Tide will use the the `Cookies`'s `Extract` implementation to build this parameter.
 ///
-async fn hello_cookies(cookies: Cookies) -> String {
-    format!("hello cookies: {:?}", cookies)
+async fn hello_cookies(mut cx: Context<()>) -> String {
+    format!("hello cookies: {:?}", cx.cookie("hello"))
 }
 
 fn main() {
     let mut app = tide::App::new(());
     app.at("/").get(hello_cookies);
-
-    let address = "127.0.0.1:8000".to_owned();
-    println!("Server is listening on http://{}", address);
-    app.serve();
+    app.serve("127.0.0.1:8000").unwrap();
 }

examples/default_headers.rs

@@ -11,7 +11,7 @@ fn main() {
             .header("X-Server", "Tide"),
     );
 
-    app.at("/").get(async || "Hello, world!");
+    app.at("/").get(async move |_| "Hello, world!");
 
-    app.serve();
+    app.serve("127.0.0.1:8000").unwrap();
 }

examples/graphql.rs

@@ -3,26 +3,26 @@
 //
 // [the Juniper book]: https://graphql-rust.github.io/
 
-#![feature(async_await, futures_api)]
+#![feature(async_await, futures_api, await_macro)]
 
 use http::status::StatusCode;
 use juniper::graphql_object;
 use std::sync::{atomic, Arc};
-use tide::{body, App, AppData, IntoResponse, Response};
+use tide::{error::ResultExt, response, App, Context, EndpointResult};
 
-// First, we define `Context` that holds accumulator state. This is accessible as App data in
+// First, we define `Data` that holds accumulator state. This is accessible as App data in
 // Tide, and as executor context in Juniper.
 #[derive(Clone, Default)]
-struct Context(Arc<atomic::AtomicIsize>);
+struct Data(Arc<atomic::AtomicIsize>);
 
-impl juniper::Context for Context {}
+impl juniper::Context for Data {}
 
 // We define `Query` unit struct here. GraphQL queries will refer to this struct. The struct itself
 // doesn't have any associated data (and there's no need to do so), but instead it exposes the
 // accumulator state from the context.
 struct Query;
 
-graphql_object!(Query: Context |&self| {
+graphql_object!(Query: Data |&self| {
     // GraphQL integers are signed and 32 bits long.
     field accumulator(&executor) -> i32 as "Current value of the accumulator" {
         executor.context().0.load(atomic::Ordering::Relaxed) as i32
@@ -33,7 +33,7 @@ graphql_object!(Query: Context |&self| {
 // `Query`, but it provides the way to "mutate" the accumulator state.
 struct Mutation;
 
-graphql_object!(Mutation: Context |&self| {
+graphql_object!(Mutation: Data |&self| {
     field add(&executor, by: i32) -> i32 as "Add given value to the accumulator." {
         executor.context().0.fetch_add(by as isize, atomic::Ordering::Relaxed) as i32 + by
     }
@@ -45,23 +45,21 @@ type Schema = juniper::RootNode<'static, Query, Mutation>;
 
 // Finally, we'll bridge between Tide and Juniper. `GraphQLRequest` from Juniper implements
 // `Deserialize`, so we use `Json` extractor to deserialize the request body.
-async fn handle_graphql(
-    ctx: AppData<Context>,
-    query: body::Json<juniper::http::GraphQLRequest>,
-) -> Response {
-    let response = query.execute(&Schema::new(Query, Mutation), &ctx);
+async fn handle_graphql(mut cx: Context<Data>) -> EndpointResult {
+    let query: juniper::http::GraphQLRequest = await!(cx.body_json()).client_err()?;
+    let response = query.execute(&Schema::new(Query, Mutation), cx.app_data());
     let status = if response.is_ok() {
         StatusCode::OK
     } else {
         StatusCode::BAD_REQUEST
     };
-    body::Json(response).with_status(status).into_response()
+    let mut resp = response::json(response);
+    *resp.status_mut() = status;
+    Ok(resp)
 }
 
 fn main() {
-    let mut app = App::new(Context::default());
-
+    let mut app = App::new(Data::default());
     app.at("/graphql").post(handle_graphql);
-
-    app.serve();
+    app.serve("127.0.0.1:8000").unwrap();
 }

examples/hello.rs

@@ -2,7 +2,6 @@
 
 fn main() {
     let mut app = tide::App::new(());
-    app.at("/").get(async || "Hello, world!");
-
-    app.serve();
+    app.at("/").get(async move |_| "Hello, world!");
+    app.serve("127.0.0.1:8000").unwrap();
 }