push base path handling to the caller (#301)

The caller merely has to make sure that relative paths are passed,
and this happens automatically if the base is handled correctly,
either by using `std::path::Path` to strip prefixes or to assure
that there is a trailing slash in the base.

Author: Byron

git-attributes/tests/parse/attribute.rs

@@ -30,7 +30,7 @@ fn line_numbers_are_counted_correctly() {
             (pattern(r"!foo.html", Mode::NO_SUB_DIR, None), vec![set("x")], 8),
             (pattern(r"#a/path", Mode::empty(), None), vec![unset("a")], 10),
             (
-                pattern(r"*", Mode::ABSOLUTE | Mode::NO_SUB_DIR | Mode::ENDS_WITH, Some(0)),
+                pattern(r"/*", Mode::ABSOLUTE | Mode::NO_SUB_DIR | Mode::ENDS_WITH, Some(1)),
                 vec![unspecified("b")],
                 11
             ),

git-attributes/tests/parse/ignore.rs

@@ -20,10 +20,10 @@ fn line_numbers_are_counted_correctly() {
             ("*.[oa]".into(), Mode::NO_SUB_DIR, 2),
             ("*.html".into(), Mode::NO_SUB_DIR | Mode::ENDS_WITH, 5),
             ("foo.html".into(), Mode::NO_SUB_DIR | Mode::NEGATIVE, 8),
-            ("*".into(), Mode::NO_SUB_DIR | Mode::ENDS_WITH | Mode::ABSOLUTE, 11),
-            ("foo".into(), Mode::NEGATIVE | Mode::NO_SUB_DIR | Mode::ABSOLUTE, 12),
-            ("foo/*".into(), Mode::ABSOLUTE, 13),
-            ("foo/bar".into(), Mode::ABSOLUTE | Mode::NEGATIVE, 14)
+            ("/*".into(), Mode::NO_SUB_DIR | Mode::ENDS_WITH | Mode::ABSOLUTE, 11),
+            ("/foo".into(), Mode::NEGATIVE | Mode::NO_SUB_DIR | Mode::ABSOLUTE, 12),
+            ("/foo/*".into(), Mode::ABSOLUTE, 13),
+            ("/foo/bar".into(), Mode::ABSOLUTE | Mode::NEGATIVE, 14)
         ]
     );
 }

git-glob/src/pattern.rs

@@ -52,8 +52,7 @@ impl Pattern {
     }
 
     /// Match the given `path` which takes slashes (and only slashes) literally, and is relative to the repository root.
-    /// Note that `path` is assumed to be relative to the repository, and that `base_path` is assumed to contain `path`
-    /// and is also relative to the repository.
+    /// Note that `path` is assumed to be relative to the repository.
     ///
     /// We may take various shortcuts which is when `basename_start_pos` and `is_dir` come into play.
     /// `basename_start_pos` is the index at which the `path`'s basename starts.
@@ -65,7 +64,6 @@ impl Pattern {
         &self,
         path: impl Into<&'a BStr>,
         basename_start_pos: Option<usize>,
-        base_path: Option<&BStr>,
         is_dir: bool,
         case: Case,
     ) -> bool {
@@ -84,15 +82,7 @@ impl Pattern {
             path.rfind_byte(b'/').map(|p| p + 1),
             "BUG: invalid cached basename_start_pos provided"
         );
-        debug_assert!(
-            base_path.map_or(true, |p| p.ends_with(b"/")),
-            "base must end with a trailing slash"
-        );
         debug_assert!(!path.starts_with(b"/"), "input path must be relative");
-        debug_assert!(
-            base_path.map(|base| path.starts_with(base)).unwrap_or(true),
-            "repo-relative paths must be pre-filtered to match our base."
-        );
 
         let (text, first_wildcard_pos) = self
             .mode
@@ -101,21 +91,12 @@ impl Pattern {
             .unwrap_or((self.text.as_bstr(), self.first_wildcard_pos));
         if self.mode.contains(pattern::Mode::NO_SUB_DIR) {
             let basename = if self.mode.contains(pattern::Mode::ABSOLUTE) {
-                base_path
-                    .and_then(|base| path.strip_prefix(base.as_ref()).map(|b| b.as_bstr()))
-                    .unwrap_or(path)
+                path
             } else {
                 &path[basename_start_pos.unwrap_or_default()..]
             };
             self.matches_inner(text, first_wildcard_pos, basename, flags)
         } else {
-            let path = match base_path {
-                Some(base) => match path.strip_prefix(base.as_ref()) {
-                    Some(path) => path.as_bstr(),
-                    None => return false,
-                },
-                None => path,
-            };
             self.matches_inner(text, first_wildcard_pos, path, flags)
         }
     }

git-glob/tests/matching/mod.rs

@@ -72,7 +72,6 @@ fn compare_baseline_with_ours() {
                 pattern.matches_repo_relative_path(
                     value,
                     basename_start_pos(value),
-                    None,
                     false, // TODO: does it make sense to pretend it is a dir and see what happens?
                     *case,
                 )
@@ -112,11 +111,11 @@ fn non_dirs_for_must_be_dir_patterns_are_ignored() {
     );
     let path = "hello";
     assert!(
-        !pattern.matches_repo_relative_path(path, None, None, false /* is-dir */, Case::Sensitive),
+        !pattern.matches_repo_relative_path(path, None, false /* is-dir */, Case::Sensitive),
         "non-dirs never match a dir pattern"
     );
     assert!(
-        pattern.matches_repo_relative_path(path, None, None, true /* is-dir */, Case::Sensitive),
+        pattern.matches_repo_relative_path(path, None, true /* is-dir */, Case::Sensitive),
         "dirs can match a dir pattern with the normal rules"
     );
 }
@@ -146,13 +145,6 @@ fn basename_matches_from_end() {
     assert!(!match_file(pat, "barfoo", Case::Sensitive));
 }
 
-#[test]
-#[should_panic]
-fn base_path_must_match_or_panic_occours_in_debug_mode() {
-    let pat = pat("foo");
-    assert!(match_file_with_base(&pat, "other/FoO", "base/", Case::Fold));
-}
-
 #[test]
 fn absolute_basename_matches_only_from_beginning() {
     let pat = &pat("/foo");
@@ -161,13 +153,6 @@ fn absolute_basename_matches_only_from_beginning() {
     assert!(match_file(pat, "foo", Case::Sensitive));
     assert!(!match_file(pat, "Foo", Case::Sensitive));
     assert!(!match_file(pat, "bar/foo", Case::Sensitive));
-
-    let base = "base/";
-    assert!(match_file_with_base(pat, "base/FoO", base, Case::Fold));
-    assert!(!match_file_with_base(pat, "base/bar/Foo", base, Case::Fold));
-    assert!(match_file_with_base(pat, "base/foo", base, Case::Sensitive));
-    assert!(!match_file_with_base(pat, "base/Foo", base, Case::Sensitive));
-    assert!(!match_file_with_base(pat, "base/bar/foo", base, Case::Sensitive));
 }
 
 #[test]
@@ -178,13 +163,6 @@ fn absolute_path_matches_only_from_beginning() {
     assert!(!match_file(pat, "foo", Case::Sensitive));
     assert!(match_file(pat, "bar/foo", Case::Sensitive));
     assert!(!match_file(pat, "bar/Foo", Case::Sensitive));
-
-    let base = "base/";
-    assert!(!match_file_with_base(pat, "base/FoO", base, Case::Fold));
-    assert!(match_file_with_base(pat, "base/bar/Foo", base, Case::Fold));
-    assert!(!match_file_with_base(pat, "base/foo", base, Case::Sensitive));
-    assert!(match_file_with_base(pat, "base/bar/foo", base, Case::Sensitive));
-    assert!(!match_file_with_base(pat, "base/bar/Foo", base, Case::Sensitive));
 }
 
 #[test]
@@ -193,22 +171,13 @@ fn absolute_path_with_recursive_glob_detects_mismatches_quickly() {
     assert!(!match_file(pat, "FoO", Case::Fold));
     assert!(!match_file(pat, "bar/Fooo", Case::Fold));
     assert!(!match_file(pat, "baz/bar/Foo", Case::Fold));
-
-    let base = "base/";
-    assert!(!match_file_with_base(pat, "base/FoO", base, Case::Fold));
-    assert!(!match_file_with_base(pat, "base/bar/Fooo", base, Case::Fold));
-    assert!(!match_file_with_base(pat, "base/baz/bar/foo", base, Case::Sensitive));
 }
 
 #[test]
 fn absolute_path_with_recursive_glob_can_do_case_insensitive_prefix_search() {
     let pat = &pat("/bar/foo/**");
     assert!(!match_file(pat, "bar/Foo/match", Case::Sensitive));
     assert!(match_file(pat, "bar/Foo/match", Case::Fold));
-
-    let base = "base/";
-    assert!(!match_file_with_base(pat, "base/bar/Foo/match", base, Case::Sensitive));
-    assert!(match_file_with_base(pat, "base/bar/Foo/match", base, Case::Fold));
 }
 
 #[test]
@@ -303,18 +272,7 @@ fn match_file<'a>(pattern: &git_glob::Pattern, path: impl Into<&'a BStr>, case:
 
 fn match_path<'a>(pattern: &git_glob::Pattern, path: impl Into<&'a BStr>, is_dir: bool, case: Case) -> bool {
     let path = path.into();
-    pattern.matches_repo_relative_path(path, basename_start_pos(path), None, is_dir, case)
-}
-
-fn match_file_with_base<'a>(
-    pattern: &git_glob::Pattern,
-    path: impl Into<&'a BStr>,
-    base: impl Into<&'a BStr>,
-    case: Case,
-) -> bool {
-    let path = path.into();
-    let base = base.into();
-    pattern.matches_repo_relative_path(path, basename_start_pos(path), Some(base), false, case)
+    pattern.matches_repo_relative_path(path, basename_start_pos(path), is_dir, case)
 }
 
 fn basename_start_pos(value: &BStr) -> Option<usize> {

git-glob/tests/wildmatch/mod.rs

@@ -363,7 +363,7 @@ impl Display for MatchResult {
 }
 
 fn match_file_path(pattern: &git_glob::Pattern, path: &str, case: Case) -> bool {
-    pattern.matches_repo_relative_path(path, basename_of(path), None, false /* is_dir */, case)
+    pattern.matches_repo_relative_path(path, basename_of(path), false /* is_dir */, case)
 }
 fn basename_of(path: &str) -> Option<usize> {
     path.rfind('/').map(|pos| pos + 1)