Make the hooks more verbose

doc/filegen.md

@@ -29,7 +29,10 @@ This has two main advantages:
 
 ## Usage
 
-To re-generate the files run:
+The files specified in `files.*` are regenerated automatically when entering
+the devshell (unless `filegen_hook` is set to false).
+
+They can also be regenerated manually with:
 
 ```bash
 nix run .#regenerate-files

lib/files.ncl

@@ -12,7 +12,18 @@ let nix = import "./nix-interop/nix.ncl" in
       | doc m%"
         The content of the file.
       "%
-      | nix.derivation.NixString,
+      | nix.derivation.NullOr nix.derivation.NixString
+      | default
+      = null,
+    file
+      | doc "File from which to read the body of the script"
+      | nix.derivation.NullOr nix.derivation.NixString
+      | default
+      =
+        if content == null then
+          null
+        else
+          nix.builtins.to_file "generated-content" content,
     materialisation_method
       : [| 'Symlink, 'Copy |]
       | doc m%"
@@ -39,7 +50,25 @@ let nix = import "./nix-interop/nix.ncl" in
         Set of files that should be generated in the project's directory.
       "%
       = {},
+    filegen_hook.enable
+      | Bool
+      | doc m%"
+        Enable a hook that will automatically regenerate the files managed by
+        Nickel when entering the shell.
+      "%
+      | default
+      = true,
     flake.apps.regenerate-files.program = nix-s%"%{regenerate_files files}/bin/regenerate-files"%,
+
+    shells.build.hooks =
+      if filegen_hook.enable then
+        {
+          filegen_hook.content = nix-s%"
+            %{regenerate_files files}/bin/regenerate-files
+          "%
+        }
+      else
+        {},
   },
 
   regenerate_files | Files -> nix.derivation.Derivation = fun files_to_generate =>
@@ -53,17 +82,17 @@ let nix = import "./nix-interop/nix.ncl" in
             }
               file_descr.materialisation_method
           in
-          let file_in_store =
-            nix.builtins.to_file
-              (nix.utils.escape_drv_name key)
-              file_content
-          in
           nix-s%"
-            rm -f %{target}
-            echo "Regenerating %{target}"
-	    target_dir=$(dirname %{target})
-	    test "${target_dir}" != "." && mkdir -p "${target_dir}"
-            %{copy_command} %{file_in_store} %{target}
+            if [[ ! -f "%{target}" ]] || [[ $(cat "%{target}") != $(cat "%{file_descr.file}") ]]; then
+              echo "Regenerating %{target}"
+              rm -f %{target}
+              target_dir=$(dirname "%{target}")
+              test "${target_dir}" != "." && mkdir -p "${target_dir}"
+              # XXX: If `source.file` is set explicitely to a relative path
+              # and `materialisation_method` is `'Symlink`, this will link to the
+              # original file, not one in the store. Not sure that's what we want.
+              %{copy_command} "%{file_descr.file}" "%{target}"
+            fi
           "%
         in
       {

lib/lib.nix

@@ -167,23 +167,19 @@
       passAsFile = ["expectedLockfileContents"];
     } (
       if needNewLockfile
-      then
-        lib.warn ''
-          Lockfile contents are outdated. Please run "nix run .#regenerate-lockfile" to update them.
-        ''
-        ''
-          cp -r "${sources}" sources
-          if [ -f sources/nickel.lock.ncl ]; then
-            chmod +w sources sources/nickel.lock.ncl
-          else
-            chmod +w sources
-          fi
-          cp $expectedLockfileContentsPath sources/nickel.lock.ncl
-          cat > eval.ncl <<EOF
-          ${nickelWithImports "sources"}
-          EOF
-          ${nickel}/bin/nickel export eval.ncl > $out
-        ''
+      then ''
+        cp -r "${sources}" sources
+        if [ -f sources/nickel.lock.ncl ]; then
+          chmod +w sources sources/nickel.lock.ncl
+        else
+          chmod +w sources
+        fi
+        cp $expectedLockfileContentsPath sources/nickel.lock.ncl
+        cat > eval.ncl <<EOF
+        ${nickelWithImports "sources"}
+        EOF
+        ${nickel}/bin/nickel export eval.ncl > $out
+      ''
       else ''
         cat > eval.ncl <<EOF
         ${nickelWithImports sources}
@@ -210,9 +206,17 @@
     nickelResult = callNickel {
       inherit nickelFile baseDir flakeInputs lockFileContents;
     };
+    enrichedFlakeInputs =
+      flakeInputs
+      // {
+        # XXX: Hack to pass the lockfile path to the Nickel world, so that
+        # we can point `files."nickel.lock.ncl"` to it and have it regenerated
+        # automatically.
+        "%%organist_internal".nickelLock = builtins.toFile "nickel.lock.ncl" (buildLockFileContents lockFileContents);
+      };
   in
     {rawNickel = nickelResult;}
-    // (importFromNickel flakeInputs system baseDir (builtins.fromJSON
+    // (importFromNickel enrichedFlakeInputs system baseDir (builtins.fromJSON
         (builtins.unsafeDiscardStringContext (builtins.readFile nickelResult))));
 in {
   inherit

lib/lockfile.ncl

@@ -0,0 +1,8 @@
+let filegen = import "files.ncl" in
+let nix = import "nix-interop/nix.ncl" in
+{
+  Schema =
+    {
+      files."nickel.lock.ncl".file = nix.import_nix "%%organist_internal#nickelLock",
+    } | filegen.Schema,
+}

lib/nix-interop/builders.ncl

@@ -76,29 +76,6 @@ in
       }
         | NickelPkg,
 
-  Shell
-    | doc m%"
-      A derivation that is to be used as a shell, e.g. with `nix develop`.
-      Analogous to `mkShell`.
-    "%
-    =
-      NixpkgsPkg
-      & {
-        hooks | doc "Bash scripts to run when entering the shell" = {},
-
-        name | default = "shell",
-        version | default = "dev",
-        packages | doc "Packages to be added to the shell, setting PATH, LD_LIBRARY_PATH and other variables as needed" = {},
-
-        env.buildCommand = nix-s%"
-          echo "This derivation is not supposed to be built" 1>&2 1>/dev/null
-          exit 1
-        "%,
-        env.shellHook = concat_strings_sep "\n" (std.record.values hooks),
-        structured_env.nativeBuildInputs = packages,
-      }
-        | NickelPkg,
-
   ShellApplication
     | doc m%"
       A derivation that writes contents of `content.file` to `bin/$name` in the output and makes it executable.

lib/nix-interop/shells.ncl

@@ -1,4 +1,3 @@
-let builders = import "builders.ncl" in
 let nix_builtins = import "builtins.ncl" in
 
 let concat_strings_sep = fun sep values =>
@@ -9,6 +8,7 @@ let concat_strings_sep = fun sep values =>
 in
 
 {
+  Base = import "./shells/base.ncl",
   Bash = import "./shells/bash.ncl",
   Rust = import "./shells/rust.ncl",
 
@@ -95,9 +95,9 @@ in
       build.packages.opam = nix_builtins.import_nix "nixpkgs#opam",
       dev.packages.ocaml-lsp = nix_builtins.import_nix "nixpkgs#ocamlPackages.ocaml-lsp",
 
-      dev.hooks.enter_opam_env = m%"
+      dev.hooks.enter_opam_env.content = m%"
         echo "==> Reloading the OPAM environment."
-        echo "==> Set 'shells.dev.hooks.enter_opam_env' to false to disable."
+        echo "==> Set 'shells.dev.hooks.enter_opam_env' to `""` to disable."
         eval $(opam env)
       "%,
     },

lib/nix-interop/shells/base.ncl

@@ -0,0 +1,82 @@
+let builders = import "../builders.ncl" in
+let derivation = import "../derivation.ncl" in
+
+let Hook = {
+  name
+    | doc m%"
+        The name of the hook.
+        If null, defaults to the attribute name.
+      "%
+    | String
+    | optional,
+  enabled
+    | doc m%"
+      Whether to run the hook
+    "%
+    | Bool
+    | default
+    = true,
+  verbose
+    | doc m%"
+      Whether to announce when the hook runs
+    "%
+    | Bool
+    | default
+    = true,
+  content
+    | doc m%"
+        The bash snippet to run
+      "%
+    | derivation.NixString,
+}
+in
+let concat_strings_sep = fun sep values =>
+  if std.array.length values == 0 then
+    ""
+  else
+    std.array.reduce_left (fun acc value => nix-s%"%{acc}%{sep}%{value}"%) values
+in
+
+let hook_to_string | Hook -> derivation.NixString = fun hook =>
+    if hook.enabled then
+      let header =
+        if hook.verbose then
+          nix-s%"
+            echo -e '\033[34;1m==> Running hook %{hook.name}\033[0m'
+          "%
+        else
+          nix-s%""%
+      in
+
+      nix-s%"
+        %{header}
+        %{hook.content}
+      "%
+    else
+      nix-s%""%
+  in
+let NormaliseNames = fun label items =>
+  items
+  |> std.record.map (fun item_name item => item & { name | default = item_name })
+in
+
+builders.NixpkgsPkg
+& {
+  hooks
+    | doc "Bash scripts to run when entering the shell"
+    | { _ : Hook }
+    | NormaliseNames
+    = {},
+
+  name | default = "shell",
+  version | default = "dev",
+  packages | doc "Packages to be added to the shell, setting PATH, LD_LIBRARY_PATH and other variables as needed" = {},
+
+  env.buildCommand = nix-s%"
+          echo "This derivation is not supposed to be built" 1>&2 1>/dev/null
+          exit 1
+        "%,
+  env.shellHook = concat_strings_sep "\n" (std.record.values hooks |> std.array.map hook_to_string),
+  structured_env.nativeBuildInputs = packages,
+}
+  | builders.NickelPkg

lib/nix-interop/shells/bash.ncl

@@ -1,8 +1,9 @@
 let builders = import "../builders.ncl" in
+let base = import "./base.ncl" in
 let nix_builtins = import "../builtins.ncl" in
 {
   build =
-    builders.Shell
+    base
     & {
       packages = {
         bash = nix_builtins.import_nix "nixpkgs#bash",

lib/schema.ncl

@@ -1,5 +1,6 @@
 let nix = import "./nix-interop/nix.ncl" in
 let filegen = import "files.ncl" in
+let lockfile = import "lockfile.ncl" in
 {
   OrganistShells = {
     dev
@@ -64,4 +65,5 @@ let filegen = import "files.ncl" in
         = {},
     }
     & filegen.Schema
+    & lockfile.Schema
 }

run-test.sh

@@ -62,16 +62,15 @@ test_one_template () (
   fi
 
   echo "Running without nickel.lock.ncl" 1>&2
-  rm nickel.lock.ncl
+  rm -f nickel.lock.ncl
   nix develop --accept-flake-config --print-build-logs --command bash <<<"$TEST_SCRIPT"
 
   echo "Run with proper nickel.lock.ncl" 1>&2
-  nix run .\#regenerate-lockfile
-  PROPER_LOCKFILE_CONTENTS="$(cat nickel.lock.ncl)"
   nix develop --accept-flake-config --print-build-logs --command bash <<<"$TEST_SCRIPT"
 
   echo "Testing without flakes" 1>&2
   # restore lockfile
+  rm -f nickel.lock.ncl
   cat > nickel.lock.ncl <<<"$STORED_LOCKFILE_CONTENTS"
   # pretend it's not flake anymore
   rm flake.*
@@ -89,7 +88,7 @@ EOF
   nix develop --impure -f shell.nix -I nixpkgs="$NIXPKGS_PATH" --command bash <<<"$TEST_SCRIPT"
 
   echo "Running without nickel.lock.ncl" 1>&2
-  rm nickel.lock.ncl
+  rm -f nickel.lock.ncl
   nix develop --impure -f shell.nix -I nixpkgs="$NIXPKGS_PATH" --command bash <<<"$TEST_SCRIPT"
 
   echo "Run with proper nickel.lock.ncl" 1>&2
@@ -120,7 +119,6 @@ test_example () (
   cp -r "$examplePath" ./example
   pushd ./example
   prepare_shell
-  nix run .\#regenerate-files --print-build-logs
   nix develop --print-build-logs --command bash test.sh
   popd
   popd