flagon-io/hello

/work/repo/src/lib.rs

1	//! Greetings.
2	
3	/// Parsed command-line options.
4	#[derive(Debug, PartialEq, Eq)]
5	pub struct Options {
6	    /// The name to greet, if one was given.
7	    pub name: Option<String>,
8	    /// Whether to upper-case the greeting (`--shout`).
9	    pub shout: bool,
10	    /// Whether to print the crate version and exit (`--version`).
11	    pub version: bool,
12	    /// How many times to print the greeting (`--times N`).
13	    pub times: usize,
14	}
15	
16	impl Default for Options {
17	    fn default() -> Self {
18	        Options {
19	            name: None,
20	            shout: false,
21	            version: false,
22	            times: 1,
23	        }
24	    }
25	}
26	
27	/// Parses command-line arguments (excluding the program name).
28	///
29	/// `--shout` sets [`Options::shout`], `--version` sets
30	/// [`Options::version`], and `--times N` sets [`Options::times`] (the
31	/// next argument is consumed as the value); other arguments starting
32	/// with `--` are treated as flags and skipped. The name is the first
33	/// remaining argument.
34	///
35	/// Returns an error message if `--times` has a missing or non-numeric value.
36	pub fn parse_args<I: IntoIterator<Item = String>>(args: I) -> Result<Options, String> {
37	    let mut options = Options::default();
38	    let mut args = args.into_iter();
39	    while let Some(arg) = args.next() {
40	        if arg == "--shout" {
41	            options.shout = true;
42	        } else if arg == "--version" {
43	            options.version = true;
44	        } else if arg == "--times" {
45	            let value = args
46	                .next()
47	                .ok_or_else(|| "--times requires a value".to_owned())?;
48	            options.times = value
49	                .parse()
50	                .map_err(|_| format!("--times value must be a number, got {value:?}"))?;
51	        } else if !arg.starts_with("--") && options.name.is_none() {
52	            options.name = Some(arg);
53	        }
54	    }
55	    Ok(options)
56	}
57	
58	/// `text` upper-cased.
59	pub fn shout(text: &str) -> String {
60	    text.to_uppercase()
61	}
62	
63	/// The greeting for `name`.
64	pub fn greeting(name: &str) -> String {
65	    let trimmed = name.trim();
66	    let display_name = if trimmed.is_empty() { "world" } else { trimmed };
67	    format!("Hi, {display_name}!")
68	}
69	
70	/// The farewell for `name`.
71	pub fn farewell(name: &str) -> String {
72	    let trimmed = name.trim();
73	    let display_name = if trimmed.is_empty() { "world" } else { trimmed };
74	    format!("Goodbye, {display_name}!")
75	}
76	
77	#[cfg(test)]
78	mod tests {
79	    use super::*;
80	
81	    fn args(list: &[&str]) -> Vec<String> {
82	        list.iter().map(|s| s.to_string()).collect()
83	    }
84	
85	    #[test]
86	    fn parse_args_no_args() {
87	        assert_eq!(parse_args(args(&[])).unwrap().name, None);
88	    }
89	
90	    #[test]
91	    fn parse_args_name() {
92	        assert_eq!(parse_args(args(&["Ada"])).unwrap().name.as_deref(), Some("Ada"));
93	    }
94	
95	    #[test]
96	    fn parse_args_skips_leading_flag() {
97	        assert_eq!(
98	            parse_args(args(&["--unknown", "Ada"])).unwrap().name.as_deref(),
99	            Some("Ada")
100	        );
101	    }
102	
103	    #[test]
104	    fn parse_args_shout_defaults_off() {
105	        assert!(!parse_args(args(&["Ada"])).unwrap().shout);
106	    }
107	
108	    #[test]
109	    fn parse_args_shout_before_name() {
110	        let options = parse_args(args(&["--shout", "Ada"])).unwrap();
111	        assert!(options.shout);
112	        assert_eq!(options.name.as_deref(), Some("Ada"));
113	    }
114	
115	    #[test]
116	    fn parse_args_shout_after_name() {
117	        let options = parse_args(args(&["Ada", "--shout"])).unwrap();
118	        assert!(options.shout);
119	        assert_eq!(options.name.as_deref(), Some("Ada"));
120	    }
121	
122	    #[test]
123	    fn parse_args_shout_alone() {
124	        let options = parse_args(args(&["--shout"])).unwrap();
125	        assert!(options.shout);
126	        assert_eq!(options.name, None);
127	    }
128	
129	    #[test]
130	    fn parse_args_version_defaults_off() {
131	        assert!(!parse_args(args(&["Ada"])).unwrap().version);
132	    }
133	
134	    #[test]
135	    fn parse_args_version() {
136	        let options = parse_args(args(&["--version"])).unwrap();
137	        assert!(options.version);
138	        assert_eq!(options.name, None);
139	    }
140	
141	    #[test]
142	    fn parse_args_times_defaults_to_one() {
143	        assert_eq!(parse_args(args(&["Ada"])).unwrap().times, 1);
144	    }
145	
146	    #[test]
147	    fn parse_args_times_valid() {
148	        let options = parse_args(args(&["--times", "3", "Ada"])).unwrap();
149	        assert_eq!(options.times, 3);
150	        assert_eq!(options.name.as_deref(), Some("Ada"));
151	    }
152	
153	    #[test]
154	    fn parse_args_times_missing_value() {
155	        assert!(parse_args(args(&["--times"])).is_err());
156	    }
157	
158	    #[test]
159	    fn parse_args_times_non_number() {
160	        assert!(parse_args(args(&["--times", "abc", "Ada"])).is_err());
161	    }
162	
163	    #[test]
164	    fn shout_upper_cases_greeting() {
165	        assert_eq!(shout(&greeting("Ada")), "HI, ADA!");
166	    }
167	
168	    #[test]
169	    fn greets_by_name() {
170	        assert_eq!(greeting("Ada"), "Hi, Ada!");
171	    }
172	
173	    #[test]
174	    fn greets_world_with_empty_string() {
175	        assert_eq!(greeting(""), "Hi, world!");
176	    }
177	
178	    #[test]
179	    fn greets_world_with_whitespace_only() {
180	        assert_eq!(greeting("  "), "Hi, world!");
181	    }
182	
183	    #[test]
184	    fn trims_whitespace_from_name() {
185	        assert_eq!(greeting("  Ada  "), "Hi, Ada!");
186	    }
187	
188	    #[test]
189	    fn says_goodbye_by_name() {
190	        assert_eq!(farewell("Ada"), "Goodbye, Ada!");
191	    }
192	
193	    #[test]
194	    fn says_goodbye_to_world_when_blank() {
195	        assert_eq!(farewell("  "), "Goodbye, world!");
196	    }
197	
198	    #[test]
199	    fn farewell_trims_whitespace() {
200	        assert_eq!(farewell("  Ada  "), "Goodbye, Ada!");
201	    }
202	}
203

/work/repo/src/main.rs

1	use std::{env, process};
2	
3	use hello::{greeting, parse_args, shout};
4	
5	fn main() {
6	    let options = match parse_args(env::args().skip(1)) {
7	        Ok(options) => options,
8	        Err(message) => {
9	            eprintln!("error: {message}");
10	            process::exit(2);
11	        }
12	    };
13	    if options.version {
14	        println!("{}", env!("CARGO_PKG_VERSION"));
15	        return;
16	    }
17	    // The name given, or whoever is signed in.
18	    let name = options
19	        .name
20	        .or_else(|| env::var("USER").ok())
21	        .unwrap_or_else(|| "world".to_owned());
22	    let message = greeting(&name);
23	    let line = if options.shout { shout(&message) } else { message };
24	    for _ in 0..options.times {
25	        println!("{line}");
26	    }
27	}
28

/work/repo/tests/cli.rs

1	use std::process::Command;
2	
3	#[test]
4	fn version_flag_prints_crate_version() {
5	    let output = Command::new(env!("CARGO_BIN_EXE_hello"))
6	        .arg("--version")
7	        .output()
8	        .unwrap();
9	    assert!(output.status.success());
10	    assert_eq!(
11	        String::from_utf8(output.stdout).unwrap(),
12	        format!("{}\n", env!("CARGO_PKG_VERSION"))
13	    );
14	}
15	
16	fn run(args: &[&str]) -> std::process::Output {
17	    Command::new(env!("CARGO_BIN_EXE_hello"))
18	        .args(args)
19	        .output()
20	        .unwrap()
21	}
22	
23	#[test]
24	fn times_prints_greeting_repeatedly() {
25	    let output = run(&["--times", "3", "Ada"]);
26	    assert!(output.status.success());
27	    assert_eq!(
28	        String::from_utf8(output.stdout).unwrap(),
29	        "Hi, Ada!\n".repeat(3)
30	    );
31	}
32	
33	#[test]
34	fn times_combines_with_shout() {
35	    let output = run(&["--times", "2", "--shout", "Ada"]);
36	    assert!(output.status.success());
37	    assert_eq!(
38	        String::from_utf8(output.stdout).unwrap(),
39	        "HI, ADA!\n".repeat(2)
40	    );
41	}
42	
43	#[test]
44	fn times_with_bad_value_fails() {
45	    let output = run(&["--times", "abc"]);
46	    assert!(!output.status.success());
47	    assert!(!output.stderr.is_empty());
48	}
49

/work/repo/src/lib.rs

The file /work/repo/src/lib.rs has been updated successfully. (file state is current in your context — no need to Read it back)

/work/repo/src/lib.rs

The file /work/repo/src/lib.rs has been updated successfully. (file state is current in your context — no need to Read it back)

/work/repo/src/lib.rs

The file /work/repo/src/lib.rs has been updated successfully. (file state is current in your context — no need to Read it back)

/work/repo/src/lib.rs

The file /work/repo/src/lib.rs has been updated successfully. (file state is current in your context — no need to Read it back)

/work/repo/src/lib.rs

The file /work/repo/src/lib.rs has been updated successfully. (file state is current in your context — no need to Read it back)

/work/repo/src/lib.rs

The file /work/repo/src/lib.rs has been updated successfully. (file state is current in your context — no need to Read it back)

/work/repo/src/lib.rs

The file /work/repo/src/lib.rs has been updated successfully. (file state is current in your context — no need to Read it back)

/work/repo/src/main.rs

The file /work/repo/src/main.rs has been updated successfully. (file state is current in your context — no need to Read it back)

/work/repo/src/main.rs

The file /work/repo/src/main.rs has been updated successfully. (file state is current in your context — no need to Read it back)

cat >> /work/repo/tests/cli.rs <<'EOF'

#[test]
fn lang_es_greets_in_spanish() {
    let output = run(&["--lang", "es", "Ana"]);
    assert!(output.status.success());
    assert_eq!(String::from_utf8(output.stdout).unwrap(), "¡Hola, Ana!\n");
}

#[test]
fn lang_fr_greets_in_french() {
    let output = run(&["--lang", "fr", "Luc"]);
    assert!(output.status.success());
    assert_eq!(String::from_utf8(output.stdout).unwrap(), "Bonjour, Luc !\n");
}

#[test]
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:?}");
}
EOF
cd /work/repo && cargo test 2>&1 | tail -15; cargo run -q -- --lang es Ana; cargo run -q -- --lang fr Luc

test lang_missing_value_fails ... ok
test lang_unknown_fails_naming_supported_languages ... ok
test times_combines_with_shout ... ok
test times_prints_greeting_repeatedly ... ok
test times_with_bad_value_fails ... ok
test version_flag_prints_crate_version ... ok

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

   Doc-tests hello

running 0 tests

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

¡Hola, Ana!
Bonjour, Luc !

git add -A && git commit -q -m "Add --lang option (en, es, fr) to the greeter" && git log --oneline | head -1

ff5df87 Add --lang option (en, es, fr) to the greeter

{"body":"Heads up: the PR for issue #49 (add `--lang en|es|fr`) also edits src/lib.rs and src/main.rs. It adds a `Lang` enum, `Options::lang`, a `--lang` branch in `parse_args`, and `greeting_in(name, lang)` with `greeting` kept as English. Whichever of us merges second will likely conflict in `greeting`/`parse_args`/`Options`, and the two overlap in purpose.","number":8,"repo":"syntaqx/hello"}

{"body":"Heads up: the PR for issue #49 (add `--lang en|es|fr`) also edits src/lib.rs and src/main.rs. It adds a `Lang` enum, `Options::lang`, a `--lang` branch in `parse_args`, and `greeting_in(name, lang)` with `greeting` kept as English. Whichever of us merges second will likely conflict in `greeting`/`parse_args`/`Options`, and the two overlap in purpose.","number":7,"repo":"syntaqx/hello"}

{
  "id": "cmt_01m3znkhzfeztv3628qm21aa1e",
  "kind": "comment",
  "author": {
    "id": "usr_g1t_agent",
    "username": "g1t-agent",
    "kind": "agent",
    "verified": true,
    "workspaces": [
      {
        "slug": "syntaqx",
        "role": "member"
      }
    ]
  },
  "body": "Heads up: the PR for issue #49 (add `--lang en|es|fr`) also edits src/lib.rs and src/main.rs. It adds a `Lang` enum, `Options::lang`, a `--lang` branch in `parse_args`, and `greeting_in(name, lang)` with `greeting` kept as English. Whichever of us merges second will likely conflict in `greeting`/`parse_args`/`Options`, and the two overlap in purpose.",
  "path": null,
  "line": null,
  "verdict": null,
  "createdAt": "2026-10-03T01:21:09.103Z"
}

{
  "id": "cmt_01m3znkjgne4babzy1xda9d8n1",
  "kind": "comment",
  "author": {
    "id": "usr_g1t_agent",
    "username": "g1t-agent",
    "kind": "agent",
    "verified": true,
    "workspaces": [
      {
        "slug": "syntaqx",
        "role": "member"
      }
    ]
  },
  "body": "Heads up: the PR for issue #49 (add `--lang en|es|fr`) also edits src/lib.rs and src/main.rs. It adds a `Lang` enum, `Options::lang`, a `--lang` branch in `parse_args`, and `greeting_in(name, lang)` with `greeting` kept as English. Whichever of us merges second will likely conflict in `greeting`/`parse_args`/`Options`, and the two overlap in purpose.",
  "path": null,
  "line": null,
  "verdict": null,
  "createdAt": "2026-10-03T01:21:09.653Z"
}