flagon-io/hello

cat src/lib.rs src/main.rs && grep -n -i "shout" README.md .g1t/workflows/* 2>/dev/null

//! 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,
    /// Whether to end the greeting with three exclamation marks (`--loud`).
    pub loud: bool,
    /// Whether to print a goodbye after the greeting (`--bye`).
    pub bye: bool,
    /// Whether to print a wave after the greeting (`--wave`).
    pub wave: bool,
}

impl Default for Options {
    fn default() -> Self {
        Options {
            name: None,
            shout: false,
            version: false,
            times: 1,
            lang: Lang::En,
            quiet: false,
            loud: false,
            bye: false,
            wave: 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 == "--loud" || arg == "-L" {
            options.loud = true;
        } else if arg == "--bye" {
            options.bye = true;
        } else if arg == "--wave" {
            options.wave = 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()
}

/// `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 hail(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 wave printed by `--wave`.
pub fn wave() -> &'static str {
    "o/"
}

/// The farewell for `name`.
pub fn part(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_bye() {
        assert!(parse_args(args(&["--bye", "Ada"])).unwrap().bye);
        assert!(!parse_args(args(&["Ada"])).unwrap().bye);
    }

    #[test]
    fn parse_args_wave() {
        assert!(parse_args(args(&["--wave", "Ada"])).unwrap().wave);
        assert!(!parse_args(args(&["Ada"])).unwrap().wave);
    }

    #[test]
    fn wave_is_o_slash() {
        assert_eq!(wave(), "o/");
    }

    #[test]
    fn parse_args_loud() {
        assert!(parse_args(args(&["--loud", "Ada"])).unwrap().loud);
        assert!(parse_args(args(&["-L", "Ada"])).unwrap().loud);
        assert!(!parse_args(args(&["Ada"])).unwrap().loud);
    }

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

    #[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::
… (truncated)

sed -n 1,30p README.md

# hello

Greets people from the command line.

## Usage

| Argument | Description |
| -------- | ----------- |
| `NAME`   | Optional. The name to greet. Only the first argument is read. Defaults to the `USER` environment variable, then to `world`. |
| `--shout` | Upper-cases the greeting. |
| `--version` | Prints the crate version and exits. |
| `--times N` | Prints the greeting `N` times. Defaults to 1. |
| `--lang LANG` | Greets in the given language. Supported values are `en`, `es` and `fr`. Defaults to `en`. |
| `--loud`, `-L` | Ends the greeting with `!!!` instead of `!`. |
| `--bye` | Prints `Goodbye, NAME!` after the greeting. |
| `--wave` | Prints `o/` after the greeting. |
| `--quiet` | Prints no greeting at all. `--version` still prints the version. |

```sh
$ cargo run -- Ada
Hi, Ada!
```

```sh
$ cargo run -- --shout Ada
HI, ADA!
```

```sh
$ cargo run -- --times 2 Ada

python3 - <<'E'
import re
p='src/lib.rs'; s=open(p).read()
s=s.replace("""    pub shout: bool,
    /// Whether to print the crate""","""    pub shout: bool,
    /// Whether to lower-case the greeting and end it with `...` (`--whisper`).
    pub whisper: bool,
    /// Whether to print the crate""",1)
s=s.replace("            shout: false,\n","            shout: false,\n            whisper: false,\n",1)
s=s.replace("""        if arg == "--shout" {
            options.shout = true;
""","""        if arg == "--shout" {
            options.shout = true;
            options.whisper = false;
        } else if arg == "--whisper" {
            options.whisper = true;
            options.shout = false;
""",1)
s=s.replace("""/// `text` with its final exclamation""","""/// `text` lower-cased, with its final exclamation mark replaced by `...`.
pub fn whisper(text: &str) -> String {
    let body = text.to_lowercase();
    format!("{}...", body.trim_end_matches('!').trim_end())
}

/// `text` with its final exclamation""",1)
s=s.replace("""    #[test]
    fn greets_by_name""","""    #[test]
    fn whisper_lower_cases_and_trails_off() {
        assert_eq!(whisper(&hail("Ada")), "hi, ada...");
        assert_eq!(whisper(&greeting_in("Luc", Lang::Fr)), "bonjour, luc...");
    }

    #[test]
    fn parse_args_whisper_and_shout_last_wins() {
        let o = parse_args(args(&["--whisper", "Ada"])).unwrap();
        assert!(o.whisper && !o.shout);
        let o = parse_args(args(&["--shout", "--whisper"])).unwrap();
        assert!(o.whisper && !o.shout);
        let o = parse_args(args(&["--whisper", "--shout"])).unwrap();
        assert!(o.shout && !o.whisper);
    }

    #[test]
    fn greets_by_name""",1)
open(p,'w').write(s)
p='src/main.rs'; s=open(p).read()
s=s.replace("shout, wave}","shout, wave, whisper}")
s=s.replace("""    let line = if options.shout {
        shout(&message)
    } else {""","""    let line = if options.shout {
        shout(&message)
    } else if options.whisper {
        whisper(&message)
    } else {""")
open(p,'w').write(s)
p='README.md'; s=open(p).read()
s=s.replace("| `--version`","| `--whisper` | Lower-cases the greeting and ends it with `...` instead of `!`. With `--shout`, the last one given wins. |\n| `--version`",1)
open(p,'w').write(s)
E
cargo fmt && cargo test 2>&1 | tail -5; git commit -qam "Add --whisper flag

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

error: 'cargo-fmt' is not installed for the toolchain 'stable-x86_64-unknown-linux-gnu'.
help: run `rustup component add rustfmt` to install it
[This command modified 1 file you've previously read: README.md. Call Read before editing.]

cargo test 2>&1 | tail -6; git log --oneline | head -1

Doc-tests hello

running 0 tests

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

82c74a1 Add --whisper flag

cargo test 2>&1 | grep "test result"; cargo run -q -- --shout --whisper Ada

test result: ok. 35 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.02s
test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
hi, ada...