feat: add std.path.filter

Easily filter directories based on a simple whitelist of paths:
```
std.path.filter [
  "some/dir"
  "some/other/file"
] ./some/dir
```

`std.set.filter` returns a store path with the filtered directories
contents. This is useful for quickly collecting paths in a large
repository, e.g. a mono-repo.

If the second argument is not a directory, it will simply return a store
path with an empty file (same as passing a constant `false` value to a
`builtins.path` filter.

If a directory is in the list, it's entire contents are added.

This function is used to offer a simple API in the TOML manifest to
include filtered source files as dependencies available at `atom.src`:
```toml
[src]
binSrcA = ["paths" "to" "include"]
binSrcB = ["some" "other" "paths"]
```

src/atom/fromManifest.nix

@@ -11,6 +11,7 @@ let
   file = builtins.readFile path;
   config = builtins.fromTOML file;
   atom = config.atom or { };
+  src = config.src or { };
   name = atom.name or (mod.errors.missingName path);
 
   features' =
@@ -25,9 +26,9 @@ let
   compose = config.compose or { };
 
   root = atom.path or name;
-  extern =
+  fetches =
     let
-      fetcher = nix.fetcher or "native"; # native doesn't exist yet
+      fetcher = nix.fetcher or "native"; # TODO: native doesn't exist yet
       conf = config.fetcher or { };
       f = conf.${fetcher} or { };
       root = f.root or "npins";
@@ -55,6 +56,22 @@ let
     else
       { };
 
+  srcs =
+    let
+      filter = scopedImport {
+        std = builtins // {
+          string.split = import ../std/string/split.nix;
+        };
+      } ../std/path/filter.nix;
+    in
+    mod.filterMap (
+      name: paths: if builtins.isList paths != true then null else filter paths (dirOf path)
+    ) src;
+
+  extern = fetches // {
+    src = srcs;
+  };
+
   meta = atom.meta or { };
 
   composeFeatures = compose.features or { };

src/atom/mod.nix

@@ -49,14 +49,22 @@ rec {
     if s == k then null else { ${s} = v; }
   );
 
-  rmNixSrcs = l.filterSource (
-    path: type:
+  rmNixSrcs =
+    path:
     let
-      file = parse (baseNameOf path);
+      name = baseNameOf path;
     in
-    (type == "regular" && file.ext or null != "nix")
-    || (type == "directory" && !l.pathExists "${path}/mod.nix")
-  );
+    l.path {
+      inherit name path;
+      filter = (
+        path: type:
+        let
+          file = parse name;
+        in
+        (type == "regular" && file.ext or null != "nix")
+        || (type == "directory" && !l.pathExists "${path}/mod.nix")
+      );
+    };
 
   readStd = opts: fromManifest { inherit (opts) __internal__test features; };
 

src/std/path/filter.nix

@@ -0,0 +1,29 @@
+paths: path:
+let
+  f =
+    dir:
+    let
+      pred = builtins.elem dir paths;
+      next = f (dirOf dir);
+    in
+    dir != "." && (pred || next);
+
+  type = builtins.readFileType path;
+  name =
+    let
+      s = std.string.split "-" path;
+      pred = builtins.match "^${builtins.storeDir}/.*" (toString path) == null;
+    in
+    if pred || builtins.length s < 2 then baseNameOf path else builtins.elemAt s 1;
+in
+builtins.path {
+  inherit path name;
+  filter =
+    p: t:
+    let
+      frag = builtins.match "^${toString path}/(.*)" p;
+      frag' = builtins.head frag;
+      pred = if frag == null then false else builtins.elem frag' paths;
+    in
+    (t == "directory" && type == "directory" && pred) || f (dirOf frag');
+}

src/std/string/split.nix

@@ -0,0 +1,5 @@
+sep: str:
+let
+  p = builtins.split sep (toString str);
+in
+builtins.filter (x: builtins.typeOf x == "string") p