Struct WizardBuilder 

pub struct WizardBuilder<T: Wizard> { /* private fields */ }

Builder for configuring and executing a wizard

Implementations

impl<T: Wizard> WizardBuilder<T>

pub fn new() -> Self

Create a new wizard builder

pub fn with_suggestions(self, suggestions: T) -> Self

Set suggested values for the wizard

Examples found in repository

examples/builders/builder_comprehensive.rs (line 124)

fn run_suggestions_demo() {
    println!("\n--- Demo with Suggestions ---");
    let suggestions = UserProfile {
        name: "John Doe".to_string(),
        age: 30,
        email: "john@example.com".to_string(),
        subscribe: true,
    };
    let profile = UserProfile::wizard_builder()
        .with_suggestions(suggestions)
        .build()
        .unwrap();
    println!("Profile: {:#?}", profile);
}

examples/features/suggestions.rs (line 24)

fn main() {
    println!("=== Creating a new user profile ===");
    let profile = UserProfile::wizard_builder().build().unwrap();
    println!("Created profile: {profile:#?}");

    println!("=== Editing the existing profile ===");
    println!("The current values will be pre-filled as suggestions.");
    let updated_profile = UserProfile::wizard_builder()
        .with_suggestions(profile)
        .build()
        .unwrap();
    println!("Updated profile: {updated_profile:#?}");
}

examples/builders/builder_api.rs (line 45)

fn main() {
    println!("=== Builder API Demo ===");

    // Example 1: Simple builder with default backend
    println!("Example 1: Using default backend");
    let config1 = ServerConfig::wizard_builder().build().unwrap();
    println!("Config: {:#?}", config1);

    // Example 2: Builder with custom backend (dialoguer)
    #[cfg(feature = "dialoguer-backend")]
    {
        println!("Example 2: Using dialoguer backend");
        let backend = derive_wizard::DialoguerBackend::new();
        let config2 = ServerConfig::wizard_builder()
            .with_backend(backend)
            .build()
            .unwrap();
        println!("Config: {:#?}", config2);
    }

    // Example 3: Builder with suggestions
    println!("Example 3: Using suggestions (re-prompting with existing values)");
    let suggestions = ServerConfig {
        host: "localhost".to_string(),
        port: 8080,
        ssl: true,
    };
    let config3 = ServerConfig::wizard_builder()
        .with_suggestions(suggestions)
        .build()
        .unwrap();
    println!("Config: {:#?}", config3);
}

pub fn suggest_field( self, field: impl Into<FieldPath>, value: impl Into<SuggestedAnswer>, ) -> Self

Suggest a specific field value. The question will still be asked but with a pre-filled default.

For nested fields, use the field! macro.

pub fn assume_field( self, field: impl Into<FieldPath>, value: impl Into<AssumedAnswer>, ) -> Self

Assume a specific field value. The question for this field will be skipped.

For nested fields, use the field! macro.

Examples found in repository

examples/features/assumptions.rs (line 34)

fn main() {
    println!("=== Deployment Configuration Tool ===");

    // Scenario 1: Partial assumptions - the most common use case
    println!("--- Scenario 1: Partial Assumptions (Recommended) ---");
    println!("We'll assume some security-critical values but ask about others.");

    let config = DeploymentConfig::wizard_builder()
        .assume_field("environment", "production".to_string()) // Fixed: production
        .assume_field("debug", false) // Fixed: no debug in prod
        .assume_field("port", 443) // Fixed: HTTPS port
        .build()
        .unwrap(); // Will only ask about 'app_name' and 'database_url'

    println!("=== Configuration (with partial assumptions) ===");
    println!("{:#?}", config);
    println!("Notice: Only asked about app_name and database_url!");
    println!("The fields 'environment', 'debug', and 'port' were assumed.");

    // Scenario 2: Full assumptions - for batch processing
    println!("--- Scenario 2: Full Assumptions (for automation) ---");
    println!("Using a complete template - no questions will be asked.");

    let batch_config = DeploymentConfig::wizard_builder()
        .assume_field("app_name", "batch-processor".to_string())
        .assume_field("environment", "production".to_string())
        .assume_field("port", 8080)
        .assume_field("debug", false)
        .assume_field(
            "database_url",
            "postgresql://prod-db:5432/batch".to_string(),
        )
        .build()
        .unwrap();

    println!("=== Batch Configuration (all assumed, no questions) ===");
    println!("{:#?}", batch_config);

    println!("--- Summary ---");
    println!("Partial assumptions: Fix some fields, ask about others");
    println!("Full assumptions: Fix all fields, no user interaction");
    println!("Suggestions: Pre-fill values, but still ask all questions");
}

pub fn with_backend<B: InterviewBackend + 'static>(self, backend: B) -> Self

Set a custom backend

Examples found in repository

examples/backends/requestty_multi_select.rs (line 44)

fn main() {
    let backend = derive_wizard::RequesttyBackend;
    let order = PizzaOrder::wizard_builder()
        .with_backend(backend)
        .build()
        .unwrap();

    println!("\n📋 Order Summary");
    println!("────────────────");
    println!("Name: {}", order.name);
    println!("Size: {:?}", order.size);
    println!("Toppings: {:?}", order.toppings);
}

pub fn build(self) -> Result<T, BackendError>

Execute the wizard and return the result

Examples found in repository

examples/basic/nested_structs.rs (line 43)

fn main() {
    let user = User::wizard_builder().build().unwrap();
    println!("{user:#?}");
}

examples/advanced/deeply_nested.rs (line 40)

fn main() {
    let event = Event::wizard_builder().build().unwrap();
    println!("{event:#?}");
}

examples/advanced/nested_enum_payment.rs (line 40)

fn main() {
    let order = Order::wizard_builder().build().unwrap();
    println!("{:#?}", order);
}

examples/features/validation.rs (line 66)

fn main() {
    let config = ServerConfig::wizard_builder().build().unwrap();
    println!("{config:#?}");
}

examples/features/password_masking.rs (line 15)

fn main() {
    let form = LoginForm::wizard_builder().build().unwrap();
    println!("LoginForm: {form:#?}");
}

examples/basic/pathbuf.rs (line 11)

fn main() {
    let config = FileConfig::wizard_builder().build().unwrap();
    println!("  Input:  {:?}", config.path);
}

Additional examples can be found in:

• examples/basic/enum_transport.rs
• examples/basic/simple_struct.rs
• examples/features/prelude_epilogue.rs
• examples/features/nested_validation.rs
• examples/features/multiline.rs
• examples/backends/requestty_multi_select.rs
• examples/features/suggestions.rs
• examples/builders/builder_comprehensive.rs
• examples/showcase.rs
• examples/builders/builder_api.rs
• examples/features/assumptions.rs

Trait Implementations

impl<T: Default + Wizard> Default for WizardBuilder<T>

fn default() -> WizardBuilder<T>

Returns the “default value” for a type.