-
Notifications
You must be signed in to change notification settings - Fork 12
/
default.nix
318 lines (284 loc) · 11.3 KB
/
default.nix
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
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
# Copyright (c) 2023 BirdeeHub
# Licensed under the MIT license
with builtins; rec {
# These are to be exported in flake outputs
utils = {
# The big function that does everything
baseBuilder =
luaPath:
{
nixpkgs
, system
, extra_pkg_config ? {}
, dependencyOverlays ? null
, nixCats_passthru ? {}
, ...
}:
categoryDefinitions:
packageDefinitions: name:
nixpkgs.lib.makeOverridable (import ../builder) {
inherit luaPath categoryDefinitions packageDefinitions name
nixpkgs system extra_pkg_config dependencyOverlays nixCats_passthru;
};
templates = import ../templates;
# allows for inputs named plugins-something to be turned into plugins automatically
standardPluginOverlay = (import ./autoPluginOverlay.nix).standardPluginOverlay;
# same as standardPluginOverlay except if you give it `plugins-foo.bar`
# you can `pkgs.neovimPlugins.foo-bar` and still `packadd foo.bar`
sanitizedPluginOverlay = (import ./autoPluginOverlay.nix).sanitizedPluginOverlay;
# returns a merged set of definitions, with new overriding old.
# updates anything it finds that isn't another set.
# this means it works slightly differently for environment variables
# because each one will be updated individually rather than at a category level.
mergeCatDefs = oldCats: newCats:
(packageDef: lib.recursiveUpdateUntilDRV (oldCats packageDef) (newCats packageDef));
# recursiveUpdate each overlay output to avoid issues where
# two overlays output a set of the same name when importing from other nixCats.
# Merges everything into 1 overlay
mergeOverlayLists = oldOverlist: newOverlist: self: super: let
oldOversMapped = map (value: value self super) oldOverlist;
newOversMapped = map (value: value self super) newOverlist;
combinedOversCalled = oldOversMapped ++ newOversMapped;
mergedOvers = foldl' lib.recursiveUpdateUntilDRV { } combinedOversCalled;
in
mergedOvers;
# if your dependencyOverlays is a list rather than a system-wrapped set,
# to deal with when other people output an overlay wrapped in a system variable
# you may call the following function on it.
fixSystemizedOverlay = overlaysSet: outfunc:
(final: prev: if !(overlaysSet ? prev.system) then {}
else (outfunc prev.system) final prev);
# Simple helper function for mergeOverlayLists
# If dependencyOverlays is an attrset, system string is required.
# If dependencyOverlays is a list, system string is ignored
# if invalid type or system, returns an empty list
safeOversList = { dependencyOverlays, system ? null }:
if isAttrs dependencyOverlays && system == null then
throw "dependencyOverlays is a set, but no system was provided"
else if isAttrs dependencyOverlays && dependencyOverlays ? system then
dependencyOverlays.${system}
else if isList dependencyOverlays then
dependencyOverlays
else [];
# makes a default package and then one for each name in packageDefinitions
mkPackages = finalBuilder: packageDefinitions: defaultName:
{ default = finalBuilder defaultName; }
// utils.mkExtraPackages finalBuilder packageDefinitions;
mkExtraPackages = finalBuilder: packageDefinitions:
(mapAttrs (name: _: finalBuilder name) packageDefinitions);
makeOverlays =
luaPath:
{
nixpkgs
, extra_pkg_config ? {}
, dependencyOverlays ? null
, nixCats_passthru ? {}
, ...
}@pkgsParams:
categoryDefFunction:
packageDefinitions: defaultName: let
keepLuaBuilder = if isFunction luaPath then luaPath else utils.baseBuilder luaPath;
makeOverlay = name: final: prev: {
${name} = keepLuaBuilder (pkgsParams // { inherit (final) system; }) categoryDefFunction packageDefinitions name;
};
overlays = (mapAttrs (name: _: makeOverlay name) packageDefinitions) // { default = (makeOverlay defaultName); };
in overlays;
makeOverlaysWithMultiDefault =
luaPath:
{
nixpkgs
, extra_pkg_config ? {}
, dependencyOverlays ? null
, nixCats_passthru ? {}
, ...
}@pkgsParams:
categoryDefFunction:
packageDefinitions: defaultName: let
keepLuaBuilder = if isFunction luaPath then luaPath else utils.baseBuilder luaPath;
makeOverlay = name: final: prev: {
${name} = keepLuaBuilder (pkgsParams // { inherit (final) system; }) categoryDefFunction packageDefinitions name;
};
overlays = (mapAttrs (name: _: makeOverlay name) packageDefinitions) // {
default = (utils.makeMultiOverlay luaPath pkgsParams categoryDefFunction packageDefinitions defaultName (attrNames packageDefinitions));
};
in overlays;
easyMultiOverlayNamespaced = package: importName: let
allnames = builtins.attrNames package.passthru.packageDefinitions;
in
(final: prev: {
${importName} = listToAttrs (map (name:
lib.nameValuePair name (package.override { inherit name; inherit (prev) system; })
) allnames);
});
mkAllPackages = package: let
allnames = builtins.attrNames package.passthru.packageDefinitions;
in
listToAttrs (map (name:
lib.nameValuePair name (package.override { inherit name; })
) allnames);
mkAllWithDefault = package:
{ default = package; } // (utils.mkAllPackages package);
easyMultiOverlay = package: let
allnames = builtins.attrNames package.passthru.packageDefinitions;
in
(final: prev: listToAttrs (map (name:
lib.nameValuePair name (package.override { inherit name; inherit (prev) system; })
) allnames));
easyNamedOvers = package: let
allnames = builtins.attrNames package.passthru.packageDefinitions;
mapfunc = map (name:
lib.nameValuePair name (final: prev: {
${name} = package.override { inherit (prev) system; };
}));
in
listToAttrs (mapfunc allnames);
# maybe you want multiple nvim packages in the same system and want
# to add them like pkgs.MyNeovims.packageName when you install them?
# both to keep it organized and also to not have to worry about naming conflicts with programs?
makeMultiOverlay = luaPath:
{
nixpkgs
, extra_pkg_config ? {}
, dependencyOverlays ? null
, nixCats_passthru ? {}
, ...
}@pkgsParams:
categoryDefFunction:
packageDefinitions:
importName:
namesIncList:
(final: prev: {
${importName} = listToAttrs (
map
(name: let
keepLuaBuilder = if builtins.isFunction luaPath then luaPath else utils.baseBuilder luaPath;
in
{
inherit name;
value = keepLuaBuilder (pkgsParams // { inherit (final) system; }) categoryDefFunction packageDefinitions name;
}
) namesIncList
);
}
);
mkNixosModules = {
dependencyOverlays
, luaPath ? ""
, keepLuaBuilder ? null
, categoryDefinitions
, packageDefinitions
, defaultPackageName
, nixpkgs
, ... }:
(import ./nixosModule.nix {
oldDependencyOverlays = dependencyOverlays;
inherit nixpkgs luaPath keepLuaBuilder categoryDefinitions
packageDefinitions defaultPackageName utils;
});
mkHomeModules = {
dependencyOverlays
, luaPath ? ""
, keepLuaBuilder ? null
, categoryDefinitions
, packageDefinitions
, defaultPackageName
, nixpkgs
, ... }:
(import ./homeManagerModule.nix {
oldDependencyOverlays = dependencyOverlays;
inherit nixpkgs luaPath keepLuaBuilder categoryDefinitions
packageDefinitions defaultPackageName utils;
});
# These were deprecated due to needing to be wrapped with ${system} and thus failing flake check
mkOverlays = finalBuilder: packageDefinitions: defaultName:
let
warn = trace "WARNING: utils.mkOverlays is deprecated. Use utils.makeOverlays instead. Will be removed on 2024-09-01.";
in (warn (
(utils.mkDefaultOverlay finalBuilder defaultName)
//
(utils.mkExtraOverlays finalBuilder packageDefinitions)
)
);
mkDefaultOverlay = finalBuilder: defaultName:
let
warn = trace "WARNING: utils.mkDefaultOverlay is deprecated. Will be removed on 2024-09-01.";
in warn { default = (self: super: { ${defaultName} = finalBuilder defaultName; }); };
mkExtraOverlays = finalBuilder: packageDefinitions:
let
warn = trace "WARNING: utils.mkExtraOverlays is deprecated. Will be removed on 2024-09-01.";
in warn (mapAttrs (name: (self: super: { ${name} = finalBuilder name; })) packageDefinitions);
mkMultiOverlay = finalBuilder: importName: namesIncList:
let
warn = trace "WARNING: utils.mkMultiOverlay is deprecated. Use utils.makeMultiOverlay instead. Will be removed on 2024-09-01.";
in (warn
(self: super: {
${importName} = listToAttrs (
map
(name:
{
inherit name;
value = finalBuilder name;
}
) namesIncList
);
}
)
);
# flake-utils' main function, because its all I used
# Builds a map from <attr>=value to <attr>.<system>=value for each system
eachSystem = systems: f:
let
# Merge together the outputs for all systems.
op = attrs: system:
let
ret = f system;
op = attrs: key: attrs //
{
${key} = (attrs.${key} or { })
// { ${system} = ret.${key}; };
}
;
in
foldl' op attrs (attrNames ret);
in
foldl' op { }
(systems
++ # add the current system if --impure is used
(if builtins ? currentSystem then
if elem currentSystem systems
then []
else [ currentSystem ]
else []));
# in case someoneone wants flake-utils but for only 1 output.
bySystems = lib.genAttrs;
};
# https://github.com/NixOS/nixpkgs/blob/nixos-23.05/lib/attrsets.nix
lib = {
isDerivation = value: value.type or null == "derivation";
recursiveUpdateUntil = pred: lhs: rhs:
let f = attrPath:
zipAttrsWith (n: values:
let here = attrPath ++ [n]; in
if length values == 1
|| pred here (elemAt values 1) (head values) then
head values
else
f here values
);
in f [] [rhs lhs];
recursiveUpdateUntilDRV = lhs: rhs:
lib.recursiveUpdateUntil (path: lhs: rhs:
# I added this check for derivation because a category can be just a derivation.
# otherwise it would squish our single derivation category rather than update.
(!((isAttrs lhs && !lib.isDerivation lhs) && (isAttrs rhs && !lib.isDerivation rhs)))
) lhs rhs;
genAttrs =
names:
f:
listToAttrs (map (n: lib.nameValuePair n (f n)) names);
nameValuePair =
name:
value:
{ inherit name value; };
};
}