flagon-io/hello

cat src/main.rs; cat src/lib.rs | head -80; ls tests 2>/dev/null

use std::{env, process};

use hello::{greeting_in, parse_args, shout};

fn main() {
    let options = match parse_args(env::args().skip(1)) {
        Ok(options) => options,
        Err(message) => {
            eprintln!("error: {message}");
            process::exit(2);
        }
    };
    if options.version {
        println!("{}", env!("CARGO_PKG_VERSION"));
        return;
    }
    // The name given, or whoever is signed in.
    let name = options
        .name
        .or_else(|| env::var("USER").ok())
        .unwrap_or_else(|| "world".to_owned());
    let message = greeting_in(&name, options.lang);
    let line = if options.shout { shout(&message) } else { message };
    for _ in 0..options.times {
        println!("{line}");
    }
}
//! Greetings.

/// A supported greeting language.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum Lang {
    #[default]
    En,
    Es,
    Fr,
}

impl Lang {
    /// Parses a language code (`en`, `es` or `fr`).
    pub fn parse(code: &str) -> Option<Lang> {
        match code {
            "en" => Some(Lang::En),
            "es" => Some(Lang::Es),
            "fr" => Some(Lang::Fr),
            _ => None,
        }
    }
}

/// Parsed command-line options.
#[derive(Debug, PartialEq, Eq)]
pub struct Options {
    /// The name to greet, if one was given.
    pub name: Option<String>,
    /// Whether to upper-case the greeting (`--shout`).
    pub shout: bool,
    /// Whether to print the crate version and exit (`--version`).
    pub version: bool,
    /// How many times to print the greeting (`--times N`).
    pub times: usize,
    /// The greeting language (`--lang CODE`).
    pub lang: Lang,
}

impl Default for Options {
    fn default() -> Self {
        Options {
            name: None,
            shout: false,
            version: false,
            times: 1,
            lang: Lang::En,
        }
    }
}

/// Parses command-line arguments (excluding the program name).
///
/// `--shout` sets [`Options::shout`], `--version` sets
/// [`Options::version`], and `--times N` sets [`Options::times`] (the
/// next argument is consumed as the value), and `--lang CODE` sets
/// [`Options::lang`] (likewise consuming the next argument); other
/// arguments starting with `--` are treated as flags and skipped. The
/// name is the first remaining argument.
///
/// Returns an error message if `--times` has a missing or non-numeric
/// value, or if `--lang` has a missing or unsupported value.
pub fn parse_args<I: IntoIterator<Item = String>>(args: I) -> Result<Options, String> {
    let mut options = Options::default();
    let mut args = args.into_iter();
    while let Some(arg) = args.next() {
        if arg == "--shout" {
            options.shout = true;
        } else if arg == "--version" {
            options.version = true;
        } else if arg == "--times" {
            let value = args
                .next()
                .ok_or_else(|| "--times requires a value".to_owned())?;
            options.times = value
                .parse()
                .map_err(|_| format!("--times value must be a number, got {value:?}"))?;
        } else if arg == "--lang" {
            let value = args
                .next()
                .ok_or_else(|| "--lang requires a value".to_owned())?;
cli.rs

sed -n 80,140p src/lib.rs; head -30 tests/cli.rs

.ok_or_else(|| "--lang requires a value".to_owned())?;
            options.lang = Lang::parse(&value).ok_or_else(|| {
                format!("--lang value must be one of en, es, fr, got {value:?}")
            })?;
        } else if !arg.starts_with("--") && options.name.is_none() {
            options.name = Some(arg);
        }
    }
    Ok(options)
}

/// `text` upper-cased.
pub fn shout(text: &str) -> String {
    text.to_uppercase()
}

/// The greeting for `name`.
pub fn greeting(name: &str) -> String {
    greeting_in(name, Lang::En)
}

/// The greeting for `name` in `lang`.
pub fn greeting_in(name: &str, lang: Lang) -> String {
    let trimmed = name.trim();
    let display_name = if trimmed.is_empty() { "world" } else { trimmed };
    match lang {
        Lang::En => format!("Hi, {display_name}!"),
        Lang::Es => format!("¡Hola, {display_name}!"),
        Lang::Fr => format!("Bonjour, {display_name} !"),
    }
}

/// The farewell for `name`.
pub fn farewell(name: &str) -> String {
    let trimmed = name.trim();
    let display_name = if trimmed.is_empty() { "world" } else { trimmed };
    format!("Goodbye, {display_name}!")
}

#[cfg(test)]
mod tests {
    use super::*;

    fn args(list: &[&str]) -> Vec<String> {
        list.iter().map(|s| s.to_string()).collect()
    }

    #[test]
    fn parse_args_no_args() {
        assert_eq!(parse_args(args(&[])).unwrap().name, None);
    }

    #[test]
    fn parse_args_name() {
        assert_eq!(parse_args(args(&["Ada"])).unwrap().name.as_deref(), Some("Ada"));
    }

    #[test]
    fn parse_args_skips_leading_flag() {
        assert_eq!(
            parse_args(args(&["--unknown", "Ada"])).unwrap().name.as_deref(),
use std::process::Command;

#[test]
fn version_flag_prints_crate_version() {
    let output = Command::new(env!("CARGO_BIN_EXE_hello"))
        .arg("--version")
        .output()
        .unwrap();
    assert!(output.status.success());
    assert_eq!(
        String::from_utf8(output.stdout).unwrap(),
        format!("{}\n", env!("CARGO_PKG_VERSION"))
    );
}

fn run(args: &[&str]) -> std::process::Output {
    Command::new(env!("CARGO_BIN_EXE_hello"))
        .args(args)
        .output()
        .unwrap()
}

#[test]
fn times_prints_greeting_repeatedly() {
    let output = run(&["--times", "3", "Ada"]);
    assert!(output.status.success());
    assert_eq!(
        String::from_utf8(output.stdout).unwrap(),
        "Hi, Ada!\n".repeat(3)
    );

python3 - <<'E'
p='src/lib.rs';s=open(p).read()
s=s.replace("""    pub lang: Lang,
}

impl Default""","""    pub lang: Lang,
    /// Whether to print nothing (`--quiet`).
    pub quiet: bool,
}

impl Default""",1)
s=s.replace("""            lang: Lang::En,
        }""","""            lang: Lang::En,
            quiet: false,
        }""",1)
s=s.replace("""        } else if arg == "--times" {""","""        } else if arg == "--quiet" {
            options.quiet = true;
        } else if arg == "--times" {""",1)
s=s.replace("""    #[test]
    fn parse_args_no_args()""","""    #[test]
    fn parse_args_quiet() {
        assert!(parse_args(args(&["--quiet", "Ada"])).unwrap().quiet);
        assert!(!parse_args(args(&["Ada"])).unwrap().quiet);
    }

    #[test]
    fn parse_args_no_args()""",1)
open(p,'w').write(s)
p='src/main.rs';s=open(p).read()
s=s.replace("""    // The name given""","""    if options.quiet {
        return;
    }
    // The name given""",1)
open(p,'w').write(s)
E
cat >> tests/cli.rs <<'E'

#[test]
fn quiet_prints_nothing() {
    let output = run(&["--quiet", "Ada"]);
    assert!(output.status.success());
    assert!(output.stdout.is_empty());
}
E
cargo test -q 2>&1 | tail -8; test -z "$(cargo run -q -- --quiet Ada)" && echo ok
git commit -qam "Add --quiet flag that prints nothing" && echo done

..........
test result: ok. 10 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.06s


running 0 tests

test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s

ok
done