fix(lib): remove interior mutability issue from OnceCell that prevented stable use in HashMaps/Sets

Author: lalvarezt

src/pipeline/mod.rs

@@ -47,7 +47,7 @@ mod template;
 
 use dashmap::DashMap;
 use memchr::memchr_iter;
-use once_cell::sync::{Lazy, OnceCell};
+use once_cell::sync::Lazy;
 use std::collections::HashMap;
 use std::time::{Duration, Instant};
 use strip_ansi_escapes::strip;
@@ -686,10 +686,7 @@ pub enum StringOp {
     /// let template = Template::parse("{split:,:..|filter:\\.txt$|join:\\n}").unwrap();
     /// assert_eq!(template.format("file.txt,readme.md,data.txt").unwrap(), "file.txt\ndata.txt");
     /// ```
-    Filter {
-        pattern: String,
-        regex: OnceCell<Regex>,
-    },
+    Filter { pattern: String },
 
     /// Remove list items matching a regex pattern.
     ///
@@ -724,10 +721,7 @@ pub enum StringOp {
     /// let template = Template::parse("{split:\\n:..|filter_not:^$|join:\\n}").unwrap();
     /// assert_eq!(template.format("line1\n\nline2\n\nline3").unwrap(), "line1\nline2\nline3");
     /// ```
-    FilterNot {
-        pattern: String,
-        regex: OnceCell<Regex>,
-    },
+    FilterNot { pattern: String },
 
     /// Select a range of items from a list.
     ///
@@ -899,7 +893,6 @@ pub enum StringOp {
     RegexExtract {
         pattern: String,
         group: Option<usize>,
-        regex: OnceCell<Regex>,
     },
 }
 
@@ -1360,21 +1353,17 @@ fn apply_single_operation(
         StringOp::Slice { range } => {
             apply_list_operation(val, |list| apply_range(&list, range), "Slice")
         }
-        StringOp::Filter { pattern, regex } => {
-            let re = regex.get_or_try_init(|| {
-                Regex::new(pattern).map_err(|e| format!("Invalid regex: {e}"))
-            })?;
+        StringOp::Filter { pattern } => {
+            let re = get_cached_regex(pattern)?;
             match val {
                 Value::List(list) => Ok(Value::List(
                     list.into_iter().filter(|s| re.is_match(s)).collect(),
                 )),
                 Value::Str(s) => Ok(Value::Str(if re.is_match(&s) { s } else { String::new() })),
             }
         }
-        StringOp::FilterNot { pattern, regex } => {
-            let re = regex.get_or_try_init(|| {
-                Regex::new(pattern).map_err(|e| format!("Invalid regex: {e}"))
-            })?;
+        StringOp::FilterNot { pattern } => {
+            let re = get_cached_regex(pattern)?;
             match val {
                 Value::List(list) => Ok(Value::List(
                     list.into_iter().filter(|s| !re.is_match(s)).collect(),
@@ -1576,15 +1565,9 @@ fn apply_single_operation(
                 )
             }
         }
-        StringOp::RegexExtract {
-            pattern,
-            group,
-            regex,
-        } => {
+        StringOp::RegexExtract { pattern, group } => {
             if let Value::Str(s) = val {
-                let re = regex.get_or_try_init(|| {
-                    Regex::new(pattern).map_err(|e| format!("Invalid regex: {e}"))
-                })?;
+                let re = get_cached_regex(pattern)?;
                 let result = if let Some(group_idx) = group {
                     re.captures(&s)
                         .and_then(|caps| caps.get(*group_idx))

src/pipeline/parser.rs

@@ -8,7 +8,6 @@
 //! escape sequences, and debug flags.
 //!
 
-use once_cell::sync::OnceCell;
 use pest::Parser;
 use pest_derive::Parser;
 use smallvec::SmallVec;
@@ -270,11 +269,9 @@ fn parse_operation(pair: pest::iterators::Pair<Rule>) -> Result<StringOp, String
         Rule::strip_ansi => Ok(StringOp::StripAnsi),
         Rule::filter => Ok(StringOp::Filter {
             pattern: extract_single_arg_raw(pair)?,
-            regex: OnceCell::new(),
         }),
         Rule::filter_not => Ok(StringOp::FilterNot {
             pattern: extract_single_arg_raw(pair)?,
-            regex: OnceCell::new(),
         }),
         Rule::slice => Ok(StringOp::Slice {
             range: extract_range_arg(pair)?,
@@ -500,11 +497,7 @@ fn parse_regex_extract_operation(pair: pest::iterators::Pair<Rule>) -> Result<St
     let mut parts = pair.into_inner();
     let pattern = parts.next().unwrap().as_str().to_string();
     let group = parts.next().and_then(|p| p.as_str().parse().ok());
-    Ok(StringOp::RegexExtract {
-        pattern,
-        group,
-        regex: OnceCell::new(),
-    })
+    Ok(StringOp::RegexExtract { pattern, group })
 }
 
 /// Parses a map operation with nested operation list.
@@ -610,11 +603,9 @@ fn parse_map_inner_operation(pair: pest::iterators::Pair<Rule>) -> Result<String
         Rule::map_unique => Ok(StringOp::Unique),
         Rule::map_filter => Ok(StringOp::Filter {
             pattern: extract_single_arg_raw(pair)?,
-            regex: OnceCell::new(),
         }),
         Rule::map_filter_not => Ok(StringOp::FilterNot {
             pattern: extract_single_arg_raw(pair)?,
-            regex: OnceCell::new(),
         }),
 
         _ => Err(format!("Unsupported map operation: {:?}", pair.as_rule())),