feat: add Pattern::from_bytes_without_negation()

Author: Byron

gix-glob/src/parse.rs

@@ -6,19 +6,23 @@ use crate::{pattern, pattern::Mode};
 /// A sloppy parser that performs only the most basic checks, providing additional information
 /// using `pattern::Mode` flags.
 ///
+/// If `may_alter` is `false`, we won't parse leading `!` or its escaped form.
+///
 /// Returns `(pattern, mode, no_wildcard_len)`
-pub fn pattern(mut pat: &[u8]) -> Option<(&[u8], pattern::Mode, Option<usize>)> {
+pub fn pattern(mut pat: &[u8], may_alter: bool) -> Option<(&[u8], pattern::Mode, Option<usize>)> {
     let mut mode = Mode::empty();
     if pat.is_empty() {
         return None;
     };
-    if pat.first() == Some(&b'!') {
-        mode |= Mode::NEGATIVE;
-        pat = &pat[1..];
-    } else if pat.first() == Some(&b'\\') {
-        let second = pat.get(1);
-        if second == Some(&b'!') || second == Some(&b'#') {
+    if may_alter {
+        if pat.first() == Some(&b'!') {
+            mode |= Mode::NEGATIVE;
             pat = &pat[1..];
+        } else if pat.first() == Some(&b'\\') {
+            let second = pat.get(1);
+            if second == Some(&b'!') || second == Some(&b'#') {
+                pat = &pat[1..];
+            }
         }
     }
     if pat.iter().all(u8::is_ascii_whitespace) {

gix-glob/src/pattern.rs

@@ -44,7 +44,18 @@ pub enum Case {
 impl Pattern {
     /// Parse the given `text` as pattern, or return `None` if `text` was empty.
     pub fn from_bytes(text: &[u8]) -> Option<Self> {
-        crate::parse::pattern(text).map(|(text, mode, first_wildcard_pos)| Pattern {
+        crate::parse::pattern(text, true).map(|(text, mode, first_wildcard_pos)| Pattern {
+            text: text.into(),
+            mode,
+            first_wildcard_pos,
+        })
+    }
+
+    /// Parse the given `text` as pattern without supporting leading `!` or `\\!` , or return `None` if `text` was empty.
+    ///
+    /// This assures that `text` remains entirely unaltered, but removes built-in support for negation as well.
+    pub fn from_bytes_without_negation(text: &[u8]) -> Option<Self> {
+        crate::parse::pattern(text, false).map(|(text, mode, first_wildcard_pos)| Pattern {
             text: text.into(),
             mode,
             first_wildcard_pos,

gix-glob/tests/parse/mod.rs

@@ -66,11 +66,21 @@ fn leading_exclamation_mark_negates_pattern() {
         gix_glob::parse(b"!hello"),
         pat("hello", Mode::NEGATIVE | Mode::NO_SUB_DIR, None)
     );
+    assert_eq!(
+        gix_glob::Pattern::from_bytes_without_negation(b"!hello"),
+        pat("!hello", Mode::NO_SUB_DIR, None),
+        "negation can be disabled entirely"
+    );
 }
 
 #[test]
 fn leading_exclamation_marks_can_be_escaped_with_backslash() {
     assert_eq!(gix_glob::parse(br"\!hello"), pat("!hello", Mode::NO_SUB_DIR, None));
+    assert_eq!(
+        gix_glob::Pattern::from_bytes_without_negation(br"\!hello"),
+        pat("\\!hello", Mode::NO_SUB_DIR, Some(0)),
+        "negation can be disabled entirely, leaving escapes in place"
+    );
 }
 
 #[test]