# random-constructible-derive
[](https://crates.io/crates/random-constructible-derive)
[](https://docs.rs/random-constructible-derive)
`random-constructible-derive` is a procedural macro crate that provides custom derive macros for the [`random-constructible`](https://crates.io/crates/random-constructible) crate. It allows you to automatically implement the `RandConstruct` trait for your structs and enums, enabling easy random generation of complex types with minimal boilerplate.
## Features
- **Automatic Implementation**: Derive `RandConstruct` for structs and enums without manual implementation.
- **Support for Enums**: Handle enums with unit variants, named fields, and unnamed fields, including custom probabilities.
- **Support for Structs**: Derive for structs with named, unnamed, or unit fields.
- **Custom Probabilities**: Specify custom probabilities for enum variants and `Option` fields using attributes.
- **Option Field Handling**: Customize the probability of `Some` values in `Option<T>` fields.
## Installation
Add the following to your `Cargo.toml`:
```toml
[dependencies]
random-constructible = "0.6.0"
random-constructible-derive = "0.6.0"
```
And include it in your crate:
```rust
use random_constructible::RandConstruct;
use random_constructible_derive::RandConstruct;
```
## Usage
### Deriving for Structs
You can derive `RandConstruct` for your structs to enable random generation:
```rust
use random_constructible::RandConstruct;
use random_constructible_derive::RandConstruct;
#[derive(RandConstruct)]
struct MyStruct {
a: u8,
b: String,
c: f64,
}
```
### Deriving for Enums
Similarly, you can derive `RandConstruct` for enums:
```rust
use random_constructible::RandConstruct;
use random_constructible_derive::RandConstruct;
#[derive(RandConstruct)]
enum MyEnum {
VariantA,
VariantB(i32, String),
VariantC { x: f64, y: bool },
}
```
### Custom Probabilities for Enum Variants
You can specify custom probabilities for each variant using the `#[rand_construct(p = ...)]` attribute:
```rust
use random_constructible::RandConstruct;
use random_constructible_derive::RandConstruct;
#[derive(RandConstruct)]
enum MyEnum {
#[rand_construct(p = 0.5)]
VariantA,
#[rand_construct(p = 0.3)]
VariantB,
#[rand_construct(p = 0.2)]
VariantC,
}
```
### Handling `Option` Fields
For `Option<T>` fields, you can specify the probability of generating a `Some` value using the `#[rand_construct(psome = ...)]` attribute:
```rust
use random_constructible::RandConstruct;
use random_constructible_derive::RandConstruct;
#[derive(RandConstruct)]
struct MyStruct {
#[rand_construct(psome = 0.8)]
optional_field: Option<String>,
}
```
If you don't specify `psome`, it defaults to `0.5`.
## Examples
### Struct Example
```rust
use random_constructible::RandConstruct;
use random_constructible_derive::RandConstruct;
#[derive(RandConstruct)]
struct Config {
pub id: u32,
pub name: String,
#[rand_construct(psome = 0.9)]
pub description: Option<String>,
}
fn main() {
let random_config = Config::random();
println!("{:?}", random_config);
}
```
### Enum Example with Custom Probabilities
```rust
use random_constructible::RandConstruct;
use random_constructible_derive::RandConstruct;
#[derive(Debug, RandConstruct)]
enum Status {
#[rand_construct(p = 0.7)]
Active,
#[rand_construct(p = 0.2)]
Inactive,
#[rand_construct(p = 0.1)]
Pending,
}
fn main() {
let random_status = Status::random();
println!("Random Status: {:?}", random_status);
}
```
### Complex Enum with Fields
```rust
use random_constructible::RandConstruct;
use random_constructible_derive::RandConstruct;
#[derive(Debug, RandConstruct)]
enum Message {
Text(String),
Data(u8, u8, u8),
#[rand_construct(p = 0.05)]
Disconnect,
}
fn main() {
let random_message = Message::random();
println!("Random Message: {:?}", random_message);
}
```
## How It Works
The `random-constructible-derive` crate provides the `RandConstruct` derive macro, which automatically generates implementations of the `RandConstruct` trait for your types. It handles different kinds of data structures:
- **Structs**: Generates random values for each field, respecting any specified attributes.
- **Enums**: Generates random variants based on specified probabilities, and recursively generates random values for any associated data.
### Attributes
- `#[rand_construct(p = <probability>)]`: Sets the probability for an enum variant. The probabilities are relative weights.
- `#[rand_construct(psome = <probability>)]`: Sets the probability of `Some` for `Option<T>` fields.
## Limitations
- The derive macro requires that all fields also implement `RandConstruct`.
- For generic types, ensure that the generic parameters are constrained with `RandConstruct` where necessary.
- The current implementation assumes that probabilities are specified as `f64` literals.
## Contributing
Contributions are welcome! Please feel free to submit a pull request or open an issue for any bugs or feature requests.
## License
This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
---
*Note: This crate is a companion to the [`random-constructible`](https://crates.io/crates/random-constructible) crate. Ensure that you have both crates added to your dependencies to utilize the full functionality.*