update url-dispatch examples

examples/url-dispatch/Cargo.toml

@@ -0,0 +1,12 @@
+[package]
+name = "url-dispatch"
+version = "0.6.0"
+workspace = "../"
+
+[dependencies]
+actix = "0.5"
+actix-web = "0.6"
+futures = "0.1"
+openssl = "0.10"
+serde = "1.0"
+serde_derive = "1.0"

examples/url-dispatch/src/cfg.rs

@@ -0,0 +1,15 @@
+// <cfg>
+use actix_web::{pred, App, HttpResponse};
+
+fn main() {
+    App::new()
+        .resource("/path", |resource| {
+            resource
+                .route()
+                .filter(pred::Get())
+                .filter(pred::Header("content-type", "text/plain"))
+                .f(|req| HttpResponse::Ok())
+        })
+        .finish();
+}
+// </cfg>

examples/url-dispatch/src/dhandler.rs

@@ -0,0 +1,14 @@
+// <default>
+use actix_web::{http::Method, pred, App, HttpResponse};
+
+fn main() {
+    App::new()
+        .default_resource(|r| {
+            r.method(Method::GET).f(|req| HttpResponse::NotFound());
+            r.route()
+                .filter(pred::Not(pred::Get()))
+                .f(|req| HttpResponse::MethodNotAllowed());
+        })
+        .finish();
+}
+// </default>

examples/url-dispatch/src/main.rs

@@ -0,0 +1,38 @@
+extern crate actix;
+extern crate actix_web;
+extern crate futures;
+extern crate openssl;
+#[macro_use]
+extern crate serde_derive;
+extern crate serde;
+
+mod cfg;
+mod dhandler;
+mod minfo;
+mod norm;
+mod norm2;
+mod path;
+mod path2;
+mod pbuf;
+mod pred;
+mod pred2;
+mod prefix;
+mod resource;
+mod scope;
+mod url_ext;
+mod urls;
+
+// <main>
+use actix_web::{http::Method, App, HttpRequest, HttpResponse};
+
+fn index(req: HttpRequest) -> HttpResponse {
+    unimplemented!()
+}
+
+fn main() {
+    App::new()
+        .route("/user/{name}", Method::GET, index)
+        .route("/user/{name}", Method::POST, index)
+        .finish();
+}
+// </main>

examples/url-dispatch/src/minfo.rs

@@ -0,0 +1,15 @@
+// <minfo>
+use actix_web::{App, HttpRequest, Result};
+
+fn index(req: HttpRequest) -> Result<String> {
+    let v1: u8 = req.match_info().query("v1")?;
+    let v2: u8 = req.match_info().query("v2")?;
+    Ok(format!("Values {} {}", v1, v2))
+}
+
+fn main() {
+    App::new()
+        .resource(r"/a/{v1}/{v2}/", |r| r.f(index))
+        .finish();
+}
+// </minfo>

examples/url-dispatch/src/norm.rs

@@ -0,0 +1,15 @@
+// <norm>
+use actix_web::{http::NormalizePath, App};
+
+fn main() {
+    let app = App::new()
+        .resource("/resource/", |r| r.f(index))
+        .default_resource(|r| r.h(NormalizePath::default()))
+        .finish();
+}
+// </norm>
+
+use actix_web::HttpRequest;
+fn index(req: HttpRequest) -> String {
+    unimplemented!()
+}

examples/url-dispatch/src/norm2.rs

@@ -0,0 +1,16 @@
+// <norm>
+use actix_web::{http::Method, http::NormalizePath, App};
+
+fn main() {
+    let app = App::new()
+        .resource("/resource/", |r| r.f(index))
+        .default_resource(|r| r.method(Method::GET).h(NormalizePath::default()))
+        .finish();
+}
+// </norm>
+
+use actix_web::HttpRequest;
+
+fn index(req: HttpRequest) -> String {
+    unimplemented!()
+}

examples/url-dispatch/src/path.rs

@@ -0,0 +1,15 @@
+// <path>
+use actix_web::{http::Method, App, Path, Result};
+
+// extract path info using serde
+fn index(info: Path<(String, u32)>) -> Result<String> {
+    Ok(format!("Welcome {}! id: {}", info.0, info.1))
+}
+
+fn main() {
+    let app = App::new().resource(
+        "/{username}/{id}/index.html", // <- define path parameters
+        |r| r.method(Method::GET).with(index),
+    );
+}
+// </path>

examples/url-dispatch/src/path2.rs

@@ -0,0 +1,21 @@
+// <path>
+extern crate serde_derive;
+use actix_web::{http::Method, App, Path, Result};
+
+#[derive(Deserialize)]
+struct Info {
+    username: String,
+}
+
+// extract path info using serde
+fn index(info: Path<Info>) -> Result<String> {
+    Ok(format!("Welcome {}!", info.username))
+}
+
+fn main() {
+    let app = App::new().resource(
+        "/{username}/index.html", // <- define path parameters
+        |r| r.method(Method::GET).with(index),
+    );
+}
+// </path>

examples/url-dispatch/src/pbuf.rs

@@ -0,0 +1,15 @@
+// <pbuf>
+use actix_web::{http::Method, App, HttpRequest, Result};
+use std::path::PathBuf;
+
+fn index(req: HttpRequest) -> Result<String> {
+    let path: PathBuf = req.match_info().query("tail")?;
+    Ok(format!("Path {:?}", path))
+}
+
+fn main() {
+    App::new()
+        .resource(r"/a/{tail:.*}", |r| r.method(Method::GET).f(index))
+        .finish();
+}
+// </pbuf>

examples/url-dispatch/src/pred.rs

@@ -0,0 +1,19 @@
+// <pred>
+use actix_web::{http, pred::Predicate, App, HttpMessage, HttpRequest, HttpResponse};
+
+struct ContentTypeHeader;
+
+impl<S: 'static> Predicate<S> for ContentTypeHeader {
+    fn check(&self, req: &mut HttpRequest<S>) -> bool {
+        req.headers().contains_key(http::header::CONTENT_TYPE)
+    }
+}
+
+fn main() {
+    App::new().resource("/index.html", |r| {
+        r.route()
+            .filter(ContentTypeHeader)
+            .f(|_| HttpResponse::Ok())
+    });
+}
+// </pred>

examples/url-dispatch/src/pred2.rs

@@ -0,0 +1,13 @@
+// <pred>
+use actix_web::{pred, App, HttpResponse};
+
+fn main() {
+    App::new()
+        .resource("/index.html", |r| {
+            r.route()
+                .filter(pred::Not(pred::Get()))
+                .f(|req| HttpResponse::MethodNotAllowed())
+        })
+        .finish();
+}
+// </pred>

examples/url-dispatch/src/prefix.rs

@@ -0,0 +1,14 @@
+use actix_web::{App, HttpRequest, HttpResponse};
+
+// <prefix>
+fn show_users(req: HttpRequest) -> HttpResponse {
+    unimplemented!()
+}
+
+fn main() {
+    App::new()
+        .prefix("/users")
+        .resource("/show", |r| r.f(show_users))
+        .finish();
+}
+// </prefix>

examples/url-dispatch/src/resource.rs

@@ -0,0 +1,16 @@
+// <resource>
+use actix_web::{http::Method, App, HttpRequest, HttpResponse};
+
+fn index(req: HttpRequest) -> HttpResponse {
+    unimplemented!()
+}
+
+fn main() {
+    App::new()
+        .resource("/prefix", |r| r.f(index))
+        .resource("/user/{name}", |r| {
+            r.method(Method::GET).f(|req| HttpResponse::Ok())
+        })
+        .finish();
+}
+// </resource>

examples/url-dispatch/src/scope.rs

@@ -0,0 +1,54 @@
+#![allow(dead_code)]
+use actix_web::{http::Method, App, HttpRequest};
+
+fn get_projects(_: HttpRequest) -> String {
+    unimplemented!()
+}
+fn create_project(_: HttpRequest) -> String {
+    unimplemented!()
+}
+fn update_project(_: HttpRequest) -> String {
+    unimplemented!()
+}
+fn delete_project(_: HttpRequest) -> String {
+    unimplemented!()
+}
+fn get_tasks(_: HttpRequest) -> String {
+    unimplemented!()
+}
+fn create_task(_: HttpRequest) -> String {
+    unimplemented!()
+}
+fn update_task(_: HttpRequest) -> String {
+    unimplemented!()
+}
+fn delete_task(_: HttpRequest) -> String {
+    unimplemented!()
+}
+
+fn main() {
+// <scope>
+App::new().scope("/project", |proj_scope| {
+    proj_scope
+        .resource("", |r| {
+            r.method(Method::GET).f(get_projects);
+            r.method(Method::POST).f(create_project)
+        })
+        .resource("/{project_id}", |r| {
+            r.method(Method::PUT).with(update_project);
+            r.method(Method::DELETE).f(delete_project)
+        })
+        .nested("/{project_id}/task", |task_scope| {
+            task_scope
+                .resource("", |r| {
+                    r.method(Method::GET).f(get_tasks);
+                    r.method(Method::POST).f(create_task)
+                })
+                .resource("/{task_id}", |r| {
+                    r.method(Method::PUT).with(update_task);
+                    r.method(Method::DELETE).with(delete_task)
+                })
+        })
+});
+// </scope>
+}

examples/url-dispatch/src/url_ext.rs

@@ -0,0 +1,16 @@
+// <ext>
+use actix_web::{App, Error, HttpRequest, HttpResponse};
+
+fn index(mut req: HttpRequest) -> Result<HttpResponse, Error> {
+    let url = req.url_for("youtube", &["oHg5SJYRHA0"])?;
+    assert_eq!(url.as_str(), "https://youtube.com/watch/oHg5SJYRHA0");
+    Ok(HttpResponse::Ok().into())
+}
+
+fn main() {
+    let app = App::new()
+        .resource("/index.html", |r| r.f(index))
+        .external_resource("youtube", "https://youtube.com/watch/{video_id}")
+        .finish();
+}
+// </ext>

examples/url-dispatch/src/urls.rs

@@ -0,0 +1,20 @@
+// <url>
+use actix_web::{http::header, http::Method, App, HttpRequest, HttpResponse, Result};
+
+fn index(req: HttpRequest) -> Result<HttpResponse> {
+    let url = req.url_for("foo", &["1", "2", "3"])?; // <- generate url for "foo" resource
+    Ok(HttpResponse::Found()
+        .header(header::LOCATION, url.as_str())
+        .finish())
+}
+
+fn main() {
+    let app = App::new()
+        .resource("/test/{a}/{b}/{c}", |r| {
+            r.name("foo"); // <- set resource name, then it could be used in `url_for`
+            r.method(Method::GET).f(|_| HttpResponse::Ok());
+        })
+        .route("/test/", Method::GET, index)
+        .finish();
+}
+// </url>