use std::path::Path;
use zenquirer::{
ConfirmPrompt, CrosstermBackend, Error, InputPrompt, MultiSelectPrompt, QuestionData,
QuestionOption, Questionnaire, SelectPrompt, ValidationRule, Validator,
};
use zenquirer_core::question::{QuestionConfig, QuestionType};
#[derive(Debug, Clone, Copy)]
enum OutputFormat {
Json,
Yaml,
}
pub fn build_command(output: Option<&Path>, preview: bool) -> Result<(), Error> {
zenquirer::smol::block_on(async {
let backend = CrosstermBackend::new()?;
backend.clear_screen()?; let questionnaire = build_workflow(backend).await?;
if preview {
preview_questionnaire(&questionnaire)?;
let backend = CrosstermBackend::new()?;
let should_save = backend
.confirm("Save this questionnaire?".into(), None)
.await?;
if !should_save {
eprintln!("Questionnaire discarded.");
return Ok(());
}
}
match output {
Some(path) => {
let format = get_output_format(path)?;
let content = serialize_questionnaire(&questionnaire, format)?;
std::fs::write(path, content)?;
eprintln!("✓ Saved to {}", path.display());
}
None => {
let content = serialize_questionnaire(&questionnaire, OutputFormat::Yaml)?;
println!("{content}");
}
}
Ok(())
})
}
async fn build_workflow(_backend: CrosstermBackend) -> Result<Questionnaire, Error> {
let mut questionnaire = Questionnaire::new();
let mut backend = CrosstermBackend::new()?;
questionnaire.header = {
let header = backend
.text_input(
"Questionnaire title (header)".into(),
Some("Optional - press Enter to skip".into()),
None,
None,
None,
)
.await?;
if header.is_empty() {
None
} else {
Some(header)
}
};
backend = CrosstermBackend::new()?;
questionnaire.footer = {
let footer = backend
.text_input(
"Questionnaire footer".into(),
Some("Optional - press Enter to skip".into()),
None,
None,
None,
)
.await?;
if footer.is_empty() {
None
} else {
Some(footer)
}
};
add_question_loop(backend, &mut questionnaire).await?;
Ok(questionnaire)
}
async fn add_question_loop(
_backend: CrosstermBackend,
questionnaire: &mut Questionnaire,
) -> Result<(), Error> {
loop {
let mut backend = CrosstermBackend::new()?;
let add_question = backend
.confirm(
"Add a question?".into(),
Some(format!(
"Current questions: {}",
questionnaire.questions.len()
)),
)
.await?;
if !add_question {
break;
}
backend = CrosstermBackend::new()?;
let name = backend
.text_input(
"Question ID/name".into(),
Some("e.g., username, email, language".into()),
Some(
Validator::new()
.rule(ValidationRule::NotEmpty)
.rule(ValidationRule::AlphanumericWithUnderscore)
.message("Must be non-empty, alphanumeric with underscores only"),
),
None,
None,
)
.await?;
if questionnaire.questions.contains_key(&name) {
eprintln!("⚠ Question '{name}' already exists. Skipping.");
continue;
}
backend = CrosstermBackend::new()?;
let question_type_answer = backend
.select(
"Select question type".into(),
vec![
QuestionOption::new("Input - Free text input"),
QuestionOption::new("Select - Single choice"),
QuestionOption::new("MultiSelect - Multiple choices"),
QuestionOption::new("Confirm - Yes/no"),
QuestionOption::new("Number - Numeric input"),
],
None,
None,
None,
None,
)
.await?;
let question_type = question_type_answer
.value
.split(" - ")
.next()
.unwrap_or("Input");
backend = CrosstermBackend::new()?;
let question_data = configure_question(backend, question_type, name.clone()).await?;
questionnaire.insert(name, question_data);
eprintln!("✓ Question added");
}
Ok(())
}
async fn configure_question(
backend: CrosstermBackend,
question_type: &str,
name: String,
) -> Result<QuestionData, Error> {
match question_type {
"Input" => configure_input_question(backend, name).await,
"Select" => configure_select_question(backend, name, false).await,
"MultiSelect" => configure_select_question(backend, name, true).await,
"Confirm" => configure_confirm_question(backend, name).await,
"Number" => configure_number_question(backend, name).await,
_ => Err(Error::Validation(format!(
"Unknown question type: {question_type}"
))),
}
}
async fn configure_input_question(
_backend: CrosstermBackend,
_name: String,
) -> Result<QuestionData, Error> {
let mut backend = CrosstermBackend::new()?;
let prompt = backend
.text_input(
"Question prompt".into(),
Some("e.g., What's your name?".into()),
Some(Validator::not_empty()),
None,
None,
)
.await?;
backend = CrosstermBackend::new()?;
let hint = backend
.text_input(
"Hint text (optional)".into(),
Some("Press Enter to skip".into()),
None,
None,
None,
)
.await?;
backend = CrosstermBackend::new()?;
let validator = add_validators(backend, "input").await?;
Ok(QuestionData {
question_type: QuestionType::Input,
prompt,
config: QuestionConfig::Input {
default_value: None,
},
hint: if hint.is_empty() { None } else { Some(hint) },
validator,
formatter: None,
})
}
async fn configure_select_question(
_backend: CrosstermBackend,
_name: String,
is_multi: bool,
) -> Result<QuestionData, Error> {
let mut backend = CrosstermBackend::new()?;
let prompt = backend
.text_input(
"Question prompt".into(),
Some("e.g., Choose your language".into()),
Some(Validator::not_empty()),
None,
None,
)
.await?;
backend = CrosstermBackend::new()?;
let raw_options = backend
.text_input(
"Enter options (comma-separated)".into(),
Some("e.g., Rust, Python, Go, JavaScript".into()),
Some(Validator::not_empty()),
None,
None,
)
.await?;
let options: Vec<String> = raw_options
.split(',')
.map(|s| s.trim().to_string())
.filter(|s| !s.is_empty())
.collect();
if options.is_empty() {
return Err(Error::Validation(
"Must provide at least one option".to_string(),
));
}
backend = CrosstermBackend::new()?;
let hint = backend
.text_input(
"Hint text (optional)".into(),
Some("Press Enter to skip".into()),
None,
None,
None,
)
.await?;
let (min_selections, max_selections) =
if is_multi {
backend = CrosstermBackend::new()?;
let min_str = backend
.text_input(
"Minimum selections (optional)".into(),
Some("Press Enter for no minimum".into()),
None,
None,
None,
)
.await?;
backend = CrosstermBackend::new()?;
let max_str = backend
.text_input(
"Maximum selections (optional)".into(),
Some("Press Enter for no maximum".into()),
None,
None,
None,
)
.await?;
let min =
if min_str.is_empty() {
None
} else {
Some(min_str.parse().map_err(|_| {
Error::Validation("Minimum must be a valid number".to_string())
})?)
};
let max =
if max_str.is_empty() {
None
} else {
Some(max_str.parse().map_err(|_| {
Error::Validation("Maximum must be a valid number".to_string())
})?)
};
(min, max)
} else {
(None, None)
};
let config = if is_multi {
QuestionConfig::MultiSelect {
options,
min_selections,
max_selections,
}
} else {
QuestionConfig::Select { options }
};
Ok(QuestionData {
question_type: if is_multi {
QuestionType::MultiSelect
} else {
QuestionType::Select
},
prompt,
config,
hint: if hint.is_empty() { None } else { Some(hint) },
validator: None,
formatter: None,
})
}
async fn configure_confirm_question(
_backend: CrosstermBackend,
_name: String,
) -> Result<QuestionData, Error> {
let mut backend = CrosstermBackend::new()?;
let prompt = backend
.text_input(
"Question prompt".into(),
Some("e.g., Subscribe to newsletter?".into()),
Some(Validator::not_empty()),
None,
None,
)
.await?;
backend = CrosstermBackend::new()?;
let hint = backend
.text_input(
"Hint text (optional)".into(),
Some("Press Enter to skip".into()),
None,
None,
None,
)
.await?;
Ok(QuestionData {
question_type: QuestionType::Confirm,
prompt,
config: QuestionConfig::Confirm,
hint: if hint.is_empty() { None } else { Some(hint) },
validator: None,
formatter: None,
})
}
async fn configure_number_question(
_backend: CrosstermBackend,
_name: String,
) -> Result<QuestionData, Error> {
let mut backend = CrosstermBackend::new()?;
let prompt = backend
.text_input(
"Question prompt".into(),
Some("e.g., Enter your age".into()),
Some(Validator::not_empty()),
None,
None,
)
.await?;
backend = CrosstermBackend::new()?;
let hint = backend
.text_input(
"Hint text (optional)".into(),
Some("Press Enter to skip".into()),
None,
None,
None,
)
.await?;
backend = CrosstermBackend::new()?;
let validator = add_validators(backend, "number").await?;
Ok(QuestionData {
question_type: QuestionType::Number,
prompt,
config: QuestionConfig::Number {
default_value: None,
},
hint: if hint.is_empty() { None } else { Some(hint) },
validator,
formatter: None,
})
}
async fn add_validators(
_backend: CrosstermBackend,
_question_type: &str,
) -> Result<Option<Validator>, Error> {
let mut backend = CrosstermBackend::new()?;
let add_validation = backend.confirm("Add validation?".into(), None).await?;
if !add_validation {
return Ok(None);
}
backend = CrosstermBackend::new()?;
let category = backend
.select(
"Select validation category".into(),
vec![
QuestionOption::new("String Validation"),
QuestionOption::new("Numeric Validation"),
QuestionOption::new("Network Validation"),
QuestionOption::new("Path Validation"),
QuestionOption::new("Security"),
],
None,
None,
None,
None,
)
.await?;
backend = CrosstermBackend::new()?;
let rules = select_validation_rules(backend, &category.value).await?;
if rules.is_empty() {
return Ok(None);
}
backend = CrosstermBackend::new()?;
let custom_message = backend
.text_input(
"Custom error message (optional)".into(),
Some("Press Enter for default messages".into()),
None,
None,
None,
)
.await?;
let mut validator = Validator::new();
for rule in rules {
validator = validator.rule(rule);
}
if !custom_message.is_empty() {
validator = validator.message(custom_message);
}
Ok(Some(validator))
}
async fn select_validation_rules(
backend: CrosstermBackend,
category: &str,
) -> Result<Vec<ValidationRule>, Error> {
let rules_for_category = match category {
"String Validation" => vec![
("Not empty", ValidationRule::NotEmpty),
("Minimum length (3)", ValidationRule::MinLength(3)),
("Maximum length (100)", ValidationRule::MaxLength(100)),
("Lowercase only", ValidationRule::Lowercase),
("Uppercase only", ValidationRule::Uppercase),
("Alphanumeric only", ValidationRule::AlphanumericOnly),
(
"Alphanumeric with underscore",
ValidationRule::AlphanumericWithUnderscore,
),
("No whitespace", ValidationRule::NoWhitespace),
],
"Numeric Validation" => vec![
("Must be numeric", ValidationRule::Numeric),
("Must be integer", ValidationRule::Integer),
(
"Range (0-100)",
ValidationRule::Range {
min: Some(0.0),
max: Some(100.0),
},
),
("Greater than 0", ValidationRule::GreaterThan(0.0)),
],
"Network Validation" => vec![
#[cfg(feature = "validators-regex")]
("Email address", ValidationRule::EmailRegex),
#[cfg(feature = "validators-regex")]
("URL", ValidationRule::UrlRegex),
#[cfg(feature = "validators-regex")]
("IP address", ValidationRule::IpAddress),
("Port number", ValidationRule::Port),
#[cfg(feature = "validators-regex")]
("Hostname", ValidationRule::Hostname),
],
"Path Validation" => vec![
("Path exists", ValidationRule::PathExists),
("File exists", ValidationRule::FileExists),
("Directory exists", ValidationRule::DirectoryExists),
],
"Security" => vec![(
"Strong password",
ValidationRule::PasswordStrength {
min_length: 8,
require_uppercase: true,
require_lowercase: true,
require_digit: true,
require_special: true,
},
)],
_ => vec![],
};
if rules_for_category.is_empty() {
return Ok(vec![]);
}
let options: Vec<QuestionOption> = rules_for_category
.iter()
.map(|(label, _)| QuestionOption::new(*label))
.collect();
let selected = backend
.multi_select(
format!("Select {category} rules (multiple)"),
options,
None,
None,
None,
None,
)
.await?;
let rules: Vec<ValidationRule> = selected
.iter()
.filter_map(|s| {
rules_for_category
.iter()
.find(|(label, _)| *label == s.value)
.map(|(_, rule)| rule.clone())
})
.collect();
Ok(rules)
}
fn get_output_format(path: &Path) -> Result<OutputFormat, Error> {
match path.extension().and_then(|s| s.to_str()) {
Some("json") => Ok(OutputFormat::Json),
Some("yaml") | Some("yml") => Ok(OutputFormat::Yaml),
None => Ok(OutputFormat::Yaml), Some(ext) => Err(Error::Validation(format!(
"Unsupported extension '{ext}'. Use .json, .yaml, or .yml"
))),
}
}
fn serialize_questionnaire(q: &Questionnaire, format: OutputFormat) -> Result<String, Error> {
match format {
OutputFormat::Json => serde_json::to_string_pretty(q).map_err(Error::Json),
OutputFormat::Yaml => serde_yaml::to_string(q).map_err(Error::Yaml),
}
}
fn preview_questionnaire(q: &Questionnaire) -> Result<(), Error> {
println!("\n═══════════════════════════════════════");
println!(" QUESTIONNAIRE PREVIEW");
println!("═══════════════════════════════════════\n");
if let Some(header) = &q.header {
println!("Header: {header}\n");
}
println!("Questions ({}):", q.questions.len());
for (i, (name, data)) in q.questions.iter().enumerate() {
println!("\n{}. {} [{:?}]", i + 1, name, data.question_type);
println!(" Prompt: {}", data.prompt);
match &data.config {
QuestionConfig::Select { options } | QuestionConfig::MultiSelect { options, .. } => {
println!(" Options: {}", options.join(", "));
}
_ => {}
}
if data.validator.is_some() {
println!(" ✓ Has validation");
}
if let Some(hint) = &data.hint {
println!(" Hint: {hint}");
}
}
if let Some(footer) = &q.footer {
println!("\nFooter: {footer}");
}
println!("\n═══════════════════════════════════════\n");
Ok(())
}