WIP: expose flake directory to nix fmt as FLAKE_DIR env var

This was discussed in #8034. I
personally like `FLAKE_DIR`, which hopefully avoids some ambiguity around
with subflakes.

I only implemented this for `nix fmt` because it doesn't let you point
at a flake not on your filesystem.

This is in a bit of a rough state. I left conflict markers (`<<<`) anywhere I
did something in need of cleanup.

Author: jfly

src/nix/formatter-run.md

@@ -8,6 +8,9 @@ Flags can be forwarded to the formatter by using `--` followed by the flags.
 
 Any arguments will be forwarded to the formatter. Typically these are the files to format.
 
+The environment variable `FLAKE_DIR` will be set to the absolute path to the
+directory containing the flake's `flake.nix`.
+
 
 # Example
 

src/nix/formatter.cc

@@ -7,6 +7,28 @@
 
 using namespace nix;
 
+//<<< where should this go?
+Environment getEnvironment()
+{
+    Environment env;
+
+    for (char **envp = environ; *envp != NULL; ++envp) {
+        std::string envStr = *envp;
+        size_t equalsIndex = envStr.find("=");
+
+        if(equalsIndex == std::string::npos) {
+            throw Error("invalid environment variable %s', must contain '='", envStr);
+        }
+
+        std::string key = envStr.substr(0, equalsIndex);
+        std::string value = envStr.substr(equalsIndex + 1);
+        env[key] = value;
+    }
+
+    return env;
+}
+//<<<
+
 struct CmdFormatter : NixMultiCommand
 {
     CmdFormatter()
@@ -72,6 +94,12 @@ struct CmdFormatterRun : MixFormatter, MixJSON
         auto evalState = getEvalState();
         auto evalStore = getEvalStore();
 
+        auto flakeRef = parseFlakeRef(fetchSettings, ".", std::filesystem::current_path().string());
+        auto flakeUrl = flakeRef.input.toURL();
+        // TODO: <<< is there a more future-proof way to assert that this flake is on the file system? >>>
+        assert(flakeUrl.scheme == "path" || flakeUrl.scheme == "git+file");
+        auto flakeDir = flakeUrl.path;
+
         auto installable_ = parseInstallable(store, ".");
         auto & installable = InstallableValue::require(*installable_);
         auto app = installable.toApp(*evalState).resolve(evalStore, store);
@@ -87,7 +115,12 @@ struct CmdFormatterRun : MixFormatter, MixJSON
         // we are about to exec out of this process without running C++ destructors.
         evalState->evalCaches.clear();
 
-        execProgramInStore(store, UseLookupPath::DontUse, app.program, programArgs);
+        Environment env = getEnvironment();
+        env["FLAKE_DIR"] = flakeDir;
+
+        execProgramInStore(store, UseLookupPath::DontUse, app.program, programArgs,
+                           "", // <<< is there a cleaner way of passing the default value?
+                           env);
     };
 };
 

src/nix/run.cc

@@ -10,6 +10,7 @@
 #include "nix/util/finally.hh"
 #include "nix/util/source-accessor.hh"
 #include "nix/expr/eval.hh"
+#include "nix/util/util.hh"
 #include <filesystem>
 
 #ifdef __linux__
@@ -27,14 +28,39 @@ std::string chrootHelperName = "__run_in_chroot";
 
 namespace nix {
 
+//<<< code copied (and modified) from src/libstore/unix/build/derivation-builder.cc
+Strings toEnvp(Environment env)
+{
+    /* Convert `env` to a list of strings suitable for `execve`'s `envp` argument. */
+    Strings envStrs;
+    for (auto & i : env) {
+        envStrs.push_back(i.first + "=" + i.second);
+    }
+
+    return envStrs;
+}
+//<<<
+
 void execProgramInStore(ref<Store> store,
     UseLookupPath useLookupPath,
     const std::string & program,
     const Strings & args,
-    std::optional<std::string_view> system)
+    std::optional<std::string_view> system,
+    std::optional<Environment> env)
 {
     logger->stop();
 
+    char **envp;
+    Strings envStrs;
+    std::vector<char *> envCharPtrs;
+    if (env.has_value()) {
+        envStrs = toEnvp(env.value());
+        envCharPtrs = stringsToCharPtrs(envStrs);
+        envp = envCharPtrs.data();
+    } else {
+        envp = environ;
+    }
+
     restoreProcessContext();
 
     /* If this is a diverted store (i.e. its "logical" location
@@ -54,7 +80,7 @@ void execProgramInStore(ref<Store> store,
         Strings helperArgs = { chrootHelperName, store->storeDir, store2->getRealStoreDir(), std::string(system.value_or("")), program };
         for (auto & arg : args) helperArgs.push_back(arg);
 
-        execv(getSelfExe().value_or("nix").c_str(), stringsToCharPtrs(helperArgs).data());
+        execve(getSelfExe().value_or("nix").c_str(), stringsToCharPtrs(helperArgs).data(), envp);
 
         throw SysError("could not execute chroot helper");
     }
@@ -65,9 +91,9 @@ void execProgramInStore(ref<Store> store,
 #endif
 
     if (useLookupPath == UseLookupPath::Use)
-        execvp(program.c_str(), stringsToCharPtrs(args).data());
+        execvpe(program.c_str(), stringsToCharPtrs(args).data(), envp);
     else
-        execv(program.c_str(), stringsToCharPtrs(args).data());
+        execve(program.c_str(), stringsToCharPtrs(args).data(), envp);
 
     throw SysError("unable to execute '%s'", program);
 }

src/nix/run.hh

@@ -10,10 +10,15 @@ enum struct UseLookupPath {
     DontUse
 };
 
+//<<< code copied (and modified) from src/libstore/unix/build/derivation-builder.cc
+typedef std::map<std::string, std::string> Environment;
+//<<<
+
 void execProgramInStore(ref<Store> store,
     UseLookupPath useLookupPath,
     const std::string & program,
     const Strings & args,
-    std::optional<std::string_view> system = std::nullopt);
+    std::optional<std::string_view> system = std::nullopt,
+    std::optional<Environment> env = std::nullopt);
 
 }

tests/functional/formatter.sh

@@ -35,12 +35,12 @@ cat << EOF > flake.nix
 EOF
 
 # No arguments check
-[[ "$(nix fmt)" = "Formatting(0):" ]]
-[[ "$(nix formatter run)" = "Formatting(0):" ]]
+[[ "$(nix fmt)" = "FLAKE_DIR=$TEST_HOME Formatting(0):" ]]
+[[ "$(nix formatter run)" = "FLAKE_DIR=$TEST_HOME Formatting(0):" ]]
 
 # Argument forwarding check
-nix fmt ./file ./folder | grep 'Formatting(2): ./file ./folder'
-nix formatter run ./file ./folder | grep 'Formatting(2): ./file ./folder'
+nix fmt ./file ./folder | grep "FLAKE_DIR=$TEST_HOME Formatting(2): ./file ./folder"
+nix formatter run ./file ./folder | grep "FLAKE_DIR=$TEST_HOME Formatting(2): ./file ./folder"
 
 # Build checks
 ## Defaults to a ./result.

tests/functional/formatter.simple.sh

@@ -1,2 +1,2 @@
 #!/usr/bin/env bash
-echo "Formatting(${#}):" "${@}"
+echo "FLAKE_DIR=$FLAKE_DIR Formatting(${#}):" "${@}"