Per-endpoint configuration (#109)

* Add configuration types

* Expose configuration to endpoints

* Make configurations actually configurable

* Use typemap approach for configuration

* Add example for configuration

* Change module organization of configuration

* Add docs for configuration module

* Add tests for Configuration, fix existing tests

* Run rustfmt

* Change how the configuration is nested

* Add tests for Router with configuration

* Add comments to configuration example

* Change the name of `RequestConext::get_config` to get_config_item

* Rename Configuration to Store and move it to configuration module.

* This is because the Confiugration type is a App global sharable
TypeMap which is avaiable across both middleware and endpoints.
Therefore, this can be used to store arbitrary types and not only
configuartion.
* Tis commit renames all occurrances of Configuration to Store and
updates the parameters and struct field names appropriately.

* Add default configuration and configuration builder types

* Have simple hook into the App by the way of the `setup_configuration`
method. This is pretty basic rightn now, but can be the point of entry
for hooking in custom configuration.

* Simple useage of app configuration internally

* Use address from confiugration when starting up server

* Fix tests

* Adress review comments.

* Add more documentation for Configuration

* Address clippy lints

* Make naming consistent

* Change name of Store tests

* Add Debug impl for Store

* Add configuration debug example

Author: tirr-c

examples/body_types.rs

@@ -52,7 +52,5 @@ fn main() {
     app.at("/echo/json").post(echo_json);
     app.at("/echo/form").post(echo_form);
 
-    let address = "127.0.0.1:8000".to_owned();
-    println!("Server is listening on http://{}", address);
-    app.serve(address);
+    app.serve();
 }

examples/catch_all.rs

@@ -10,7 +10,5 @@ fn main() {
         router.at("*").get(echo_path);
     });
 
-    let address = "127.0.0.1:8000".to_owned();
-    println!("Server is listening on http://{}", address);
-    app.serve(address);
+    app.serve();
 }

examples/computed_values.rs

@@ -34,7 +34,5 @@ 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(address);
+    app.serve();
 }

examples/configuration.rs

@@ -0,0 +1,34 @@
+#![feature(async_await, futures_api)]
+
+use futures::future::FutureObj;
+use tide::{head::Path, middleware::RequestContext, ExtractConfiguration, Response};
+
+/// A type that represents how much value will be added by the `add` handler.
+#[derive(Clone, Debug, Default)]
+struct IncreaseBy(i32);
+
+async fn add(
+    Path(base): Path<i32>,
+    // `ExtractConfiguration` will extract the configuration item of given type, and provide it as
+    // `Option<T>`. If it is not set, the inner value will be `None`.
+    ExtractConfiguration(amount): ExtractConfiguration<IncreaseBy>,
+) -> String {
+    let IncreaseBy(amount) = amount.unwrap_or_default();
+    format!("{} plus {} is {}", base, amount, base + amount)
+}
+
+fn debug_store(ctx: RequestContext<()>) -> FutureObj<Response> {
+    println!("{:#?}", ctx.store());
+    ctx.next()
+}
+
+fn main() {
+    let mut app = tide::App::new(());
+    // `App::config` sets the default configuration of the app (that is, a top-level router).
+    app.config(IncreaseBy(1));
+    app.middleware(debug_store);
+    app.at("add_one/{}").get(add); // `IncreaseBy` is set to 1
+    app.at("add_two/{}").get(add).config(IncreaseBy(2)); // `IncreaseBy` is overridden to 2
+
+    app.serve();
+}

examples/default_handler.rs

@@ -9,7 +9,5 @@ fn main() {
 
     app.default_handler(async || "¯\\_(ツ)_/¯".with_status(StatusCode::NOT_FOUND));
 
-    let address = "127.0.0.1:8000".to_owned();
-    println!("Server is listening on http://{}", address);
-    app.serve(address)
+    app.serve()
 }

examples/default_headers.rs

@@ -13,7 +13,5 @@ fn main() {
 
     app.at("/").get(async || "Hello, world!");
 
-    let address = "127.0.0.1:8000".to_owned();
-    println!("Server is listening on http://{}", address);
-    app.serve(address);
+    app.serve();
 }

examples/graphql.rs

@@ -70,7 +70,5 @@ fn main() {
 
     app.at("/graphql").post(handle_graphql);
 
-    let address = "127.0.0.1:8000".to_owned();
-    println!("Server is listening on http://{}", address);
-    app.serve(address);
+    app.serve();
 }

examples/hello.rs

@@ -4,7 +4,5 @@ fn main() {
     let mut app = tide::App::new(());
     app.at("/").get(async || "Hello, world!");
 
-    let address = "127.0.0.1:8000".to_owned();
-    println!("Server is listening on http://{}", address);
-    app.serve(address);
+    app.serve();
 }

examples/messages.rs

@@ -81,7 +81,5 @@ fn main() {
     app.at("/message/{}").get(get_message);
     app.at("/message/{}").post(set_message);
 
-    let address = "127.0.0.1:8000".to_owned();
-    println!("Server is listening on http://{}", address);
-    app.serve(address);
+    app.serve();
 }

examples/multipart-form/main.rs

@@ -65,9 +65,7 @@ fn main() {
 
     app.at("/upload_file").post(upload_file);
 
-    let address = "127.0.0.1:8000".to_owned();
-    println!("Server is listening on http://{}", address);
-    app.serve(address);
+    app.serve();
 }
 
 // Test with:

examples/named_path.rs

@@ -25,7 +25,5 @@ fn main() {
     let mut app = tide::App::new(());
     app.at("add_two/{num}").get(add_two);
 
-    let address = "127.0.0.1:8000".to_owned();
-    println!("Server is listening on http://{}", address);
-    app.serve(address);
+    app.serve();
 }

examples/simple_nested_router.rs

@@ -34,7 +34,5 @@ fn main() {
     let mut app = tide::App::new(());
     app.at("add_two").nest(build_add_two);
 
-    let address = "127.0.0.1:8000".to_owned();
-    println!("Server is listening on http://{}", address);
-    app.serve(address);
+    app.serve();
 }

src/app.rs

@@ -5,17 +5,20 @@ use futures::{
 };
 use hyper::service::Service;
 use std::{
+    any::Any,
+    fmt::Debug,
     ops::{Deref, DerefMut},
     sync::Arc,
 };
 
 use crate::{
     body::Body,
+    configuration::{Configuration, Store},
     endpoint::BoxedEndpoint,
     endpoint::Endpoint,
     extract::Extract,
     middleware::{logger::RootLogger, RequestContext},
-    router::{Resource, RouteResult, Router},
+    router::{EndpointData, Resource, RouteResult, Router},
     Middleware, Request, Response, RouteMatch,
 };
 
@@ -35,7 +38,7 @@ use crate::{
 ///
 /// let mut app = tide::App::new(());
 /// app.at("/hello").get(async || "Hello, world!");
-/// app.serve("127.0.0.1:7878")
+/// app.serve()
 /// ```
 ///
 /// `App` state can be modeled with an underlying `Data` handle for a cloneable type `T`. Endpoints
@@ -74,7 +77,7 @@ use crate::{
 /// fn main() {
 ///     let mut app = tide::App::new(Database::new());
 ///     app.at("/messages/insert").post(insert);
-///     app.serve("127.0.0.1:7878")
+///     app.serve()
 /// }
 /// ```
 ///
@@ -84,7 +87,7 @@ use crate::{
 pub struct App<Data> {
     data: Data,
     router: Router<Data>,
-    default_handler: BoxedEndpoint<Data>,
+    default_handler: EndpointData<Data>,
 }
 
 impl<Data: Clone + Send + Sync + 'static> App<Data> {
@@ -94,14 +97,25 @@ impl<Data: Clone + Send + Sync + 'static> App<Data> {
         let mut app = App {
             data,
             router: Router::new(),
-            default_handler: BoxedEndpoint::new(async || http::status::StatusCode::NOT_FOUND),
+            default_handler: EndpointData {
+                endpoint: BoxedEndpoint::new(async || http::status::StatusCode::NOT_FOUND),
+                store: Store::new(),
+            },
         };
 
         // Add RootLogger as a default middleware
         app.middleware(logger);
+        app.setup_configuration();
+
         app
     }
 
+    // Add default configuration
+    fn setup_configuration(&mut self) {
+        let config = Configuration::build().finalize();
+        self.config(config);
+    }
+
     /// Get the top-level router.
     pub fn router(&mut self) -> &mut Router<Data> {
         &mut self.router
@@ -114,9 +128,16 @@ impl<Data: Clone + Send + Sync + 'static> App<Data> {
     }
 
     /// Set the default handler for the app, a fallback function when there is no match to the route requested
-    pub fn default_handler<T: Endpoint<Data, U>, U>(&mut self, handler: T) -> &mut Self {
-        self.default_handler = BoxedEndpoint::new(handler);
-        self
+    pub fn default_handler<T: Endpoint<Data, U>, U>(
+        &mut self,
+        handler: T,
+    ) -> &mut EndpointData<Data> {
+        let endpoint = EndpointData {
+            endpoint: BoxedEndpoint::new(handler),
+            store: self.router.store_base.clone(),
+        };
+        self.default_handler = endpoint;
+        &mut self.default_handler
     }
 
     /// Apply `middleware` to the whole app. Note that the order of nesting subrouters and applying
@@ -126,7 +147,18 @@ impl<Data: Clone + Send + Sync + 'static> App<Data> {
         self
     }
 
-    fn into_server(self) -> Server<Data> {
+    /// Add a default configuration `item` for the whole app.
+    pub fn config<T: Any + Debug + Clone + Send + Sync>(&mut self, item: T) -> &mut Self {
+        self.router.config(item);
+        self
+    }
+
+    pub fn get_item<T: Any + Debug + Clone + Send + Sync>(&self) -> Option<&T> {
+        self.router.get_item()
+    }
+
+    fn into_server(mut self) -> Server<Data> {
+        self.router.apply_default_config();
         Server {
             data: self.data,
             router: Arc::new(self.router),
@@ -137,12 +169,17 @@ impl<Data: Clone + Send + Sync + 'static> App<Data> {
     /// Start serving the app at the given address.
     ///
     /// Blocks the calling thread indefinitely.
-    pub fn serve<A: std::net::ToSocketAddrs>(self, addr: A) {
+    pub fn serve(self) {
+        let configuration = self.get_item::<Configuration>().unwrap();
+        let addr = format!("{}:{}", configuration.address, configuration.port)
+            .parse::<std::net::SocketAddr>()
+            .unwrap();
+
+        println!("Server is listening on: http://{}", addr);
+
         let server: Server<Data> = self.into_server();
 
         // TODO: be more robust
-        let addr = addr.to_socket_addrs().unwrap().next().unwrap();
-
         let server = hyper::Server::bind(&addr)
             .serve(move || {
                 let res: Result<_, std::io::Error> = Ok(server.clone());
@@ -162,7 +199,7 @@ impl<Data: Clone + Send + Sync + 'static> App<Data> {
 struct Server<Data> {
     data: Data,
     router: Arc<Router<Data>>,
-    default_handler: Arc<BoxedEndpoint<Data>>,
+    default_handler: Arc<EndpointData<Data>>,
 }
 
 impl<Data: Clone + Send + Sync + 'static> Service for Server<Data> {
@@ -223,7 +260,12 @@ impl<T> DerefMut for AppData<T> {
 
 impl<T: Clone + Send + 'static> Extract<T> for AppData<T> {
     type Fut = future::Ready<Result<Self, Response>>;
-    fn extract(data: &mut T, req: &mut Request, params: &Option<RouteMatch<'_>>) -> Self::Fut {
+    fn extract(
+        data: &mut T,
+        req: &mut Request,
+        params: &Option<RouteMatch<'_>>,
+        store: &Store,
+    ) -> Self::Fut {
         future::ok(AppData(data.clone()))
     }
 }