feat(ariadne): add Rust CLI skeleton

Cargo.lock

@@ -2,6 +2,10 @@
 # It is not intended for manual editing.
 version = 4
 
+[[package]]
+name = "ariadne"
+version = "0.1.0"
+
 [[package]]
 name = "machoke"
 version = "0.1.0"

Cargo.toml

@@ -1,5 +1,6 @@
 [workspace]
 members = [
+    "src/ariadne",
     "src/machoke",
 ]
 resolver = "3"

src/ariadne/BUILD

@@ -1,3 +1,27 @@
+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",
+    ],
+)
+
+rust_binary(
+    name = "ariadne",
+    crate_name = "ariadne_cli",
+    srcs = ["main.rs"],
+    deps = [":ariadne_lib"],
+)
+
+rust_test(
+    name = "ariadne_test",
+    srcs = ["lib_test.rs"],
+    deps = [":ariadne_lib"],
+)
+
 sh_binary(
     name = "extract_and_decompile",
     srcs = ["extract-and-decompile.sh"],

src/ariadne/Cargo.toml

@@ -0,0 +1,17 @@
+[package]
+name = "ariadne"
+version = "0.1.0"
+edition = "2024"
+
+[lib]
+path = "lib.rs"
+
+[[bin]]
+name = "ariadne"
+path = "main.rs"
+
+[[test]]
+name = "lib_test"
+path = "lib_test.rs"
+
+[dependencies]

src/ariadne/cli.rs

@@ -0,0 +1,22 @@
+use crate::{CliError, CliRequest, Command, COMMAND_NAME, PRODUCT_NAME};
+
+pub fn parse_args(args: impl IntoIterator<Item = String>) -> Result<CliRequest, CliError> {
+    let mut args = args.into_iter();
+    let _program = args.next();
+
+    match args.next() {
+        None => Ok(CliRequest {
+            command: Command::Help,
+        }),
+        Some(value) if value == "--help" || value == "-h" => Ok(CliRequest {
+            command: Command::Help,
+        }),
+        Some(value) => Err(CliError::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/lib.rs

@@ -0,0 +1,27 @@
+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

@@ -0,0 +1,41 @@
+use ariadne::{CliError, Command};
+
+#[test]
+fn library_names_distinguish_product_from_command() {
+    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

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