Last parts

Author: andreabedini

builder/comp-builder.nix

@@ -8,7 +8,6 @@ let self =
 , setup
 , src
 , flags
-, revision
 , cabalFile
 , cabal-generator
 , patches ? []
@@ -239,16 +238,16 @@ let
   executableToolDepends =
     (lib.concatMap (c: if c.isHaskell or false
       then builtins.attrValues (c.components.exes or {})
-      else [c]) 
+      else [c])
       (builtins.filter (x: !(isNull x))
-      (map 
+      (map
         (p: if builtins.isFunction p
-          then p { inherit  (package.identifier) version; inherit revision; }
+          then p { inherit  (package.identifier) version; }
           else p) build-tools))) ++
     lib.optional (pkgconfig != []) buildPackages.cabalPkgConfigWrapper;
 
   # Unfortunately, we need to wrap ghc commands for cabal builds to
-  # work in the nix-shell. See ../doc/removing-with-package-wrapper.md.
+  # work in the nix-shell. See ../docs/dev/removing-with-package-wrapper.md.
   shellWrappers = ghcForComponent {
     componentName = fullName;
     inherit configFiles enableDWARF;
@@ -298,11 +297,11 @@ let
             ''
         );
     }
-    # patches can (if they like) depend on the version and revision of the package.
+    # patches can (if they like) depend on the version of the package.
     // lib.optionalAttrs (patches != []) {
       patches = map (p:
         if builtins.isFunction p
-          then p { inherit (package.identifier) version; inherit revision; }
+          then p { inherit (package.identifier) version; }
           else p
         ) patches;
     }
@@ -316,7 +315,7 @@ let
 
   haddock = haddockBuilder {
     inherit componentId component package flags commonConfigureFlags
-      commonAttrs revision doHaddock
+      commonAttrs doHaddock
       doHoogle hyperlinkSource quickjump setupHaddockFlags
       needsProfiling configFiles preHaddock postHaddock pkgconfig;
 
@@ -328,7 +327,7 @@ let
     outputHashMode = "recursive";
     outputHashAlgo = "sha256";
   };
-                    
+
   drv = stdenv.mkDerivation (commonAttrs // contentAddressedAttrs // {
     pname = nameOnly;
     inherit (package.identifier) version;

builder/haddock-builder.nix

@@ -4,7 +4,6 @@
 , component
 , package
 , flags
-, revision
 , commonAttrs
 , preHaddock
 , postHaddock

builder/hspkg-builder.nix

@@ -9,8 +9,7 @@ config:
 , name
 , sha256
 , src
-, revision
-, revisionSha256
+, cabalFile
 , patches
 
 , shellHook
@@ -48,12 +47,6 @@ let
         # repository.
         inputMap.${__head baseUrlMatch} + "/package/${__elemAt baseUrlMatch 1}"
     else pkg.src;
-  cabalFile = if revision == null || revision == 0 || bundledSrc != null then null else
-    fetchurl {
-      name = "${name}-${toString revision}.cabal";
-      url = "https://hackage.haskell.org/package/${name}/revision/${toString revision}.cabal";
-      sha256 = revisionSha256;
-    };
 
   defaultSetupSrc = if stdenv.hostPlatform.isGhcjs then ./Setup.ghcjs.hs else ./Setup.hs;
 
@@ -134,12 +127,12 @@ let
         extraSrcFiles = components.setup.extraSrcFiles ++ [ "Setup.hs" "Setup.lhs" ];
         pkgconfig = if components ? library then components.library.pkgconfig or [] else [];
       };
-      inherit package name src flags revision patches defaultSetupSrc;
+      inherit package name src flags patches defaultSetupSrc;
       inherit (pkg) preUnpack postUnpack;
     };
 
   buildComp = allComponent: componentId: component: comp-builder {
-    inherit allComponent componentId component package name src flags setup cabalFile cabal-generator patches revision
+    inherit allComponent componentId component package name src flags setup cabalFile cabal-generator patches
             shellHook
             ;
   };

lib/cabal-project-parser.nix

@@ -121,99 +121,6 @@ let
         initialText
         ++ (builtins.map (x: x.otherText) repoBlocks));
     };
-
-  # Parse and replace repository
-  # This works in a similar way to the `source-repository-package` but we are
-  # able to simply replace the `repository` blocks with local `file:/nix/store` ones.
-  # This works because `cabal configure` does not include any of the `/nix/sore/`
-  # paths in the `plan.json` (so materialized plan-nix will still work as expeced).
-  # See tests/unit.nix for examples of input and output.
-  parseRepositoryBlock = evalPackages: cabalProjectFileName: sha256map: inputMap: cabal-install: nix-tools: block:
-    let
-      lines = pkgs.lib.splitString "\n" block;
-      # The first line will contain the repository name.
-      x = span (pkgs.lib.strings.hasPrefix " ") (__tail lines);
-      attrs = parseBlockLines x.fst;
-      sha256 = attrs."--sha256" or (
-        if sha256map != null
-          then sha256map."${attrs.url}"
-          else null);
-    in rec {
-      # This is `some-name` from the `repository some-name` line in the `cabal.project` file.
-      name = __head lines;
-      # The $HOME/.cabal/packages/${name} after running `cabal v2-update` to download the repository
-      repoContents = if inputMap ? ${attrs.url}
-        # If there is an input use it to make `file:` url and create a suitable `.cabal/packages/${name}` directory
-        then evalPackages.runCommand name ({
-          nativeBuildInputs = [ cabal-install ] ++ evalPackages.haskell-nix.cabal-issue-8352-workaround;
-          preferLocalBuild = true;
-        }) ''
-            HOME=$(mktemp -d)
-            mkdir -p $HOME/.cabal/packages/${name}
-            cat <<EOF > $HOME/.cabal/config
-            repository ${name}
-              url: file:${inputMap.${attrs.url}}
-              ${pkgs.lib.optionalString (attrs ? secure) "secure: ${attrs.secure}"}
-              ${pkgs.lib.optionalString (attrs ? root-keys) "root-keys: ${attrs.root-keys}"}
-              ${pkgs.lib.optionalString (attrs ? key-threshold) "key-threshold: ${attrs.key-threshold}"}
-            EOF
-
-            cabal v2-update ${name}
-            cp -r $HOME/.cabal/packages/${name} $out
-        ''
-        else evalPackages.runCommand name ({
-          nativeBuildInputs = [ cabal-install evalPackages.curl nix-tools ] ++ evalPackages.haskell-nix.cabal-issue-8352-workaround;
-          LOCALE_ARCHIVE = pkgs.lib.optionalString (evalPackages.stdenv.buildPlatform.libc == "glibc") "${evalPackages.glibcLocales}/lib/locale/locale-archive";
-          LANG = "en_US.UTF-8";
-          preferLocalBuild = true;
-        } // pkgs.lib.optionalAttrs (sha256 != null) {
-          outputHashMode = "recursive";
-          outputHashAlgo = "sha256";
-          outputHash = sha256;
-        }) ''
-            HOME=$(mktemp -d)
-            mkdir -p $HOME/.cabal/packages/${name}
-            cat <<EOF > $HOME/.cabal/config
-            repository ${name}
-              url: ${attrs.url}
-              ${pkgs.lib.optionalString (attrs ? secure) "secure: ${attrs.secure}"}
-              ${pkgs.lib.optionalString (attrs ? root-keys) "root-keys: ${attrs.root-keys}"}
-              ${pkgs.lib.optionalString (attrs ? key-threshold) "key-threshold: ${attrs.key-threshold}"}
-            EOF
-
-            export SSL_CERT_FILE=${evalPackages.cacert}/etc/ssl/certs/ca-bundle.crt
-            cabal v2-update ${name}
-            cp -r $HOME/.cabal/packages/${name} $out
-        '';
-      # Output of hackage-to-nix
-      hackage = import (
-        evalPackages.runCommand ("hackage-to-nix-" + name) {
-          nativeBuildInputs = [ cabal-install evalPackages.curl nix-tools ];
-          LOCALE_ARCHIVE = pkgs.lib.optionalString (evalPackages.stdenv.buildPlatform.libc == "glibc") "${evalPackages.glibcLocales}/lib/locale/locale-archive";
-          LANG = "en_US.UTF-8";
-          preferLocalBuild = true;
-        } ''
-          mkdir -p $out
-          hackage-to-nix $out ${repoContents}/01-index.tar ${attrs.url}
-        '');
-      # Directory to `lndir` when constructing a suitable $HOME/.cabal dir
-      repo = {
-        ${name} = repoContents;
-      };
-    };
-
-  parseRepositories = evalPackages: cabalProjectFileName: sha256map: inputMap: cabal-install: nix-tools: projectFile:
-    let
-      # This will leave the name of repository in the first line of each block
-      blocks = pkgs.lib.splitString "\nrepository " ("\n" + projectFile);
-      repoBlocks = builtins.map (parseRepositoryBlock evalPackages cabalProjectFileName sha256map inputMap cabal-install nix-tools) (pkgs.lib.lists.drop 1 blocks);
-    in {
-      extra-hackages = pkgs.lib.lists.map (block: block.hackage) repoBlocks;
-      repos = pkgs.lib.lists.foldl' (x: block: x // block.repo) {} repoBlocks;
-    };
-
 in {
-  inherit parseIndexState parseSourceRepositoryPackages parseRepositories
-    # These are only exposed for tests
-    parseSourceRepositoryPackageBlock parseRepositoryBlock;
+  inherit parseIndexState parseSourceRepositoryPackages;
 }

lib/call-cabal-project-to-nix.nix

@@ -261,10 +261,6 @@ let
       sourceRepoPackageResult = pkgs.haskell-nix.haskellLib.parseSourceRepositoryPackages
         cabalProjectFileName sha256map source-repo-override projectFile;
 
-      # Parse the `repository` blocks
-      repoResult = pkgs.haskell-nix.haskellLib.parseRepositories
-        evalPackages cabalProjectFileName sha256map inputMap cabal-install nix-tools sourceRepoPackageResult.otherText;
-
       # we need the repository content twice:
       # * at eval time (below to build the fixed project file)
       #   Here we want to use evalPackages.fetchgit, so one can calculate
@@ -278,7 +274,6 @@ let
       sourceReposBuild = builtins.map (x: (fetchPackageRepo pkgs.fetchgit x).fetched) sourceRepoPackageResult.sourceRepos;
     in {
       sourceRepos = sourceReposBuild;
-      inherit (repoResult) repos extra-hackages;
       makeFixedProjectFile = ''
         cp -f ${evalPackages.writeText "cabal.project" sourceRepoPackageResult.otherText} ./cabal.project
       '' +
@@ -522,7 +517,7 @@ let
       "freeze"  # The `cabal.project.freeze` file created by `cabal v2-freeze`
     ];
   } ''
-    set -x
+    set -e
 
     tmp=$(mktemp -d)
     cd $tmp
@@ -578,19 +573,17 @@ let
     EOF
     cat $CABAL_DIR/config
 
+    echo "Installing fake curl"
     PATH=${
       fakeCurl ({
         "http://hackage.haskell.org" = hackageRepo { index-state = cached-index-state; sha256 = index-sha256-found; };
       } // inputMap)
-    }/bin:$PATH \
-    cabal update -v \
+    }/bin:$PATH
+
+    cabal update \
         -w ${ghc.targetPrefix}ghc \
-        --with-ghc-pkg=${ghc.targetPrefix}ghc-pkg \
+        --with-ghc-pkg=${ghc.targetPrefix}ghc-pkg
 
-    # Using `cabal v2-freeze` will configure the project (since
-    # it is not configured yet), taking the existing `cabal.project.freeze`
-    # file into account.  Then it "writes out a freeze file which
-    # records all of the versions and flags that are picked" (from cabal docs).
     echo "Using index-state ${index-state-found}"
 
     make-install-plan ${
@@ -661,5 +654,5 @@ in {
   projectNix = plan-nix;
   index-state = index-state-found;
   inherit src;
-  inherit (fixedProject) sourceRepos extra-hackages;
+  inherit (fixedProject) sourceRepos;
 }

modules/configuration-nix.nix

@@ -5,12 +5,12 @@
 
 { pkgs, config, ... }:
 let
-  fromUntil = from: until: patch: { version, revision }:
+  fromUntil = from: until: patch: { version }:
     if   builtins.compareVersions version from  >= 0
       && builtins.compareVersions version until <  0
       then patch
       else null;
-  from = v: patch: { version, revision }:
+  from = v: patch: { version }:
     if builtins.compareVersions version v >= 0
       then patch
       else null;
@@ -91,16 +91,16 @@ in {
 
   packages.discount.components.library.libs = pkgs.lib.mkForce [ pkgs.discount ];
 
-  packages.llvm-hs.components.library.build-tools = pkgs.lib.mkForce [ 
+  packages.llvm-hs.components.library.build-tools = pkgs.lib.mkForce [
     (fromUntil "5.0.0" "6" pkgs.llvmPackages_5.llvm)
     (fromUntil "6.0.0" "7" pkgs.llvmPackages_6.llvm)
     (fromUntil "7.0.0" "8" pkgs.llvmPackages_7.llvm)
     (fromUntil "8.0.0" "9" pkgs.llvmPackages_8.llvm)
     (fromUntil "9.0.0" "12" pkgs.llvmPackages_9.llvm)
     (fromUntil "12.0.0" "15" pkgs.llvmPackages_12.llvm)
-    # NOTE: we currently don't have a llvm versoin > 12 that has a tag 
-    #       in nixpkgs, so we probably can't build `llvm-hs > 12`, there 
-    #       is however a head version of llvm in nixpkgs, which we might 
+    # NOTE: we currently don't have a llvm versoin > 12 that has a tag
+    #       in nixpkgs, so we probably can't build `llvm-hs > 12`, there
+    #       is however a head version of llvm in nixpkgs, which we might
     #       be able to use if that case were to occur
   ];
 

modules/hackage-project.nix

@@ -32,8 +32,8 @@ in {
     '';
     cabalProjectLocal = lib.mkOverride 1100 null;
     cabalProjectFreeze = lib.mkOverride 1100 null;
-    src = 
-      let      
+    src =
+      let
         tarball = config.evalPackages.fetchurl {
           url = "mirror://hackage/${name}-${version}.tar.gz";
           inherit (pkgs.haskell-nix.hackage.${name}.${version}) sha256; };

modules/package.nix

@@ -129,6 +129,9 @@ in {
     flags = mkOption {
       type = attrsOf bool;
     };
+    cabalFile = mkOption {
+      type = nullOr path;
+    };
     package = {
       specVersion = mkOption {
         type = str;

modules/plan.nix

@@ -253,7 +253,7 @@ let
       '';
     };
     planned = mkOption {
-      description = "Set to true by `plan-to-nix` for any component that was included in the `plan.json` file.";  
+      description = "Set to true by `plan-to-nix` for any component that was included in the `plan.json` file.";
       # This is here so that (rather than in componentOptions) so it can be set project wide for stack projects
       type = bool;
       default = def.planned or false;
@@ -316,7 +316,9 @@ in {
               then (abort "${name} has no revision!")
               else revision (modArgs // { hsPkgs = hsPkgs // (mapAttrs (l: _: hsPkgs.${name}.components.sublibs.${l}) (m.components.sublibs or {})); });
       in
-        m // { flags = lib.mapAttrs (_: lib.mkDefault) (m.flags // revArgs.flags or {}); }
+        m // { flags = lib.mapAttrs (_: lib.mkDefault) (m.flags // revArgs.flags or {});
+               cabalFile = revArgs.cabalFile or null;
+             }
     ) (lib.filterAttrs (n: v: v == null || v.revision != null ) module.packages);
   };
 }

nix-tools/plan2nix/Plan2Nix.hs

@@ -139,7 +139,7 @@ plan2nix args Plan { packages, extras, components, compilerVersion, compilerPack
     [revBinding pkg mkNull]
   bind pkg (Just Package { packageFlags, packageHasDescriptionOverride = True }) =
       bindPath (VarName pkg :| ["revision"])  (mkSym "import" @@ mkPath False ("." </> "cabal-files" </> T.unpack pkg <.> "nix"))
-    : bindPath (VarName pkg :| ["cabalFile"]) (mkSym "builtins" @. "readFile" @@ mkPath False ("." </> "cabal-files" </> T.unpack pkg <.> "cabal"))
+    : bindPath (VarName pkg :| ["cabalFile"]) (mkPath False ("." </> "cabal-files" </> T.unpack pkg <.> "cabal"))
     : flagBindings
 
     where