Fix gitignore glob behavior introduced in #1234 (#1236)

Author: cakekindel

src/Spago/Glob.purs

@@ -49,7 +49,7 @@ gitignoreGlob base =
       ( \line -> do
           let
             resolve a = Path.concat [ base, a ]
-            pat a = resolve $ unpackPattern a
+            pat a = withForwardSlashes $ resolve $ unpackPattern a
           case String.stripPrefix (String.Pattern "!") line of
             Just negated -> Left $ pat negated
             Nothing -> Right $ pat line
@@ -78,16 +78,18 @@ fsWalk cwd ignorePatterns includePatterns = Aff.makeAff \cb -> do
 
   -- If this Ref contains `true` because this Aff has been canceled, then deepFilter will always return false.
   canceled <- Ref.new false
+
   let
     entryGitignore :: Entry -> Effect Unit
     entryGitignore entry =
       try (SyncFS.readTextFile UTF8 entry.path)
         >>= traverse_ \gitignore ->
           let
             base = Path.relative cwd $ Path.dirname entry.path
-            pats = splitGlob $ gitignoreGlob base gitignore
-            patIsOk g = not $ any (testGlob g) includePatterns
-            newPats = filter (patIsOk) pats
+            glob = gitignoreGlob base gitignore
+            pats = splitGlob glob
+            patOk g = not $ any (testGlob g) includePatterns
+            newPats = filter patOk pats
           in
             void $ Ref.modify (_ <> fold newPats) $ ignoreMatcherRef
 

test/Spago/Glob.purs

@@ -2,10 +2,12 @@ module Test.Spago.Glob where
 
 import Test.Prelude
 
+import Data.Array as Array
 import Data.Foldable (intercalate)
 import Data.String.Gen (genAlphaLowercaseString)
 import Effect.Aff as Aff
 import Node.Path as Path
+import Node.Process as Process
 import Spago.FS as FS
 import Spago.Glob as Glob
 import Test.QuickCheck.Gen (randomSample', resize)
@@ -29,10 +31,10 @@ globTmpDir m = Aff.bracket make cleanup m
         base
       dir
         "fruits"
-        [ touch "apple"
-        , touch "orange"
-        , touch "banana"
-        , dir "special"
+        [ dir "left"
+          [ touch "apple"
+          ]
+        , dir "right"
           [ touch "apple"
           ]
         ]
@@ -48,36 +50,55 @@ globTmpDir m = Aff.bracket make cleanup m
 spec :: Spec Unit
 spec = Spec.around globTmpDir do
   Spec.describe "glob" do
+    Spec.describe "glob behavior" do
+      Spec.it "'**/..' matches 0 or more directories" \p -> do
+        a <- Glob.gitignoringGlob (Path.concat [p, "fruits/left"]) ["**/apple"]
+        b <- Glob.gitignoringGlob (Path.concat [p, "fruits"]) ["**/apple"]
+        Array.sort a `Assert.shouldEqual` ["apple"]
+        Array.sort b `Assert.shouldEqual` ["left/apple", "right/apple"]
+
+      Spec.it "'../**/..' matches 0 or more directories" \p -> do
+        a <- Glob.gitignoringGlob p ["fruits/**/apple"]
+        Array.sort a `Assert.shouldEqual` ["fruits/left/apple", "fruits/right/apple"]
+
+      Spec.it "'../**' matches 0 or more directories" \p -> do
+        a <- Glob.gitignoringGlob p ["fruits/left/**"]
+        Array.sort a `Assert.shouldEqual` ["fruits/left", "fruits/left/apple"]
+
     Spec.describe "gitignoringGlob" do
       Spec.it "when no .gitignore, yields all matches" \p -> do
         a <- Glob.gitignoringGlob p ["**/apple"]
-        a `Assert.shouldEqual` ["fruits/apple", "fruits/special/apple", "src/fruits/apple"]
+        Array.sort a `Assert.shouldEqual` ["fruits/left/apple", "fruits/right/apple", "src/fruits/apple"]
 
       Spec.it "respects a .gitignore pattern that doesn't conflict with search" \p -> do
-        FS.writeTextFile (Path.concat [p, ".gitignore"]) "/fruits"
-        a <- Glob.gitignoringGlob p ["**/apple"]
-        a `Assert.shouldEqual` ["src/fruits/apple"]
+        FS.writeTextFile (Path.concat [p, ".gitignore"]) "fruits/right"
+        a <- Glob.gitignoringGlob p ["fruits/**/apple"]
+        Array.sort a `Assert.shouldEqual` ["fruits/left/apple"]
+
+      Spec.it "respects some .gitignore patterns" \p -> do
+        FS.writeTextFile (Path.concat [p, ".gitignore"]) "fruits\nfruits/right"
+        a <- Glob.gitignoringGlob p ["fruits/**/apple"]
+        Array.sort a `Assert.shouldEqual` ["fruits/left/apple"]
 
       Spec.it "respects a negated .gitignore pattern" \p -> do
-        FS.writeTextFile (Path.concat [p, ".gitignore"]) "!/fruits/special/apple\n/fruits/apple"
+        FS.writeTextFile (Path.concat [p, ".gitignore"]) "!/fruits/left/apple\n/fruits/**/apple"
         a <- Glob.gitignoringGlob p ["**/apple"]
-        a `Assert.shouldEqual` ["fruits/special/apple", "src/fruits/apple"]
+        Array.sort a `Assert.shouldEqual` ["fruits/left/apple", "src/fruits/apple"]
 
       for_ ["/fruits", "fruits", "fruits/", "**/fruits", "fruits/**", "**/fruits/**"] \gitignore -> do
-        Spec.focus $ Spec.it
+        Spec.it
           ("does not respect a .gitignore pattern that conflicts with search: " <> gitignore)
           \p -> do
             FS.writeTextFile (Path.concat [p, ".gitignore"]) gitignore
-            a <- Glob.gitignoringGlob p ["fruits/apple/**"]
-            a `Assert.shouldEqual` ["fruits/apple"]
-
-      Spec.it "respects some .gitignore patterns" \p -> do
-        FS.writeTextFile (Path.concat [p, ".gitignore"]) """/fruits\n/src"""
-        a <- Glob.gitignoringGlob p ["fruits/apple/**"]
-        a `Assert.shouldEqual` ["fruits/apple"]
+            a <- Glob.gitignoringGlob p ["fruits/**/apple"]
+            Array.sort a `Assert.shouldEqual` ["fruits/left/apple", "fruits/right/apple"]
 
       Spec.it "is stacksafe" \p -> do
-        hugeGitignore <- liftEffect $ intercalate "\n" <$> randomSample' 10000 (resize 4 $ genAlphaLowercaseString)
+        let
+          chars = ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k"]
+          -- 10,000-line gitignore
+          words = [\a b c d -> a <> b <> c <> d] <*> chars <*> chars <*> chars <*> chars
+          hugeGitignore = intercalate "\n" words
         FS.writeTextFile (Path.concat [p, ".gitignore"]) hugeGitignore
-        a <- Glob.gitignoringGlob p ["fruits/apple/**"]
-        a `Assert.shouldEqual` ["fruits/apple"]
+        a <- Glob.gitignoringGlob p ["fruits/**/apple"]
+        Array.sort a `Assert.shouldEqual` ["fruits/left/apple", "fruits/right/apple"]