zenquirer 0.1.0

Interactive command-line questionnaires and prompts with async support
Documentation
use std::collections::HashMap;
use zenquirer::{Answer, CrosstermBackend, QuestionnaireBuilder, QuestionnaireExt};

fn main() {
    let result = zenquirer::smol::block_on(async { run().await });

    if let Err(e) = result {
        eprintln!("Error: {e}");
    }
}

async fn run() -> Result<(), zenquirer::Error> {
    let backend = CrosstermBackend::new()?;
    backend.clear_screen()?;

    // KeyValue Demo: Demonstrates selecting from structured key-value data
    // Useful for configuration options, database records, API responses, etc.

    // Example 1: Simple configuration selection
    let config_entries = vec![
        ("env".to_string(), Answer::text("production")),
        ("port".to_string(), Answer::number(8080.0)),
        ("debug".to_string(), Answer::boolean(false)),
    ];

    // Example 2: User records selection
    let user_entries = vec![
        (
            "user_1".to_string(),
            create_user_record("Alice", "alice@example.com", 28.0),
        ),
        (
            "user_2".to_string(),
            create_user_record("Bob", "bob@example.com", 35.0),
        ),
        (
            "user_3".to_string(),
            create_user_record("Charlie", "charlie@example.com", 42.0),
        ),
    ];

    // Example 3: API endpoint selection
    let endpoint_entries = vec![
        (
            "get_users".to_string(),
            create_endpoint_config("GET", "/api/users", true),
        ),
        (
            "create_user".to_string(),
            create_endpoint_config("POST", "/api/users", true),
        ),
        (
            "delete_user".to_string(),
            create_endpoint_config("DELETE", "/api/users/:id", false),
        ),
    ];

    let survey = QuestionnaireBuilder::new()
        .header("KeyValue Selection Demo")
        .select_keyvalue("config", "Select a configuration setting to view")
        .entries(config_entries)
        .hint("Use ↑↓ to navigate, Enter to select")
        .multiselect_keyvalue("users", "Select users to export")
        .entries(user_entries)
        .hint("Use ↑↓ to navigate, Space to select, Enter to confirm")
        .multiselect_keyvalue("endpoints", "Select API endpoints to enable")
        .entries(endpoint_entries)
        .hint("Choose which endpoints should be active")
        .footer("KeyValue questions return structured data preserving types")
        .build();

    let results = survey.ask_all_async(backend, None).await?;

    // Display results
    println!("\n\nResults:");
    println!("========\n");

    if let Some(Answer::KeyValue(config)) = results.get("config") {
        println!("Selected configuration:");
        for (key, value) in config {
            println!("  {key}: {value:?}");
        }
    }

    if let Some(Answer::KeyValue(users)) = results.get("users") {
        println!("\nSelected users:");
        for (key, value) in users {
            println!("  {key}: {value:?}");
        }
    }

    if let Some(Answer::KeyValue(endpoints)) = results.get("endpoints") {
        println!("\nEnabled endpoints:");
        for (key, value) in endpoints {
            println!("  {key}: {value:?}");
        }
    }

    Ok(())
}

// Helper function to create a nested user record
fn create_user_record(name: &str, email: &str, age: f64) -> Answer {
    let mut record = HashMap::new();
    record.insert("name".to_string(), Answer::text(name));
    record.insert("email".to_string(), Answer::text(email));
    record.insert("age".to_string(), Answer::number(age));
    Answer::KeyValue(record)
}

// Helper function to create an endpoint configuration
fn create_endpoint_config(method: &str, path: &str, enabled: bool) -> Answer {
    let mut config = HashMap::new();
    config.insert("method".to_string(), Answer::text(method));
    config.insert("path".to_string(), Answer::text(path));
    config.insert("enabled".to_string(), Answer::boolean(enabled));
    Answer::KeyValue(config)
}