refactor(usage_md): return custom error type instead of calling process::exit

Define a non-exhaustive `RenderUsageMdError` enum with
`derive_more::{Display, Error}` and make `render_usage_md` return
`Result<String, RenderUsageMdError>`. The callsites in cli/usage_md.rs
and tests/sync_usage_md.rs now handle the error appropriately.

https://claude.ai/code/session_01TSnvxN1HBwwzhxfFShWAQ5

Author: claude

cli/usage_md.rs

@@ -1,5 +1,11 @@
 use parallel_disk_usage::usage_md::render_usage_md;
 
 fn main() {
-    println!("{}", render_usage_md().trim_end());
+    match render_usage_md() {
+        Ok(content) => println!("{}", content.trim_end()),
+        Err(error) => {
+            eprintln!("error: {error}");
+            std::process::exit(1);
+        }
+    }
 }

src/usage_md.rs

@@ -1,13 +1,23 @@
 use crate::args::Args;
 use clap::builder::PossibleValue;
 use clap::{Arg, ArgAction, Command, CommandFactory};
+use derive_more::{Display, Error};
 use itertools::Itertools;
 use std::borrow::Cow;
 
+/// Error produced when generating the usage Markdown.
+#[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),
+}
+
 /// Renders a Markdown reference page for `pdu`'s CLI.
-pub fn render_usage_md() -> String {
+pub fn render_usage_md() -> Result<String, RenderUsageMdError> {
     let mut command: Command = Args::command();
-    validate_no_redundant_visible_aliases(&command);
+    validate_no_redundant_visible_aliases(&command)?;
     let mut out = String::new();
 
     let usage = command.render_usage().to_string();
@@ -60,7 +70,7 @@ pub fn render_usage_md() -> String {
         }
     }
 
-    out
+    Ok(out)
 }
 
 fn render_argument(out: &mut String, arg: &Arg) {
@@ -239,35 +249,28 @@ fn ensure_ends_with_punctuation(line: &str) -> Cow<'_, str> {
 /// 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) {
-    let mut errors = Vec::<String>::new();
-
+fn validate_no_redundant_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 {
-                    errors.push(format!(
+                    return Err(RenderUsageMdError::RedundantVisibleAlias(format!(
                         "--{primary_long} has visible_alias \"{alias}\" that duplicates its own flag name",
-                    ));
+                    )));
                 }
             }
         }
 
         if let Some(primary_short) = arg.get_short() {
             for alias in arg.get_visible_short_aliases().unwrap_or_default() {
                 if alias == primary_short {
-                    errors.push(format!(
+                    return Err(RenderUsageMdError::RedundantVisibleAlias(format!(
                         "-{primary_short} has visible_short_alias '{alias}' that duplicates its own flag name",
-                    ));
+                    )));
                 }
             }
         }
     }
 
-    if !errors.is_empty() {
-        for error in &errors {
-            eprintln!("error: {error}");
-        }
-        std::process::exit(1);
-    }
+    Ok(())
 }

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();
+    let actual = render_usage_md().expect("render_usage_md failed");
     let expected = include_str!("../USAGE.md");
     assert!(
         actual.trim_end() == expected.trim_end(),