gitignore: fix prefix handling when chaining .gitignore in sub directory

lib/src/gitignore.rs

@@ -16,7 +16,7 @@
 
 use std::path::PathBuf;
 use std::sync::Arc;
-use std::{fs, io};
+use std::{fs, io, iter};
 
 use ignore::gitignore;
 use thiserror::Error;
@@ -39,29 +39,32 @@ pub enum GitIgnoreError {
 /// Models the effective contents of multiple .gitignore files.
 #[derive(Debug)]
 pub struct GitIgnoreFile {
-    path: String,
-    matchers: Vec<gitignore::Gitignore>,
+    parent: Option<Arc<GitIgnoreFile>>,
+    matcher: gitignore::Gitignore,
 }
 
 impl GitIgnoreFile {
     pub fn empty() -> Arc<GitIgnoreFile> {
         Arc::new(GitIgnoreFile {
-            path: Default::default(),
-            matchers: Default::default(),
+            parent: None,
+            matcher: gitignore::Gitignore::empty(),
         })
     }
 
+    /// Concatenates new `.gitignore` content at the `prefix` directory.
+    ///
+    /// The `prefix` should be a slash-separated path relative to the workspace
+    /// root.
     pub fn chain(
         self: &Arc<GitIgnoreFile>,
         prefix: &str,
         input: &[u8],
     ) -> Result<Arc<GitIgnoreFile>, GitIgnoreError> {
-        let path = self.path.clone() + prefix;
-        let mut builder = gitignore::GitignoreBuilder::new(&path);
+        let mut builder = gitignore::GitignoreBuilder::new(prefix);
         for (i, input_line) in input.split(|b| *b == b'\n').enumerate() {
             let line =
                 std::str::from_utf8(input_line).map_err(|err| GitIgnoreError::InvalidUtf8 {
-                    path: PathBuf::from(&path),
+                    path: PathBuf::from(prefix),
                     line_num_for_display: i + 1,
                     line: String::from_utf8_lossy(input_line).to_string(),
                     source: err,
@@ -71,12 +74,18 @@ impl GitIgnoreFile {
             builder.add_line(None, line)?;
         }
         let matcher = builder.build()?;
-        let mut matchers = self.matchers.clone();
-        matchers.push(matcher);
-
-        Ok(Arc::new(GitIgnoreFile { path, matchers }))
+        let parent = if self.matcher.is_empty() {
+            self.parent.clone() // omit the empty root
+        } else {
+            Some(self.clone())
+        };
+        Ok(Arc::new(GitIgnoreFile { parent, matcher }))
     }
 
+    /// Concatenates new `.gitignore` file at the `prefix` directory.
+    ///
+    /// The `prefix` should be a slash-separated path relative to the workspace
+    /// root.
     pub fn chain_with_file(
         self: &Arc<GitIgnoreFile>,
         prefix: &str,
@@ -94,18 +103,17 @@ impl GitIgnoreFile {
     }
 
     fn matches_helper(&self, path: &str, is_dir: bool) -> bool {
-        self.matchers
-            .iter()
-            .rev()
-            .find_map(|matcher|
-                      // TODO: the documentation warns that
-                      // `matched_path_or_any_parents` is slower than `matched`;
-                      // ideally, we would switch to that.
-                      match matcher.matched_path_or_any_parents(path, is_dir) {
-                          ignore::Match::None => None,
-                          ignore::Match::Ignore(_) => Some(true),
-                          ignore::Match::Whitelist(_) => Some(false),
-                      })
+        iter::successors(Some(self), |file| file.parent.as_deref())
+            .find_map(|file| {
+                // TODO: the documentation warns that
+                // `matched_path_or_any_parents` is slower than `matched`;
+                // ideally, we would switch to that.
+                match file.matcher.matched_path_or_any_parents(path, is_dir) {
+                    ignore::Match::None => None,
+                    ignore::Match::Ignore(_) => Some(true),
+                    ignore::Match::Whitelist(_) => Some(false),
+                }
+            })
             .unwrap_or_default()
     }
 
@@ -199,6 +207,23 @@ mod tests {
         assert!(file.matches("dir1/dir2/dir3/dir4/foo"));
     }
 
+    #[test]
+    fn test_gitignore_deep_dir_chained() {
+        // Prefix is relative to root, not to parent file
+        let file = GitIgnoreFile::empty()
+            .chain("", b"/dummy\n")
+            .unwrap()
+            .chain("dir1/", b"/dummy\n")
+            .unwrap()
+            .chain("dir1/dir2/", b"/dir3\n")
+            .unwrap();
+        assert!(!file.matches("foo"));
+        assert!(!file.matches("dir1/foo"));
+        assert!(!file.matches("dir1/dir2/foo"));
+        assert!(file.matches("dir1/dir2/dir3/foo"));
+        assert!(file.matches("dir1/dir2/dir3/dir4/foo"));
+    }
+
     #[test]
     fn test_gitignore_match_only_dir() {
         let file = GitIgnoreFile::empty().chain("", b"/dir/\n").unwrap();
@@ -354,12 +379,13 @@ mod tests {
 
     #[test]
     fn test_gitignore_file_ordering() {
-        let file1 = GitIgnoreFile::empty().chain("", b"foo\n").unwrap();
-        let file2 = file1.chain("foo/", b"!bar").unwrap();
-        let file3 = file2.chain("foo/bar/", b"baz").unwrap();
+        let file1 = GitIgnoreFile::empty().chain("", b"/foo\n").unwrap();
+        let file2 = file1.chain("foo/", b"!/bar").unwrap();
+        let file3 = file2.chain("foo/bar/", b"/baz").unwrap();
         assert!(file1.matches("foo"));
         assert!(file1.matches("foo/bar"));
         assert!(!file2.matches("foo/bar"));
+        assert!(!file2.matches("foo/bar/baz"));
         assert!(file2.matches("foo/baz"));
         assert!(file3.matches("foo/bar/baz"));
         assert!(!file3.matches("foo/bar/qux"));