dont filter on root prefix. (#22)

for example, if user does `import-tree ./_foo`,

explicitly asking to traverse `./_foo`, then results must be
`./_foo/bar.nix` but not `./_foo/_baz.nix`.

that is, filtering occurs only on after-root paths.

Author: vic

checkmate.nix

@@ -255,6 +255,11 @@ in
             ./tree/modules/hello-world/mod.nix
           ];
         };
+
+        leafs."test loads from hidden directory but excludes sub-hidden" = {
+          expr = lit.leafs ./tree/a/b/_c;
+          expected = [ ./tree/a/b/_c/d/e.nix ];
+        };
       };
 
     }

default.nix

@@ -27,9 +27,10 @@ let
         };
 
       leafs =
-        lib: root:
+        lib:
         let
           treeFiles = t: (t.withLib lib).files;
+
           listFilesRecursive =
             x:
             if isImportTree x then
@@ -40,19 +41,66 @@ let
               lib.filesystem.listFilesRecursive x
             else
               [ x ];
+
           nixFilter = andNot (lib.hasInfix "/_") (lib.hasSuffix ".nix");
+
           initialFilter = if initf != null then initf else nixFilter;
+
           pathFilter = compose (and filterf initialFilter) toString;
+
           otherFilter = and filterf (if initf != null then initf else (_: true));
+
           filter = x: if isPathLike x then pathFilter x else otherFilter x;
+
+          isFileRelative =
+            root:
+            { file, rel }:
+            if file != null && lib.hasPrefix root file then
+              {
+                file = null;
+                rel = lib.removePrefix root file;
+              }
+            else
+              { inherit file rel; };
+          getFileRelative = { file, rel }: if rel == null then file else rel;
+
+          makeRelative =
+            roots:
+            lib.pipe roots [
+              (lib.lists.flatten)
+              (builtins.filter isDirectory)
+              (builtins.map builtins.toString)
+              (builtins.map isFileRelative)
+              (fx: fx ++ [ getFileRelative ])
+              (
+                fx: file:
+                lib.pipe {
+                  file = builtins.toString file;
+                  rel = null;
+                } fx
+              )
+            ];
+
+          rootRelative =
+            roots:
+            let
+              mkRel = makeRelative roots;
+            in
+            x: if isPathLike x then mkRel x else x;
         in
+        root:
         lib.pipe
           [ paths root ]
           [
             (lib.lists.flatten)
             (map listFilesRecursive)
             (lib.lists.flatten)
-            (builtins.filter filter)
+            (builtins.filter (
+              compose filter (rootRelative [
+                paths
+                root
+              ])
+            ))
             (map mapf)
           ];
 

tree/a/b/_c/d/_f.nix

@@ -0,0 +1 @@
+true