flagon-io/hello

cat README.md; cat src/main.rs

# 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. |

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

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

```sh
$ cargo run -- --times 2 Ada
Hello, Ada!
Hello, Ada!
```

```sh
$ cargo run -- --version
0.1.0
```

With no name it greets whoever is signed in.

## Develop

This project uses the Rust 2021 edition.

```sh
cargo test
```

## License

This project is licensed under the MIT License.
The full license text is available at https://opensource.org/license/mit.
use std::{env, process};

use hello::{greeting, 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(&name);
    let line = if options.shout { shout(&message) } else { message };
    for _ in 0..options.times {
        println!("{line}");
    }
}

/work/repo/README.md

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

cargo run -q -- --shout --times 2 Ada; git commit -qam "Add Examples section to README" && echo ok

HELLO, ADA!
HELLO, ADA!
ok

grep -n -B3 -A30 '## Examples' README.md; ls src; cat src/main.rs

34-
35-With no name it greets whoever is signed in.
36-
37:## Examples
38-
39-```sh
40-$ cargo run -- --shout --times 2 Ada
41-HELLO, ADA!
42-HELLO, ADA!
43-```
44-
45-```sh
46-$ cargo run -- --times 3 Grace
47-Hello, Grace!
48-Hello, Grace!
49-Hello, Grace!
50-```
51-
52-```sh
53-$ cargo run -- --shout Linus
54-HELLO, LINUS!
55-```
56-
57-## Develop
58-
59-This project uses the Rust 2021 edition.
60-
61-```sh
62-cargo test
63-```
64-
65-## License
66-
67-This project is licensed under the MIT License.
lib.rs
main.rs
use std::{env, process};

use hello::{greeting, 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(&name);
    let line = if options.shout { shout(&message) } else { message };
    for _ in 0..options.times {
        println!("{line}");
    }
}

cat src/lib.rs | head -80; cargo run -q -- '' 2>&1 | cat -A

//! Greetings.

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

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

/// 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); 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.
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.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 {
    let trimmed = name.trim();
    let display_name = if trimmed.is_empty() { "world" } else { trimmed };
    format!("Hello, {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::*;

Hello, world!$

python3 - <<'E'
s=open('README.md').read()
a="HELLO, LINUS!\n```\n"
s=s.replace(a,a+"\n```sh\n$ cargo run -- ''\nHello, world!\n```\n",1)
open('README.md','w').write(s)
E
cargo run -q -- --times 3 Grace; cargo run -q -- --shout Linus; git commit -qam "Add empty-name example to README" && git diff HEAD~1 --stat

Hello, Grace!
Hello, Grace!
Hello, Grace!
HELLO, LINUS!
 README.md | 5 +++++
 1 file changed, 5 insertions(+)

grep -n "" README.md | sed -n 35,75p

35:With no name it greets whoever is signed in.
36:
37:## Examples
38:
39:```sh
40:$ cargo run -- --shout --times 2 Ada
41:HELLO, ADA!
42:HELLO, ADA!
43:```
44:
45:```sh
46:$ cargo run -- --times 3 Grace
47:Hello, Grace!
48:Hello, Grace!
49:Hello, Grace!
50:```
51:
52:```sh
53:$ cargo run -- --shout Linus
54:HELLO, LINUS!
55:```
56:
57:```sh
58:$ cargo run -- ''
59:Hello, world!
60:```
61:
62:## Develop
63:
64:This project uses the Rust 2021 edition.
65:
66:```sh
67:cargo test
68:```
69:
70:## License
71:
72:This project is licensed under the MIT License.
73:The full license text is available at https://opensource.org/license/mit.

sed -i '56,60d' README.md && sed -n 50,62p README.md && git diff main~3 --stat -- README.md | tail -1; git commit -qam "Drop out-of-scope empty-name example from README" && git log --oneline -1

```

```sh
$ cargo run -- --shout Linus
HELLO, LINUS!
```

## Develop

This project uses the Rust 2021 edition.

```sh
cargo test
 1 file changed, 20 insertions(+)
8f9cdfb Drop out-of-scope empty-name example from README