{home,nixos}: make nh commands aware of NH_OS_FLAKE and NH_HOME_FLAKE variables

Author: NotAShelf

src/home.rs

@@ -162,7 +162,14 @@ where
             ref reference,
             ref mut attribute,
         } => 'flake: {
-            // If user explicitely selects some other attribute, don't push homeConfigurations
+            // Check if we're using NH_HOME_FLAKE to give it precedence
+            if env::var("NH_HOME_FLAKE").is_ok()
+                && env::var("NH_HOME_FLAKE").unwrap() == reference.to_string()
+            {
+                debug!("Using NH_HOME_FLAKE: {}", reference);
+            }
+
+            // If user explicitly selects some other attribute, don't push homeConfigurations
             if !attribute.is_empty() {
                 break 'flake;
             }

src/installable.rs

@@ -70,7 +70,32 @@ impl FromArgMatches for Installable {
             });
         }
 
-        // env var fallacks
+        // env var fallbacks
+
+        // Check for command-specific flake env vars first
+        if let Ok(subcommand) = env::var("NH_CURRENT_COMMAND") {
+            if subcommand == "os" {
+                if let Ok(f) = env::var("NH_OS_FLAKE") {
+                    let mut elems = f.splitn(2, '#');
+                    return Ok(Self::Flake {
+                        reference: elems.next().unwrap().to_owned(),
+                        attribute: parse_attribute(
+                            elems.next().map(|s| s.to_string()).unwrap_or_default(),
+                        ),
+                    });
+                }
+            } else if subcommand == "home" {
+                if let Ok(f) = env::var("NH_HOME_FLAKE") {
+                    let mut elems = f.splitn(2, '#');
+                    return Ok(Self::Flake {
+                        reference: elems.next().unwrap().to_owned(),
+                        attribute: parse_attribute(
+                            elems.next().map(|s| s.to_string()).unwrap_or_default(),
+                        ),
+                    });
+                }
+            }
+        }
 
         if let Ok(f) = env::var("NH_FLAKE") {
             let mut elems = f.splitn(2, '#');
@@ -80,10 +105,26 @@ impl FromArgMatches for Installable {
             });
         }
 
+        if let Ok(f) = env::var("NH_OS_FLAKE") {
+            let mut elems = f.splitn(2, '#');
+            return Ok(Self::Flake {
+                reference: elems.next().unwrap().to_owned(),
+                attribute: parse_attribute(elems.next().map(|s| s.to_string()).unwrap_or_default()),
+            });
+        }
+
+        if let Ok(f) = env::var("NH_HOME_FLAKE") {
+            let mut elems = f.splitn(2, '#');
+            return Ok(Self::Flake {
+                reference: elems.next().unwrap().to_owned(),
+                attribute: parse_attribute(elems.next().map(|s| s.to_string()).unwrap_or_default()),
+            });
+        }
+
         if let Ok(f) = env::var("NH_FILE") {
             return Ok(Self::File {
                 path: PathBuf::from(f),
-                attribute: parse_attribute(env::var("NH_ATTR").unwrap_or_default()),
+                attribute: parse_attribute(env::var("NH_ATTRP").unwrap_or_default()),
             });
         }
 
@@ -124,11 +165,13 @@ Nix accepts various kinds of installables:
 [FLAKEREF[#ATTRPATH]]
     Flake reference with an optional attribute path.
     [env: NH_FLAKE={}]
+    [env: NH_OS_FLAKE={}]
+    [env: NH_HOME_FLAKE={}]
 
 {}, {} <FILE> [ATTRPATH]
     Path to file with an optional attribute path.
     [env: NH_FILE={}]
-    [env: NH_ATTR={}]
+    [env: NH_ATTRP={}]
 
 {}, {} <EXPR> [ATTRPATH]
     Nix expression with an optional attribute path.
@@ -137,10 +180,12 @@ Nix accepts various kinds of installables:
     Path or symlink to a /nix/store path
 "#,
                     env::var("NH_FLAKE").unwrap_or_default(),
+                    env::var("NH_OS_FLAKE").unwrap_or_default(),
+                    env::var("NH_HOME_FLAKE").unwrap_or_default(),
                     "-f".yellow(),
                     "--file".yellow(),
                     env::var("NH_FILE").unwrap_or_default(),
-                    env::var("NH_ATTRP").unwrap_or_default(),
+                    env::var("NH_ATTR").unwrap_or_default(),
                     "-e".yellow(),
                     "--expr".yellow(),
                 )),

src/nixos.rs

@@ -1,3 +1,4 @@
+use std::env;
 use std::fs;
 use std::path::{Path, PathBuf};
 
@@ -177,8 +178,17 @@ pub fn toplevel_for<S: AsRef<str>>(hostname: S, installable: Installable) -> Ins
 
     match res {
         Installable::Flake {
-            ref mut attribute, ..
+            ref reference,
+            ref mut attribute,
+            ..
         } => {
+            // Check if using NH_OS_FLAKE
+            if let Ok(os_flake) = env::var("NH_OS_FLAKE") {
+                if os_flake == *reference {
+                    debug!("Using NH_OS_FLAKE: {}", reference);
+                }
+            }
+
             // If user explicitly selects some other attribute, don't push nixosConfigurations
             if attribute.is_empty() {
                 attribute.push(String::from("nixosConfigurations"));