Crate reinhardt_forms

Expand description

§Reinhardt Forms

Form processing and validation for the Reinhardt framework.

§Overview

This crate provides comprehensive form processing capabilities inspired by Django’s form system, focusing on data validation and multi-step form wizards.

This crate is designed to be WASM-compatible, providing a pure form processing layer without HTML generation or platform-specific features.

§Features

Form: Base form class with validation
ModelForm: Auto-generated forms from model definitions
FormSet: Handle multiple forms of the same type
FormWizard: Multi-step form workflows
Field Types: 20+ field types (CharField, IntegerField, EmailField, etc.)
WASM Support: Compatible with WebAssembly targets via wasm_compat module

§Quick Start

§Basic Form

use reinhardt_forms::{Form, CharField, EmailField, IntegerField};

// Build a form imperatively using add_field()
let mut form = Form::new();
form.add_field(Box::new(CharField::new("name")));
form.add_field(Box::new(EmailField::new("email")));
form.add_field(Box::new(IntegerField::new("age")));
form.add_field(Box::new(CharField::new("message")));

// Validate form data
form.bind(&request_data);
if form.is_valid() {
    // Process the validated form...
} else {
    let errors = form.errors();
}

§Prefixed Form Data

A prefixed form expects submitted field names to use the prefix. The validated values are exposed through canonical field names, while bound fields continue to read the original submitted values for rerendering.

use reinhardt_forms::{CharField, Field, Form};
use serde_json::json;
use std::collections::HashMap;

let mut form = Form::with_prefix("profile".to_string());
form.add_field(Box::new(CharField::new("name".to_string()).required()));
form.bind(HashMap::from([("profile-name".to_string(), json!("Ada"))]));

assert!(form.is_valid());
assert_eq!(form.cleaned_data().get("name"), Some(&json!("Ada")));
assert_eq!(
    form.get_bound_field("name").unwrap().value(),
    Some(&json!("Ada"))
);

§Model Form

use reinhardt_forms::{ModelForm, ModelFormBuilder};

// Auto-generate form from User model
let form = ModelFormBuilder::<User>::new()
    .fields(vec!["username".to_string(), "email".to_string(), "bio".to_string()])
    .exclude(vec!["password".to_string()])
    .build();

§Available Field Types

Field	Description
`CharField`	Text input with max_length validation
`IntegerField`	Integer input with min/max validation
`FloatField`	Floating-point number input
`DecimalField`	Decimal number with precision control
`BooleanField`	Checkbox input
`EmailField`	Email address validation
`URLField`	URL validation
`DateField`	Date input with format parsing
`DateTimeField`	DateTime input
`TimeField`	Time input
`DurationField`	Duration input
`FileField`	File upload
`ImageField`	Image upload with dimension validation
`ChoiceField`	Select dropdown
`MultipleChoiceField`	Multi-select
`ModelChoiceField`	Foreign key selection
`ModelMultipleChoiceField`	Multiple model selection with normalized dirty-state comparison
`JSONField`	JSON data input
`UUIDField`	UUID input
`SlugField`	URL-safe slug input
`RegexField`	Custom regex validation

ModelMultipleChoiceField compares selected values without considering order when Form::has_changed runs. Numeric IDs and strings with the same textual representation are equivalent, while booleans, nulls, arrays, and objects remain distinct JSON types.

§FormSets

Handle multiple forms of the same type:

use reinhardt_forms::{FormSet, FormSetFactory};

// Create a formset with 3 forms
let formset = FormSetFactory::<ItemForm>::new()
    .extra(3)
    .min_num(1)
    .max_num(10)
    .build();

if formset.is_valid() {
    for form in formset.forms() {
        // Process each form
    }
}

§Form Wizard

Multi-step forms:

use reinhardt_forms::{FormWizard, WizardStep};

let wizard = FormWizard::new()
    .add_step(WizardStep::new("account", AccountForm::new()))
    .add_step(WizardStep::new("profile", ProfileForm::new()))
    .add_step(WizardStep::new("confirmation", ConfirmForm::new()));

// Process wizard step
let result = wizard.process_step(&request).await?;

Re-exports§

pub use bound_field::BoundField;
pub use field::ErrorType;
pub use field::FieldError;
pub use field::FieldResult;
pub use field::FormField as Field;
pub use field::FormField;
pub use field::Widget;
pub use field::escape_attribute;
pub use field::html_escape;
pub use fields::BooleanField;
pub use fields::CharField;
pub use fields::ChoiceField;
pub use fields::ColorField;
pub use fields::ComboField;
pub use fields::DateField;
pub use fields::DateTimeField;
pub use fields::DecimalField;
pub use fields::DurationField;
pub use fields::EmailField;
pub use fields::FileField;
pub use fields::FloatField;
pub use fields::GenericIPAddressField;
pub use fields::IPProtocol;
pub use fields::ImageField;
pub use fields::IntegerField;
pub use fields::JSONField;
pub use fields::ModelChoiceField;
pub use fields::ModelMultipleChoiceField;
pub use fields::MultiValueField;
pub use fields::MultipleChoiceField;
pub use fields::PASSWORD_REDACTED;
pub use fields::PasswordField;
pub use fields::RegexField;
pub use fields::SlugField;
pub use fields::SplitDateTimeField;
pub use fields::TimeField;
pub use fields::URLField;
pub use fields::UUIDField;
pub use form::Form;
pub use form::FormError;
pub use form::FormResult;
pub use formset::FormSet;
pub use formsets::FormSetFactory;
pub use formsets::InlineFormSet;
pub use formsets::ModelFormSet as AdvancedModelFormSet;
pub use model_form::FieldType;
pub use model_form::FormModel;
pub use model_form::ModelForm;
pub use model_form::ModelFormBuilder;
pub use model_form::ModelFormConfig;
pub use model_formset::ModelFormSet;
pub use model_formset::ModelFormSetBuilder;
pub use model_formset::ModelFormSetConfig;
pub use validators::SlugValidator;
pub use validators::UrlValidator;
pub use wizard::FormWizard;
pub use wizard::WizardStep;

Modules§

bound_field: Bound field rendering with data and errors attached.
field: Core form field trait and error types.
fields: Built-in field types (text, email, integer, choice, etc.).
form: Form trait and validation logic.
formset: Formset for managing multiple form instances.
formsets: Built-in formset types (inline, base). Advanced FormSet functionality
model_form: Model-backed form with automatic field generation. ModelForm implementation for ORM integration
model_formset: Model-backed formset for bulk editing. ModelFormSet implementation for managing multiple model forms
validators: Field-level and form-level validators. Page/URL validators for form fields
wasm_compat: WASM compatibility layer for client-side forms. WASM Compatibility Layer for Forms (Week 5 Day 1-2)
wizard: Multi-step form wizard.