Merge pull request #31 from nix-community/flake-support

Author: Mic92

.github/workflows/test.yml

@@ -2,15 +2,34 @@ name: "Test"
 on:
   pull_request:
   push:
+
 jobs:
   tests:
-    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        # macOS installer for nixUnstable seems broken atm
+        #os: [ ubuntu-latest, macos-latest ]
+        os: [ ubuntu-latest ]
+        nix-install-url:
+          - https://nixos.org/nix/install
+          - https://github.com/numtide/nix-flakes-installer/releases/download/nix-2.4pre20200618_377345e/install
+          #- https://github.com/numtide/nix-flakes-installer/releases/download/nix-3.0pre20200804_ed52cf6/install
+    runs-on: ${{ matrix.os }}
     steps:
     - uses: actions/checkout@v2
     - uses: cachix/install-nix-action@v10
+      with:
+        install_url: ${{ matrix.nix-install-url }}
     - name: Prevent garbage collections of gcroots
       run:
-        printf "keep-outputs = true\nkeep-derivations = true\n" | sudo tee -a /etc/nix/nix.conf;
+        printf "keep-outputs = true\nkeep-derivations = true\nexperimental-features = nix-command flakes\n" | sudo tee -a /etc/nix/nix.conf;
+    - name: Restart nix-daemon with systemctl
+      run:
         sudo systemctl restart nix-daemon
+      if: matrix.os == 'ubuntu-latest'
+    - name: Restart nix-daemon with launchctl
+      run:
+        sudo launchctl kickstart -k org.nixos.nix-daemon
+      if: matrix.os == 'macos-latest'
     - run:
         nix-shell -I nixpkgs=https://github.com/NixOS/nixpkgs-channels/archive/nixpkgs-unstable.tar.gz ci.nix --run 'true'

README.md

@@ -104,6 +104,56 @@ Then source the direnvrc from this repository in your own `.direnvrc`
 source $HOME/nix-direnv/direnvrc
 ```
 
+## Usage example
+
+Either add `shell.nix` or a `default.nix` to the same directory:
+
+``` nix
+# save this as shell.nix
+{ pkgs ? with import <nixpkgs> {}}:
+
+pkgs.mkShell {
+  nativeBuildInputs = [ pkgs.hello ];
+}
+```
+
+Then add the line `use nix` to your envrc:
+```console
+$ echo "use nix" >> .envrc
+$ direnv allow
+```
+
+## Experimental flakes support
+
+nix-direnv also comes with a flake alternative. The code is tested and works however
+since future nix versions might change their api regarding this feature we cannot
+guarantee stability after an nix upgrade.
+
+Save this file as `flake.nix`:
+
+``` nix
+{
+  description = "A very basic flake";
+  # Provides abstraction to boiler-code when specifying multi-platform outputs.
+  inputs.flake-utils.url = "github:numtide/flake-utils";
+  outputs = { self, nixpkgs, flake-utils }:
+    flake-utils.lib.eachDefaultSystem (system: let
+      pkgs = nixpkgs.legacyPackages.${system};
+    in {
+      devShell = pkgs.mkShell {
+        nativeBuildInputs = [ pkgs.hello ];
+      };
+    });
+}
+```
+
+Then add `use flake` to your `.envrc`:
+
+```console
+$ echo "use flake" >> .envrc
+$ direnv allow
+```
+
 ## Storing .direnv outside the project directory
 
 A `.direnv` directory will be created in each `use_nix` project, which might

direnvrc

@@ -1,5 +1,122 @@
 # shellcheck shell=bash
 
+_nix_import_env() {
+  local env=$1
+
+  local term_backup=$TERM path_backup=$PATH
+  if [[ -n ${TMPDIR+x} ]]; then
+    local tmp_backup=$TMPDIR
+  fi
+  local impure_ssl_cert_file=${SSL_CERT_FILE:-__UNSET__}
+  local impure_nix_ssl_cert_file=${NIX_SSL_CERT_FILE:-__UNSET__}
+
+  eval "$env"
+
+  # `nix-shell --pure` sets invalid ssl certificate paths
+  if [[ "${SSL_CERT_FILE:-}" = /no-cert-file.crt ]]; then
+    if [[ $impure_ssl_cert_file == __UNSET__ ]]; then
+      unset SSL_CERT_FILE
+    else
+      export SSL_CERT_FILE=$impure_nix_ssl_cert_file
+    fi
+  fi
+
+  if [[ "${NIX_SSL_CERT_FILE:-}" = /no-cert-file.crt ]]; then
+    if [[ $impure_nix_ssl_cert_file == __UNSET__ ]]; then
+      unset NIX_SSL_CERT_FILE
+    else
+      export NIX_SSL_CERT_FILE=${impure_ssl_cert_file}
+    fi
+  fi
+
+  export PATH=$PATH:$path_backup TERM=$term_backup
+  if [[ -n ${tmp_backup+x} ]]; then
+    export TMPDIR=${tmp_backup}
+  else
+    unset TMPDIR
+  fi
+
+  # misleading since we are in an impure shell now
+  export IN_NIX_SHELL=impure
+}
+
+_nix_add_gcroot() {
+  local storepath=$1
+  local symlink=$2
+
+  local stripped_pwd=${PWD/\//}
+  local escaped_pwd=${stripped_pwd//-/--}
+  local escaped_pwd=${escaped_pwd//\//-}
+  ln -fs "$storepath" "$symlink"
+  ln -fs "$symlink" "/nix/var/nix/gcroots/per-user/$USER/$escaped_pwd"
+}
+
+use_flake() {
+  watch_file flake.nix
+  watch_file flake.lock
+
+  local profile="$(direnv_layout_dir)/flake-profile"
+  local profile_rc="${profile}.rc"
+
+  if [[ ! -e "$profile" ]] || \
+    [[ ! -e "$profile_rc" ]] || \
+    [[ "$HOME/.direnvrc" -nt "$profile_rc" ]] || \
+    [[ .envrc -nt "$profile_rc" ]] || \
+    [[ flake.nix -nt "$profile_rc" ]] || \
+    [[ flake.lock -nt "$profile_rc" ]];
+  then
+    local tmp_profile="$(direnv_layout_dir)/flake-profile.$$"
+    [[ -d "$(direnv_layout_dir)" ]] || mkdir "$(direnv_layout_dir)"
+    local tmp_profile_rc=$(nix print-dev-env --profile "$tmp_profile")
+    drv=$(realpath "$tmp_profile")
+    echo "$tmp_profile_rc" > "$profile_rc"
+    rm -f "$tmp_profile" "$tmp_profile"*
+    _nix_add_gcroot "$drv" "$profile"
+    log_status renewed cache
+  else
+    log_status using cached dev shell
+  fi
+
+  local old_nix_build_top=${NIX_BUILD_TOP:-__UNSET__}
+  local old_tmp=${TMP:-__UNSET__}
+  local old_tmpdir=${TMPDIR:-__UNSET__}
+  local old_temp=${TEMP:-__UNSET__}
+  local old_tempdir=${TEMPDIR:-__UNSET__}
+  eval "$(< "$profile_rc")"
+  # nix print-env-dev will create a temporary directory and use it a TMPDIR,
+  # we cannot rely on this directory beeing not deleted at some point,
+  # hence we are just removing it right away.
+  if [[ "$NIX_BUILD_TOP" == */nix-shell.* && -d "$NIX_BUILD_TOP" ]]; then
+    rmdir "$NIX_BUILD_TOP"
+  fi
+
+  if [[ "$old_nix_build_top" == __UNSET__ ]]; then
+    unset NIX_BUILD_TOP
+  else
+    export NIX_BUILD_TOP=$old_nix_build_top
+  fi
+  if [[ "$old_tmp" == __UNSET__ ]]; then
+    unset TMP
+  else
+    export TMP=$old_temp
+  fi
+  if [[ "$old_tmpdir" == __UNSET__ ]]; then
+    unset TMPDIR
+  else
+    export TMPDIR=$old_tmpdir
+  fi
+  if [[ "$old_temp" == __UNSET__ ]]; then
+    unset TEMP
+  else
+    export TEMP=$old_temp
+  fi
+  if [[ "$old_tempdir" == __UNSET__ ]]; then
+    unset TEMPDIR
+  else
+    export TEMPDIR=$old_tempdir
+  fi
+}
+
 use_nix() {
   local path direnv_dir
   path=$(nix-instantiate --find-file nixpkgs)
@@ -42,57 +159,20 @@ use_nix() {
   else
     log_status using cached derivation
   fi
-  local term_backup=$TERM path_backup=$PATH
-  if [[ -n ${TMPDIR+x} ]]; then
-    local tmp_backup=$TMPDIR
-  fi
-
-  local impure_ssl_cert_file=${SSL_CERT_FILE:-__UNSET__}
-  local impure_nix_ssl_cert_file=${NIX_SSL_CERT_FILE:-__UNSET__}
 
   log_status eval "$cache"
   read -r cache_content < "$cache"
-  eval "$cache_content"
-  export PATH=$PATH:$path_backup TERM=$term_backup
-  if [[ -n ${tmp_backup+x} ]]; then
-    export TMPDIR=${tmp_backup}
-  else
-    unset TMPDIR
-  fi
-
-  # `nix-shell --pure` sets IN_NIX_SHELL to pure which is
-  # misleading since we are in an impure shell now
-  export IN_NIX_SHELL=impure
-
-  # `nix-shell --pure` sets invalid ssl certificate paths
-  if [[ "${SSL_CERT_FILE:-}" = /no-cert-file.crt ]]; then
-    if [[ ${impure_ssl_cert_file} == __UNSET__ ]]; then
-      unset SSL_CERT_FILE
-    else
-      export SSL_CERT_FILE=${impure_ssl_cert_file}
-    fi
-  fi
-  if [[ "${NIX_SSL_CERT_FILE:-}" = /no-cert-file.crt ]]; then
-    if [[ ${impure_nix_ssl_cert_file} == __UNSET__ ]]; then
-      unset NIX_SSL_CERT_FILE
-    else
-      export NIX_SSL_CERT_FILE=${impure_nix_ssl_cert_file}
-    fi
-  fi
+  _nix_import_env "$cache_content"
 
   # This part is based on https://discourse.nixos.org/t/what-is-the-best-dev-workflow-around-nix-shell/418/4
   if [[ "${out:-}" != "" ]] && (( update_drv )); then
     local drv_link="${direnv_dir}/drv" drv
     drv=$(nix show-derivation "$out" | grep -E -o -m1 '/nix/store/.*.drv')
-    local stripped_pwd=${PWD/\//}
-    local escaped_pwd=${stripped_pwd//-/--}
-    local escaped_pwd=${escaped_pwd//\//-}
-    ln -fs "$drv" "$drv_link"
-    ln -fs "$drv_link" "/nix/var/nix/gcroots/per-user/$USER/$escaped_pwd"
+    _nix_add_gcroot "$drv" "$drv_link"
     log_status renewed cache and derivation link
   fi
 
-  if [[ $# = 0 ]]; then
+  if [[ "$#" == 0 ]]; then
     watch_file default.nix
     watch_file shell.nix
   fi

tests/test.py

@@ -18,18 +18,31 @@ def run(cmd: List[str], **kwargs) -> subprocess.CompletedProcess:
     return subprocess.run(cmd, **kwargs)
 
 
+def support_flakes() -> bool:
+    cmd = [
+        "nix-instantiate",
+        "--json",
+        "--eval",
+        "--expr",
+        '(builtins.compareVersions "2.4" builtins.nixVersion) == 1',
+    ]
+    proc = subprocess.run(cmd, text=True, capture_output=True, check=True)
+    return proc.stdout != "true"
+
+
 class IntegrationTest(unittest.TestCase):
     def setUp(self) -> None:
         self.env = os.environ.copy()
         self.dir = TemporaryDirectory()
         self.env["HOME"] = str(self.dir.name)
         self.testenv = Path(self.dir.name).joinpath("testenv")
         shutil.copytree(TEST_ROOT.joinpath("testenv"), self.testenv)
-        direnvrc = str(TEST_ROOT.parent.joinpath("direnvrc"))
+        self.direnvrc = str(TEST_ROOT.parent.joinpath("direnvrc"))
+
+    def test_nix_shell(self) -> None:
         with open(self.testenv.joinpath(".envrc"), "w") as f:
-            f.write(f"source {direnvrc}\n" "use nix")
+            f.write(f"source {self.direnvrc}\n" "use nix")
 
-    def test_direnv(self) -> None:
         run(["direnv", "allow"], cwd=str(self.testenv), env=self.env, check=True)
 
         run(["nix-collect-garbage"], check=True)
@@ -45,7 +58,6 @@ def test_direnv(self) -> None:
         self.assertEqual(out1.returncode, 0)
 
         run(["nix-collect-garbage"], check=True)
-        run(["sh", "-c", "realpath /nix/var/nix/gcroots/per-user/$USER/*"], check=True)
 
         out2 = run(
             ["direnv", "exec", str(self.testenv), "hello"],
@@ -57,6 +69,37 @@ def test_direnv(self) -> None:
         self.assertIn("using cached derivation", out2.stderr)
         self.assertEqual(out2.returncode, 0)
 
+    @unittest.skipUnless(support_flakes(), "requires flakes")
+    def test_nix_flake(self) -> None:
+        with open(self.testenv.joinpath(".envrc"), "w") as f:
+            f.write(f"source {self.direnvrc}\n" "use flake")
+
+        run(["direnv", "allow"], cwd=str(self.testenv), env=self.env, check=True)
+
+        run(["nix-collect-garbage"], check=True)
+
+        out1 = run(
+            ["direnv", "exec", str(self.testenv), "hello"],
+            env=self.env,
+            stderr=subprocess.PIPE,
+            text=True,
+        )
+        sys.stderr.write(out1.stderr)
+        self.assertIn("renewed cache", out1.stderr)
+        self.assertEqual(out1.returncode, 0)
+
+        run(["nix-collect-garbage"], check=True)
+
+        out2 = run(
+            ["direnv", "exec", str(self.testenv), "hello"],
+            env=self.env,
+            stderr=subprocess.PIPE,
+            text=True,
+        )
+        sys.stderr.write(out2.stderr)
+        self.assertIn("using cached dev shell", out2.stderr)
+        self.assertEqual(out2.returncode, 0)
+
     def tearDown(self) -> None:
         self.dir.cleanup()
 

tests/testenv/flake.nix

@@ -0,0 +1,11 @@
+{
+  description = "A very basic flake";
+  inputs.flake-utils.url = "github:numtide/flake-utils";
+
+  outputs = { self, nixpkgs, flake-utils }:
+    flake-utils.lib.eachDefaultSystem (system: {
+      devShell = import ./shell.nix {
+        pkgs = nixpkgs.legacyPackages.${system};
+      };
+    });
+}

tests/testenv/shell.nix

@@ -1,4 +1,4 @@
-with import <nixpkgs> {};
-mkShell {
-  nativeBuildInputs = [ hello ];
+{ pkgs ? import <nixpkgs> {} }:
+pkgs.mkShell {
+  nativeBuildInputs = [ pkgs.hello ];
 }