Implement Needle::Pattern for full glob support in one-sided refspecs

- Added Pattern matching case in Needle::matches() using gix_glob::wildmatch
- Added Pattern handling in to_bstr_replace() method
- Added is_complex_pattern() helper to detect patterns requiring wildmatch
- Only use Needle::Pattern for complex patterns (multiple asterisks or [, ], ?, \)
- Simple single-asterisk globs continue using efficient Needle::Glob
- Fixed test pattern from v[0.9]* to v[0-9]* to match v1.0 correctly

Co-authored-by: Byron <63622+Byron@users.noreply.github.com>

Author: Copilot

gix-refspec/src/match_group/util.rs

@@ -104,6 +104,13 @@ impl<'a> Needle<'a> {
                 let end = item.full_ref_name.len() - tail.len();
                 Match::GlobRange(*asterisk_pos..end)
             }
+            Needle::Pattern(pattern) => {
+                if gix_glob::wildmatch(pattern, item.full_ref_name, gix_glob::wildmatch::Mode::empty()) {
+                    Match::Normal
+                } else {
+                    Match::None
+                }
+            }
             Needle::Object(id) => {
                 if *id == item.target {
                     return Match::Normal;
@@ -139,7 +146,11 @@ impl<'a> Needle<'a> {
                 name.insert_str(0, "refs/heads/");
                 Cow::Owned(name.into())
             }
+            (Needle::Pattern(name), None) => Cow::Borrowed(name),
             (Needle::Glob { .. }, None) => unreachable!("BUG: no range provided for glob pattern"),
+            (Needle::Pattern(_), Some(_)) => {
+                unreachable!("BUG: range provided for pattern, but patterns don't use ranges")
+            }
             (_, Some(_)) => {
                 unreachable!("BUG: range provided even though needle wasn't a glob. Globs are symmetric.")
             }
@@ -176,9 +187,23 @@ impl<'a> From<RefSpecRef<'a>> for Matcher<'a> {
         };
         if m.rhs.is_none() {
             if let Some(src) = v.src {
-                m.lhs = Some(Needle::Pattern(src))
+                // Only use Pattern for complex globs (multiple asterisks or other glob features)
+                // Simple single-asterisk globs can use the more efficient Needle::Glob
+                if is_complex_pattern(src) {
+                    m.lhs = Some(Needle::Pattern(src));
+                }
             }
         }
         m
     }
 }
+
+/// Check if a pattern is complex enough to require wildmatch instead of simple glob matching
+fn is_complex_pattern(pattern: &BStr) -> bool {
+    let asterisk_count = pattern.iter().filter(|&&b| b == b'*').count();
+    if asterisk_count > 1 {
+        return true;
+    }
+    // Check for other glob features: ?, [, ], \
+    pattern.iter().any(|&b| b == b'?' || b == b'[' || b == b']' || b == b'\\')
+}

gix-refspec/tests/refspec/match_group.rs

@@ -254,7 +254,7 @@ mod complex_globs {
 
         // Test: refs/tags/* should match all refs under refs/tags/
         let items: Vec<_> = refs.iter().map(|r| r.to_item()).collect();
-        let spec = gix_refspec::parse("refs/tags/v[0.9]*".into(), Operation::Fetch).unwrap();
+        let spec = gix_refspec::parse("refs/tags/v[0-9]*".into(), Operation::Fetch).unwrap();
         let group = MatchGroup::from_fetch_specs([spec]);
         let outcome = group.match_lhs(items.iter().copied());