Restructure folders (#411)

2025-06-28 09:50:36 +02:00 · 2021-02-25 21:57:58 -03:00
parent 9db98162b2
commit c3407627d0
334 changed files with 127 additions and 120 deletions
--- a/template_engines/askama/Cargo.toml
+++ b/template_engines/askama/Cargo.toml
@ -0,0 +1,12 @@
+[package]
+name = "template-askama"
+version = "2.0.0"
+authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
+edition = "2018"
+
+[dependencies]
+actix-web = "3"
+askama = "0.9"
+
+[build-dependencies]
+askama = "0.9"
--- a/template_engines/askama/src/main.rs
+++ b/template_engines/askama/src/main.rs
@ -0,0 +1,40 @@
+use std::collections::HashMap;
+
+use actix_web::{web, App, HttpResponse, HttpServer, Result};
+use askama::Template;
+
+#[derive(Template)]
+#[template(path = "user.html")]
+struct UserTemplate<'a> {
+    name: &'a str,
+    text: &'a str,
+}
+
+#[derive(Template)]
+#[template(path = "index.html")]
+struct Index;
+
+async fn index(query: web::Query<HashMap<String, String>>) -> Result<HttpResponse> {
+    let s = if let Some(name) = query.get("name") {
+        UserTemplate {
+            name,
+            text: "Welcome!",
+        }
+        .render()
+        .unwrap()
+    } else {
+        Index.render().unwrap()
+    };
+    Ok(HttpResponse::Ok().content_type("text/html").body(s))
+}
+
+#[actix_web::main]
+async fn main() -> std::io::Result<()> {
+    // start http server
+    HttpServer::new(move || {
+        App::new().service(web::resource("/").route(web::get().to(index)))
+    })
+    .bind("127.0.0.1:8080")?
+    .run()
+    .await
+}
--- a/template_engines/askama/templates/index.html
+++ b/template_engines/askama/templates/index.html
@ -0,0 +1,17 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="utf-8" />
+  <title>Actix web</title>
+</head>
+<body>
+  <h1>Welcome!</h1>
+  <p>
+    <h3>What is your name?</h3>
+    <form>
+      <input type="text" name="name" /><br/>
+      <p><input type="submit"></p>
+    </form>
+  </p>
+</body>
+</html>
--- a/template_engines/askama/templates/user.html
+++ b/template_engines/askama/templates/user.html
@ -0,0 +1,13 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="utf-8" />
+  <title>Actix web</title>
+</head>
+<body>
+  <h1>Hi, {{ name }}!</h1>
+  <p>
+    {{ text }}
+  </p>
+</body>
+</html>
--- a/template_engines/handlebars/Cargo.toml
+++ b/template_engines/handlebars/Cargo.toml
@ -0,0 +1,11 @@
+[package]
+name = "template_handlebars"
+version = "1.0.0"
+authors = ["Alexandru Tiniuc <tiniuc.alexandru@gmail.com>"]
+edition = "2018"
+
+[dependencies]
+actix-http = "2"
+actix-web = "3"
+handlebars = { version = "3.0.0", features = ["dir_source"] }
+serde_json = "1.0"
--- a/template_engines/handlebars/README.md
+++ b/template_engines/handlebars/README.md
@ -0,0 +1,8 @@
+# Handlebars
+
+This is an example of how to use Actix Web with the [Handlebars templating language](https://crates.io/crates/handlebars), which is currently the most popular crate that achieves this. After starting the server with `cargo run`, you may visit the following pages:
+
+- http://localhost:8080
+- http://localhost:8080/Emma/documents
+- http://localhost:8080/Bob/passwords
+- http://localhost:8080/some-non-existing-page - 404 error rendered using template
--- a/template_engines/handlebars/src/main.rs
+++ b/template_engines/handlebars/src/main.rs
@ -0,0 +1,110 @@
+#[macro_use]
+extern crate actix_web;
+
+#[macro_use]
+extern crate serde_json;
+
+use actix_http::{body::Body, Response};
+use actix_web::dev::ServiceResponse;
+use actix_web::http::StatusCode;
+use actix_web::middleware::errhandlers::{ErrorHandlerResponse, ErrorHandlers};
+use actix_web::{web, App, HttpResponse, HttpServer, Result};
+
+use handlebars::Handlebars;
+
+use std::io;
+
+// Macro documentation can be found in the actix_web_codegen crate
+#[get("/")]
+async fn index(hb: web::Data<Handlebars<'_>>) -> HttpResponse {
+    let data = json!({
+        "name": "Handlebars"
+    });
+    let body = hb.render("index", &data).unwrap();
+
+    HttpResponse::Ok().body(body)
+}
+
+#[get("/{user}/{data}")]
+async fn user(
+    hb: web::Data<Handlebars<'_>>,
+    web::Path(info): web::Path<(String, String)>,
+) -> HttpResponse {
+    let data = json!({
+        "user": info.0,
+        "data": info.1
+    });
+    let body = hb.render("user", &data).unwrap();
+
+    HttpResponse::Ok().body(body)
+}
+
+#[actix_web::main]
+async fn main() -> io::Result<()> {
+    // Handlebars uses a repository for the compiled templates. This object must be
+    // shared between the application threads, and is therefore passed to the
+    // Application Builder as an atomic reference-counted pointer.
+    let mut handlebars = Handlebars::new();
+    handlebars
+        .register_templates_directory(".html", "./static/templates")
+        .unwrap();
+    let handlebars_ref = web::Data::new(handlebars);
+
+    HttpServer::new(move || {
+        App::new()
+            .wrap(error_handlers())
+            .app_data(handlebars_ref.clone())
+            .service(index)
+            .service(user)
+    })
+    .bind("127.0.0.1:8080")?
+    .run()
+    .await
+}
+
+// Custom error handlers, to return HTML responses when an error occurs.
+fn error_handlers() -> ErrorHandlers<Body> {
+    ErrorHandlers::new().handler(StatusCode::NOT_FOUND, not_found)
+}
+
+// Error handler for a 404 Page not found error.
+fn not_found<B>(res: ServiceResponse<B>) -> Result<ErrorHandlerResponse<B>> {
+    let response = get_error_response(&res, "Page not found");
+    Ok(ErrorHandlerResponse::Response(
+        res.into_response(response.into_body()),
+    ))
+}
+
+// Generic error handler.
+fn get_error_response<B>(res: &ServiceResponse<B>, error: &str) -> Response<Body> {
+    let request = res.request();
+
+    // Provide a fallback to a simple plain text response in case an error occurs during the
+    // rendering of the error page.
+    let fallback = |e: &str| {
+        Response::build(res.status())
+            .content_type("text/plain")
+            .body(e.to_string())
+    };
+
+    let hb = request
+        .app_data::<web::Data<Handlebars>>()
+        .map(|t| t.get_ref());
+    match hb {
+        Some(hb) => {
+            let data = json!({
+                "error": error,
+                "status_code": res.status().as_str()
+            });
+            let body = hb.render("error", &data);
+
+            match body {
+                Ok(body) => Response::build(res.status())
+                    .content_type("text/html")
+                    .body(body),
+                Err(_) => fallback(error),
+            }
+        }
+        None => fallback(error),
+    }
+}
--- a/template_engines/handlebars/static/templates/error.html
+++ b/template_engines/handlebars/static/templates/error.html
@ -0,0 +1,10 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="utf-8" />
+  <title>{{error}}</title>
+</head>
+<body>
+  <h1>{{status_code}} {{error}}</h1>
+</body>
+</html>
--- a/template_engines/handlebars/static/templates/index.html
+++ b/template_engines/handlebars/static/templates/index.html
@ -0,0 +1,12 @@
+<!DOCTYPE html>
+<html>
+
+<head>
+    <title>{{name}} Example</title>
+</head>
+
+<body>
+    <h1>{{name}} example</h1>
+    <p>This is an example of how to use {{name}} with Actix-Web.</p>
+</body>
+</html>
--- a/template_engines/handlebars/static/templates/user.html
+++ b/template_engines/handlebars/static/templates/user.html
@ -0,0 +1,12 @@
+<!DOCTYPE html>
+<html>
+
+<head>
+    <title>{{user}}'s homepage</title>
+</head>
+
+<body>
+    <h1>Welcome back, {{user}}</h1>
+    <p>Here's your {{data}}.</p>
+</body>
+</html>
--- a/template_engines/tera/Cargo.toml
+++ b/template_engines/tera/Cargo.toml
@ -0,0 +1,11 @@
+[package]
+name = "template-tera"
+version = "2.0.0"
+authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
+edition = "2018"
+
+[dependencies]
+env_logger = "0.8"
+tera = "1.0"
+actix-http = "2"
+actix-web = "3"
--- a/template_engines/tera/README.md
+++ b/template_engines/tera/README.md
@ -0,0 +1,18 @@
+# template_tera
+
+Minimal example of using the template [tera](https://github.com/Keats/tera) that displays a form.
+
+## Usage
+
+### server
+
+```bash
+cd examples/template_tera
+cargo run (or ``cargo watch -x run``)
+# Started http server: 127.0.0.1:8080
+```
+
+### web client
+
+- [http://localhost:8080](http://localhost:8080)
+- [http://localhost:8080/non-existing-page](http://localhost:8080/non-existing-page) - 404 page rendered using template
--- a/template_engines/tera/src/main.rs
+++ b/template_engines/tera/src/main.rs
@ -0,0 +1,91 @@
+use std::collections::HashMap;
+
+use actix_http::{body::Body, Response};
+use actix_web::dev::ServiceResponse;
+use actix_web::http::StatusCode;
+use actix_web::middleware::errhandlers::{ErrorHandlerResponse, ErrorHandlers};
+use actix_web::{error, middleware, web, App, Error, HttpResponse, HttpServer, Result};
+use tera::Tera;
+
+// store tera template in application state
+async fn index(
+    tmpl: web::Data<tera::Tera>,
+    query: web::Query<HashMap<String, String>>,
+) -> Result<HttpResponse, Error> {
+    let s = if let Some(name) = query.get("name") {
+        // submitted form
+        let mut ctx = tera::Context::new();
+        ctx.insert("name", &name.to_owned());
+        ctx.insert("text", &"Welcome!".to_owned());
+        tmpl.render("user.html", &ctx)
+            .map_err(|_| error::ErrorInternalServerError("Template error"))?
+    } else {
+        tmpl.render("index.html", &tera::Context::new())
+            .map_err(|_| error::ErrorInternalServerError("Template error"))?
+    };
+    Ok(HttpResponse::Ok().content_type("text/html").body(s))
+}
+
+#[actix_web::main]
+async fn main() -> std::io::Result<()> {
+    std::env::set_var("RUST_LOG", "actix_web=info");
+    env_logger::init();
+
+    HttpServer::new(|| {
+        let tera =
+            Tera::new(concat!(env!("CARGO_MANIFEST_DIR"), "/templates/**/*")).unwrap();
+
+        App::new()
+            .data(tera)
+            .wrap(middleware::Logger::default()) // enable logger
+            .service(web::resource("/").route(web::get().to(index)))
+            .service(web::scope("").wrap(error_handlers()))
+    })
+    .bind("127.0.0.1:8080")?
+    .run()
+    .await
+}
+
+// Custom error handlers, to return HTML responses when an error occurs.
+fn error_handlers() -> ErrorHandlers<Body> {
+    ErrorHandlers::new().handler(StatusCode::NOT_FOUND, not_found)
+}
+
+// Error handler for a 404 Page not found error.
+fn not_found<B>(res: ServiceResponse<B>) -> Result<ErrorHandlerResponse<B>> {
+    let response = get_error_response(&res, "Page not found");
+    Ok(ErrorHandlerResponse::Response(
+        res.into_response(response.into_body()),
+    ))
+}
+
+// Generic error handler.
+fn get_error_response<B>(res: &ServiceResponse<B>, error: &str) -> Response<Body> {
+    let request = res.request();
+
+    // Provide a fallback to a simple plain text response in case an error occurs during the
+    // rendering of the error page.
+    let fallback = |e: &str| {
+        Response::build(res.status())
+            .content_type("text/plain")
+            .body(e.to_string())
+    };
+
+    let tera = request.app_data::<web::Data<Tera>>().map(|t| t.get_ref());
+    match tera {
+        Some(tera) => {
+            let mut context = tera::Context::new();
+            context.insert("error", error);
+            context.insert("status_code", res.status().as_str());
+            let body = tera.render("error.html", &context);
+
+            match body {
+                Ok(body) => Response::build(res.status())
+                    .content_type("text/html")
+                    .body(body),
+                Err(_) => fallback(error),
+            }
+        }
+        None => fallback(error),
+    }
+}
--- a/template_engines/tera/templates/error.html
+++ b/template_engines/tera/templates/error.html
@ -0,0 +1,10 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="utf-8" />
+  <title>{{ error }}</title>
+</head>
+<body>
+  <h1>{{ status_code }} {{ error }}</h1>
+</body>
+</html>
--- a/template_engines/tera/templates/index.html
+++ b/template_engines/tera/templates/index.html
@ -0,0 +1,17 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="utf-8" />
+  <title>Actix web</title>
+</head>
+<body>
+  <h1>Welcome!</h1>
+  <p>
+    <h3>What is your name?</h3>
+    <form>
+      <input type="text" name="name" /><br/>
+      <p><input type="submit"></p>
+    </form>
+  </p>
+</body>
+</html>
--- a/template_engines/tera/templates/user.html
+++ b/template_engines/tera/templates/user.html
@ -0,0 +1,13 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="utf-8" />
+  <title>Actix web</title>
+</head>
+<body>
+  <h1>Hi, {{ name }}!</h1>
+  <p>
+    {{ text }}
+  </p>
+</body>
+</html>
--- a/template_engines/tinytemplate/Cargo.toml
+++ b/template_engines/tinytemplate/Cargo.toml
@ -0,0 +1,12 @@
+[package]
+name = "template-tinytemplate"
+version = "2.0.0"
+authors = ["Hanif Bin Ariffin <hanif.ariffin.4326@gmail.com>"]
+edition = "2018"
+
+[dependencies]
+env_logger = "0.8"
+tinytemplate = "1.1"
+actix-http = "2"
+actix-web = "3"
+serde_json = "1"
--- a/template_engines/tinytemplate/README.md
+++ b/template_engines/tinytemplate/README.md
@ -0,0 +1,18 @@
+# template_tinytemplate
+
+See the documentation for the minimalist template engine [tiny_template](https://docs.rs/tinytemplate/1.1.0/tinytemplate/).
+
+## Usage
+
+### Server
+
+```bash
+cd examples/template_tinytemplate
+cargo run # (or ``cargo watch -x run``)
+# Started http server: 127.0.0.1:8080
+```
+
+### Web Client
+
+- [http://localhost:8080](http://localhost:8080)
+- [http://localhost:8080/non-existing-page](http://localhost:8080/non-existing-page) - 404 page rendered using template
--- a/template_engines/tinytemplate/src/main.rs
+++ b/template_engines/tinytemplate/src/main.rs
@ -0,0 +1,101 @@
+use std::collections::HashMap;
+
+use actix_http::{body::Body, Response};
+use actix_web::dev::ServiceResponse;
+use actix_web::http::StatusCode;
+use actix_web::middleware::errhandlers::{ErrorHandlerResponse, ErrorHandlers};
+use actix_web::{error, middleware, web, App, Error, HttpResponse, HttpServer, Result};
+use serde_json::json;
+use tinytemplate::TinyTemplate;
+
+// store tiny_template in application state
+async fn index(
+    tmpl: web::Data<TinyTemplate<'_>>,
+    query: web::Query<HashMap<String, String>>,
+) -> Result<HttpResponse, Error> {
+    let s = if let Some(name) = query.get("name") {
+        // submitted form
+        let ctx = json!({
+          "name" : name.to_owned(),
+          "text" : "Welcome!".to_owned()
+        });
+        tmpl.render("user.html", &ctx)
+            .map_err(|_| error::ErrorInternalServerError("Template error"))?
+    } else {
+        tmpl.render("index.html", &serde_json::Value::Null)
+            .map_err(|_| error::ErrorInternalServerError("Template error"))?
+    };
+    Ok(HttpResponse::Ok().content_type("text/html").body(s))
+}
+
+#[actix_web::main]
+async fn main() -> std::io::Result<()> {
+    std::env::set_var("RUST_LOG", "actix_web=info");
+    env_logger::init();
+
+    HttpServer::new(|| {
+        let mut tt = TinyTemplate::new();
+        tt.add_template("index.html", INDEX).unwrap();
+        tt.add_template("user.html", USER).unwrap();
+        tt.add_template("error.html", ERROR).unwrap();
+
+        App::new()
+            .data(tt)
+            .wrap(middleware::Logger::default()) // enable logger
+            .service(web::resource("/").route(web::get().to(index)))
+            .service(web::scope("").wrap(error_handlers()))
+    })
+    .bind("127.0.0.1:8080")?
+    .run()
+    .await
+}
+
+// Custom error handlers, to return HTML responses when an error occurs.
+fn error_handlers() -> ErrorHandlers<Body> {
+    ErrorHandlers::new().handler(StatusCode::NOT_FOUND, not_found)
+}
+
+// Error handler for a 404 Page not found error.
+fn not_found<B>(res: ServiceResponse<B>) -> Result<ErrorHandlerResponse<B>> {
+    let response = get_error_response(&res, "Page not found");
+    Ok(ErrorHandlerResponse::Response(
+        res.into_response(response.into_body()),
+    ))
+}
+
+// Generic error handler.
+fn get_error_response<B>(res: &ServiceResponse<B>, error: &str) -> Response<Body> {
+    let request = res.request();
+
+    // Provide a fallback to a simple plain text response in case an error occurs during the
+    // rendering of the error page.
+    let fallback = |e: &str| {
+        Response::build(res.status())
+            .content_type("text/plain")
+            .body(e.to_string())
+    };
+
+    let tt = request
+        .app_data::<web::Data<TinyTemplate<'_>>>()
+        .map(|t| t.get_ref());
+    match tt {
+        Some(tt) => {
+            let mut context = std::collections::HashMap::new();
+            context.insert("error", error.to_owned());
+            context.insert("status_code", res.status().as_str().to_owned());
+            let body = tt.render("error.html", &context);
+
+            match body {
+                Ok(body) => Response::build(res.status())
+                    .content_type("text/html")
+                    .body(body),
+                Err(_) => fallback(error),
+            }
+        }
+        None => fallback(error),
+    }
+}
+
+static ERROR: &str = include_str!("../templates/error.html");
+static INDEX: &str = include_str!("../templates/index.html");
+static USER: &str = include_str!("../templates/user.html");
--- a/template_engines/tinytemplate/templates/error.html
+++ b/template_engines/tinytemplate/templates/error.html
@ -0,0 +1,10 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="utf-8" />
+    <title>{error}</title>
+  </head>
+  <body>
+    <h1>{status_code} {error}</h1>
+  </body>
+</html>
--- a/template_engines/tinytemplate/templates/index.html
+++ b/template_engines/tinytemplate/templates/index.html
@ -0,0 +1,17 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="utf-8" />
+  <title>Actix web</title>
+</head>
+<body>
+  <h1>Welcome!</h1>
+  <p>
+    <h3>What is your name?</h3>
+    <form>
+      <input type="text" name="name" /><br/>
+      <p><input type="submit"></p>
+    </form>
+  </p>
+</body>
+</html>
--- a/template_engines/tinytemplate/templates/user.html
+++ b/template_engines/tinytemplate/templates/user.html
@ -0,0 +1,11 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="utf-8" />
+    <title>Actix web</title>
+  </head>
+  <body>
+    <h1>Hi, {name}!</h1>
+    <p>{text}</p>
+  </body>
+</html>
--- a/template_engines/yarte/Cargo.toml
+++ b/template_engines/yarte/Cargo.toml
@ -0,0 +1,21 @@
+[package]
+name = "template_yarte"
+version = "0.0.1"
+authors = ["Juan Aguilar Santillana <mhpoin@gmail.com>"]
+publish = false
+edition = "2018"
+
+[dependencies]
+actix-web = "3"
+env_logger = "0.8"
+# TODO: remove fixed feature. Is a bug.
+yarte = { version = "0.12", features = ["bytes-buf", "html-min", "fixed"] }
+derive_more = "0.99"
+
+[build-dependencies.yarte_helpers]
+version = "0.12"
+default-features = false
+features = ["config"]
+
+[dev-dependencies]
+actix-rt = "1"
--- a/template_engines/yarte/README.md
+++ b/template_engines/yarte/README.md
@ -0,0 +1,10 @@
+# yarte
+
+Minimal example of using template [yarte](https://github.com/botika/yarte) that displays a form.
+
+```bash
+cargo test
+
+cargo run
+```
+> open `localhost:8080`
--- a/template_engines/yarte/build.rs
+++ b/template_engines/yarte/build.rs
@ -0,0 +1,3 @@
+fn main() {
+    yarte_helpers::recompile::when_changed();
+}
--- a/template_engines/yarte/src/main.rs
+++ b/template_engines/yarte/src/main.rs
@ -0,0 +1,126 @@
+use std::collections::HashMap;
+
+use actix_web::{
+    get, middleware::Logger, web, App, Error, HttpResponse, HttpServer, ResponseError,
+};
+use derive_more::Display;
+use yarte::ywrite_min;
+
+#[derive(Debug, Display)]
+struct MyErr(pub &'static str);
+
+impl ResponseError for MyErr {}
+
+#[get("/")]
+async fn index(
+    query: web::Query<HashMap<String, String>>,
+) -> Result<HttpResponse, Error> {
+    let mut body = web::BytesMut::with_capacity(512);
+    // `ywrite_min` is work in progress check your templates before put in production
+    // or use `ywrite_html`
+    ywrite_min!(body, "{{> index }}");
+
+    Ok(HttpResponse::Ok()
+        .content_type("text/html; charset=utf-8")
+        .body(body))
+}
+
+#[actix_web::main]
+async fn main() -> std::io::Result<()> {
+    std::env::set_var("RUST_LOG", "actix_web=info");
+    env_logger::init();
+
+    // start http server
+    HttpServer::new(move || App::new().wrap(Logger::default()).service(index))
+        .bind("127.0.0.1:8080")?
+        .run()
+        .await
+}
+
+#[cfg(test)]
+mod test {
+    use actix_web::{http, test as atest, web::Bytes};
+
+    use super::*;
+
+    #[actix_rt::test]
+    async fn test() {
+        let mut app = atest::init_service(App::new().service(index)).await;
+
+        let req = atest::TestRequest::with_uri("/").to_request();
+        let resp = atest::call_service(&mut app, req).await;
+
+        assert!(resp.status().is_success());
+
+        assert_eq!(
+            resp.headers().get(http::header::CONTENT_TYPE).unwrap(),
+            "text/html; charset=utf-8"
+        );
+
+        let bytes = atest::read_body(resp).await;
+        assert_eq!(
+            bytes,
+            Bytes::from_static(
+                "<!DOCTYPE html><html><head><meta charset=\"utf-8\"><title>Actix \
+                 web</title></head><body><h1 id=\"welcome\" \
+                 class=\"welcome\">Welcome!</h1><div><h3>What is your name?</h3><form>Name: \
+                 <input type=\"text\" name=\"name\"><br>Last name: <input type=\"text\" \
+                 name=\"lastname\"><br><p><input type=\"submit\"></p></form></div></body></html>"
+                    .as_ref()
+            )
+        );
+
+        let req = atest::TestRequest::with_uri("/?name=foo&lastname=bar").to_request();
+        let resp = atest::call_service(&mut app, req).await;
+
+        assert!(resp.status().is_success());
+
+        assert_eq!(
+            resp.headers().get(http::header::CONTENT_TYPE).unwrap(),
+            "text/html; charset=utf-8"
+        );
+
+        let bytes = atest::read_body(resp).await;
+        assert_eq!(
+            bytes,
+            Bytes::from_static(
+                "<!DOCTYPE html><html><head><meta charset=\"utf-8\"><title>Actix \
+                 web</title></head><body><h1>Hi, foo bar!</h1><p id=\"hi\" \
+                 class=\"welcome\">Welcome</p></body></html>"
+                    .as_ref()
+            )
+        );
+
+        let req = atest::TestRequest::with_uri("/?name=foo").to_request();
+        let resp = atest::call_service(&mut app, req).await;
+
+        assert!(resp.status().is_server_error());
+
+        let bytes = atest::read_body(resp).await;
+
+        assert_eq!(bytes, Bytes::from_static("Bad query".as_ref()));
+
+        let req = atest::TestRequest::with_uri("/?lastname=bar").to_request();
+        let resp = atest::call_service(&mut app, req).await;
+
+        assert!(resp.status().is_success());
+
+        assert_eq!(
+            resp.headers().get(http::header::CONTENT_TYPE).unwrap(),
+            "text/html; charset=utf-8"
+        );
+
+        let bytes = atest::read_body(resp).await;
+        assert_eq!(
+            bytes,
+            Bytes::from_static(
+                "<!DOCTYPE html><html><head><meta charset=\"utf-8\"><title>Actix \
+                 web</title></head><body><h1 id=\"welcome\" \
+                 class=\"welcome\">Welcome!</h1><div><h3>What is your name?</h3><form>Name: \
+                 <input type=\"text\" name=\"name\"><br>Last name: <input type=\"text\" \
+                 name=\"lastname\"><br><p><input type=\"submit\"></p></form></div></body></html>"
+                    .as_ref()
+            )
+        );
+    }
+}
--- a/template_engines/yarte/templates/base.hbs
+++ b/template_engines/yarte/templates/base.hbs
@ -0,0 +1,8 @@
+{{! Simple example !}}
+{{> doc/t }}
+<html>
+{{> doc/head }}
+<body>
+{{> @partial-block }}
+</body>
+</html>
--- a/template_engines/yarte/templates/deep/more/card/form.hbs
+++ b/template_engines/yarte/templates/deep/more/card/form.hbs
@ -0,0 +1,16 @@
+{{!
+    Form: What is your name?
+!}}
+{{> ../deep/welcome id = "welcome", tag = "h1", tail = '!' ~}}
+<div>
+    <h3>What is your name?</h3>
+    <form>
+        {{! Input name !}}
+        Name: <input type="text" name="name" /><br/>
+        {{! Input last name !}}
+        Last name: <input type="text" name="lastname"/><br/>
+        <p>
+            <input type="submit">
+        </p>
+    </form>
+</div>
--- a/template_engines/yarte/templates/deep/more/card/hi.hbs
+++ b/template_engines/yarte/templates/deep/more/card/hi.hbs
@ -0,0 +1,8 @@
+{{!
+    Hi message:
+    args:
+        - lastname
+        - name
+!}}
+<h1>Hi, {{ name }} {{ lastname }}!</h1>
+{{~> alias/welcome id = "hi", tag = 'p', tail = "" }}
--- a/template_engines/yarte/templates/deep/more/deep/welcome.hbs
+++ b/template_engines/yarte/templates/deep/more/deep/welcome.hbs
@ -0,0 +1,11 @@
+{{!
+    Welcome card:
+    args:
+        - tag
+        - id
+        - tail
+!}}
+{{#unless tag.is_match(r"^p|(h[1-6])$") && !id.is_empty() }}
+   {{$ "Need static args: tag: str /^h[1-6]$/, id: str" }}
+{{/unless }}
+<{{ tag }} id="{{ id }}" class="welcome">Welcome{{ tail }}</{{ tag }}>
--- a/template_engines/yarte/templates/deep/more/doc/head.hbs
+++ b/template_engines/yarte/templates/deep/more/doc/head.hbs
@ -0,0 +1,7 @@
+{{# unless title.is_str() && !title.is_empty() }}
+    {{$ "Need static args: title: str" }}
+{{/unless}}
+<head>
+    <meta charset="utf-8"/>
+    <title>{{ title }}</title>
+</head>
--- a/template_engines/yarte/templates/deep/more/doc/t.hbs
+++ b/template_engines/yarte/templates/deep/more/doc/t.hbs
@ -0,0 +1 @@
+<!DOCTYPE html>
--- a/template_engines/yarte/templates/index.hbs
+++ b/template_engines/yarte/templates/index.hbs
@ -0,0 +1,8 @@
+{{#> base title = "Actix web" }}
+    {{~#if let Some(name) = query.get("name") }}
+        {{ let lastname = query.get("lastname").ok_or(MyErr("Bad query"))? }}
+        {{> card/hi ~}}
+    {{ else ~}}
+        {{> card/form ~}}
+    {{/if ~}}
+{{/base }}
--- a/template_engines/yarte/yarte.toml
+++ b/template_engines/yarte/yarte.toml
@ -0,0 +1,9 @@
+# root dir of templates
+[main]
+dir = "templates"
+
+# Alias for partials. In call, change the start of partial path with one of this, if exist.
+[partials]
+alias = "./deep/more/deep"
+doc = "./deep/more/doc"
+card = "./deep/more/card"