flagon-io/hello

{"body":"Which name should I use for the library's greeting function: greeting() or greet()? I'm adding a --bye flag on top of it for issue #63.","from_number":63,"kind":"question","number":62,"repo":"syntaqx/hello"}

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

{
  "id": "msg_01m3zrabtcesktx39vydfwkgqq",
  "author": "g1t-agent",
  "body": "Which name should I use for the library's greeting function: greeting() or greet()? I'm adding a --bye flag on top of it for issue #63.",
  "createdAt": "2026-10-03T02:08:33.612Z",
  "deliveredAt": null,
  "kind": "question",
  "fromNumber": 63,
  "toNumber": 62,
  "answer": null,
  "declined": false
}

//! 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,
}

impl Default for Options {
    fn default() -> Self {
        Options {
            name: None,
            shout: false,
            version: false,
            times: 1,
            lang: Lang::En,
            quiet: false,
            loud: 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 == "--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 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_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(&greeting("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::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!(
… (truncated)

python3 - <<'E'
p='src/lib.rs'
s=open(p).read()
s=s.replace("""    pub loud: bool,
}
""","""    pub loud: bool,
    /// Whether to print a goodbye after the greeting (`--bye`).
    pub bye: bool,
}
""",1)
s=s.replace("            loud: false,\n","            loud: false,\n            bye: false,\n",1)
s=s.replace("""        } else if arg == "--times" {""","""        } else if arg == "--bye" {
            options.bye = true;
        } else if arg == "--times" {""",1)
s=s.replace("""    #[test]
    fn parse_args_loud() {""","""    #[test]
    fn parse_args_bye() {
        assert!(parse_args(args(&["--bye", "Ada"])).unwrap().bye);
        assert!(!parse_args(args(&["Ada"])).unwrap().bye);
    }

    #[test]
    fn parse_args_loud() {""",1)
open(p,'w').write(s)
p='src/main.rs'
s=open(p).read()
s=s.replace("use hello::{greeting_in,","use hello::{farewell, greeting_in,")
s=s.replace("""        println!("{line}");
    }
""","""        println!("{line}");
    }
    if options.bye {
        println!("{}", farewell(&name));
    }
""")
open(p,'w').write(s)
E
cargo test -q 2>&1 | tail -5

{"number":63,"repo":"syntaqx/hello"}

running 0 tests

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

Pull request not found.

git commit -qam "Add --bye flag that prints a goodbye after the greeting

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>" && git log --oneline | head -1

d4eb1c4 Add --bye flag that prints a goodbye after the greeting