zenquirer 0.1.0

Interactive command-line questionnaires and prompts with async support
Documentation
use zenquirer::{
    Answers, Questionnaire, QuestionnaireBuilder, ValidationRule, Validator, macros::answers,
};

fn main() -> Result<(), zenquirer::Error> {
    // Create output directory
    std::fs::create_dir_all("examples/output")?;

    // Create a questionnaire with validators - demonstrates full serialization support
    let questionnaire = QuestionnaireBuilder::new()
        .header("Serialization Demo with Validators")
        .input("username", "Choose a username")
        .validator(
            Validator::new()
                .rule(ValidationRule::MinLength(3))
                .rule(ValidationRule::MaxLength(20))
                .rule(ValidationRule::AlphanumericWithUnderscore)
                .message("Username must be 3-20 characters, alphanumeric and underscores only"),
        )
        .input("email", "Enter your email address")
        .validator(Validator::email().message("Please enter a valid email address"))
        .input("website", "Personal website URL (optional)")
        .validator(Validator::url())
        .select("language", "What's your primary programming language?")
        .options(["Rust", "Python", "JavaScript", "Go", "Java"])
        .multiselect("tools", "Which development tools do you use?")
        .options([
            "Git",
            "Docker",
            "Kubernetes",
            "CI/CD",
            "VS Code",
            "IntelliJ",
        ])
        .min_selections(1)
        .max_selections(4)
        .confirm("newsletter", "Subscribe to our developer newsletter?")
        .number("lucky", "Choose your lucky number (1-100)")
        .validator(Validator::numeric().rule(ValidationRule::Range {
            min: Some(1.0),
            max: Some(100.0),
        }))
        .integer("workers", "How many worker threads?")
        .validator(Validator::integer().rule(ValidationRule::Range {
            min: Some(1.0),
            max: Some(64.0),
        }))
        .filepicker("config_file", "Select configuration file")
        .only_files()
        .extensions(["toml", "yaml", "json"])
        .build();

    // Serialize and save questionnaire (JSON)
    let questionnaire_json = serde_json::to_string_pretty(&questionnaire)?;
    std::fs::write("examples/output/questionnaire.json", &questionnaire_json)?;

    // Serialize and save questionnaire (YAML)
    let questionnaire_yaml = serde_yaml::to_string(&questionnaire)?;
    std::fs::write("examples/output/questionnaire.yaml", &questionnaire_yaml)?;

    // Create override answers
    let answers = answers! {
        "language" => "Rust",
        "newsletter" => true,
        // Plain serialized values stay ergonomic in override files.
        // They normalize to typed runtime answers, then serialize back as plain values.
        "workers" => 8,
        "config_file" => "examples/output/config.toml",
    };

    // Serialize and save override answers (JSON)
    let override_answers_json = serde_json::to_string_pretty(&answers)?;
    std::fs::write(
        "examples/output/override_answers.json",
        &override_answers_json,
    )?;

    // Serialize and save override answers (YAML)
    let override_answers_yaml = serde_yaml::to_string(&answers)?;
    std::fs::write(
        "examples/output/override_answers.yaml",
        &override_answers_yaml,
    )?;

    // Load questionnaire and override answers from JSON
    let loaded_questionnaire_json = std::fs::read_to_string("examples/output/questionnaire.json")?;
    let loaded_questionnaire: Questionnaire = serde_json::from_str(&loaded_questionnaire_json)?;

    let loaded_override_answers_json =
        std::fs::read_to_string("examples/output/override_answers.json")?;
    let loaded_override_answers: Answers = serde_json::from_str(&loaded_override_answers_json)?;

    // Load questionnaire and override answers from YAML
    let loaded_questionnaire_yaml = std::fs::read_to_string("examples/output/questionnaire.yaml")?;
    let _loaded_questionnaire_from_yaml: Questionnaire =
        serde_yaml::from_str(&loaded_questionnaire_yaml)?;

    let loaded_override_answers_yaml =
        std::fs::read_to_string("examples/output/override_answers.yaml")?;
    let loaded_override_answers_from_yaml: Answers =
        serde_yaml::from_str(&loaded_override_answers_yaml)?;

    // Demonstrate serialization-first type safety: override files can use plain
    // JSON/YAML values, then question config normalizes them at runtime.
    let mut final_answers = Answers::new();
    for (name, answer) in &loaded_override_answers {
        if let Some(question_data) = loaded_questionnaire.questions.get(name) {
            final_answers.insert(name.clone(), question_data.normalize_answer(name, answer)?);
        }
    }

    // Serialize final answers (JSON)
    let answers_json = serde_json::to_string_pretty(&final_answers)?;
    std::fs::write("examples/output/final_answers.json", &answers_json)?;

    // Serialize final answers (YAML)
    let answers_yaml = serde_yaml::to_string(&final_answers)?;
    std::fs::write("examples/output/final_answers.yaml", &answers_yaml)?;

    // Verify YAML roundtrip works with the same normalization path.
    let mut yaml_final_answers = Answers::new();
    for (name, answer) in &loaded_override_answers_from_yaml {
        if let Some(question_data) = loaded_questionnaire.questions.get(name) {
            yaml_final_answers.insert(name.clone(), question_data.normalize_answer(name, answer)?);
        }
    }
    let yaml_answers_output = serde_yaml::to_string(&yaml_final_answers)?;
    std::fs::write(
        "examples/output/yaml_roundtrip_answers.yaml",
        &yaml_answers_output,
    )?;

    println!("Successfully demonstrated JSON and YAML serialization!");
    println!("Check examples/output/ for generated files:");
    println!("  - questionnaire.json/yaml (includes validators!)");
    println!("  - override_answers.json/yaml");
    println!("  - final_answers.json/yaml");
    println!();
    println!("Key feature: Validators are fully serialized!");
    println!("  - Email validation rules preserved");
    println!("  - URL validation rules preserved");
    println!("  - Length/range constraints preserved");
    println!("  - Custom error messages preserved");
    println!("  - Plain override values normalize at runtime and stay plain on disk");
    println!();
    println!("This enables:");
    println!("  - Load questionnaires with validation from YAML/JSON");
    println!("  - Build questionnaire editors and tools");
    println!("  - Create CLI tools (like zenq) with full validation support");

    Ok(())
}