flagon-io/hello

cat src/lib.rs src/main.rs; git log -3 --stat | head -30

//! 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,
    /// Whether to print nothing (`--quiet`).
    pub quiet: bool,
}

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

/// 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 == "--quiet" {
            options.quiet = 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())?;
            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_quiet() {
        assert!(parse_args(args(&["--quiet", "Ada"])).unwrap().quiet);
        assert!(!parse_args(args(&["Ada"])).unwrap().quiet);
    }

    #[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(),
            Some("Ada")
        );
    }

    #[test]
    fn parse_args_shout_defaults_off() {
        assert!(!parse_args(args(&["Ada"])).unwrap().shout);
    }

    #[test]
    fn parse_args_shout_before_name() {
        let options = parse_args(args(&["--shout", "Ada"])).unwrap();
        assert!(options.shout);
        assert_eq!(options.name.as_deref(), Some("Ada"));
    }

    #[test]
    fn parse_args_shout_after_name() {
        let options = parse_args(args(&["Ada", "--shout"])).unwrap();
        assert!(options.shout);
        assert_eq!(options.name.as_deref(), Some("Ada"));
    }

    #[test]
    fn parse_args_shout_alone() {
        let options = parse_args(args(&["--shout"])).unwrap();
        assert!(options.shout);
        assert_eq!(options.name, None);
    }

    #[test]
    fn parse_args_version_defaults_off() {
        assert!(!parse_args(args(&["Ada"])).unwrap().version);
    }

    #[test]
    fn parse_args_version() {
        let options = parse_args(args(&["--version"])).unwrap();
        assert!(options.version);
        assert_eq!(options.name, None);
    }

    #[test]
    fn parse_args_times_defaults_to_one() {
        assert_eq!(parse_args(args(&["Ada"])).unwrap().times, 1);
    }

    #[test]
    fn parse_args_times_valid() {
        let options = parse_args(args(&["--times", "3", "Ada"])).unwrap();
        assert_eq!(options.times, 3);
        assert_eq!(options.name.as_deref(), Some("Ada"));
    }

    #[test]
    fn parse_args_times_missing_value() {
        assert!(parse_args(args(&["--times"])).is_err());
    }

    #[test]
    fn parse_args_times_non_number() {
        assert!(parse_args(args(&["--times", "abc", "Ada"])).is_err());
    }

    #[test]
    fn parse_args_lang_defaults_to_en() {
        assert_eq!(parse_args(args(&["Ada"])).unwrap().lang, Lang::En);
    }

    #[test]
    fn parse_args_lang_valid() {
        let options = parse_args(args(&["--lang", "es", "Ana"])).unwrap();
        assert_eq!(options.lang, Lang::Es);
        assert_eq!(options.name.as_deref(), Some("Ana"));
        assert_eq!(parse_args(args(&["--lang", "fr"])).unwrap().lang, Lang::Fr);
    }

    #[test]
    fn parse_args_lang_missing_value() {
        assert_eq!(
            parse_args(args(&["--lang"])).unwrap_err(),
            "--lang requires a value"
        );
    }

    #[test]
    fn parse_args_lang_unknown() {
        assert_eq!(
            parse_args(args(&["--lang", "de"])).unwrap_err(),
            "--lang value must be one of en, es, fr, got \"de\""
        );
    }

    #[test]
    fn greeting_in_each_language() {
        assert_eq!(greeting_in("Ada", Lang::En), "Hi, Ada!");
        assert_eq!(greeting_in("Ana", Lang::Es), "¡Hola, Ana!");
        assert_eq!(greeting_in("Luc", Lang::Fr), "Bonjour, Luc !");
    }

    #[test]
    fn greeting_in_trims_and_falls_back_to_world() {
        assert_eq!(greeting_in("  Ana  ", Lang::Es), "¡Hola, Ana!");
        assert_eq!(greeting_in(" ", Lang::Fr), "Bonjour, world !");
    }

    #[test]
    fn shout_upper_cases_greeting() {
        assert_eq!(shout(&greeting("Ada")), "HI, ADA!");
    }

    #[test]
    fn greets_by_name() {
        assert_eq!(greeting("Ada"), "Hi, Ada!");
    }

    #[test]
    fn greets_world_with_empty_string() {
        assert_eq!(greeting(""), "Hi, world!");
    }

    #[test]
    fn greets_world_with_whitespace_only() {
        assert_eq!(greeting("  "), "Hi, world!");
    }

    #[test]
    fn trims_whitespac
… (truncated)

cat tests/cli.rs | tail -30

fn lang_en_is_the_default() {
    let output = run(&["--lang", "en", "Ada"]);
    assert!(output.status.success());
    assert_eq!(String::from_utf8(output.stdout).unwrap(), "Hi, Ada!\n");
    let output = run(&["Ada"]);
    assert_eq!(String::from_utf8(output.stdout).unwrap(), "Hi, Ada!\n");
}

#[test]
fn lang_unknown_fails_naming_supported_languages() {
    let output = run(&["--lang", "de", "Ada"]);
    assert_eq!(output.status.code(), Some(2));
    let stderr = String::from_utf8(output.stderr).unwrap();
    assert!(stderr.contains("en, es, fr"), "stderr was {stderr:?}");
}

#[test]
fn lang_missing_value_fails() {
    let output = run(&["--lang"]);
    assert_eq!(output.status.code(), Some(2));
    let stderr = String::from_utf8(output.stderr).unwrap();
    assert!(stderr.contains("--lang requires a value"), "stderr was {stderr:?}");
}

#[test]
fn quiet_prints_nothing() {
    let output = run(&["--quiet", "Ada"]);
    assert!(output.status.success());
    assert!(output.stdout.is_empty());
}

python3 - <<'E'
p='src/lib.rs'; s=open(p).read()
s=s.replace("""    pub quiet: bool,
}
""","""    pub quiet: bool,
    /// Whether to end the greeting with three exclamation marks (`--loud`).
    pub loud: bool,
}
""",1)
s=s.replace("            quiet: false,\n","            quiet: false,\n            loud: false,\n",1)
s=s.replace("""        } else if arg == "--times" {""","""        } else if arg == "--loud" {
            options.loud = true;
        } else if arg == "--times" {""",1)
s=s.replace("""/// The greeting for `name`.
pub fn greeting(""","""/// `text` with its final exclamation mark replaced by three.
pub fn loud(text: &str) -> String {
    format!("{}!!!", text.strip_suffix('!').unwrap_or(text))
}

/// The greeting for `name`.
pub fn greeting(""",1)
s=s.replace("""    #[test]
    fn parse_args_no_args""","""    #[test]
    fn parse_args_loud() {
        assert!(parse_args(args(&["--loud", "Ada"])).unwrap().loud);
        assert!(!parse_args(args(&["Ada"])).unwrap().loud);
    }

    #[test]
    fn loud_uses_three_exclamation_marks() {
        assert_eq!(loud(&greeting("Ada")), "Hi, Ada!!!");
    }

    #[test]
    fn parse_args_no_args""",1)
open(p,'w').write(s)
p='src/main.rs'; s=open(p).read()
s=s.replace("{greeting_in, parse_args, shout}","{greeting_in, loud, parse_args, shout}")
s=s.replace("""    let line = if""","""    let message = if options.loud { loud(&message) } else { message };
    let line = if""",1)
open(p,'w').write(s)
E
cat >> tests/cli.rs <<'E'

#[test]
fn loud_ends_with_three_exclamation_marks() {
    let output = run(&["--loud", "Ada"]);
    assert!(output.status.success());
    assert_eq!(String::from_utf8(output.stdout).unwrap(), "Hi, Ada!!!\n");
}
E
cargo test -q 2>&1 | tail -8; git commit -qam "Add --loud flag that ends the greeting with three exclamation marks

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>"

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


running 0 tests

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

python3 - <<'E'
p='src/lib.rs'; s=open(p).read()
s=s.replace('arg == "--loud"','arg == "--loud" || arg == "-L"',1)
s=s.replace("""        assert!(!parse_args(args(&["Ada"])).unwrap().loud);""","""        assert!(parse_args(args(&["-L", "Ada"])).unwrap().loud);
        assert!(!parse_args(args(&["Ada"])).unwrap().loud);""",1)
open(p,'w').write(s)
E
cat >> tests/cli.rs <<'E'

#[test]
fn short_l_is_an_alias_for_loud() {
    let output = run(&["-L", "Ada"]);
    assert!(output.status.success());
    assert_eq!(String::from_utf8(output.stdout).unwrap(), "Hi, Ada!!!\n");
}
E
cargo test -q 2>&1 | grep "test result"; git commit -qam "Accept -L as a short alias for --loud

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>"

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