babashka · borkdude · Apr 30, 2025 · Apr 29, 2025 · Apr 29, 2025 · Apr 29, 2025
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -4,6 +4,9 @@ For a list of breaking changes, check [here](#breaking-changes).
 
 Babashka [fs](https://github.com/babashka/fs): file system utility library for Clojure
 
+## Unreleased
+
+- #141: `fs/match` doesn't match when root dir contains glob or regex characters in path
 - [#138](https://github.com/babashka/fs/issues/138): Fix `fs/update-file` to support paths ([@rfhayashi](https://github.com/rfhayashi))
 
 ## v0.5.24 (2025-01-09)

diff --git a/src/babashka/fs.cljc b/src/babashka/fs.cljc
@@ -259,6 +259,21 @@
       (str/lower-case)
       (str/includes? "win")))
 
+(defn- escape-glob-chars
+  "Escapes special glob characters in the input string."
+  [s]
+  (let [special-chars #{\\ \* \? \[ \] \{ \}}
+        escape-char (fn [c]
+                      (if (contains? special-chars c)
+                        (str "\\" c)
+                        (str c)))]
+    (apply str (map escape-char s))))
+
+(defn- escape-regex-chars
+  "Escapes a string so it can be used literally in a regular expression."
+  [s]
+  (java.util.regex.Pattern/quote s))
+
 (defn match
   "Given a file and match pattern, returns matches as vector of
   paths. Pattern interpretation is done using the rules described in
@@ -276,19 +291,20 @@
   `(fs/match \".\" \"regex:.*\\\\.clj\" {:recursive true})`"
   ([root pattern] (match root pattern nil))
   ([root pattern {:keys [hidden follow-links max-depth recursive]}]
-   (let [base-path (-> root absolutize normalize)
-         base-path (if win?
-                     (str/replace base-path file-separator (str "\\" file-separator))
-                     (str base-path))
+   (let [[prefix pattern] (str/split pattern #":")
+         base-path (-> root absolutize normalize str)
+         escaped-base-path (case prefix
+                             "glob" (escape-glob-chars base-path)
+                             "regex" (escape-regex-chars base-path)
+                             base-path)
          skip-hidden? (not hidden)
          results (atom (transient []))
          past-root? (volatile! nil)
-         [prefix pattern] (str/split pattern #":")
          pattern (let [separator (when-not (str/ends-with? base-path file-separator)
                                    ;; we need to escape the file separator on Windows
                                    (str (when win? "\\")
                                         file-separator))]
-                   (str base-path
+                   (str escaped-base-path
                         separator
                         (if win?
                           (str/replace pattern "/" "\\\\")

diff --git a/test/babashka/fs_test.clj b/test/babashka/fs_test.clj
@@ -76,7 +76,16 @@
           _ (spit (fs/file nested-dir "dude.txt") "contents")]
       (is (= 1 (count (if windows?
                         (fs/match tmp-dir1 "regex:foo\\\\bar\\\\baz\\\\.*" {:recursive true})
-                        (fs/match tmp-dir1 "regex:foo/bar/baz/.*" {:recursive true}))))))))
+                        (fs/match tmp-dir1 "regex:foo/bar/baz/.*" {:recursive true})))))))
+  (when-not windows?
+    (testing "match on root with special chars"
+      (let [dir (fs/create-dirs (fs/path "test-resources" "foo*{[]}"))
+            txt-file (fs/file dir "test.txt")]
+        (fs/delete-on-exit dir)
+        (fs/delete-on-exit txt-file)
+        (spit txt-file "hello"))
+      (is (= "test.txt" (fs/file-name (first (fs/match "test-resources/foo*{[]}" "glob:*.txt")))))
+      (is (= "test.txt" (fs/file-name (first (fs/match "test-resources/foo*{[]}" "regex:.*\\.txt"))))))))
 
 (deftest glob-test
   (let [readme-match (fs/glob "." "README.md")]