Merge remote-tracking branch 'origin/master' into coerce-string

1 files changed, 27 insertions, 40 deletions

diff --git a/src/nix/show-derivation.cc b/src/nix/show-derivation.cc
index fb46b4dbf..af2e676a4 100644
--- a/src/nix/show-derivation.cc
+++ b/src/nix/show-derivation.cc
@@ -5,10 +5,11 @@
 #include "common-args.hh"
 #include "store-api.hh"
 #include "archive.hh"
-#include "json.hh"
 #include "derivations.hh"
+#include <nlohmann/json.hpp>
 
 using namespace nix;
+using json = nlohmann::json;
 
 struct CmdShowDerivation : InstallablesCommand
 {
@@ -48,77 +49,63 @@ struct CmdShowDerivation : InstallablesCommand
             drvPaths = std::move(closure);
         }
 
-        {
-
-        JSONObject jsonRoot(std::cout, true);
+        json jsonRoot = json::object();
 
         for (auto & drvPath : drvPaths) {
             if (!drvPath.isDerivation()) continue;
 
-            auto drvObj(jsonRoot.object(store->printStorePath(drvPath)));
+            json& drvObj = jsonRoot[store->printStorePath(drvPath)];
 
             auto drv = store->readDerivation(drvPath);
 
             {
-                auto outputsObj(drvObj.object("outputs"));
+                json& outputsObj = drvObj["outputs"];
+                outputsObj = json::object();
                 for (auto & [_outputName, output] : drv.outputs) {
                     auto & outputName = _outputName; // work around clang bug
-                    auto outputObj { outputsObj.object(outputName) };
+                    auto& outputObj = outputsObj[outputName];
+                    outputObj = json::object();
                     std::visit(overloaded {
                         [&](const DerivationOutput::InputAddressed & doi) {
-                            outputObj.attr("path", store->printStorePath(doi.path));
+                            outputObj["path"] = store->printStorePath(doi.path);
                         },
                         [&](const DerivationOutput::CAFixed & dof) {
-                            outputObj.attr("path", store->printStorePath(dof.path(*store, drv.name, outputName)));
-                            outputObj.attr("hashAlgo", dof.hash.printMethodAlgo());
-                            outputObj.attr("hash", dof.hash.hash.to_string(Base16, false));
+                            outputObj["path"] = store->printStorePath(dof.path(*store, drv.name, outputName));
+                            outputObj["hashAlgo"] = dof.hash.printMethodAlgo();
+                            outputObj["hash"] = dof.hash.hash.to_string(Base16, false);
                         },
                         [&](const DerivationOutput::CAFloating & dof) {
-                            outputObj.attr("hashAlgo", makeFileIngestionPrefix(dof.method) + printHashType(dof.hashType));
+                            outputObj["hashAlgo"] = makeFileIngestionPrefix(dof.method) + printHashType(dof.hashType);
                         },
                         [&](const DerivationOutput::Deferred &) {},
                         [&](const DerivationOutput::Impure & doi) {
-                            outputObj.attr("hashAlgo", makeFileIngestionPrefix(doi.method) + printHashType(doi.hashType));
-                            outputObj.attr("impure", true);
+                            outputObj["hashAlgo"] = makeFileIngestionPrefix(doi.method) + printHashType(doi.hashType);
+                            outputObj["impure"] = true;
                         },
                     }, output.raw());
                 }
             }
 
             {
-                auto inputsList(drvObj.list("inputSrcs"));
+                auto& inputsList = drvObj["inputSrcs"];
+                inputsList = json::array();
                 for (auto & input : drv.inputSrcs)
-                    inputsList.elem(store->printStorePath(input));
-            }
-
-            {
-                auto inputDrvsObj(drvObj.object("inputDrvs"));
-                for (auto & input : drv.inputDrvs) {
-                    auto inputList(inputDrvsObj.list(store->printStorePath(input.first)));
-                    for (auto & outputId : input.second)
-                        inputList.elem(outputId);
-                }
+                    inputsList.emplace_back(store->printStorePath(input));
             }
 
-            drvObj.attr("system", drv.platform);
-            drvObj.attr("builder", drv.builder);
-
             {
-                auto argsList(drvObj.list("args"));
-                for (auto & arg : drv.args)
-                    argsList.elem(arg);
+                auto& inputDrvsObj = drvObj["inputDrvs"];
+                inputDrvsObj = json::object();
+                for (auto & input : drv.inputDrvs)
+                    inputDrvsObj[store->printStorePath(input.first)] = input.second;
             }
 
-            {
-                auto envObj(drvObj.object("env"));
-                for (auto & var : drv.env)
-                    envObj.attr(var.first, var.second);
-            }
+            drvObj["system"] = drv.platform;
+            drvObj["builder"] = drv.builder;
+            drvObj["args"] = drv.args;
+            drvObj["env"] = drv.env;
         }
-
-        }
-
-        std::cout << "\n";
+        std::cout << jsonRoot.dump(2) << std::endl;
     }
 };