Rewrite pattern parser

Author: mmastrac

.github/workflows/ci.yml

@@ -2,6 +2,8 @@ name: Continuous Integration
 
 on:
   pull_request:
+    branches:
+      - main
   push:
     branches:
       - main
@@ -39,3 +41,13 @@ jobs:
         with:
           command: test
           args: --no-default-features --features pcre2
+      - uses: actions-rs/cargo@v1
+        with:
+          command: test
+          args: --no-default-features --features onig
+      - uses: actions-rs/cargo@v1
+      with:
+        command: test
+        args: --no-default-features --features regex
+
+  

CHANGELOG.md

@@ -4,6 +4,33 @@ All user visible changes to this project will be documented in this file.
 This project adheres to [Semantic Versioning](http://semver.org/), as described
 for Rust libraries in [RFC #1105](https://github.com/rust-lang/rfcs/blob/master/text/1105-api-evolution.md)
 
+## 2.2.0 - 2025-07-04
+
+ * Rewrote the pattern parsing to avoid using regular expressions, making all
+   regular expression engine features optional (though at least one is still
+   required).
+ * Ensure correctness in capture names, even when using duplicate names
+   generated from pattern names. These were previously unspecified:
+   * (breaking) Duplicate pattern names result in matches with incrementing names in the format:
+     `NAME`, `NAME[1]`, `NAME[2]`, etc.
+   * (breaking) Duplicate pattern names from aliases are now guaranteed to be
+     "last one wins".
+ * (breaking) `Matches::len()` was removed as it was previously reporting the
+   pattern name count. Use `Matches::iter().count()` instead.
+ * (breaking) `Matches::is_empty()` was removed. Use `Matches::iter().count() == 0` instead.
+
+## 2.1.0 - 2025-05-29
+
+ * Add support for `pcre2` feature which is significantly faster than `onig`.
+ * Add support for `regex` and `fancy_regex` features which allow for pure Rust
+   operation.
+ * Some default patterns were updated from upstream sources for better
+   compatibility across engines.
+
+## 2.0.2 - 2025-05-29
+
+ * Workaround for an issue with `onig` where certain patterns could panic.
+
 ## 2.0.1 - Unreleased
 
  * Updated `onig` to `6.4`.

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "grok"
-version = "2.1.0"
+version = "2.2.0"
 authors = ["Matt Mastracci <[email protected]>", "Michael Nitschinger <[email protected]>"]
 license = "Apache-2.0"
 readme = "README.md"
@@ -20,14 +20,14 @@ rust-version = "1.56"
 [features]
 default = ["onig"]
 
-onig = []
+onig = ["dep:onig"]
 regex = ["dep:regex"]
 fancy-regex = ["dep:fancy-regex"]
 pcre2 = ["dep:pcre2"]
 
 [dependencies]
 # The default regex engine. Use default-feature = false to disable it.
-onig = { version = "6.5", default-features = false }
+onig = { version = "6.5", optional = true, default-features = false }
 
 # The Rust regex library. Does not support backtracking, so many patterns are unusable.
 regex = { version = "1", optional = true, default-features = false, features = ["std", "unicode", "perf", "perf-dfa-full"] }

src/fancy_regex.rs

@@ -4,9 +4,9 @@ use std::collections::{btree_map, BTreeMap, HashMap};
 
 /// The `Pattern` represents a compiled regex, ready to be matched against arbitrary text.
 #[derive(Debug)]
-pub struct FancyRegexPattern {
+pub(crate) struct FancyRegexPattern {
     regex: Regex,
-    names: BTreeMap<String, usize>,
+    pub names: BTreeMap<String, usize>,
 }
 
 impl FancyRegexPattern {
@@ -18,10 +18,7 @@ impl FancyRegexPattern {
                 let mut names = BTreeMap::new();
                 for (i, name) in r.capture_names().enumerate() {
                     if let Some(name) = name {
-                        let name = match alias.iter().find(|&(_k, v)| *v == name) {
-                            Some(item) => item.0.clone(),
-                            None => String::from(name),
-                        };
+                        let name = alias.get(name).map_or(name, |s| s).to_string();
                         names.insert(name, i);
                     }
                 }
@@ -51,9 +48,9 @@ impl FancyRegexPattern {
 
 /// The `Matches` represent matched results from a `Pattern` against a provided text.
 #[derive(Debug)]
-pub struct FancyRegexMatches<'a> {
+pub(crate) struct FancyRegexMatches<'a> {
     captures: Captures<'a>,
-    pattern: &'a FancyRegexPattern,
+    pub pattern: &'a FancyRegexPattern,
 }
 
 impl<'a> FancyRegexMatches<'a> {
@@ -66,19 +63,7 @@ impl<'a> FancyRegexMatches<'a> {
             .map(|m| m.as_str())
     }
 
-    /// Returns the number of matches.
-    pub fn len(&self) -> usize {
-        self.pattern.names.len()
-    }
-
-    /// Returns true if there are no matches, false otherwise.
-    pub fn is_empty(&self) -> bool {
-        self.len() == 0
-    }
-
     /// Returns a tuple of key/value with all the matches found.
-    ///
-    /// Note that if no match is found, the value is empty.
     pub fn iter(&'a self) -> FancyRegexMatchesIter<'a> {
         FancyRegexMatchesIter {
             captures: &self.captures,
@@ -97,7 +82,7 @@ impl<'a> IntoIterator for &'a FancyRegexMatches<'a> {
 }
 
 /// An `Iterator` over all matches, accessible via `Matches`.
-pub struct FancyRegexMatchesIter<'a> {
+pub(crate) struct FancyRegexMatchesIter<'a> {
     captures: &'a Captures<'a>,
     names: btree_map::Iter<'a, String, usize>,
 }