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 {
let username_validator = AsyncValidator::new(|username: &String| {
let username = username.clone();
async move {
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?;
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?;
let age_validator = AsyncValidator::new(|age: &f64| {
let age = *age;
async move {
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?;
let role_validator = AsyncValidator::new(|role: &zenquirer::OptionValue| {
let role_value = role.value.clone();
async move {
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?;
let tools_validator = AsyncValidator::new(|tools: &Vec<zenquirer::OptionValue>| {
let tool_count = tools.len();
async move {
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?;
let _confirmed = builder.confirm("terms")
.prompt("Do you agree to the terms? [Demo 6: No validation]")
.hint("Standard confirm prompt")
.ask()
.await?;
let password_validator = AsyncValidator::new(|password: &String| {
let password = password.clone();
async move {
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?;
let date_validator = AsyncValidator::new(|date: &String| {
let date = date.clone();
async move {
zenquirer::smol::Timer::after(Duration::from_millis(400)).await;
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?;
let datetime_validator = AsyncValidator::new(|datetime: &String| {
let datetime = datetime.clone();
async move {
zenquirer::smol::Timer::after(Duration::from_millis(500)).await;
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(),
));
}
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?;
let file_validator = AsyncValidator::new(|files: &Vec<String>| {
let files = files.clone();
async move {
zenquirer::smol::Timer::after(Duration::from_millis(450)).await;
for file in &files {
if file.contains("/System/") || file.contains("/private/") {
return Err(Error::Validation(format!("Access denied: {file} is in a restricted directory")));
}
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?;
Ok(())
}