zenquirer 0.1.0

Interactive command-line questionnaires and prompts with async support
Documentation
//! Async validator demo using AsyncScope
//!
//! This example demonstrates how to use async validators with the Scope API
//! for operations like:
//! - Text input: API calls to check username availability
//! - Text input: Email validation with timeout protection
//! - Number input: Async range checks (age validation)
//! - Select: Role permission validation
//! - MultiSelect: Count/license limit validation
//! - Password: Breach database checks
//! - Date: Appointment availability checks
//! - DateTime: Meeting room scheduling with business hours
//! - FilePicker: File permission and security validation

use std::time::Duration;
use zenquirer::{AsyncScope, CrosstermBackend, Error, scope::AsyncValidator};

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

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

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

    let scope = AsyncScope::new(backend);

    scope.run(|mut builder| async move {
            // Demo 1: Username with API validation
            let username_validator = AsyncValidator::new(|username: &String| {
                let username = username.clone();
                async move {
                    // Simulate API call delay
                    zenquirer::smol::Timer::after(Duration::from_millis(500)).await;

                    if username == "admin" || username == "root" {
                        Err(Error::Validation("Username already taken".to_string()))
                    } else if username.len() < 3 {
                        Err(Error::Validation("Username must be at least 3 characters".to_string()))
                    } else {
                        Ok(())
                    }
                }
            });

            let _username = builder.input("username")
                .prompt("Enter your username [Demo 1: API validation]")
                .hint("Simulates API call - 'admin' and 'root' are taken, min 3 chars")
                .default("johndoe")
                .validator(username_validator)
                .ask()
                .await?;

            // Demo 2: Email with timeout
            let email_validator = AsyncValidator::new(|email: &String| {
                let email = email.clone();
                async move {
                    use zenquirer::common::with_timeout;

                    let verification_future = async {
                        zenquirer::smol::Timer::after(Duration::from_secs(2)).await;

                        if email.contains('@') && email.contains('.') {
                            Ok(())
                        } else {
                            Err(Error::Validation("Invalid email format".to_string()))
                        }
                    };

                    with_timeout(Duration::from_secs(3), verification_future).await
                }
            });

            let _email = builder.input("email")
                .prompt("Enter your email [Demo 2: Timeout protection]")
                .hint("Validates with 3-second timeout - must contain @ and .")
                .default("user@example.com")
                .validator(email_validator)
                .ask()
                .await?;

            // Demo 3: Age with async range check
            let age_validator = AsyncValidator::new(|age: &f64| {
                let age = *age;
                async move {
                    // Simulate async database lookup
                    zenquirer::smol::Timer::after(Duration::from_millis(300)).await;

                    if age < 13.0 {
                        Err(Error::Validation("Must be at least 13 years old".to_string()))
                    } else if age > 120.0 {
                        Err(Error::Validation("Invalid age".to_string()))
                    } else {
                        Ok(())
                    }
                }
            });

            let _age = builder.number("age")
                .prompt("Enter your age [Demo 3: Async range validation]")
                .hint("Simulates database lookup - must be between 13 and 120")
                .default("25")
                .validator(age_validator)
                .ask()
                .await?;

            // Demo 4: Role with permission validation
            let role_validator = AsyncValidator::new(|role: &zenquirer::OptionValue| {
                let role_value = role.value.clone();
                async move {
                    // Simulate permission check
                    zenquirer::smol::Timer::after(Duration::from_millis(400)).await;

                    if role_value == "admin" {
                        Err(Error::Validation("Admin role requires approval".to_string()))
                    } else {
                        Ok(())
                    }
                }
            });

            let _role = builder.select("role")
                .prompt("Select your role [Demo 4: Permission validation]")
                .options(["viewer", "editor", "moderator", "admin"])
                .hint("Simulates permission check - admin role requires special approval")
                .validator(role_validator)
                .ask()
                .await?;

            // Demo 5: Tools with count validation
            let tools_validator = AsyncValidator::new(|tools: &Vec<zenquirer::OptionValue>| {
                let tool_count = tools.len();
                async move {
                    // Simulate license check
                    zenquirer::smol::Timer::after(Duration::from_millis(300)).await;

                    if tool_count == 0 {
                        Err(Error::Validation("Must select at least one tool".to_string()))
                    } else if tool_count > 3 {
                        Err(Error::Validation("Maximum 3 tools allowed on free plan".to_string()))
                    } else {
                        Ok(())
                    }
                }
            });

            let _tools = builder.multi_select("tools")
                .prompt("Select development tools [Demo 5: Count validation]")
                .options(["Git", "Docker", "Kubernetes", "VS Code", "IntelliJ"])
                .hint("Simulates license check - select 1-3 tools (free plan limit)")
                .validator(tools_validator)
                .ask()
                .await?;

            // Demo 6: Confirm (no validation, just showing scope API)
            let _confirmed = builder.confirm("terms")
                .prompt("Do you agree to the terms? [Demo 6: No validation]")
                .hint("Standard confirm prompt")
                .ask()
                .await?;

            // Demo 7: Password with breach check
            let password_validator = AsyncValidator::new(|password: &String| {
                let password = password.clone();
                async move {
                    // Simulate breach database API call
                    zenquirer::smol::Timer::after(Duration::from_millis(600)).await;

                    if password.len() < 8 {
                        Err(Error::Validation("Password must be at least 8 characters".to_string()))
                    } else if password == "password" || password == "12345678" {
                        Err(Error::Validation("Password found in breach database".to_string()))
                    } else if !password.chars().any(|c| c.is_numeric()) {
                        Err(Error::Validation("Password must contain at least one number".to_string()))
                    } else {
                        Ok(())
                    }
                }
            });

            let _password = builder.password("password")
                .prompt("Create a password [Demo 7: Breach check]")
                .hint("Simulates breach DB check - avoid 'password' or '12345678', min 8 chars + number")
                .validator(password_validator)
                .ask()
                .await?;

            // Demo 8: Date with availability check
            let date_validator = AsyncValidator::new(|date: &String| {
                let date = date.clone();
                async move {
                    // Simulate appointment availability check
                    zenquirer::smol::Timer::after(Duration::from_millis(400)).await;

                    // Parse date to check day of week (simple check)
                    if date.ends_with("2025-01-01") || date.ends_with("2025-12-25") {
                        Err(Error::Validation("Date is a holiday - appointments not available".to_string()))
                    } else if date.contains("2025-12-") {
                        Err(Error::Validation("December is fully booked".to_string()))
                    } else {
                        Ok(())
                    }
                }
            });

            let _appointment_date = builder.date("appointment")
                .prompt("Select appointment date [Demo 8: Availability check]")
                .hint("Simulates availability check - avoid holidays and December 2025")
                .default("2025-06-15")
                .validator(date_validator)
                .ask()
                .await?;

            // Demo 9: DateTime with scheduling validation
            let datetime_validator = AsyncValidator::new(|datetime: &String| {
                let datetime = datetime.clone();
                async move {
                    // Simulate meeting room availability check
                    zenquirer::smol::Timer::after(Duration::from_millis(500)).await;

                    // Check if time is within business hours (simple check on hour)
                    let outside_business_hours = datetime
                        .split(' ')
                        .nth(1)
                        .and_then(|time_part| time_part.split(':').next())
                        .and_then(|hour_str| hour_str.parse::<u32>().ok())
                        .is_some_and(|hour| !(9..17).contains(&hour));
                    if outside_business_hours {
                        return Err(Error::Validation(
                            "Meeting rooms only available 9 AM - 5 PM".to_string(),
                        ));
                    }

                    // Check for conflicting meetings (hardcoded example)
                    if datetime.contains("2025-06-15 14:00") {
                        Err(Error::Validation("Time slot already booked".to_string()))
                    } else {
                        Ok(())
                    }
                }
            });

            let _meeting_time = builder.datetime("meeting")
                .prompt("Schedule meeting [Demo 9: Room availability]")
                .hint("Simulates calendar check - business hours only (9-17), avoid 2025-06-15 14:00")
                .default("2025-06-15 10:00:00")
                .validator(datetime_validator)
                .ask()
                .await?;

            // Demo 10: FilePicker with permission validation
            let file_validator = AsyncValidator::new(|files: &Vec<String>| {
                let files = files.clone();
                async move {
                    // Simulate file permission/accessibility check
                    zenquirer::smol::Timer::after(Duration::from_millis(450)).await;

                    for file in &files {
                        // Check if file is in restricted directory
                        if file.contains("/System/") || file.contains("/private/") {
                            return Err(Error::Validation(format!("Access denied: {file} is in a restricted directory")));
                        }
                        // Check file extension
                        if file.ends_with(".exe") || file.ends_with(".dll") {
                            return Err(Error::Validation("Executable files not allowed for security reasons".to_string()));
                        }
                    }
                    Ok(())
                }
            });

            let _selected_files = builder.file_picker("files")
                .prompt("Select files [Demo 10: Permission check]")
                .hint("Simulates permission check - avoid System/private dirs and .exe/.dll files")
                .multi_select(true)
                .validator(file_validator)
                .ask()
                .await?;

            Ok(())
        }).await?;

    // Complete silently - avoid println after prompts (backend manages terminal control)
    Ok(())
}