1 files changed, 110 insertions, 56 deletions
diff --git a/by-name-overlay.nix b/by-name-overlay.nix
index eb35b5f..2d03e75 100644
--- a/by-name-overlay.nix
+++ b/by-name-overlay.nix
@@ -1,36 +1,33 @@
 # nixLib - A library of nix functions for vhack.eu
 #
 # Copyright (C) 2025 Benedikt Peetz <benedikt.peetz@b-peetz.de>
-# SPDX-License-Identifier: AGPL-3.0-or-later
+# SPDX-License-Identifier: LGPL-3.0-or-later
 #
 # This file is part of vhack.eu's nix library.
 #
 # You should have received a copy of the License along with this program.
 # If not, see <https://www.gnu.org/licenses/gpl-3.0.txt>.
-
 {warn}:
 # Adapted from this: https://github.com/NixOS/nixpkgs/blob/1814b56453c91192f6d5a6276079948f9fe96c18/pkgs/top-level/by-name-overlay.nix
 # This file should not depend on `pkgs` and thus not use `lib`.
 {
   baseDirectory,
-  fileName,
-  finalizeFunction,
-  coImportsNameFunction ? null,
-  coImportsWarnMessageObject ? null,
+  fileName ? null,
+  fileRegex ? null,
+  finalizeFunction ? name: value: value,
   useShards ? true,
-}: let
-  # Takes a list of attrs as input and returns one merged attr set.
-  flattenAttrs = list:
-    if builtins.isList list
-    then
-      builtins.foldl' (acc: elem:
-        if builtins.isList elem
-        # Merging them with `//` is okay here, as we can be sure that the attr names are
-        # unique (they were separate dictionary after all)
-        then acc // (flattenAttrs elem)
-        else acc // elem) {}
-      list
-    else list;
+  relativePaths ? false,
+}:
+assert fileName == null -> fileRegex != null;
+assert fileRegex == null -> fileName != null; let
+  finalFileRegex =
+    if fileRegex == null
+    then "^${escapeRegex fileName}$"
+    else fileRegex;
+  fileDisplay =
+    if fileName == null
+    then "matching ${fileRegex}"
+    else fileName;
 
   # From nixpkgs/lib {{{
   # These functions are taken straight out of the `nixpkgs/lib`.
@@ -39,6 +36,12 @@
   mapAttrsToList = f: attrs:
     builtins.map (name: f name attrs.${name}) (builtins.attrNames attrs);
 
+  stringToCharacters = s: builtins.genList (p: builtins.substring p 1 s) (builtins.stringLength s);
+  escape = list: builtins.replaceStrings list (map (c: "\\${c}") list);
+  escapeRegex = escape (stringToCharacters "\\[{()^$?*+|.");
+
+  mapAttrs' = f: set: builtins.listToAttrs (map (attr: f attr set.${attr}) (builtins.attrNames set));
+
   nameValuePair = name: value: {inherit name value;};
   filterAttrs = pred: set:
     builtins.listToAttrs (builtins.concatMap (name: let
@@ -49,47 +52,98 @@
       else []) (builtins.attrNames set));
   # }}}
 
-  # Module files for a single shard
-  # Type: String -> String -> ListOf Path
-  namesForShard = shard: type:
-    if type != "directory"
-    then warn "Ignored non-directory, whilst importing by-name directory (${fileName}): '${shard}'" {}
-    else if useShards
-    then namesForElement shard type
-    else namesForElement "." type;
+  rawByName = {
+    baseDirectory,
+    finalFileRegex,
+    fileDisplay,
+    finalizeFunction,
+    useShards,
+    relativePaths,
+  }: let
+    # Takes a list of attrs as input and returns one merged attr set.
+    flattenAttrs = list:
+      if builtins.isList list
+      then
+        builtins.foldl' (acc: elem:
+          if builtins.isList elem
+          # Merging them with `//` is okay here, as we can be sure that the attr names are
+          # unique (they were separate dictionary after all)
+          then acc // (flattenAttrs elem)
+          else acc // elem) {}
+        list
+      else list;
+
+    # Module files for a single shard
+    # Type: String -> String -> ListOf Path
+    namesForShard = shard: type:
+      if type != "directory"
+      then warn "Ignored non-directory, whilst importing by-name directory (${fileDisplay}): '${shard}'" {}
+      else if useShards
+      then namesForElementShard shard type
+      else namesForElementDirect shard type;
 
-  namesForElement = shard: _type: let
-    mkPath = name: type: let
-      path = baseDirectory + "/${shard}/${name}" + "/${fileName}";
-      coImportPath =
-        if coImportsNameFunction != null
+    # Type: String -> String -> String -> ListOf Path
+    mkPath = shard: name: toplevelType: let
+      rawPath = baseDirectory + "/${shard}/${name}";
+      paths = filterAttrs (_: v: v != null) (mapAttrs' (name: value:
+        if builtins.match finalFileRegex name != null
+        then nameValuePair name value
+        else nameValuePair name null) (builtins.readDir rawPath));
+
+      checkPath = pathSegment: type: let
+        path = rawPath + "/${pathSegment}";
+      in
+        if builtins.pathExists path
         then
-          coImportsNameFunction
-          {inherit shard name;}
-        else path;
+          if toplevelType != "directory"
+          then
+            # The `namesForShard` function should have already printed a warning.
+            [null]
+          else if relativePaths
+          then pathSegment
+          else path
+        else warn "'${builtins.toString path}' does not exist. Skipped" null;
     in
-      if builtins.pathExists path
+      if toplevelType != "directory"
       then
-        if type != "directory"
-        then
-          # The `namesForShard` function should have already printed a warning.
-          null
-        else if builtins.pathExists coImportPath
-        then path
-        else warn "'${builtins.toString coImportPath}' does not exist. Should include ${coImportsWarnMessageObject} for '${shard}/${name}'" path
-      else warn "'${builtins.toString path}' does not exist. Skipped" null;
-  in
-    filterAttrs (name: value: value != null)
-    (builtins.mapAttrs
-      mkPath
+        # The `namesForShard` function should have already printed a warning.
+        [null]
+      else if (builtins.attrValues paths) == []
+      then warn "'${fileDisplay}' did not match anything in ${builtins.toString rawPath}. Skipped" [null]
+      else mapAttrsToList checkPath paths;
+
+    filterNull = list: builtins.filter (value: value != null) list;
+    # Type: String -> String -> AttrSet
+    namesForElementShard = shard: _type: (builtins.mapAttrs
+      (name: type: filterNull (mkPath shard name type))
       (builtins.readDir (baseDirectory + "/${shard}")));
 
-  # A list of all module paths.
-  # These can the be simply injected into `import`
-  files = flattenAttrs (mapAttrsToList namesForShard (builtins.readDir baseDirectory));
-  output =
-    builtins.mapAttrs
-    finalizeFunction
-    files;
+    # Type: String -> String -> AttrSet
+    namesForElementDirect = name: type: {"${name}" = filterNull ((mkPath ".") name type);};
+
+    # A list of all paths.
+    output = flattenAttrs (mapAttrsToList namesForShard (builtins.readDir baseDirectory));
+  in
+    output;
+
+  firstPass = rawByName {
+    inherit
+      baseDirectory
+      finalFileRegex
+      fileDisplay
+      finalizeFunction
+      useShards
+      relativePaths
+      ;
+  };
+
+  secondPass =
+    if fileName != null
+    then
+      builtins.mapAttrs (name: value: builtins.head value)
+      (filterAttrs (_: value: value != []) firstPass)
+    else firstPass;
 in
-  output
+  builtins.mapAttrs
+  finalizeFunction
+  secondPass