refactor(usage_md): address review feedback on error type and callsites

- Split RedundantVisibleAlias into RedundantVisibleLongAlias(String)
  and RedundantVisibleShortAlias(char), moving message into #[display]
- Rename validate_no_redundant_visible_aliases to check_visible_aliases
- Use if-let-Err pattern in cli/usage_md.rs to match lib.rs style
- Simplify test to use .unwrap() instead of .expect()
- Fix doc comment to use plain English instead of backtick-wrapped flags

https://claude.ai/code/session_01TSnvxN1HBwwzhxfFShWAQ5

Author: claude

cli/usage_md.rs

@@ -1,11 +1,14 @@
 use parallel_disk_usage::usage_md::render_usage_md;
 
 fn main() {
-    match render_usage_md() {
-        Ok(content) => println!("{}", content.trim_end()),
-        Err(error) => {
-            eprintln!("error: {error}");
-            std::process::exit(1);
-        }
+    if let Err(error) = run() {
+        eprintln!("error: {error}");
+        std::process::exit(1);
     }
 }
+
+fn run() -> Result<(), parallel_disk_usage::usage_md::RenderUsageMdError> {
+    let content = render_usage_md()?;
+    println!("{}", content.trim_end());
+    Ok(())
+}

src/usage_md.rs

@@ -9,15 +9,18 @@ use std::borrow::Cow;
 #[derive(Debug, Display, Error)]
 #[non_exhaustive]
 pub enum RenderUsageMdError {
-    /// A `visible_alias` or `visible_short_alias` duplicates the argument's own flag name.
-    #[display("redundant visible alias: {_0}")]
-    RedundantVisibleAlias(#[error(not(source))] String),
+    /// A `visible_alias` duplicates the argument's own long flag name.
+    #[display("--{_0} has a visible_alias that duplicates its own flag name")]
+    RedundantVisibleLongAlias(#[error(not(source))] String),
+    /// A `visible_short_alias` duplicates the argument's own short flag name.
+    #[display("-{_0} has a visible_short_alias that duplicates its own flag name")]
+    RedundantVisibleShortAlias(#[error(not(source))] char),
 }
 
 /// Renders a Markdown reference page for `pdu`'s CLI.
 pub fn render_usage_md() -> Result<String, RenderUsageMdError> {
     let mut command: Command = Args::command();
-    validate_no_redundant_visible_aliases(&command)?;
+    check_visible_aliases(&command)?;
     let mut out = String::new();
 
     let usage = command.render_usage().to_string();
@@ -246,27 +249,27 @@ fn ensure_ends_with_punctuation(line: &str) -> Cow<'_, str> {
 
 /// Checks that no argument has a visible alias that duplicates its own primary flag name.
 ///
-/// A `visible_alias` matching the argument's own `--long` name, or a `visible_short_alias`
-/// matching its own `-short` flag, is a coding mistake that produces redundant output in
-/// USAGE.md. This function detects such mistakes and terminates the process.
-fn validate_no_redundant_visible_aliases(command: &Command) -> Result<(), RenderUsageMdError> {
+/// A visible alias matching the argument's own long name, or a visible short alias
+/// matching its own short flag, is a coding mistake that produces redundant output in
+/// USAGE.md.
+fn check_visible_aliases(command: &Command) -> Result<(), RenderUsageMdError> {
     for arg in command.get_arguments() {
         if let Some(primary_long) = arg.get_long() {
             for alias in arg.get_visible_aliases().unwrap_or_default() {
                 if alias == primary_long {
-                    return Err(RenderUsageMdError::RedundantVisibleAlias(format!(
-                        "--{primary_long} has visible_alias \"{alias}\" that duplicates its own flag name",
-                    )));
+                    return Err(RenderUsageMdError::RedundantVisibleLongAlias(
+                        primary_long.to_owned(),
+                    ));
                 }
             }
         }
 
         if let Some(primary_short) = arg.get_short() {
             for alias in arg.get_visible_short_aliases().unwrap_or_default() {
                 if alias == primary_short {
-                    return Err(RenderUsageMdError::RedundantVisibleAlias(format!(
-                        "-{primary_short} has visible_short_alias '{alias}' that duplicates its own flag name",
-                    )));
+                    return Err(RenderUsageMdError::RedundantVisibleShortAlias(
+                        primary_short,
+                    ));
                 }
             }
         }

tests/sync_usage_md.rs

@@ -11,7 +11,7 @@ use parallel_disk_usage::usage_md::render_usage_md;
 
 #[test]
 fn usage_md() {
-    let actual = render_usage_md().expect("render_usage_md failed");
+    let actual = render_usage_md().unwrap();
     let expected = include_str!("../USAGE.md");
     assert!(
         actual.trim_end() == expected.trim_end(),