FIXME

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "nh"
-version = "3.5.25"
+version = "4.0.0-alpha.1"
 edition = "2021"
 license = "EUPL-1.2"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

src/installables.rs

@@ -0,0 +1,95 @@
+use core::fmt;
+use std::fmt::Write;
+
+#[derive(Debug, Clone)]
+pub enum Installable {
+    Flake(FlakeInstallable),
+}
+
+#[derive(Debug, Clone)]
+pub struct FlakeInstallable {
+    pub reference: String,
+    pub attribute: Vec<String>,
+}
+
+impl From<&str> for Installable {
+    fn from(value: &str) -> Self {
+        todo!()
+    }
+}
+
+impl Installable {
+    pub fn flake<S>(reference: S, attribute: &[S]) -> Self
+    where
+        S: AsRef<str>,
+    {
+        Installable::Flake(FlakeInstallable {
+            reference: reference.as_ref().to_string(),
+            attribute: attribute.iter().map(|s| s.as_ref().to_string()).collect(),
+        })
+    }
+
+    pub fn to_args(&self) -> Vec<String> {
+        let mut res = Vec::new();
+
+        match &self {
+            Installable::Flake(flake) => {
+                let mut f = String::new();
+                write!(f, "{}", flake.reference).unwrap();
+
+                if !flake.attribute.is_empty() {
+                    write!(f, "#").unwrap();
+
+                    let mut first = true;
+
+                    for elem in &flake.attribute {
+                        if !first {
+                            write!(f, ".").unwrap();
+                        }
+
+                        if elem.contains('.') {
+                            write!(f, r#""{}""#, elem).unwrap();
+                        } else {
+                            write!(f, "{}", elem).unwrap();
+                        }
+
+                        first = false;
+                    }
+
+                    res.push(f);
+                }
+            }
+        }
+
+        return res;
+    }
+}
+
+impl fmt::Display for Installable {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let mut first = true;
+
+        for elem in self.to_args() {
+            if !first {
+                write!(f, " ")?;
+            } else {
+                first = false;
+            }
+
+            write!(f, "{}", elem)?;
+        }
+
+        Ok(())
+    }
+}
+
+#[test]
+fn test_display() {
+    let installable = Installable::flake(".", &["foo", "bar.local", "baz"]);
+
+    let args = installable.to_args();
+    assert_eq!(args, vec![String::from(".#foo.\"bar.local\".baz")]);
+
+    let displayed = format!("{}", installable);
+    assert_eq!(".#foo.\"bar.local\".baz", displayed);
+}

src/interface.rs

@@ -4,6 +4,8 @@ use clap::{builder::Styles, Args, Parser, Subcommand};
 use color_eyre::Result;
 use std::{ffi::OsString, ops::Deref, path::PathBuf};
 
+use crate::installables::Installable;
+
 #[derive(Debug, Clone, Default)]
 pub struct FlakeRef(String);
 impl From<&str> for FlakeRef {
@@ -61,7 +63,6 @@ pub trait NHRunnable {
 #[command(disable_help_subcommand = true)]
 pub enum NHCommand {
     Os(OsArgs),
-    Home(HomeArgs),
     Search(SearchArgs),
     Clean(CleanProxy),
     Completions(CompletionArgs),
@@ -130,7 +131,7 @@ pub struct CommonRebuildArgs {
 
     /// Flake reference to build
     #[arg(env = "FLAKE", value_hint = clap::ValueHint::DirPath)]
-    pub flakeref: FlakeRef,
+    pub installable: Installable,
 
     /// Update flake inputs before building specified configuration
     #[arg(long, short = 'u')]

src/main.rs

@@ -1,7 +1,7 @@
 mod clean;
 mod commands;
 mod completion;
-mod home;
+mod installables;
 mod interface;
 mod json;
 mod logging;