mirror of
https://github.com/CHN-beta/nixos.git
synced 2024-10-23 01:59:19 +08:00
90 lines
4.4 KiB
Nix
90 lines
4.4 KiB
Nix
lib: rec
|
|
{
|
|
attrsToList = attrs: builtins.map (name: { inherit name; value = attrs.${name}; }) (builtins.attrNames attrs);
|
|
mkConditional = condition: trueResult: falseResult: let inherit (lib) mkMerge mkIf; in
|
|
mkMerge [ ( mkIf condition trueResult ) ( mkIf (!condition) falseResult ) ];
|
|
|
|
# Behaviors of these two NixOS modules would be different:
|
|
# { pkgs, ... }@inputs: { environment.systemPackages = [ pkgs.hello ]; }
|
|
# inputs: { environment.systemPackages = [ pkgs.hello ]; }
|
|
# The second one would failed to evaluate because nixpkgs would not pass pkgs to it.
|
|
# So that we wrote a wrapper to make it always works like the first one.
|
|
mkModules = moduleList:
|
|
(builtins.map
|
|
(
|
|
let handle = module: let type = builtins.typeOf module; in
|
|
if type == "path" || type == "string" then (handle (import module))
|
|
else if type == "lambda" then ({ pkgs, utils, ... }@inputs: (module inputs))
|
|
else module;
|
|
in handle
|
|
)
|
|
moduleList);
|
|
|
|
# from: https://github.com/NixOS/nix/issues/3759
|
|
stripeTabs = text:
|
|
let
|
|
# Whether all lines start with a tab (or is empty)
|
|
shouldStripTab = lines: builtins.all (line: (line == "") || (lib.strings.hasPrefix " " line)) lines;
|
|
# Strip a leading tab from all lines
|
|
stripTab = lines: builtins.map (line: lib.strings.removePrefix " " line) lines;
|
|
# Strip tabs recursively until there are none
|
|
stripTabs = lines: if (shouldStripTab lines) then (stripTabs (stripTab lines)) else lines;
|
|
in
|
|
# Split into lines. Strip leading tabs. Concat back to string.
|
|
builtins.concatStringsSep "\n" (stripTabs (lib.strings.splitString "\n" text));
|
|
|
|
# find an element in a list, return the index
|
|
findIndex = e: list:
|
|
let findIndex_ = i: list: if (builtins.elemAt list i) == e then i else findIndex_ (i + 1) list;
|
|
in findIndex_ 0 list;
|
|
|
|
# return a list of path, including:
|
|
# - all .nix file in the directory except for default.nix
|
|
# - all directories containing a default.nix
|
|
findModules = path:
|
|
mkModules (builtins.filter (path: path != null) (builtins.map
|
|
(subPath:
|
|
if subPath.value == "regular" && subPath.name != "default.nix"
|
|
then if lib.strings.hasSuffix ".nix" subPath.name
|
|
then "${path}/${subPath.name}"
|
|
else null
|
|
else if subPath.value == "directory"
|
|
then if (builtins.readDir "${path}/${subPath.name}")."default.nix" or null == "regular"
|
|
then "${path}/${subPath.name}"
|
|
else null
|
|
else null)
|
|
(attrsToList (builtins.readDir path))));
|
|
|
|
# replace the value in a nested attrset. example:
|
|
# deepReplace
|
|
# [ { path = [ "a" "b" 1 ]; value = "new value"; } ]
|
|
# { a = { b = [ "old value" "old value" ]; }; }
|
|
# => { a = { b = [ "old value" "new value" ]; }; }
|
|
deepReplace = pattern: origin:
|
|
let replace = { path, value, content }:
|
|
if path == [] then
|
|
if (builtins.typeOf value) == "lambda" then value content
|
|
else value
|
|
else let currentPath = builtins.head path; nextPath = builtins.tail path; in
|
|
if (builtins.typeOf currentPath) == "string" then
|
|
if (builtins.typeOf content) != "set" then builtins.throw "content should be a set"
|
|
else builtins.mapAttrs
|
|
(n: v: if n == currentPath then replace { path = nextPath; inherit value; content = v; } else v) content
|
|
else if (builtins.typeOf currentPath) == "int" then
|
|
if (builtins.typeOf content) != "list" then builtins.throw "content should be a list"
|
|
else lib.imap0
|
|
(i: v: if i == currentPath then replace { path = nextPath; inherit value; content = v; } else v) content
|
|
else if (builtins.typeOf currentPath) != "lambda" then throw "path should be a lambda"
|
|
else
|
|
if (builtins.typeOf content) == "list" then builtins.map
|
|
(v: if currentPath v then replace { path = nextPath; inherit value; content = v; } else v) content
|
|
else if (builtins.typeOf content) == "set" then builtins.listToAttrs (builtins.map
|
|
(v: if currentPath v then replace { path = nextPath; inherit value; content = v; } else v)
|
|
(attrsToList content))
|
|
else throw "content should be a list or a set.";
|
|
in
|
|
if (builtins.typeOf pattern) != "list" then throw "pattern should be a list"
|
|
else if pattern == [] then origin
|
|
else deepReplace (builtins.tail pattern) (replace ((builtins.head pattern) // { content = origin; }));
|
|
}
|