load NixOS options directly from the result set

3 files changed, 27 insertions, 39 deletions

diff --git a/cmd/nixos-search/main.go b/cmd/nixos-search/main.go
index 09c843a..7dec229 100644
--- a/cmd/nixos-search/main.go
+++ b/cmd/nixos-search/main.go
@@ -20,14 +20,9 @@ func main() {
 
         query := flag.Arg(0)
 
-        path, err := OptionsFilePath(*source)
+        options, err := LoadOptions(*source)
         if err != nil {
-                log.Fatalf("error getting the path to options.json: %v", err)
-        }
-
-        options, err := LoadOptions(path)
-        if err != nil {
-                log.Fatalf("error loading options.json: %v", err)
+                log.Fatalf("error loading options: %v", err)
         }
 
         for _, o := range options {
diff --git a/cmd/nixos-search/options.go b/cmd/nixos-search/options.go
index a7fe45e..57b6e13 100644
--- a/cmd/nixos-search/options.go
+++ b/cmd/nixos-search/options.go
@@ -2,9 +2,7 @@ package main
 
 import (
         _ "embed"
-        "encoding/json"
         "fmt"
-        "os"
         "strings"
 
         nix_search "git.sixfoisneuf.fr/nix-tools/nix"
@@ -36,38 +34,23 @@ let
   
   optionsDoc = pkgs.pkgs.buildPackages.nixosOptionsDoc { inherit options; };
 in
-optionsDoc.optionsJSON
+optionsDoc
 `
 
-func OptionsFilePath(nixpkgs string) (string, error) {
-
+func LoadOptions(nixpkgs string) ([]Option, error) {
         pkgs, err := nix_search.LoadNixpkgs(nixpkgs)
         if err != nil {
-                return "", fmt.Errorf("loading '%s': %v", nixpkgs, err)
-        }
-
-        path, err := pkgs.EvalString(optionsExpr)
-        if err != nil {
-                return "", fmt.Errorf("running Nix query: %v", err)
-        }
-
-        return path + "/share/doc/nixos/options.json", nil
-}
-
-func LoadOptions(path string) ([]Option, error) {
-        data, err := os.ReadFile(path)
-        if err != nil {
-                return nil, fmt.Errorf("reading '%s': %v", path, err)
+                return nil, fmt.Errorf("loading '%s': %v", nixpkgs, err)
         }
 
-        var res map[string]map[string]interface{}
-        err = json.Unmarshal(data, &res)
+        res, err := pkgs.EvalSet(optionsExpr)
         if err != nil {
-                return nil, fmt.Errorf("parsing JSON: %v", err)
+                return nil, fmt.Errorf("running Nix query: %v", err)
         }
 
         var options []Option
-        for option, params := range res {
+        for option, paramsTmp := range res["optionsNix"].(map[string]interface{}) {
+                params := paramsTmp.(map[string]interface{})
                 o := Option{
                         Name: option,
                 }
diff --git a/nix/eval.go b/nix/eval.go
index 778e805..d41532a 100644
--- a/nix/eval.go
+++ b/nix/eval.go
@@ -1,6 +1,7 @@
 package nix_search
 
 import (
+        "bytes"
         "encoding/json"
         "fmt"
         "os/exec"
@@ -20,15 +21,24 @@ var (
         NixFloat  NixType = "float"
 )
 
-func nixEval(path string) ([]byte, error) {
+func nixEval(path string) ([]byte, []byte, error) {
         cmd := exec.Command("nix", "eval", "--json", "--impure", "--expr", path)
-        return cmd.CombinedOutput()
+
+        stdout := bytes.Buffer{}
+        stderr := bytes.Buffer{}
+
+        cmd.Stdout = &stdout
+        cmd.Stderr = &stderr
+
+        err := cmd.Run()
+
+        return stdout.Bytes(), stderr.Bytes(), err
 }
 
 func nixEvalObject(path string) (map[string]interface{}, error) {
-        out, err := nixEval(path)
+        out, stderr, err := nixEval(path)
         if err != nil {
-                return nil, fmt.Errorf("eval '%s': %v\n\"\"\"\n%s\n\"\"\"", path, err, string(out))
+                return nil, fmt.Errorf("eval '%s': %v\n\"\"\"\n%s\n\"\"\"", path, err, string(stderr))
         }
 
         var result map[string]interface{}
@@ -41,9 +51,9 @@ func nixEvalObject(path string) (map[string]interface{}, error) {
 }
 
 func nixEvalArray(path string) ([]interface{}, error) {
-        out, err := nixEval(path)
+        out, stderr, err := nixEval(path)
         if err != nil {
-                return nil, fmt.Errorf("eval '%s': %v\n\"\"\"\n%s\n\"\"\"", path, err, string(out))
+                return nil, fmt.Errorf("eval '%s': %v\n\"\"\"\n%s\n\"\"\"", path, err, string(stderr))
         }
 
         var result []interface{}
@@ -57,9 +67,9 @@ func nixEvalArray(path string) ([]interface{}, error) {
 
 func nixEvalString(path string) (string, error) {
 
-        out, err := nixEval(path)
+        out, stderr, err := nixEval(path)
         if err != nil {
-                return "", fmt.Errorf("eval '%s': %v\n\"\"\"\n%s\n\"\"\"", path, err, string(out))
+                return "", fmt.Errorf("eval '%s': %v\n\"\"\"\n%s\n\"\"\"", path, err, string(stderr))
         }
 
         var result string