A slightly ugly way of not adjusting input patterns too much (#301)

Absolute patterns should stay absolute, otherwise one cannot do normal
matches anymore without getting the leading slash back, or in other
words, matches against absolute paths won't work then.

Author: Byron

git-glob/src/parse.rs

@@ -26,21 +26,23 @@ pub fn pattern(mut pat: &[u8]) -> Option<(BString, pattern::Mode, Option<usize>)
     }
     if pat.first() == Some(&b'/') {
         mode |= Mode::ABSOLUTE;
-        pat = &pat[1..];
     }
-    let mut line = truncate_non_escaped_trailing_spaces(pat);
-    if line.last() == Some(&b'/') {
+    let mut pat = truncate_non_escaped_trailing_spaces(pat);
+    if pat.last() == Some(&b'/') {
         mode |= Mode::MUST_BE_DIR;
-        line.pop();
+        pat.pop();
     }
-    if !line.contains(&b'/') {
+
+    let relative_pattern = mode.contains(Mode::ABSOLUTE).then(|| &pat[1..]).unwrap_or(&pat);
+    if !relative_pattern.contains(&b'/') {
         mode |= Mode::NO_SUB_DIR;
     }
-    let pos_of_first_wildcard = first_wildcard_pos(&line);
-    if line.first() == Some(&b'*') && first_wildcard_pos(&line[1..]).is_none() {
+    if relative_pattern.first() == Some(&b'*') && first_wildcard_pos(&relative_pattern[1..]).is_none() {
         mode |= Mode::ENDS_WITH;
     }
-    Some((line, mode, pos_of_first_wildcard))
+
+    let pos_of_first_wildcard = first_wildcard_pos(&pat);
+    Some((pat, mode, pos_of_first_wildcard))
 }
 
 fn first_wildcard_pos(pat: &[u8]) -> Option<usize> {

git-glob/src/pattern.rs

@@ -88,15 +88,17 @@ impl Pattern {
             base_path.map_or(true, |p| p.ends_with(b"/")),
             "base must end with a trailing slash"
         );
-        debug_assert!(
-            base_path.map_or(true, |p| !p.starts_with(b"/")),
-            "base must be relative"
-        );
+        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
+            .contains(pattern::Mode::ABSOLUTE)
+            .then(|| (self.text[1..].as_bstr(), self.first_wildcard_pos.map(|p| p - 1)))
+            .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
@@ -105,7 +107,7 @@ impl Pattern {
             } else {
                 &path[basename_start_pos.unwrap_or_default()..]
             };
-            self.matches(basename, flags)
+            self.matches_inner(text, first_wildcard_pos, basename, flags)
         } else {
             let path = match base_path {
                 Some(base) => match path.strip_prefix(base.as_ref()) {
@@ -114,7 +116,7 @@ impl Pattern {
                 },
                 None => path,
             };
-            self.matches(path, flags)
+            self.matches_inner(text, first_wildcard_pos, path, flags)
         }
     }
 
@@ -125,11 +127,21 @@ impl Pattern {
     ///
     /// Note that this method uses some shortcuts to accelerate simple patterns.
     pub fn matches<'a>(&self, value: impl Into<&'a BStr>, mode: wildmatch::Mode) -> bool {
+        self.matches_inner(self.text.as_bstr(), self.first_wildcard_pos, value, mode)
+    }
+
+    fn matches_inner<'a>(
+        &self,
+        text: &BStr,
+        first_wildcard_pos: Option<usize>,
+        value: impl Into<&'a BStr>,
+        mode: wildmatch::Mode,
+    ) -> bool {
         let value = value.into();
-        match self.first_wildcard_pos {
+        match first_wildcard_pos {
             // "*literal" case, overrides starts-with
             Some(pos) if self.mode.contains(pattern::Mode::ENDS_WITH) && !value.contains(&b'/') => {
-                let text = &self.text[pos + 1..];
+                let text = &text[pos + 1..];
                 if mode.contains(wildmatch::Mode::IGNORE_CASE) {
                     value
                         .len()
@@ -144,20 +156,20 @@ impl Pattern {
                 if mode.contains(wildmatch::Mode::IGNORE_CASE) {
                     if !value
                         .get(..pos)
-                        .map_or(false, |value| value.eq_ignore_ascii_case(&self.text[..pos]))
+                        .map_or(false, |value| value.eq_ignore_ascii_case(&text[..pos]))
                     {
                         return false;
                     }
-                } else if !value.starts_with(&self.text[..pos]) {
+                } else if !value.starts_with(&text[..pos]) {
                     return false;
                 }
-                crate::wildmatch(self.text.as_bstr(), value, mode)
+                crate::wildmatch(text.as_bstr(), value, mode)
             }
             None => {
                 if mode.contains(wildmatch::Mode::IGNORE_CASE) {
-                    self.text.eq_ignore_ascii_case(value)
+                    text.eq_ignore_ascii_case(value)
                 } else {
-                    self.text == value
+                    text == value
                 }
             }
         }

git-glob/tests/matching/mod.rs

@@ -122,7 +122,6 @@ fn non_dirs_for_must_be_dir_patterns_are_ignored() {
 }
 
 #[test]
-#[ignore]
 fn matches_of_absolute_paths_work() {
     let input = "/hello/git";
     let pat = pat(input);

git-glob/tests/parse/mod.rs

@@ -77,12 +77,12 @@ fn leading_exclamation_marks_can_be_escaped_with_backslash() {
 fn leading_slashes_mark_patterns_as_absolute() {
     assert_eq!(
         git_glob::parse(br"/absolute"),
-        pat("absolute", Mode::NO_SUB_DIR | Mode::ABSOLUTE, None)
+        pat("/absolute", Mode::NO_SUB_DIR | Mode::ABSOLUTE, None)
     );
 
     assert_eq!(
         git_glob::parse(br"/absolute/path"),
-        pat("absolute/path", Mode::ABSOLUTE, None)
+        pat("/absolute/path", Mode::ABSOLUTE, None)
     );
 }