installable: make installable attribute be a String

There is no point in making the attribute of an
Installable be a Vec. Attributes can are used in one of:
- Flake: FLAKEREF#ATTRIBUTE:
  Here, we cannot pass multiple attributes anyways.

- File, Expression:
  The Nix expression (in that file), or any selected attribute,
  must evaluate to a derivation.

It is fine to only accept a single attribute here,
since no one is going to add several attributes corresponding
to {nixos,home,darwin}Configurations, here.

Author: faukah

src/commands.rs

@@ -1124,7 +1124,7 @@ mod tests {
   fn test_build_new() {
     let installable = Installable::Flake {
       reference: "github:user/repo".to_string(),
-      attribute: vec!["package".to_string()],
+      attribute: "package".to_string(),
     };
 
     let build = Build::new(installable.clone());
@@ -1140,7 +1140,7 @@ mod tests {
   fn test_build_builder_pattern() {
     let installable = Installable::Flake {
       reference: "github:user/repo".to_string(),
-      attribute: vec!["package".to_string()],
+      attribute: "package".to_string(),
     };
 
     let build = Build::new(installable)

src/darwin.rs

@@ -86,10 +86,7 @@ impl DarwinRebuildArgs {
         Some(r) => r.to_owned(),
         None => return Err(eyre!("NH_DARWIN_FLAKE missing reference part")),
       };
-      let attribute = elems
-        .next()
-        .map(crate::installable::parse_attribute)
-        .unwrap_or_default();
+      let attribute = elems.next().unwrap_or_default().to_string();
 
       Installable::Flake {
         reference,
@@ -107,8 +104,7 @@ impl DarwinRebuildArgs {
       // If user explicitly selects some other attribute, don't push
       // darwinConfigurations
       if attribute.is_empty() {
-        attribute.push(String::from("darwinConfigurations"));
-        attribute.push(hostname.clone());
+        *attribute = format!("darwinConfigurations.{hostname}");
       }
     }
 
@@ -205,10 +201,7 @@ impl DarwinReplArgs {
           Some(r) => r.to_owned(),
           None => return Err(eyre!("NH_DARWIN_FLAKE missing reference part")),
         };
-        let attribute = elems
-          .next()
-          .map(crate::installable::parse_attribute)
-          .unwrap_or_default();
+        let attribute = elems.next().unwrap_or_default().to_string();
 
         Installable::Flake {
           reference,
@@ -229,8 +222,7 @@ impl DarwinReplArgs {
     } = target_installable
     {
       if attribute.is_empty() {
-        attribute.push(String::from("darwinConfigurations"));
-        attribute.push(hostname);
+        *attribute = format!("darwinConfigurations.{hostname}");
       }
     }
 

src/home.rs

@@ -69,10 +69,7 @@ impl HomeRebuildArgs {
         Some(r) => r.to_owned(),
         None => return Err(eyre!("NH_HOME_FLAKE missing reference part")),
       };
-      let attribute = elems
-        .next()
-        .map(crate::installable::parse_attribute)
-        .unwrap_or_default();
+      let attribute = elems.next().unwrap_or_default().to_string();
 
       Installable::Flake {
         reference,
@@ -223,7 +220,7 @@ where
         return Ok(res);
       }
 
-      attribute.push(String::from("homeConfigurations"));
+      *attribute = String::from("homeConfigurations");
 
       let flake_reference = reference.clone();
       let mut found_config = false;
@@ -254,7 +251,7 @@ where
         if check_res.map(|s| s.trim().to_owned()).as_deref() == Some("true") {
           debug!("Using explicit configuration from flag: {config_name:?}");
 
-          attribute.push(config_name);
+          attribute.push_str(&config_name);
           if push_drv {
             attribute.extend(toplevel.clone());
           }
@@ -264,7 +261,7 @@ where
           // Explicit config provided but not found
           let tried_attr_path = {
             let mut attr_path = attribute.clone();
-            attr_path.push(config_name);
+            attr_path.push_str(&config_name);
             Installable::Flake {
               reference: flake_reference,
               attribute: attr_path,
@@ -309,7 +306,7 @@ where
 
           let current_try_attr = {
             let mut attr_path = attribute.clone();
-            attr_path.push(attr_name.clone());
+            attr_path.push_str(&attr_name);
             attr_path
           };
           tried.push(current_try_attr.clone());
@@ -318,7 +315,7 @@ where
             check_res.map(|s| s.trim().to_owned()).as_deref()
           {
             debug!("Using automatically detected configuration: {}", attr_name);
-            attribute.push(attr_name);
+            attribute.push_str(&attr_name);
             if push_drv {
               attribute.extend(toplevel.clone());
             }
@@ -379,10 +376,7 @@ impl HomeReplArgs {
         Some(r) => r.to_owned(),
         None => return Err(eyre!("NH_HOME_FLAKE missing reference part")),
       };
-      let attribute = elems
-        .next()
-        .map(crate::installable::parse_attribute)
-        .unwrap_or_default();
+      let attribute = elems.next().unwrap_or_default().to_string();
 
       Installable::Flake {
         reference,

src/installable.rs

@@ -10,18 +10,18 @@ use yansi::{Color, Paint};
 pub enum Installable {
   Flake {
     reference: String,
-    attribute: Vec<String>,
+    attribute: String,
   },
   File {
     path:      PathBuf,
-    attribute: Vec<String>,
+    attribute: String,
   },
   Store {
     path: PathBuf,
   },
   Expression {
     expression: String,
-    attribute:  Vec<String>,
+    attribute:  String,
   },
 }
 
@@ -51,14 +51,14 @@ impl FromArgMatches for Installable {
     if let Some(f) = file {
       return Ok(Self::File {
         path:      PathBuf::from(f),
-        attribute: parse_attribute(installable.cloned().unwrap_or_default()),
+        attribute: installable.cloned().unwrap_or_default(),
       });
     }
 
     if let Some(e) = expr {
       return Ok(Self::Expression {
         expression: e.to_string(),
-        attribute:  parse_attribute(installable.cloned().unwrap_or_default()),
+        attribute:  installable.cloned().unwrap_or_default(),
       });
     }
 
@@ -67,12 +67,10 @@ impl FromArgMatches for Installable {
       let reference = elems.next().unwrap().to_owned();
       return Ok(Self::Flake {
         reference,
-        attribute: parse_attribute(
-          elems
-            .next()
-            .map(std::string::ToString::to_string)
-            .unwrap_or_default(),
-        ),
+        attribute: elems
+          .next()
+          .map(std::string::ToString::to_string)
+          .unwrap_or_default(),
       });
     }
 
@@ -82,12 +80,10 @@ impl FromArgMatches for Installable {
         let mut elems = f.splitn(2, '#');
         Installable::Flake {
           reference: elems.next().unwrap().to_owned(),
-          attribute: parse_attribute(
-            elems
-              .next()
-              .map(std::string::ToString::to_string)
-              .unwrap_or_default(),
-          ),
+          attribute: elems
+            .next()
+            .map(std::string::ToString::to_string)
+            .unwrap_or_default(),
         }
       })
     }
@@ -124,7 +120,7 @@ impl FromArgMatches for Installable {
     if let Ok(f) = env::var("NH_FILE") {
       return Ok(Self::File {
         path:      PathBuf::from(f),
-        attribute: parse_attribute(env::var("NH_ATTRP").unwrap_or_default()),
+        attribute: env::var("NH_ATTRP").unwrap_or_default(),
       });
     }
 
@@ -206,82 +202,35 @@ Nix accepts various kinds of installables:
   }
 }
 
-// TODO: should handle quoted attributes, like foo."bar.baz" -> ["foo",
-// "bar.baz"] maybe use chumsky?
-pub fn parse_attribute<S>(s: S) -> Vec<String>
-where
-  S: AsRef<str>,
-{
-  let s = s.as_ref();
-  let mut res = Vec::new();
-
-  if s.is_empty() {
-    return res;
-  }
-
-  let mut in_quote = false;
-
-  let mut elem = String::new();
-  for char in s.chars() {
-    match char {
-      '.' => {
-        if in_quote {
-          elem.push(char);
-        } else {
-          res.push(elem.clone());
-          elem = String::new();
-        }
-      },
-      '"' => {
-        in_quote = !in_quote;
-      },
-      _ => elem.push(char),
-    }
-  }
-
-  res.push(elem);
-
-  assert!(!in_quote, "Failed to parse attribute: {s}");
-
-  res
-}
-
-#[test]
-fn test_parse_attribute() {
-  assert_eq!(parse_attribute(r"foo.bar"), vec!["foo", "bar"]);
-  assert_eq!(parse_attribute(r#"foo."bar.baz""#), vec!["foo", "bar.baz"]);
-  let v: Vec<String> = vec![];
-  assert_eq!(parse_attribute(""), v);
-}
-
 impl Installable {
   #[must_use]
   pub fn to_args(&self) -> Vec<String> {
-    let mut res = Vec::new();
     match self {
       Self::Flake {
         reference,
         attribute,
       } => {
-        res.push(format!("{reference}#{}", join_attribute(attribute)));
+        vec![format!("{reference}#{attribute}")]
       },
       Self::File { path, attribute } => {
-        res.push(String::from("--file"));
-        res.push(path.to_str().unwrap().to_string());
-        res.push(join_attribute(attribute));
+        vec![
+          String::from("--file"),
+          path.to_str().unwrap().to_string(),
+          attribute.to_string(),
+        ]
       },
       Self::Expression {
         expression,
         attribute,
       } => {
-        res.push(String::from("--expr"));
-        res.push(expression.to_string());
-        res.push(join_attribute(attribute));
+        vec![
+          String::from("--expr"),
+          expression.to_string(),
+          attribute.to_string(),
+        ]
       },
-      Self::Store { path } => res.push(path.to_str().unwrap().to_string()),
+      Self::Store { path } => vec![path.to_str().unwrap().to_string()],
     }
-
-    res
   }
 }
 
@@ -306,38 +255,6 @@ fn test_installable_to_args() {
   );
 }
 
-fn join_attribute<I>(attribute: I) -> String
-where
-  I: IntoIterator,
-  I::Item: AsRef<str>,
-{
-  let mut res = String::new();
-  let mut first = true;
-  for elem in attribute {
-    if first {
-      first = false;
-    } else {
-      res.push('.');
-    }
-
-    let s = elem.as_ref();
-
-    if s.contains('.') {
-      res.push_str(&format!(r#""{s}""#));
-    } else {
-      res.push_str(s);
-    }
-  }
-
-  res
-}
-
-#[test]
-fn test_join_attribute() {
-  assert_eq!(join_attribute(vec!["foo", "bar"]), "foo.bar");
-  assert_eq!(join_attribute(vec!["foo", "bar.baz"]), r#"foo."bar.baz""#);
-}
-
 impl Installable {
   #[must_use]
   pub const fn str_kind(&self) -> &str {