zenquirer 0.1.0

Interactive command-line questionnaires and prompts with async support
Documentation
mod common;

use common::questions as common_questions;
use zenquirer::{
    CrosstermBackend, Questionnaire, QuestionnaireBuilder, QuestionnaireExt,
    macros::{answers, question},
};

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()?;

    // Example 1: Building questionnaires from individual questions

    let mut developer_survey = Questionnaire::new();
    developer_survey.header = Some("Developer Survey".to_string());

    // Add questions using our reusable definitions
    developer_survey.insert(
        "language".to_string(),
        common_questions::programming_language(),
    );
    developer_survey.insert(
        "experience".to_string(),
        common_questions::experience_level(),
    );
    developer_survey.insert("tools".to_string(), common_questions::development_tools());
    developer_survey.insert(
        "newsletter".to_string(),
        common_questions::newsletter_subscription(),
    );

    // Run the survey with some override answers for demo purposes
    let override_answers = answers! {
        "language" => "Rust",
        "newsletter" => true
    };

    let _ = developer_survey
        .ask_all_async(backend, Some(&override_answers))
        .await;

    // Example 2: Conditional questionnaire building

    // Simulate different user types
    let user_types = ["junior", "senior", "manager"];

    for user_type in user_types {
        // Building questionnaire for this user type

        let mut questionnaire = Questionnaire::new();

        // Always include basic questions
        questionnaire.insert(
            "language".to_string(),
            common_questions::programming_language(),
        );

        // Conditionally add questions based on user type
        match user_type {
            "junior" => {
                questionnaire.insert(
                    "experience".to_string(),
                    common_questions::experience_level(),
                );
                questionnaire.insert("tools".to_string(), common_questions::development_tools());
            }
            "senior" => {
                questionnaire.insert("frameworks".to_string(), common_questions::web_frameworks());
                questionnaire.insert("tools".to_string(), common_questions::development_tools());
            }
            "manager" => {
                // Managers might get different questions
                let team_size_question = question! {
                    select: "How many developers are on your team?",
                    options: ["1-3", "4-7", "8-15", "16-30", "30+"],
                    hint: "Include direct reports and indirect team members"
                };
                questionnaire.insert("team_size".to_string(), team_size_question);
            }
            _ => {}
        }

        questionnaire.insert(
            "newsletter".to_string(),
            common_questions::newsletter_subscription(),
        );

        let _question_names: Vec<String> = questionnaire.keys().cloned().collect();
        // Questions for this user type: {question_names}
    }

    // Create some questions with the question! macro
    let company_size_question = question! {
        select: "What's your company size?",
        options: ["1-10", "11-50", "51-200", "201-1000", "1000+"],
        hint: "Total number of employees"
    };

    let remote_work_question = question! {
        select: "What's your remote work preference?",
        options: ["Fully remote", "Hybrid", "Fully in-office", "No preference"],
        hint: "Choose your ideal work arrangement"
    };

    // Create a mixed questionnaire combining both approaches
    let mut mixed_questionnaire = Questionnaire::new();

    // Add pre-defined questions
    mixed_questionnaire.insert(
        "language".to_string(),
        common_questions::programming_language(),
    );
    mixed_questionnaire.insert("tools".to_string(), common_questions::development_tools());

    // Add individual questions created above
    mixed_questionnaire.insert("company_size".to_string(), company_size_question);
    mixed_questionnaire.insert("remote_work".to_string(), remote_work_question);

    // Create additional questions inline with builder pattern
    let inline_questions = QuestionnaireBuilder::new()
        .header("Additional Questions")
        .select("salary_range", "What's your salary range?")
        .options([
            "< $50k",
            "$50k-$75k",
            "$75k-$100k",
            "$100k-$150k",
            "> $150k",
        ])
        .hint("Annual salary in USD")
        .confirm("feedback", "Would you like to provide additional feedback?")
        .build();

    // Merge the inline questions
    mixed_questionnaire.extend(inline_questions);

    // Mixed questionnaire structure with various question types

    // Example 4: Question validation and serialization

    let sample_question = common_questions::programming_language();
    if let Ok(serialized) = serde_json::to_string_pretty(&sample_question) {
        // Serialized question example

        let _deserialized: Result<zenquirer::question::QuestionData, _> =
            serde_json::from_str(&serialized);
        // Successfully deserialized the question
    }

    // Question composition demo completed with key benefits:
    // • Question reusability across different questionnaires
    // • Conditional questionnaire building based on context
    // • Mixing individual questions with questionnaire macro
    // • Full integration with serialization and core features
    // • Clean, maintainable code organization

    Ok(())
}