holy 0.2.1 - Docs.rs

Holy

A proc-macro library that ships derive macros for everyday struct chores: getters, setters, observers, fuzz constructors, and input sanitization. Pulling it as a path / crates.io dep keeps each consumer free of hand-rolled boilerplate and centralizes policy changes (new sanitize rules, observer hooks, etc.) in one crate.

Available derives

Getters — auto-generates get_<field>() accessors.
Setters — auto-generates set_<field>() mutators.
Observer — emits change events on field updates.
Fuzz — generates random() constructors for tests.
Sanitize — generates .sanitize() + per-field .sanitize_<field>() methods driven by #[holy(sanitize = "rule1, rule2(arg)")] attributes.

Getters & Setters

#[derive(holy::Getters, holy::Setters)]
pub struct User {
    pub name: String,
    pub age: u32,
}

let mut user = User { name: "test".into(), age: 25 };
let name: &String = user.name();    // getter
user.set_age(26);                    // setter

Supports generic structs:

#[derive(holy::Getters, holy::Setters)]
pub struct Container<T> {
    pub value: T,
}

Attributes

Control visibility and behavior per-field with #[holy(...)]:

#[holy(public)] — make the generated getter/setter pub regardless of field visibility
#[holy(private)] — make the generated getter/setter private regardless of field visibility
#[holy(skip)] — skip generating getter/setter for this field
#[holy(observe)] — mark field for observer pattern (used with Observer derive)

Observer

Derive Observer to generate a companion struct for the observer pattern:

#[derive(holy::Observer)]
pub struct Sensor {
    #[holy(observe)]
    pub temperature: f64,
    pub name: String,
}

// Generates `SensorObservers` companion struct
let mut observers = SensorObservers::new();
observers.add_temperature_observer(|s: &Sensor| {
    println!("temp: {}", s.temperature);
});
observers.notify_temperature_observers(&sensor);

Sanitize

Derive Sanitize to generate .sanitize() plus per-field .sanitize_<field>() methods. Each rule is declared inline on the field via #[holy(sanitize = "...")] and runs in the order written.

Rule	Field type	Effect
`trim`	`String`	`.trim().to_string()`
`lowercase`	`String`	`.to_lowercase()`
`uppercase`	`String`	`.to_uppercase()`
`alphanumeric`	`String`	retain only `char::is_alphanumeric()`
`escape_html`	`String`	replace `& < > " '` with HTML entities
`nul_strip`	`String`	drop every `\0` byte (0.2.1)
`control_strip`	`String`	drop ASCII/Unicode control chars + bidi overrides (U+202A..U+202E, U+2066..U+2069) + zero-width chars (U+200B..U+200D, U+FEFF) (0.2.1)
`slug`	`String`	lowercase + ASCII alphanumerics + collapse separator runs into single `-` + trim leading/trailing `-` (0.2.1)
`truncate(N)`	`String`	UTF-8-safe byte truncate to `N`; walks back to nearest char boundary so multi-byte codepoints never panic
`clamp(min, max)`	numeric	`.clamp(min, max)`

Use control_strip only on inline text fields (titles, signatures, slugs). It removes \n and \t so it is not appropriate for markdown bodies — those should be rendered through a markdown sanitizer on the read path instead.

Option<String> fields work the same way: rules run only when the field is Some(_) and None passes through. Useful for partial-update DTOs (e.g. pub bio: Option<String>).

#[derive(holy::Sanitize, serde::Deserialize)]
pub struct CreateThreadBody {
    #[holy(sanitize = "trim, control_strip, escape_html, truncate(180)")]
    pub title: String,
    #[holy(sanitize = "trim, lowercase, slug, truncate(50)")]
    pub space_slug: String,
    #[holy(sanitize = "nul_strip, truncate(50000)")]
    pub body: String,
}

After payload.sanitize() the struct is safe to forward into downstream RPCs without per-field length / control-char checks.

Fuzz

Derive Fuzz to generate random() constructors for tests:

#[derive(holy::Fuzz)]
pub struct Coords {
    pub x: i32,
    pub y: i32,
}

let c = Coords::random();