Crate es_htmlform

Library to validate and generate HTML forms.

use es_htmlform::{HtmlForm, FormError, ValidationError};
use es_htmlform::value::ValueMap;
use es_htmlform::types::{InputType, Method, Constraint as Cons, Attr};

// simple form with 1 field
fn searchform() -> Result<HtmlForm<'static>, FormError> {
    Ok(HtmlForm::new(".", Method::Get)
        .input(
            InputType::Text, "q", "Search", true,
            vec![], vec![Attr::Placeholder("enter query")])?
        .submit(None, "go!", vec![])?)
}

// more elaborate example, with validation (both client- and
// server-side) and custom attributes
fn userform() -> Result<HtmlForm<'static>, FormError> {
    Ok(HtmlForm::new(".", Method::Post)
        .input(
            InputType::Text, "username", "Username", true,
            vec![
                Cons::MinLength(5), Cons::MaxLength(16),
                Cons::Pattern(r"^\w+$")],
            vec![])?
        .input(
            InputType::Text, "name", "Full name", true,
            vec![Cons::MinLength(0), Cons::MaxLength(64)], vec![])?
        .input(
            InputType::Password, "password", "Password", true,
            vec![
                Cons::MinLength(6), Cons::MaxLength(64),
                Cons::Pattern(r"(\d.*[^\w\s\d]|[^\w\s\d].*\d)"),
            ],
            vec![Attr::Title(
                "Must contain 1 number and 1 non-word character")])?
        .input(
            InputType::Number, "age", "Age", true,
            vec![Cons::MinNumber(18.0)],
            vec![Attr::StepInt(1), Attr::Any("id", "age")])?
        .textarea("message", "Message", false, vec![], vec![])?
        .hidden(
            "csrf", Some("foo"), true,
            vec![Cons::Func(Box::new(|v| {
                if v.as_string().as_str() != "foo" {
                    Err(ValidationError::new("invalid CSRF token"))
                } else {
                    Ok(())
                }
            }))],
            vec![])?
        .submit(None, "Submit", vec![])?
    )
}

fn main() {
    let values = ValueMap::from_urlencoded(b"q=foo").unwrap();
    let mut form = searchform().unwrap();
    form.update(&values, true);

    println!("{}", serde_json::to_string_pretty(&form).unwrap());
    assert_eq!(form.errors.len(), 0);
    assert_eq!(form.get_string("q").unwrap(), "foo");
    assert_eq!(
        serde_json::to_string_pretty(&form).unwrap(),
        r#"{
  "action": ".",
  "method": "get",
  "errors": {},
  "fields": [
    {
      "name": "q",
      "label": "Search",
      "element": "input",
      "type": "text",
      "required": true,
      "multi": false,
      "choices": [],
      "attributes": {
        "placeholder": "enter query"
      },
      "value": "foo"
    },
    {
      "name": "",
      "label": "go!",
      "element": "input",
      "type": "submit",
      "required": false,
      "multi": false,
      "choices": [],
      "attributes": {},
      "value": ""
    }
  ]
}"#);

    let values = ValueMap::from_urlencoded(
        b"username=johnny&name=Johnny&password=foobar-123&age=46&csrf=bar"
    ).unwrap();
    let mut form = userform().unwrap();
    form.update(&values, true);

    assert_eq!(form.errors.len(), 1);
    assert_eq!(
        form.errors.get("csrf").unwrap(), "invalid CSRF token");
    assert_eq!(form.get_string("username").unwrap(), "johnny");
    assert_eq!(form.get_string("password").unwrap(), "foobar-123");
    assert_eq!(form.get_string("csrf").unwrap(), "bar");
}

Modules

types

Enums representing HTML elements, attributes and values.

value

Structs

Field

Represents a form field/element.

FormError

Returned on form definition errors.

HtmlForm

HtmlForm represents an HTML form. It is used to validate data (both on the server and the client side) and to serialize forms in a consistent manner (either as JSON or using a template language of choice). The builder-style API makes it relatively easy to define forms:

ValidationError

Returned on form validation errors.