figen 0.2.0

Strongly typed configuration bindings and registries generated from a declarative schema
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133

# figen

`figen` is a Rust library for generating strongly-typed configuration bindings and registries from a compact declarative schema.

It is designed to simplify configuration management, primarily for embedded development, where parsing and wiring configuration keys by hand becomes repetitive and error-prone.

## Why this project exists

Embedded firmware often needs:

- Static, known-at-compile-time configuration structures
- Reliable parsing from key-value sources (files, NVS, RPC backends, etc.)
- A machine-readable registry that clients can fetch to discover capabilities

`figen` reduces boilerplate by generating the config structs, binders, defaults, and registry metadata from a single source of truth.

## Key features

- Works in both `std` and `no_std` environments
- Declarative config schema via `config_registry!`
- Generated strongly-typed config structs
- Default values and optional fields
- Nested keys and indexed-array key support
- Generated registry metadata with versioning
- Custom property types via `TryFrom<&str>` + `#[derive(ConfigBinder)]`

## Quick example

```rust
use figen::config_registry;

config_registry!(
    name = AppConfig
    version = 1

    str_property("telemetry.endpoint", default = "udp://127.0.0.1:14550", max_len = 64)
    num_property("control.pid.kp", default = 10)
    num_property("control.pid.ki", default = 2)
    bool_property("control.enabled", default = true)
);

// Generated:
// - AppConfig (root config struct)
// - APP_CONFIG_REGISTRY (registry static)
```

Loading:

```rust
let loader = MyPropertyLoader::new(); // implement figen::loader::PropertyLoader
let cfg: AppConfig = figen::load_config(&loader)?;
```

## Multiple registries (example)

You can define independent registries in separate modules and avoid naming collisions:

```rust
mod app {
    use figen::config_registry;

    config_registry!(
        name = AppConfig
        version = 1
        num_property("pid.kp", default = 10)
    );
}

mod board {
    use figen::config_registry;

    config_registry!(
        name = BoardConfig
        version = 1
        num_property("gpio.motor_a.pin", default = 12)
    );
}

// app::APP_CONFIG_REGISTRY
// board::BOARD_CONFIG_REGISTRY
```

## Custom types

```rust
use figen::config_registry;

#[derive(figen::ConfigBinder, Default)]
struct Gain(u16);

impl TryFrom<&str> for Gain {
    type Error = &'static str;

    fn try_from(value: &str) -> Result<Self, Self::Error> {
        value.parse::<u16>().map(Gain).map_err(|_| "parse error")
    }
}

config_registry!(
    name = AppConfig
    version = 1
    custom_property("control.gain", default = "42", ty = Gain)
);
```

## Feature flags

- `std`: enables `std` support and lazy static registry for runtime-friendly environments
- `serde`: enables serde serialization support for generated registry/config metadata

Common combinations:

- `--no-default-features`
- `--no-default-features --features serde`
- `--no-default-features --features std`
- `--no-default-features --features std --features serde`

## Project status

Early-stage and evolving. Breaking API changes are still possible while the API is being shaped.

## Contributing

Issues and pull requests are welcome. If you propose API changes, include motivation and expected embedded/firmware workflow impact.

## License

Licensed under either of:

- Apache License, Version 2.0 ([LICENSE-APACHE](LICENSE-APACHE))
- MIT license ([LICENSE-MIT](LICENSE-MIT))

at your option.