pkgs/build-support/build-nim-package.nix

   1 { lib
   2 , buildPackages
   3 , callPackage
   4 , stdenv
   5 , nim1
   6 , nim2
   7 , nim_builder
   8 , defaultNimVersion ? 2
   9 , nimOverrides
  10 , buildNimPackage
  11 }:
  12
  13 let
  14   baseAttrs = {
  15     strictDeps = true;
  16     enableParallelBuilding = true;
  17     doCheck = true;
  18     configurePhase = ''
  19       runHook preConfigure
  20       export NIX_NIM_BUILD_INPUTS=''${pkgsHostTarget[@]} $NIX_NIM_BUILD_INPUTS
  21       nim_builder --phase:configure
  22       runHook postConfigure
  23     '';
  24     buildPhase = ''
  25       runHook preBuild
  26       nim_builder --phase:build
  27       runHook postBuild
  28     '';
  29     checkPhase = ''
  30       runHook preCheck
  31       nim_builder --phase:check
  32       runHook postCheck
  33     '';
  34     installPhase = ''
  35       runHook preInstall
  36       nim_builder --phase:install
  37       runHook postInstall
  38     '';
  39     meta = { inherit (nim2.meta) maintainers platforms; };
  40   };
  41
  42   fodFromLockEntry =
  43     let
  44       methods = {
  45         fetchzip = { url, sha256, ... }:
  46           buildPackages.fetchzip {
  47             name = "source";
  48             inherit url sha256;
  49           };
  50         git = { fetchSubmodules, leaveDotGit, rev, sha256, url, ... }:
  51           buildPackages.fetchgit {
  52             inherit fetchSubmodules leaveDotGit rev sha256 url;
  53           };
  54       };
  55     in
  56     attrs@{ method, ... }:
  57     let fod = methods.${method} attrs;
  58     in ''--path:"${fod.outPath}/${attrs.srcDir}"'';
  59
  60   asFunc = x: if builtins.isFunction x then x else (_: x);
  61
  62 in
  63 buildNimPackageArgs:
  64 let
  65   composition = finalAttrs:
  66     let
  67       postPkg = baseAttrs
  68         // (asFunc ((asFunc buildNimPackageArgs) finalAttrs)) baseAttrs;
  69
  70       lockAttrs =
  71         lib.attrsets.optionalAttrs (builtins.hasAttr "lockFile" postPkg)
  72           (builtins.fromJSON (builtins.readFile postPkg.lockFile));
  73
  74       lockDepends = lockAttrs.depends or [ ];
  75
  76       lockFileNimFlags = map fodFromLockEntry lockDepends;
  77
  78       postNimOverrides = builtins.foldl' (
  79         prevAttrs:
  80         { packages, ... }@lockAttrs:
  81         builtins.foldl' (
  82           prevAttrs: name:
  83           if (builtins.hasAttr name nimOverrides) then
  84             (prevAttrs // (nimOverrides.${name} lockAttrs prevAttrs))
  85           else
  86             prevAttrs
  87         ) prevAttrs packages
  88       ) postPkg lockDepends;
  89
  90       finalOverride =
  91         { depsBuildBuild ? [ ]
  92         , nativeBuildInputs ? [ ]
  93         , nimFlags ? [ ]
  94         , requiredNimVersion ? defaultNimVersion
  95         , passthru ? { }
  96         , ...
  97         }:
  98         (if requiredNimVersion == 1 then {
  99           depsBuildBuild = [ nim_builder ] ++ depsBuildBuild;
 100           nativeBuildInputs = [ nim1 ] ++ nativeBuildInputs;
 101         } else if requiredNimVersion == 2 then {
 102           depsBuildBuild = [ nim_builder ] ++ depsBuildBuild;
 103           nativeBuildInputs = [ nim2 ] ++ nativeBuildInputs;
 104         } else
 105           throw
 106             "requiredNimVersion ${toString requiredNimVersion} is not valid") // {
 107           nimFlags = lockFileNimFlags ++ nimFlags;
 108           passthru = passthru // {
 109             # allow overriding the result of buildNimPackageArgs before this composition is applied
 110             # this allows overriding the lockFile for packages built using buildNimPackage
 111             # this is adapted from mkDerivationExtensible in stdenv.mkDerivation
 112             overrideNimAttrs = f0:
 113               let
 114                 f = self: super:
 115                   let x = f0 super;
 116                   in
 117                     if builtins.isFunction x
 118                     then f0 self super
 119                     else x;
 120               in
 121               buildNimPackage
 122                 (self:
 123                   let super = (asFunc ((asFunc buildNimPackageArgs) self)) baseAttrs;
 124                   in
 125                     super // (if builtins.isFunction f0 || f0?__functor then f self super else f0));
 126           };
 127         };
 128
 129       attrs = postNimOverrides // finalOverride postNimOverrides;
 130     in
 131     lib.trivial.warnIf (builtins.hasAttr "nimBinOnly" attrs)
 132       "the nimBinOnly attribute is deprecated for buildNimPackage"
 133       attrs;
 134
 135 in
 136 stdenv.mkDerivation composition