feat: turn into multicall binary

Cargo.toml

@@ -1,8 +1,8 @@
 [package]
-name = "lix-diff"
+name = "lemon-sorbet"
 version = "1.0.1"
 license = "MIT"
-description = "A lix plugin for diffing two generations"
+description = "A lix plugin for doing sweet stuff with your derivations"
 homepage = "https://github.com/isabelroses/lix-diff"
 authors = ["Isabel Roses <isabel@isabelroses.com>"]
 edition = "2024"

package.nix

@@ -17,6 +17,14 @@ rustPlatform.buildRustPackage {
     );
   };
 
+  postInstall =
+    # Create symlinks to multicall binary
+    lib.concatMapStringsSep "\n" (bin: ''ln -sv "$out/bin/lemon-sorbet" "$out/bin/${bin}"'')
+      # For each command in `lemon-sorbet`
+      [
+        "lix-diff"
+      ];
+
   cargoLock.lockFile = ./Cargo.lock;
 
   meta = {

src/main.rs

@@ -12,9 +12,24 @@ mod versioning;
 
 use self::parser::DiffRoot;
 
-#[derive(Parser, PartialEq, Debug)]
+#[derive(Debug, Parser)]
+#[command(multicall = true)]
+#[command(name = "lemon-sorbet")]
+#[command(bin_name = "lemon-sorbet")]
+#[clap(about, version)]
+enum Cli {
+    LixDiff(LixDiffArgs),
+    /// The multicall binary command so we can call the generated binary without creating a symlink
+    /// first
+    #[command(hide = true)]
+    LemonSorbet {
+        args: Vec<String>,
+    },
+}
+
+#[derive(clap::Args, PartialEq, Debug)]
 /// List the package differences between two `NixOS` generations
-struct Args {
+struct LixDiffArgs {
     /// the path to the lix bin directory
     #[arg(short, long)]
     lix_bin: Option<PathBuf>,
@@ -27,43 +42,57 @@ struct Args {
     after: PathBuf,
 }
 
-fn main() -> Result<()> {
-    let args = Args::parse();
-    let before = args.before;
-    let after = args.after;
-    let lix_bin = args.lix_bin;
-
-    if let Some(lix_bin) = lix_bin {
-        let current_path = env::var_os("PATH").unwrap();
-        let current_path = env::split_paths(&current_path);
-        let new_path = std::iter::once(lix_bin).chain(current_path);
-        let new_path = env::join_paths(new_path).unwrap();
-        unsafe {
-            env::set_var("PATH", &new_path);
+impl LixDiffArgs {
+    fn process(self) -> Result<()> {
+        let before = self.before;
+        let after = self.after;
+        let lix_bin = self.lix_bin;
+
+        if let Some(lix_bin) = lix_bin {
+            let current_path = env::var_os("PATH").unwrap();
+            let current_path = env::split_paths(&current_path);
+            let new_path = std::iter::once(lix_bin).chain(current_path);
+            let new_path = env::join_paths(new_path).unwrap();
+            unsafe {
+                env::set_var("PATH", &new_path);
+            }
         }
-    }
 
-    if !before.exists() {
-        eprintln!("Before generation does not exist: {}", before.display());
-        std::process::exit(1);
-    }
+        if !before.exists() {
+            eprintln!("Before generation does not exist: {}", before.display());
+            std::process::exit(1);
+        }
 
-    if !after.exists() {
-        eprintln!("After generation does not exist: {}", after.display());
-        std::process::exit(1);
-    }
+        if !after.exists() {
+            eprintln!("After generation does not exist: {}", after.display());
+            std::process::exit(1);
+        }
 
-    let packages: PackageListDiff = DiffRoot::new(&before, &after)?.into();
+        let packages: PackageListDiff = DiffRoot::new(&before, &after)?.into();
 
-    let arrow_style = Style::new().bold().fg(Color::LightGray);
+        let arrow_style = Style::new().bold().fg(Color::LightGray);
 
-    let before_text = format!("<<< {}", before.display());
-    let after_text = format!(">>> {}", after.display());
+        let before_text = format!("<<< {}", before.display());
+        let after_text = format!(">>> {}", after.display());
 
-    println!("{}", arrow_style.paint(before_text));
-    println!("{}\n", arrow_style.paint(after_text));
+        println!("{}", arrow_style.paint(before_text));
+        println!("{}\n", arrow_style.paint(after_text));
 
-    println!("{packages}");
+        println!("{packages}");
 
-    Ok(())
+        Ok(())
+    }
+}
+
+impl Cli {
+    fn process(self) -> Result<()> {
+        match self {
+            Cli::LemonSorbet { args } => Cli::parse_from(args).process(),
+            Cli::LixDiff(args) => args.process(),
+        }
+    }
+}
+
+fn main() -> Result<()> {
+    Cli::parse().process()
 }