Moves nix-tools standard templates into iohk-nix

As such we can now define:

```
let
  localLib = import ./lib.nix;
in
localLib.nix-tools.default-nix ./nix/pkgs.nix
```
as `default.nix`

and

```
let
  localLib = import ./lib.nix;
in
localLib.nix-tools.release-nix {
  packages = [ "cardano-chain" "cs-ledger" "small-steps" "cs-blockchain" ];
  required-name = "cardano-chain-required-checks";
  other-packages = {
    byronLedgerSpec = import ./specs/ledger/latex {};
    byronChainSpec = import ./specs/chain/latex {};
    semanticsSpec = import ./specs/semantics/latex {};
  };
  package-set-path = ./.;
}
```
as `release.nix`.

Author: angerman

default.nix

@@ -55,6 +55,10 @@ let
     regeneratePackages = commonLib.pkgsDefault.callPackage ./nix-tools-regenerate.nix {
       nix-tools = package;
     };
+    # default and release templates that abstract
+    # over the details for CI.
+    default-nix = import ./nix-tools-default.nix commonLib;
+    release-nix = import ./nix-tools-release.nix commonLib;
   };
 
   stack2nix = rec {

nix-tools-default.nix

@@ -0,0 +1,37 @@
+commonLib: # the iohk-nix commonLib, that provides access to the pinned packages
+pkgs-path: # the path to th local pkgs.nix file for nix-tools that imports all
+           # haskell specific data.
+
+{ system ? builtins.currentSystem
+, crossSystem ? null
+, config ? {}
+, pkgs ? commonLib.getPkgs { inherit system crossSystem config; }
+}:
+with builtins; with pkgs.lib;
+let  nix-tools = import pkgs-path { nixpkgs = _: pkgs; };
+in {
+    _lib = commonLib;
+
+    # This will allow us to build
+    # nix-tools.libs.cardano-chain to obtain all libs in a single derivation
+    # nix-tools.exes.cardano-chain for all executables, same for tests and benchmarks.
+    #
+    # The alternative syntax is: nix-tools._raw.cardano-chain.components.$comp
+    # if you want to build only a single component.
+    nix-tools = { _raw = nix-tools; }
+      # some shorthands
+      // { libs = mapAttrs (k: v: if   v ? components && v.components ? "library"
+                                  then v.components.library
+                                  else null) nix-tools; }
+      // { exes = mapAttrs (k: v: if   (v ? components && length (attrValues v.components.exes) > 0)
+                                  then if pkgs.stdenv.targetPlatform.isWindows then pkgs.copyJoin else pkgs.symlinkJoin
+                                       { name = "${k}-exes"; paths = attrValues v.components.exes; }
+                                  else null) nix-tools; }
+      // { tests = mapAttrs (k: v: if v ? components && length (attrValues v.components.tests) > 0
+                                   then v.components.tests
+                                   else null) nix-tools; }
+      // { benchmarks = mapAttrs (k: v: if v ? components && length (attrValues v.components.benchmarks) > 0
+                                   then v.components.benchmarks
+                                   else null) nix-tools; }
+      ;
+  }

nix-tools-release.nix

@@ -0,0 +1,68 @@
+commonLib: # the iohk-nix commonLib
+{ packages ? []
+, required-name ? "required"
+, other-packages ? {}
+, config ? {}
+, package-set-path # usually import ./. {}
+}:
+{ system ? builtins.currentSystem
+, pkgs ? commonLib.getPkgs { inherit system config; }
+
+, scrubJobs ? true
+, supportedSystems ? [ "x86_64-linux" "x86_64-darwin" ]
+, nixpkgsArgs ? {
+    config = config // { allowUnfree = false; inHydra = true; };
+  }
+}:
+with (import (commonLib.nixpkgs + "/pkgs/top-level/release-lib.nix") {
+  inherit supportedSystems scrubJobs nixpkgsArgs;
+  packageSet = import package-set-path;
+});
+with pkgs.lib;
+let
+
+
+  traceId = x: builtins.trace (builtins.deepSeq x x) x;
+
+  packageSet = import package-set-path {};
+  nix-tools-pkgs = supportedSystems: {
+    nix-tools.libs =
+      mapAttrs (_: _: supportedSystems)
+        (filterAttrs (n: v: builtins.elem n packages && v != null) packageSet.nix-tools.libs);
+    nix-tools.exes =
+      mapAttrs (_: mapAttrs (_: _: supportedSystems))
+        (filterAttrs (n: v: builtins.elem n packages && v != null) packageSet.nix-tools.exes);
+    nix-tools.tests =
+      mapAttrs (_: mapAttrs (_: _: supportedSystems))
+        (filterAttrs (n: v: builtins.elem n packages && v != null) packageSet.nix-tools.tests);
+    nix-tools.benchmarks =
+      mapAttrs (_: mapAttrs (_: _: supportedSystems))
+        (filterAttrs (n: v: builtins.elem n packages && v != null) packageSet.nix-tools.benchmarks);
+  };
+
+  mapped-pkgs = mapTestOn (nix-tools-pkgs supportedSystems);
+  mapped-pkgs-mingw32 = mapTestOnCross lib.systems.examples.mingwW64 (nix-tools-pkgs [ "x86_64-linux" ]);
+
+  mapped-pkgs-all
+    = lib.recursiveUpdate
+        (mapped-pkgs)
+        (lib.mapAttrs (_: (lib.mapAttrs (_: (lib.mapAttrs' (n: v: lib.nameValuePair (lib.systems.examples.mingwW64.config + "-" + n) v)))))
+          mapped-pkgs-mingw32);
+
+in fix (self: other-packages // mapped-pkgs-all
+// {
+#  forceNewEval = pkgs.writeText "forceNewEval" chain.rev;
+
+  required = pkgs.lib.hydraJob (pkgs.releaseTools.aggregate {
+    name = required-name;
+    constituents = with self;
+      [ # forceNewEval
+      ] ++ builtins.attrNames other-packages
+        ++ map (pkg: [ nix-tools.exes.${pkg}.x86_64-darwin
+                       nix-tools.exes.${pkg}.x86_64-linux
+                       nix-tools.libs.${pkg}.x86_64-darwin
+                       nix-tools.libs.${pkg}.x86_64-linux ]) packages;
+#               (packages ++ map (pkg: lib.systems.examples.mingwW64.config + "-" + pkg) packages);
+  });
+
+})