mod builder;
use clap::{Parser, Subcommand, ValueEnum};
use std::io::IsTerminal;
use std::path::{Path, PathBuf};
use zenquirer::{Answers, CrosstermBackend, Error, Questionnaire, QuestionnaireExt};
#[derive(Parser)]
#[command(name = "zenq")]
#[command(version, about = "Interactive command-line questionnaires from YAML/JSON", long_about = None)]
#[command(arg_required_else_help = true)]
struct Cli {
#[command(subcommand)]
command: Option<Commands>,
#[arg(value_name = "FILE")]
file: Option<PathBuf>,
#[arg(long)]
override_file: Option<PathBuf>,
#[arg(short, long)]
output: Option<PathBuf>,
#[arg(long, default_value = "json")]
format: OutputFormat,
}
#[derive(Subcommand)]
enum Commands {
Run {
file: PathBuf,
#[arg(long)]
override_file: Option<PathBuf>,
#[arg(short, long)]
output: Option<PathBuf>,
#[arg(long, default_value = "json")]
format: OutputFormat,
},
Validate {
file: PathBuf,
},
Convert {
input: PathBuf,
output: PathBuf,
},
Info {
file: PathBuf,
},
Build {
output: Option<PathBuf>,
#[arg(short, long)]
preview: bool,
},
}
#[derive(ValueEnum, Clone, Debug, PartialEq, Eq)]
enum OutputFormat {
Json,
Yaml,
}
enum CliAction {
Run {
file: PathBuf,
override_file: Option<PathBuf>,
output: Option<PathBuf>,
format: OutputFormat,
},
Validate {
file: PathBuf,
},
Convert {
input: PathBuf,
output: PathBuf,
},
Info {
file: PathBuf,
},
Build {
output: Option<PathBuf>,
preview: bool,
},
}
fn main() {
if let Err(e) = run() {
eprintln!("Error: {e}");
std::process::exit(1);
}
}
fn run() -> Result<(), Error> {
let cli = Cli::parse();
let action = resolve_cli_action(cli)?;
match action {
CliAction::Run {
file,
override_file,
output,
format,
} => run_command(&file, override_file.as_deref(), output.as_deref(), format),
CliAction::Validate { file } => validate_command(&file),
CliAction::Convert { input, output } => convert_command(&input, &output),
CliAction::Info { file } => info_command(&file),
CliAction::Build { output, preview } => builder::build_command(output.as_deref(), preview),
}
}
fn resolve_cli_action(cli: Cli) -> Result<CliAction, Error> {
match cli.command {
Some(Commands::Run {
file,
override_file,
output,
format,
}) => Ok(CliAction::Run {
file,
override_file,
output,
format,
}),
Some(Commands::Validate { file }) => Ok(CliAction::Validate { file }),
Some(Commands::Convert { input, output }) => Ok(CliAction::Convert { input, output }),
Some(Commands::Info { file }) => Ok(CliAction::Info { file }),
Some(Commands::Build { output, preview }) => Ok(CliAction::Build { output, preview }),
None => {
let file = cli.file.ok_or_else(|| {
Error::Validation(
"Expected a subcommand or questionnaire file (.json, .yaml, .yml)".to_string(),
)
})?;
if !is_questionnaire_file(&file) {
let message = "Shortcut form only supports .json, .yaml, or .yml questionnaire \
files; use `zenq run <file>` for explicit run semantics";
return Err(Error::Validation(message.to_string()));
}
Ok(CliAction::Run {
file,
override_file: cli.override_file,
output: cli.output,
format: cli.format,
})
}
}
}
fn is_questionnaire_file(path: &Path) -> bool {
path.extension()
.and_then(|extension| extension.to_str())
.map(|extension| {
matches!(
extension.to_ascii_lowercase().as_str(),
"json" | "yaml" | "yml"
)
})
.unwrap_or(false)
}
fn run_command(
file: &Path,
override_file: Option<&Path>,
output: Option<&Path>,
format: OutputFormat,
) -> Result<(), Error> {
let questionnaire = load_questionnaire(file)?;
let override_answers = if let Some(path) = override_file {
Some(load_answers(path)?)
} else {
None
};
let stdin_is_tty = std::io::stdin().is_terminal();
let answers = if stdin_is_tty {
zenquirer::smol::block_on(async {
let backend = CrosstermBackend::new()?;
backend.clear_screen()?;
questionnaire
.ask_all_async(backend, override_answers.as_ref())
.await
})?
} else {
match &override_answers {
Some(overrides) => {
for (key, _) in &questionnaire.questions {
if !overrides.contains_key(key) {
return Err(Error::Validation(format!(
"Missing answer for question '{key}' in override file (stderr is not a TTY)"
)));
}
}
overrides.clone()
}
None => {
return Err(Error::Validation(
"Non-interactive mode (stderr is not a TTY) requires --override-file with all answers".to_string()
));
}
}
};
let output_str = match format {
OutputFormat::Json => serde_json::to_string_pretty(&answers)?,
OutputFormat::Yaml => serde_yaml::to_string(&answers)?,
};
if let Some(path) = output {
std::fs::write(path, output_str)?;
} else {
println!("{output_str}");
}
Ok(())
}
fn validate_command(file: &Path) -> Result<(), Error> {
let questionnaire = load_questionnaire(file)?;
eprintln!("✓ Valid questionnaire");
eprintln!(" Questions: {}", questionnaire.questions.len());
let mut type_counts = std::collections::HashMap::new();
for question in questionnaire.questions.values() {
let type_name = format!("{:?}", question.question_type);
*type_counts.entry(type_name).or_insert(0) += 1;
}
let types_str = type_counts
.iter()
.map(|(t, c)| format!("{t} ({c})"))
.collect::<Vec<_>>()
.join(", ");
if !types_str.is_empty() {
eprintln!(" Types: {types_str}");
}
Ok(())
}
fn convert_command(input: &Path, output: &Path) -> Result<(), Error> {
let questionnaire = load_questionnaire(input)?;
let output_ext = output.extension().and_then(|s| s.to_str()).ok_or_else(|| {
Error::Validation("Output file must have .json, .yaml, or .yml extension".to_string())
})?;
let output_str = match output_ext {
"json" => serde_json::to_string_pretty(&questionnaire)?,
"yaml" | "yml" => serde_yaml::to_string(&questionnaire)?,
_ => {
return Err(Error::Validation(format!(
"Unsupported output extension: {output_ext}"
)));
}
};
std::fs::write(output, output_str)?;
eprintln!("✓ Converted {} → {}", input.display(), output.display());
Ok(())
}
fn info_command(file: &Path) -> Result<(), Error> {
let questionnaire = load_questionnaire(file)?;
println!("Questionnaire: {}", file.display());
if let Some(header) = &questionnaire.header {
println!("Header: {header}");
}
if let Some(footer) = &questionnaire.footer {
println!("Footer: {footer}");
}
println!("Questions: {}", questionnaire.questions.len());
let mut type_counts = std::collections::HashMap::new();
for question in questionnaire.questions.values() {
*type_counts
.entry(format!("{:?}", question.question_type))
.or_insert(0) += 1;
}
if !type_counts.is_empty() {
println!("Types:");
for (qtype, count) in type_counts {
println!(" {qtype} ({count})");
}
}
let validator_count = questionnaire
.questions
.values()
.filter(|q| q.validator.is_some())
.count();
if validator_count > 0 {
println!("Validators: {validator_count} questions with validation");
}
Ok(())
}
fn load_questionnaire(path: &Path) -> Result<Questionnaire, Error> {
let content = std::fs::read_to_string(path).map_err(Error::IO)?;
match normalized_extension(path).as_deref() {
Some("json") => serde_json::from_str(&content).map_err(Error::Json),
Some("yaml") | Some("yml") => serde_yaml::from_str(&content).map_err(Error::Yaml),
_ => Err(Error::Validation(
"File must have .json, .yaml, or .yml extension".to_string(),
)),
}
}
fn load_answers(path: &Path) -> Result<Answers, Error> {
let content = std::fs::read_to_string(path).map_err(Error::IO)?;
match normalized_extension(path).as_deref() {
Some("json") => serde_json::from_str(&content).map_err(Error::Json),
Some("yaml") | Some("yml") => serde_yaml::from_str(&content).map_err(Error::Yaml),
_ => Err(Error::Validation(
"Override file must have .json, .yaml, or .yml extension".to_string(),
)),
}
}
fn normalized_extension(path: &Path) -> Option<String> {
path.extension()
.and_then(|extension| extension.to_str())
.map(|extension| extension.to_ascii_lowercase())
}
#[cfg(test)]
mod tests {
use super::*;
use clap::Parser;
fn parse_action(args: &[&str]) -> Result<CliAction, Error> {
let cli = Cli::try_parse_from(args).expect("CLI arguments should parse");
resolve_cli_action(cli)
}
#[test]
fn shortcut_runs_questionnaire_files() {
let action = parse_action(&["zenq", "survey.yaml"]).unwrap();
match action {
CliAction::Run {
file,
override_file,
output,
format,
} => {
assert_eq!(file, PathBuf::from("survey.yaml"));
assert_eq!(override_file, None);
assert_eq!(output, None);
assert_eq!(format, OutputFormat::Json);
}
_ => panic!("Expected shortcut to resolve to run action"),
}
}
#[test]
fn shortcut_accepts_uppercase_questionnaire_extensions() {
let action = parse_action(&["zenq", "SURVEY.YAML", "--format", "yaml"]).unwrap();
match action {
CliAction::Run { file, format, .. } => {
assert_eq!(file, PathBuf::from("SURVEY.YAML"));
assert_eq!(format, OutputFormat::Yaml);
}
_ => panic!("Expected shortcut to resolve to run action"),
}
}
#[test]
fn shortcut_accepts_run_options() {
let action = parse_action(&[
"zenq",
"survey.yaml",
"--override-file",
"defaults.yaml",
"-o",
"answers.json",
])
.unwrap();
match action {
CliAction::Run {
override_file,
output,
..
} => {
assert_eq!(override_file, Some(PathBuf::from("defaults.yaml")));
assert_eq!(output, Some(PathBuf::from("answers.json")));
}
_ => panic!("Expected shortcut to resolve to run action"),
}
}
#[test]
fn shortcut_rejects_non_questionnaire_extensions() {
assert!(parse_action(&["zenq", "survey.txt"]).is_err());
assert!(parse_action(&["zenq", "./validate"]).is_err());
}
#[test]
fn explicit_run_preserves_filename_handling() {
let action = parse_action(&["zenq", "run", "validate"]).unwrap();
match action {
CliAction::Run { file, .. } => {
assert_eq!(file, PathBuf::from("validate"));
}
_ => panic!("Expected explicit run action"),
}
}
#[test]
fn subcommands_take_precedence_over_shortcut() {
let action = parse_action(&["zenq", "validate", "survey.yaml"]).unwrap();
match action {
CliAction::Validate { file } => {
assert_eq!(file, PathBuf::from("survey.yaml"));
}
_ => panic!("Expected validate action"),
}
}
}