refactor(ariadne): collapse binary CLI module

src/ariadne/BUILD

@@ -9,10 +9,7 @@ rust_library(
 rust_binary(
     name = "ariadne",
     crate_name = "ariadne_cli",
-    srcs = [
-        "cli.rs",
-        "main.rs",
-    ],
+    srcs = ["main.rs"],
     deps = [":ariadne_lib"],
 )
 
@@ -22,16 +19,6 @@ rust_test(
     deps = [":ariadne_lib"],
 )
 
-rust_test(
-    name = "ariadne_cli_test",
-    srcs = [
-        "cli.rs",
-        "cli_test.rs",
-    ],
-    crate_root = "cli_test.rs",
-    deps = [":ariadne_lib"],
-)
-
 sh_binary(
     name = "extract_and_decompile",
     srcs = ["extract-and-decompile.sh"],

src/ariadne/Cargo.toml

@@ -14,8 +14,4 @@ path = "main.rs"
 name = "lib_test"
 path = "lib_test.rs"
 
-[[test]]
-name = "cli_test"
-path = "cli_test.rs"
-
 [dependencies]

src/ariadne/cli.rs

@@ -1,39 +0,0 @@
-use ariadne::PRODUCT_NAME;
-
-pub const COMMAND_NAME: &str = "ariadne";
-
-#[derive(Debug, PartialEq, Eq)]
-pub struct Request {
-    pub command: Command,
-}
-
-#[derive(Debug, PartialEq, Eq)]
-pub enum Command {
-    Help,
-}
-
-#[derive(Debug, PartialEq, Eq)]
-pub enum Error {
-    UnknownArgument { value: String },
-}
-
-pub fn parse_args(args: impl IntoIterator<Item = String>) -> Result<Request, Error> {
-    let mut args = args.into_iter();
-    let _program = args.next();
-
-    match args.next() {
-        None => Ok(Request {
-            command: Command::Help,
-        }),
-        Some(value) if value == "--help" || value == "-h" => Ok(Request {
-            command: Command::Help,
-        }),
-        Some(value) => Err(Error::UnknownArgument { value }),
-    }
-}
-
-pub fn help_text() -> String {
-    format!(
-        "{PRODUCT_NAME}\n\nUsage: {COMMAND_NAME} [--help]\n\nCommands will inspect prepared Ren'Py source.\n"
-    )
-}

src/ariadne/cli_test.rs

@@ -1,42 +0,0 @@
-mod cli;
-
-use cli::{Command, Error};
-
-#[test]
-fn command_name_is_lowercase() {
-    assert_eq!(cli::COMMAND_NAME, "ariadne");
-}
-
-#[test]
-fn no_arguments_request_help() {
-    let request = cli::parse_args(["ariadne".to_string()]).unwrap();
-
-    assert_eq!(request.command, Command::Help);
-}
-
-#[test]
-fn help_flag_requests_help() {
-    let request = cli::parse_args(["ariadne".to_string(), "--help".to_string()]).unwrap();
-
-    assert_eq!(request.command, Command::Help);
-}
-
-#[test]
-fn unknown_argument_returns_error() {
-    let result = cli::parse_args(["ariadne".to_string(), "--unknown".to_string()]);
-
-    assert_eq!(
-        result,
-        Err(Error::UnknownArgument {
-            value: "--unknown".to_string(),
-        })
-    );
-}
-
-#[test]
-fn help_text_mentions_binary_and_command() {
-    let help = cli::help_text();
-
-    assert!(help.contains("Ariadne"));
-    assert!(help.contains("Usage: ariadne"));
-}

src/ariadne/main.rs

@@ -1,21 +1,103 @@
-mod cli;
+use ariadne::PRODUCT_NAME;
+
+const COMMAND_NAME: &str = "ariadne";
+
+#[derive(Debug, PartialEq, Eq)]
+struct Request {
+    command: Command,
+}
+
+#[derive(Debug, PartialEq, Eq)]
+enum Command {
+    Help,
+}
+
+#[derive(Debug, PartialEq, Eq)]
+enum Error {
+    UnknownArgument { value: String },
+}
 
 fn main() {
-    match cli::parse_args(std::env::args()) {
+    match parse_args(std::env::args()) {
         Ok(request) => run(request.command),
         Err(error) => exit_with_error(error),
     }
 }
 
-fn run(command: cli::Command) {
+fn run(command: Command) {
     match command {
-        cli::Command::Help => print!("{}", cli::help_text()),
+        Command::Help => print!("{}", help_text()),
     }
 }
 
-fn exit_with_error(error: cli::Error) -> ! {
+fn parse_args(args: impl IntoIterator<Item = String>) -> Result<Request, Error> {
+    let mut args = args.into_iter();
+    let _program = args.next();
+
+    match args.next() {
+        None => Ok(Request {
+            command: Command::Help,
+        }),
+        Some(value) if value == "--help" || value == "-h" => Ok(Request {
+            command: Command::Help,
+        }),
+        Some(value) => Err(Error::UnknownArgument { value }),
+    }
+}
+
+fn help_text() -> String {
+    format!(
+        "{PRODUCT_NAME}\n\nUsage: {COMMAND_NAME} [--help]\n\nCommands will inspect prepared Ren'Py source.\n"
+    )
+}
+
+fn exit_with_error(error: Error) -> ! {
     match error {
-        cli::Error::UnknownArgument { value } => eprintln!("ariadne: unknown argument: {value}"),
+        Error::UnknownArgument { value } => eprintln!("ariadne: unknown argument: {value}"),
     }
     std::process::exit(2);
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn command_name_is_lowercase() {
+        assert_eq!(COMMAND_NAME, "ariadne");
+    }
+
+    #[test]
+    fn no_arguments_request_help() {
+        let request = parse_args(["ariadne".to_string()]).unwrap();
+
+        assert_eq!(request.command, Command::Help);
+    }
+
+    #[test]
+    fn help_flag_requests_help() {
+        let request = parse_args(["ariadne".to_string(), "--help".to_string()]).unwrap();
+
+        assert_eq!(request.command, Command::Help);
+    }
+
+    #[test]
+    fn unknown_argument_returns_error() {
+        let result = parse_args(["ariadne".to_string(), "--unknown".to_string()]);
+
+        assert_eq!(
+            result,
+            Err(Error::UnknownArgument {
+                value: "--unknown".to_string(),
+            })
+        );
+    }
+
+    #[test]
+    fn help_text_mentions_binary_and_command() {
+        let help = help_text();
+
+        assert!(help.contains("Ariadne"));
+        assert!(help.contains("Usage: ariadne"));
+    }
+}