Merge master into hkm/avoid-defaults

# Conflicts:
#	lib/call-stack-to-nix.nix
#	lib/stack-cache-generator.nix
#	overlays/haskell.nix

Author: hamishmack

builder/haddock-builder.nix

@@ -83,23 +83,26 @@ let
       ++ componentDrv.executableToolDepends;
 
     configurePhase = ''
+      runHook preConfigure
       echo Configure flags:
       printf "%q " ${finalConfigureFlags}
       echo
       $SETUP_HS configure ${finalConfigureFlags}
+      runHook postConfigure
     '';
 
     buildPhase = ''
       mkdir -p $out
     '' + lib.optionalString doHaddock' ''
       runHook preHaddock
-      # If we don't have any source files, no need to run haddock
-      [[ -n $(find . -name "*.hs" -o -name "*.lhs") ]] && {
+
       docdir="${docdir "$doc"}"
-      # This mkdir needed for packages like bytestring-builder which
-      # is empty when `bytestring >= 0.10.4`
+      # This mkdir needed for packages like base-noprelude and bytestring-builder
+      # (which is also empty when `bytestring >= 0.10.4`)
       mkdir -p "$docdir"
 
+      # If we don't have any source files, no need to run haddock
+      [[ -n $(find . -name "*.hs" -o -name "*.lhs") ]] && {
       $SETUP_HS haddock \
         "--html" \
         ${lib.optionalString doHoogle "--hoogle"} \

builder/shell-for.nix

@@ -35,11 +35,12 @@ let
   removeSelectedInputs = lib.filter
     (input: lib.all (cfg: input != cfg.components.library or null) selected);
 
-  packageInputs = removeSelected
-    (lib.concatMap (cfg: cfg.depends) selectedConfigs
-    ++ additionalSelected
-    ++ lib.concatMap (cfg: cfg.setup.config.depends or []) selected
-    );
+  packageInputs =
+    removeSelected
+      (lib.concatMap (cfg: cfg.depends) selectedConfigs
+      ++ lib.concatMap (cfg: cfg.setup.config.depends or []) selected
+      )
+    ++ additionalSelected;
 
   # Add the system libraries and build tools of the selected haskell
   # packages to the shell.

docs/tutorials/development.md

@@ -4,8 +4,8 @@ your Haskell package dependencies, but also the required system
 libraries and build tools.
 
 Inside the development shell, you can run commands such as `ghc`,
-`ghci`, or `cabal new‑build`, and they will have all dependencies
-available.
+`ghci`, or `cabal new‑build` (`cabal build` on Cabal 3.0),
+and they will have all dependencies available.
 
 Every dependency will be cached in your Nix store. If you have set up
 Hydra CI, then your team can share pre-built dependencies.
@@ -21,7 +21,8 @@ it exists in a file called `default.nix`.
     rebuild all dependencies, even though they are available in the
     shell. However, if you have a Stack project, you can generate the
     package set with Haskell.nix, then use `cabal new‑build` to work
-    on it.
+    on it.  Starting Cabal 3.0 `cabal build` will work out of the box, as
+    new style builds are the default.
 
 ## How to get a development shell for a package
 

hackage-src.json

@@ -1,7 +1,7 @@
 {
   "url": "https://github.com/input-output-hk/hackage.nix",
-  "rev": "b7a2bd2c740648e7bf96b9e2d0a57ca402daf2df",
-  "date": "2020-07-01T01:15:16+00:00",
-  "sha256": "0rj1xa7wbgix7nc3kmw9477k47skdw9skbsky6vjnyrybkgffljr",
+  "rev": "2845992effbeb7adcd2389a264ecfdabbeea83ba",
+  "date": "2020-07-06T01:15:12+00:00",
+  "sha256": "0pdvh781qxqr0a62v0nwdp7agd8n6l6ilbd17zvlzblw1a5arzqv",
   "fetchSubmodules": false
 }

lib/call-stack-to-nix.nix

@@ -5,22 +5,27 @@
  *
  * see also `call-cabal-project-to-nix`!
  */
-{ runCommand, pkgs, mkCacheFile, materialize }:
+{ runCommand, pkgs, mkCacheFile, materialize, haskellLib }:
 { name ? src.name or null # optional name for better error messages
 , src
-, stackYaml ? null
+, stackYaml ? "stack.yaml"
 , ignorePackageYaml ? false
 , cache ? null
 , stack-sha256 ? null
+, resolverSha256 ? null
 , materialized ? null # Location of a materialized copy of the nix files
 , checkMaterialization ? null # If true the nix files will be generated used to check plan-sha256 and material
 , nix-tools ? pkgs.haskell-nix.nix-tools.${pkgs.haskell-nix.defaultCompilerNixNameTODO}
 , ... }:
 let
+  inherit (haskellLib.fetchResolver {
+      inherit src stackYaml resolverSha256;
+    }) resolver fetchedResolver;
+
   subDir' = src.origSubDir or "";
   stackToNixArgs = builtins.concatStringsSep " " [
     "--full"
-    "--stack-yaml=${src}/${if stackYaml == null then "stack.yaml" else stackYaml}"
+    "--stack-yaml=$SRC/${stackYaml}"
     (if ignorePackageYaml then "--ignore-package-yaml" else "")
     "-o ."
   ];
@@ -32,23 +37,40 @@ let
   } // pkgs.lib.optionalAttrs (checkMaterialization != null) {
     inherit checkMaterialization;
   }) (runCommand (if name == null then "stack-to-nix-pkgs" else name + "-stack-to-nix-pkgs") {
-    nativeBuildInputs = [ nix-tools pkgs.nix-prefetch-git pkgs.cacert ];
+    nativeBuildInputs = [ nix-tools pkgs.nix-prefetch-git pkgs.cacert pkgs.xorg.lndir ];
     # Needed or stack-to-nix will die on unicode inputs
     LOCALE_ARCHIVE = pkgs.lib.optionalString (pkgs.stdenv.hostPlatform.libc == "glibc") "${pkgs.glibcLocales}/lib/locale/locale-archive";
     LANG = "en_US.UTF-8";
     LC_ALL = "en_US.UTF-8";
     preferLocalBuild = false;
   } (''
     mkdir -p $out${subDir'}
-  '' + pkgs.lib.optionalString (cache != null) ''
-    cp ${mkCacheFile cache}/.stack-to-nix.cache* $out${subDir'}
-  '' + ''
+    ${
+    # If no resolver was fetched use the original stack.yaml
+    if fetchedResolver == null
+    then ''
+      SRC=${src}
+    ''
+    else
+      # Replace the resolver path in the stack.yaml with the fetched version
+      ''
+      SRC=$(mktemp -d)
+      cd $SRC
+      lndir -silent "${src}/." $SRC
+      rm ${stackYaml}
+      cp ${src}/${stackYaml} .
+      chmod +w ${stackYaml}
+      substituteInPlace ${stackYaml} --replace "${resolver}" "${fetchedResolver}"
+    ''}
+    ${pkgs.lib.optionalString (cache != null) ''
+      cp ${mkCacheFile cache}/.stack-to-nix.cache* $out${subDir'}
+    ''}
     (cd $out${subDir'} && stack-to-nix ${stackToNixArgs})
 
     # We need to strip out any references to $src, as those won't
     # be accessable in restricted mode.
     for nixf in $(find $out -name "*.nix" -type f); do
-      substituteInPlace $nixf --replace "${src}" "."
+      substituteInPlace $nixf --replace "$SRC" "."
     done
 
     # move pkgs.nix to default.nix ensure we can just nix `import` the result.

lib/default.nix

@@ -261,4 +261,9 @@ in {
     if lib.isAttrs versionOrArgs
       then versionOrArgs
       else { version = versionOrArgs; };
+
+  # Find the resolver in the stack.yaml file and fetch it if a sha256 value is provided
+  fetchResolver = import ./fetch-resolver.nix {
+    inherit (pkgs.evalPackages) pkgs;
+  }; 
 }

lib/fetch-resolver.nix

@@ -0,0 +1,33 @@
+# Find the resolver in the stack.yaml file and fetch it if a sha256 value is provided
+{ pkgs }:
+{ src
+, stackYaml ? "stack.yaml"
+, resolverSha256 ? null
+}:
+let
+    # Using origSrcSubDir bypasses any cleanSourceWith so that it will work when
+    # access to the store is restricted.  If origSrc was already in the store
+    # you can pass the project in as a string.
+    rawStackYaml = builtins.readFile ((src.origSrcSubDir or src) + ("/" + stackYaml));
+
+    # Determine the resolver as it may point to another file we need
+    # to look at.
+    resolver =
+      let
+        rs = pkgs.lib.lists.concatLists (
+          pkgs.lib.lists.filter (l: l != null)
+            (builtins.map (l: builtins.match "^resolver: *(.*)" l)
+              (pkgs.lib.splitString "\n" rawStackYaml)));
+      in
+        pkgs.lib.lists.head (rs ++ [ null ]);
+
+    # If we found a resolver andwe have a resolverSha256 then we should download it.
+    fetchedResolver =
+      if resolver != null && resolverSha256 != null
+        then pkgs.fetchurl {
+          url = resolver;
+          sha256 = resolverSha256;
+        }
+        else null;
+
+in { inherit resolver fetchedResolver; }

lib/stack-cache-generator.nix

@@ -13,6 +13,7 @@
   if sha256map != null
     then { location, tag, ...}: sha256map."${location}"."${tag}"
     else _: null
+, resolverSha256 ? null
 , checkMaterialization ? null
 , compiler-nix-name ? pkgs.haskell-nix.defaultCompilerNixNameTODO # We should get this from stack.yaml
 , nix-tools ? pkgs.haskell-nix.nix-tools-set {
@@ -25,21 +26,9 @@ let
     # we want to avoid recalculating the cache unless the stack.yaml file
     # changes.
 
-    # Using origSrcSubDir bypasses any cleanSourceWith so that it will work when
-    # access to the store is restricted.  If origSrc was already in the store
-    # you can pass the project in as a string.
-    rawStackYaml = builtins.readFile ((src.origSrcSubDir or src) + ("/" + stackYaml));
-
-    # Determine the resolver as it may point to another file we need
-    # to look at.
-    resolver =
-      let
-        rs = pkgs.lib.lists.concatLists (
-          pkgs.lib.lists.filter (l: l != null)
-            (builtins.map (l: builtins.match "^resolver: *(.*)" l)
-              (pkgs.lib.splitString "\n" rawStackYaml)));
-      in
-        pkgs.lib.lists.head (rs ++ [ null ]);
+    inherit (haskellLib.fetchResolver {
+        inherit src stackYaml resolverSha256;
+      }) resolver fetchedResolver;
 
     # Filter just the stack yaml file and any reolver yaml file it points to.
     maybeCleanedSource =
@@ -63,6 +52,9 @@ let
         cp -r "${maybeCleanedSource}/." $TMP
         chmod -R +w $TMP
         substituteInPlace ${stackYaml} --replace "# nix-sha256:" "nix-sha256:"
+        ${pkgs.lib.optionalString (fetchedResolver != null) ''
+          substituteInPlace ${stackYaml} --replace "${resolver}" "${fetchedResolver}"
+        ''}
         stack-repos --stack-yaml ${stackYaml}
         cp repos.json $out
       ''));

overlays/haskell.nix

@@ -264,7 +264,7 @@ final: prev: {
         callStackToNix = import ../lib/call-stack-to-nix.nix {
             pkgs = final.evalPackages.pkgs;
             inherit (final.evalPackages.pkgs) runCommand;
-            inherit (final.evalPackages.haskell-nix) mkCacheFile materialize;
+            inherit (final.evalPackages.haskell-nix) mkCacheFile materialize haskellLib;
         };
 
         # given a source location call `cabal-to-nix` (from nix-tools) on it

stackage-src.json

@@ -1,7 +1,7 @@
 {
   "url": "https://github.com/input-output-hk/stackage.nix",
-  "rev": "66d07956ef302c9c5e9c1e6011dd275b862cd597",
-  "date": "2020-06-29T01:02:37+00:00",
-  "sha256": "1a803n2257mmaz98rhzxb1a8cbdhiaqls3gwxqnrw1zhc9f785pp",
+  "rev": "2fc823c8e70858d0b41d8df2615bcab83d85a1bc",
+  "date": "2020-07-06T01:02:55+00:00",
+  "sha256": "1322iip8038f8fqh46gpk3r6jnd4v19hsnka1mkf3hpj0rvyffzz",
   "fetchSubmodules": false
 }

test/default.nix

@@ -159,6 +159,7 @@ let
     builder-haddock = callTest ./builder-haddock {};
     stack-simple = callTest ./stack-simple {};
     stack-local-resolver = callTest ./stack-local-resolver {};
+    stack-remote-resolver = callTest ./stack-remote-resolver {};
     snapshots = callTest ./snapshots {};
     shell-for = callTest ./shell-for {};
     shell-for-setup-deps = callTest ./shell-for-setup-deps { inherit compiler-nix-name; };

test/stack-remote-resolver/.gitignore

@@ -0,0 +1,2 @@
+/.stack-work/
+/*.cabal

test/stack-remote-resolver/default.nix

@@ -0,0 +1,15 @@
+{ project', recurseIntoAttrs, testSrc }:
+
+let
+  project = project' {
+    src = testSrc "stack-remote-resolver";
+    resolverSha256 = "1rldkqqsxd8zxybrkqhc25bcxinhz212kz45jcz8jinfihc91jl7";
+  };
+  packages = project.hsPkgs;
+
+in recurseIntoAttrs {
+  ifdInputs = {
+    inherit (project) stack-nix;
+  };
+  inherit (packages.stack-remote-resolver.components) library;
+}

test/stack-remote-resolver/package.yaml

@@ -0,0 +1,7 @@
+name: stack-remote-resolver
+
+dependencies:
+- base
+
+library:
+  source-dirs: src

test/stack-remote-resolver/src/Lib.hs

@@ -0,0 +1,6 @@
+module Lib
+    ( someFunc
+    ) where
+
+someFunc :: IO ()
+someFunc = putStrLn "someFunc"

test/stack-remote-resolver/stack.yaml

@@ -0,0 +1,4 @@
+resolver: https://raw.githubusercontent.com/input-output-hk/haskell.nix/master/test/stack-local-resolver/snapshot.yaml
+
+packages:
+- .