ref: streamline extra lib

modules/k8s.nix

@@ -214,6 +214,44 @@ let
       })
     latestCustomResourceTypes);
 
+  coerceListOfSubmodulesToAttrs = submodule: keyFn:
+    let
+      mergeValuesByFn = keyFn: values:
+        listToAttrs (map
+          (value:
+            nameValuePair (toString (keyFn value)) value
+          )
+          values);
+
+      # Either value of type `finalType` or `coercedType`, the latter is
+      # converted to `finalType` using `coerceFunc`.
+      coercedTo = coercedType: coerceFunc: finalType:
+        mkOptionType rec {
+          name = "coercedTo";
+          description = "${finalType.description} or ${coercedType.description}";
+          check = x: finalType.check x || coercedType.check x;
+          merge = loc: defs:
+            let
+              coerceVal = val:
+                if finalType.check val then
+                  val
+                else
+                  let coerced = coerceFunc val; in assert finalType.check coerced; coerced;
+
+            in
+            finalType.merge loc (map (def: def // { value = coerceVal def.value; }) defs);
+          getSubOptions = finalType.getSubOptions;
+          getSubModules = finalType.getSubModules;
+          substSubModules = m: coercedTo coercedType coerceFunc (finalType.substSubModules m);
+          typeMerge = t1: t2: null;
+          functor = (defaultFunctor name) // { wrapped = finalType; };
+        };
+    in
+    coercedTo
+      (types.listOf (types.submodule submodule))
+      (mergeValuesByFn keyFn)
+      (types.attrsOf (types.submodule submodule));
+
 in
 {
   imports = [ ./base.nix ];
@@ -404,7 +442,7 @@ in
       (i:
         let
           # load yaml file
-          object = loadYAML i;
+          object = importYAML i;
           groupVersion = splitString "/" object.apiVersion;
           name = object.metadata.name;
           version = last groupVersion;

modules/submodule.nix

@@ -1,7 +1,6 @@
 { config, lib, ... }:
 
 with lib;
-
 {
   imports = [ ./base.nix ];
 

modules/submodules.nix

@@ -74,6 +74,53 @@ let
         config.submodules.instances);
     })
     (removeAttrs options [ "_definedNames" "_module" "_m" "submodules" ]);
+
+  submoduleWithSpecialArgs = opts: specialArgs:
+    let
+      opts' = toList opts;
+      inherit (lib.modules) evalModules;
+    in
+    mkOptionType rec {
+      name = "submodule";
+      check = x: isAttrs x || isFunction x;
+      merge = loc: defs:
+        let
+          coerce = def: if isFunction def then def else { config = def; };
+          modules = opts' ++ map (def: { _file = def.file; imports = [ (coerce def.value) ]; }) defs;
+        in
+        (evalModules {
+          inherit modules specialArgs;
+          prefix = loc;
+        }).config;
+      getSubOptions = prefix: (evalModules
+        {
+          modules = opts'; inherit prefix specialArgs;
+          # This is a work-around due to the fact that some sub-modules,
+          # such as the one included in an attribute set, expects a "args"
+          # attribute to be given to the sub-module. As the option
+          # evaluation does not have any specific attribute name, we
+          # provide a default one for the documentation.
+          #
+          # This is mandatory as some option declaration might use the
+          # "name" attribute given as argument of the submodule and use it
+          # as the default of option declarations.
+          #
+          # Using lookalike unicode single angle quotation marks because
+          # of the docbook transformation the options receive. In all uses
+          # > and < wouldn't be encoded correctly so the encoded values
+          # would be used, and use of `<` and `>` would break the XML document.
+          # It shouldn't cause an issue since this is cosmetic for the manual.
+          args.name = "‹name›";
+        }).options;
+      getSubModules = opts';
+      substSubModules = m: submoduleWithSpecialArgs m specialArgs;
+      functor = (defaultFunctor name) // {
+        # Merging of submodules is done as part of mergeOptionDecls, as we have to annotate
+        # each submodule with its location.
+        payload = [ ];
+        binOp = lhs: rhs: [ ];
+      };
+    };
 in
 {
   imports = [ ./base.nix ];