gobuild.nix/lib.nix at master · adisbladis/gobuild.nix · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
let
  inherit (builtins)
    isAttrs
    fromTOML
    readFile
    concatMap
    elem
    groupBy
    attrNames
    mapAttrs
    genericClosure
    ;
  lockSchemaVersion = 1;

in
{
  mkGoSet =
    {
      goLock,
      go,
      callPackage,
      lib,
      overridePackage ? drv: drv,
      rootDir ? throw "Local package was used but no root directory passed",
    }:
    let
      lockFile = if isAttrs goLock then goLock else fromTOML (readFile goLock);

      overlay' =
        assert lockFile.schema == lockSchemaVersion;
        final: prev:
        let
          cycles = lockFile.cycles or { };

          # Cycle packages by their group IDs
          cyclesByGroup =
            mapAttrs
              (
                cycleIdx: cycle:
                final.callPackage (
                  {
                    stdenv,
                    fetchers,
                    hooks,
                  }:
                  stdenv.mkDerivation {
                    name = "go-cycle-${cycleIdx}";

                    srcs = map (
                      goPackagePath:
                      let
                        locked = lockFile.locked.${goPackagePath};
                      in
                      fetchers.fetchModuleProxy {
                        inherit goPackagePath;
                        inherit (locked) version hash;
                      }
                    ) cycle;

                    nativeBuildInputs = [
                      hooks.goModuleHook
                    ];

                    propagatedBuildInputs = concatMap (
                      goPackagePath:
                      let
                        locked = lockFile.locked.${goPackagePath};
                      in
                      concatMap (req: if elem req cycle then [ ] else [ final.${req} ]) (locked.require or [ ])
                    ) cycle;

                  }
                ) { }
              )
              (
                # Attrset of cycles by their numeric group -> list of members
                groupBy (n: toString cycles.${n}) (attrNames cycles)
              );

          # Map goPackagePath -> cycle package
          cyclePkgs = mapAttrs (goPackagePath: cycleGroup: cyclesByGroup.${toString cycleGroup}) final.cycles;

        in
        {
          inherit cycles;

          require = map (goPackagePath: final.${goPackagePath}) (attrNames lockFile.locked);
        }
        //
          # Create a package per Go _module_
          mapAttrs (
            goPackagePath: locked:
            cyclePkgs.${goPackagePath} or (final.callPackage (
              {
                stdenv,
                fetchers,
                hooks,
              }:
              stdenv.mkDerivation {
                name = goPackagePath;
                inherit (locked) version;

                src = fetchers.fetchModuleProxy {
                  inherit goPackagePath;
                  inherit (locked) version hash;
                };

                passthru = {
                  inherit cycles;
                  inherit cyclePkgs;
                };

                nativeBuildInputs = [
                  hooks.goModuleHook
                ];

                propagatedBuildInputs = map (depGoPackagePath: final.${depGoPackagePath} or null) (
                  locked.require or [ ]
                );

              }
            ) { })
          ) lockFile.locked
        //
          # Create a package per local Go _package_
          mapAttrs (
            goPackagePath: locked:
            let
              # Resolve local package requirements
              require = genericClosure {
                startSet = [ { key = goPackagePath; } ];
                operator =
                  item:
                  concatMap (
                    goPackagePath: if !lockFile.package ? ${goPackagePath} then [ ] else [ { key = goPackagePath; } ]
                  ) (lockFile.package.${item.key}.require or [ ]);
              };

              # Local package directories to include
              dirs = map (item: lockFile.package.${item.key}.dir) require;

            in
            overridePackage (
              final.callPackage (
                {
                  stdenv,
                  hooks,
                }:
                stdenv.mkDerivation {
                  name = goPackagePath;

                  # Create a union of all required local sources
                  src = lib.sources.sourceByGlobs rootDir ([
                    "go.mod"
                    "go.work.sum"
                  ] ++ map (dir: "${dir}/**") dirs);

                  # Only build the current Go package
                  env.goBuildPackages = goPackagePath + "/...";

                  nativeBuildInputs = [
                    hooks.goPackageHook
                  ];

                  passthru = {
                    inherit goPackagePath;
                  };

                  propagatedBuildInputs =
                    final.require ++ map (depGoPackagePath: final.${depGoPackagePath} or null) (locked.require or [ ]);
                }
              ) { }
            )
          ) (lockFile.package or { });

    in
    (callPackage ./nix { inherit go; }).overrideScope overlay';
}