sabi-maker 0.1.0

A tiny dependency-free CLI that generates catchy Japanese chorus hooks
Documentation
use sabi_maker::{Mood, Options, generate};
use std::env;
use std::process::ExitCode;
use std::time::{SystemTime, UNIX_EPOCH};

fn main() -> ExitCode {
    match parse_args(env::args().skip(1)) {
        Ok(None) => ExitCode::SUCCESS,
        Ok(Some(options)) => {
            println!("{}", generate(&options));
            ExitCode::SUCCESS
        }
        Err(message) => {
            eprintln!("error: {message}\n\n{}", help());
            ExitCode::from(2)
        }
    }
}

fn parse_args(args: impl Iterator<Item = String>) -> Result<Option<Options>, String> {
    let mut options = Options {
        seed: SystemTime::now()
            .duration_since(UNIX_EPOCH)
            .unwrap_or_default()
            .as_nanos() as u64,
        ..Options::default()
    };
    let mut args = args.peekable();

    while let Some(arg) = args.next() {
        match arg.as_str() {
            "-h" | "--help" => {
                println!("{}", help());
                return Ok(None);
            }
            "-V" | "--version" => {
                println!("sabi {}", env!("CARGO_PKG_VERSION"));
                return Ok(None);
            }
            "-t" | "--theme" => options.theme = value(&mut args, &arg)?,
            "-m" | "--mood" => {
                let raw = value(&mut args, &arg)?;
                options.mood = Mood::parse(&raw).ok_or_else(|| {
                    format!("unknown mood '{raw}' (use bright, emotional, or cool)")
                })?;
            }
            "-l" | "--lines" => {
                let raw = value(&mut args, &arg)?;
                options.lines = raw
                    .parse()
                    .map_err(|_| format!("invalid line count '{raw}'"))?;
                if !(2..=12).contains(&options.lines) {
                    return Err("line count must be between 2 and 12".into());
                }
            }
            "-s" | "--seed" => {
                let raw = value(&mut args, &arg)?;
                options.seed = raw.parse().map_err(|_| format!("invalid seed '{raw}'"))?;
            }
            _ => return Err(format!("unknown option '{arg}'")),
        }
    }

    Ok(Some(options))
}

fn value(args: &mut impl Iterator<Item = String>, option: &str) -> Result<String, String> {
    args.next()
        .ok_or_else(|| format!("{option} requires a value"))
}

fn help() -> &'static str {
    "sabi — catchy Japanese chorus-hook generator\n\n\
Usage: sabi [OPTIONS]\n\n\
Options:\n  \
-t, --theme <TEXT>   Chorus theme [default: 君]\n  \
-m, --mood <MOOD>   bright, emotional, or cool [default: bright]\n  \
-l, --lines <N>      Number of lines, 2–12 [default: 4]\n  \
-s, --seed <N>       Reproduce a result with a fixed seed\n  \
-h, --help           Print help\n  \
-V, --version        Print version"
}