Support patterns that ignore parts of stringHEADmain

1 files changed, 31 insertions, 22 deletions

diff --git a/src/main.rs b/src/main.rs
index 534f418..0e46290 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -22,24 +22,29 @@ impl Config {
 
 struct Match {
     line: String,
-    group: Range<usize>,
+    match_range: Range<usize>,
+    sort_range: Range<usize>,
 }
 
 impl Match {
-    fn new(line: String, group: Range<usize>) -> Self {
-        Self { line, group }
+    fn new(line: String, match_range: Range<usize>, sort_range: Range<usize>) -> Self {
+        Self {
+            line,
+            match_range,
+            sort_range,
+        }
     }
 
     fn prefix(&self) -> &str {
-        &self.line[0..self.group.start]
+        &self.line[0..self.match_range.start]
     }
 
     fn infix(&self) -> &str {
-        &self.line[self.group.clone()]
+        &self.line[self.sort_range.clone()]
     }
 
     fn suffix(&self) -> &str {
-        &self.line[self.group.end..self.line.len()]
+        &self.line[self.match_range.end..self.line.len()]
     }
 }
 
@@ -74,10 +79,10 @@ fn load_config(path: &PathBuf) -> anyhow::Result<Config> {
     if let Some(patterns_str) = groups.get("groups") {
         let mut patterns_regex = Vec::with_capacity(patterns_str.len());
         for pattern in patterns_str {
-            let regex = RegexBuilder::new(pattern).size_limit(42_000).build()?;
-            if regex.captures_len() != 2 {
+            let regex = RegexBuilder::new(pattern).size_limit(100_000).build()?;
+            if regex.captures_len() <= 1 {
                 return Err(anyhow!(
-                    "Invalid pattern {}, capture groups are not one",
+                    "Invalid pattern {}, expecting at least one capture group",
                     pattern
                 ));
             }
@@ -92,19 +97,23 @@ fn default_config() -> Config {
     Config::new(vec![Regex::new(r"part([0-9]+)").unwrap()])
 }
 
-fn get_group(config: &Config, input: &str) -> (i64, Range<usize>) {
+fn get_group(config: &Config, input: &str) -> (i64, Range<usize>, Range<usize>) {
     if let Some(index) = config.set.matches(input).iter().next() {
-        return (
-            index as i64,
-            config.patterns[index]
-                .captures(input)
-                .unwrap()
-                .get(1)
-                .unwrap()
-                .range(),
-        );
+        let captures = config.patterns[index].captures(input).unwrap();
+        let match_range = captures.get(0).unwrap().range();
+        let mut sort_range = captures.get(1).unwrap().range();
+        for i in 2..captures.len() {
+            let next = captures.get(i).unwrap().range();
+            if next.start < sort_range.start {
+                sort_range.start = next.start;
+            }
+            if next.end > sort_range.end {
+                sort_range.end = next.end;
+            }
+        }
+        return (index as i64, match_range, sort_range);
     }
-    (-1, 0..0)
+    (-1, 0..0, 0..0)
 }
 
 fn print_group(matches: &[Match]) {
@@ -133,8 +142,8 @@ fn main() -> anyhow::Result<()> {
             break;
         }
         buffer.truncate(buffer.trim_end().len());
-        let (group, part) = get_group(&config, &buffer);
-        let m = Match::new(buffer, part);
+        let (group, match_range, sort_range) = get_group(&config, &buffer);
+        let m = Match::new(buffer, match_range, sort_range);
         if let std::collections::hash_map::Entry::Vacant(e) = groups.entry(group) {
             e.insert(PatternGroup::new(vec![m]));
         } else {