feat: (addPath) Prepend a path to be filtered as import-tree config.

README.md

@@ -184,6 +184,21 @@ Or, in a simpler but less readable way:
 
 `mapWith` can be combined with any number of `filtered` and `matching` calls, in any order, but the (composed) transformation is applied _after_ the filters, and only to the paths that match all of them.
 
+### `import-tree.addPath`
+
+`addPath` can be used to prepend paths to be filtered as a setup for import-tree.
+This function can be applied multiple times.
+
+```nix
+# import-tree.addPath : (path_or_list_of_paths) -> import-tree
+
+# Both of these result in the same imported files.
+# however, the first adds ./vendor as a *pre-configured* path.
+# and the final user can supply ./modules or [] empty.
+(import-tree.addPath ./vendor) ./modules
+import-tree [./vendor ./modules]
+```
+
 ### `import-tree.withLib`
 
 > \[!NOTE\]
@@ -274,3 +289,9 @@ The test suite can be found in [`checkmate.nix`](checkmate.nix). To run it local
 ```sh
 nix flake check path:checkmate --override-input target path:.
 ```
+
+Run the following to format files:
+
+```sh
+nix run github:vic/checkmate#fmt
+```

checkmate.nix

@@ -84,6 +84,20 @@ in
           expected = [ 1 ];
         };
 
+        addPath."test `addPath` prepends a path to filter" = {
+          expr = (lit.addPath ./tree/x).leafs [ ];
+          expected = [ ./tree/x/y.nix ];
+        };
+
+        addPath."test `addPath` can be called multiple times" = {
+          expr = ((lit.addPath ./tree/x).addPath ./tree/a/b).leafs [ ];
+          expected = [
+            ./tree/x/y.nix
+            ./tree/a/b/b_a.nix
+            ./tree/a/b/m.nix
+          ];
+        };
+
         pipeTo."test pipes list into a function" = {
           expr = (lit.mapWith lib.pathType).pipeTo (lib.length) ./tree/x;
           expected = 1;

default.nix

@@ -5,6 +5,7 @@ let
       filterf ? null,
       mapf ? null,
       pipef ? null,
+      paths ? [ ],
       ...
     }:
     path:
@@ -29,13 +30,15 @@ let
         let
           initialFilter = p: lib.hasSuffix ".nix" p && !lib.hasInfix "/_" p;
         in
-        lib.pipe root [
-          (lib.lists.flatten)
-          (map lib.filesystem.listFilesRecursive)
-          (lib.lists.flatten)
-          (builtins.filter (compose (and filterf initialFilter) toString))
-          (map mapf)
-        ];
+        lib.pipe
+          [ paths root ]
+          [
+            (lib.lists.flatten)
+            (map lib.filesystem.listFilesRecursive)
+            (lib.lists.flatten)
+            (builtins.filter (compose (and filterf initialFilter) toString))
+            (map mapf)
+          ];
 
     in
     result;
@@ -63,6 +66,7 @@ let
         # Accumulated configuration
         mapf = (i: i);
         filterf = _: true;
+        paths = [ ];
 
         __functor = self: f: {
           config = (f self);
@@ -72,6 +76,7 @@ let
           filtered = filterf: self (c: mapAttr (f c) "filterf" (and filterf));
           matching = regex: self (c: mapAttr (f c) "filterf" (and (matchesRegex regex)));
           mapWith = mapf: self (c: mapAttr (f c) "mapf" (compose mapf));
+          addPath = path: self (c: mapAttr (f c) "paths" (p: p ++ [ path ]));
 
           # Configuration updates (non-accumulating)
           withLib = lib: self (c: (f c) // { inherit lib; });