refactor(ariadne): keep CLI parser in binary crate

src/ariadne/BUILD

@@ -3,25 +3,35 @@ load("@rules_rust//rust:defs.bzl", "rust_binary", "rust_library", "rust_test")
 rust_library(
     name = "ariadne_lib",
     crate_name = "ariadne",
-    srcs = [
-        "cli.rs",
-        "lib.rs",
-    ],
+    srcs = ["lib.rs"],
 )
 
 rust_binary(
     name = "ariadne",
     crate_name = "ariadne_cli",
-    srcs = ["main.rs"],
+    srcs = [
+        "cli.rs",
+        "main.rs",
+    ],
     deps = [":ariadne_lib"],
 )
 
 rust_test(
-    name = "ariadne_test",
+    name = "ariadne_lib_test",
     srcs = ["lib_test.rs"],
     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,4 +14,8 @@ path = "main.rs"
 name = "lib_test"
 path = "lib_test.rs"
 
+[[test]]
+name = "cli_test"
+path = "cli_test.rs"
+
 [dependencies]

src/ariadne/cli.rs

@@ -1,17 +1,34 @@
-use crate::{CliError, CliRequest, Command, COMMAND_NAME, PRODUCT_NAME};
+use ariadne::PRODUCT_NAME;
 
-pub fn parse_args(args: impl IntoIterator<Item = String>) -> Result<CliRequest, CliError> {
+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(CliRequest {
+        None => Ok(Request {
             command: Command::Help,
         }),
-        Some(value) if value == "--help" || value == "-h" => Ok(CliRequest {
+        Some(value) if value == "--help" || value == "-h" => Ok(Request {
             command: Command::Help,
         }),
-        Some(value) => Err(CliError::UnknownArgument { value }),
+        Some(value) => Err(Error::UnknownArgument { value }),
     }
 }
 

src/ariadne/cli_test.rs

@@ -0,0 +1,42 @@
+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/lib.rs

@@ -1,27 +1 @@
-pub mod cli;
-
 pub const PRODUCT_NAME: &str = "Ariadne";
-pub const COMMAND_NAME: &str = "ariadne";
-
-#[derive(Debug, PartialEq, Eq)]
-pub struct CliRequest {
-    pub command: Command,
-}
-
-#[derive(Debug, PartialEq, Eq)]
-pub enum Command {
-    Help,
-}
-
-#[derive(Debug, PartialEq, Eq)]
-pub enum CliError {
-    UnknownArgument { value: String },
-}
-
-pub fn parse_args(args: impl IntoIterator<Item = String>) -> Result<CliRequest, CliError> {
-    cli::parse_args(args)
-}
-
-pub fn help_text() -> String {
-    cli::help_text()
-}

src/ariadne/lib_test.rs

@@ -1,41 +1,4 @@
-use ariadne::{CliError, Command};
-
 #[test]
-fn library_names_distinguish_product_from_command() {
+fn library_exposes_product_name() {
     assert_eq!(ariadne::PRODUCT_NAME, "Ariadne");
-    assert_eq!(ariadne::COMMAND_NAME, "ariadne");
-}
-
-#[test]
-fn no_arguments_request_help() {
-    let request = ariadne::parse_args(["ariadne".to_string()]).unwrap();
-
-    assert_eq!(request.command, Command::Help);
-}
-
-#[test]
-fn help_flag_requests_help() {
-    let request = ariadne::parse_args(["ariadne".to_string(), "--help".to_string()]).unwrap();
-
-    assert_eq!(request.command, Command::Help);
-}
-
-#[test]
-fn unknown_argument_returns_error() {
-    let result = ariadne::parse_args(["ariadne".to_string(), "--unknown".to_string()]);
-
-    assert_eq!(
-        result,
-        Err(CliError::UnknownArgument {
-            value: "--unknown".to_string(),
-        })
-    );
-}
-
-#[test]
-fn help_text_mentions_binary_and_command() {
-    let help = ariadne::help_text();
-
-    assert!(help.contains("Ariadne"));
-    assert!(help.contains("Usage: ariadne"));
 }

src/ariadne/main.rs

@@ -1,21 +1,21 @@
-use ariadne::{CliError, Command};
+mod cli;
 
 fn main() {
-    match ariadne::parse_args(std::env::args()) {
+    match cli::parse_args(std::env::args()) {
         Ok(request) => run(request.command),
         Err(error) => exit_with_error(error),
     }
 }
 
-fn run(command: Command) {
+fn run(command: cli::Command) {
     match command {
-        Command::Help => print!("{}", ariadne::help_text()),
+        cli::Command::Help => print!("{}", cli::help_text()),
     }
 }
 
-fn exit_with_error(error: CliError) -> ! {
+fn exit_with_error(error: cli::Error) -> ! {
     match error {
-        CliError::UnknownArgument { value } => eprintln!("ariadne: unknown argument: {value}"),
+        cli::Error::UnknownArgument { value } => eprintln!("ariadne: unknown argument: {value}"),
     }
     std::process::exit(2);
 }