refactor(pest)!: greatly simplified grammar, removed expensive look-ahead that offer no real benefit

expect some change in templates that relied on smart escaping, now it's
more intentional

Author: lalvarezt

docs/template-system.md

@@ -940,9 +940,11 @@ The range system includes robust edge case handling:
 
 ### When is Escaping Required?
 
-Different argument types have different escaping requirements:
+The template parser uses a unified argument parsing system where all operations follow the same escaping rules for consistency and maintainability:
 
-### Simple Arguments (append, prepend, join, etc.)
+### Operation Arguments
+
+All operations use the same argument parsing rules. The following characters require escaping:
 
 | Character | Escape | Reason                |
 |-----------|--------|----------------------|
@@ -952,18 +954,6 @@ Different argument types have different escaping requirements:
 | `{`       | `\{`   | Starts template      |
 | `\`       | `\\`   | Escape character     |
 
-### Regex Arguments (filter, regex_extract)
-
-Regex patterns can contain most characters naturally.
-
-### Split Arguments
-
-Split separators can contain most characters. Only escape:
-
-| Character | Escape | Reason |
-|-----------|--------|--------|
-| `:` | `\:` | Visual helper |
-
 ### Special Sequences
 
 | Sequence | Result | Description |

src/pipeline/parser.rs

@@ -5,8 +5,7 @@
 //! Pest parser generator for robust syntax handling with comprehensive error reporting.
 //!
 //! The parser supports the full template syntax including operations, ranges,
-//! escape sequences, and debug flags, with intelligent handling of special
-//! characters in different contexts.
+//! escape sequences, and debug flags.
 //!
 
 use once_cell::sync::OnceCell;

src/pipeline/template.pest

@@ -40,33 +40,38 @@ shorthand_range = {
   | range_full
 }
 
+// Argument parsing - requires escaping for special characters
+argument     = { (escaped_char | normal_char)* }
+normal_char  = { !("|" | "}" | "{" | ":" | "\\") ~ ANY }
+escaped_char = { "\\" ~ ANY }
+
 // Main operations - using specific arg types where needed
-regex_extract = { "regex_extract" ~ ":" ~ regex_arg ~ (":" ~ number)? }
-filter_not    = { "filter_not" ~ ":" ~ regex_arg }
-filter        = { "filter" ~ ":" ~ regex_arg }
+regex_extract =  { "regex_extract" ~ ":" ~ argument ~ (":" ~ number)? }
+filter_not    =  { "filter_not" ~ ":" ~ argument }
+filter        =  { "filter" ~ ":" ~ argument }
 strip_ansi    = @{ "strip_ansi" }
-map           = { "map" ~ ":" ~ map_operation }
-split         = { "split" ~ ":" ~ split_arg ~ ":" ~ range_spec? }
-substring     = { "substring" ~ ":" ~ range_spec }
-replace       = { "replace" ~ ":" ~ sed_string }
-append        = { "append" ~ ":" ~ simple_arg }
-prepend       = { "prepend" ~ ":" ~ simple_arg }
-surround      = { "surround" ~ ":" ~ simple_arg }
-quote         = { "quote" ~ ":" ~ simple_arg }
+map           =  { "map" ~ ":" ~ map_operation }
+split         =  { "split" ~ ":" ~ argument ~ ":" ~ range_spec? }
+substring     =  { "substring" ~ ":" ~ range_spec }
+replace       =  { "replace" ~ ":" ~ sed_string }
+append        =  { "append" ~ ":" ~ argument }
+prepend       =  { "prepend" ~ ":" ~ argument }
+surround      =  { "surround" ~ ":" ~ argument }
+quote         =  { "quote" ~ ":" ~ argument }
 upper         = @{ "upper" }
 lower         = @{ "lower" }
-trim          = { "trim" ~ (":" ~ simple_arg)? ~ (":" ~ direction)? }
-join          = { "join" ~ ":" ~ simple_arg }
-slice         = { "slice" ~ ":" ~ range_spec }
-sort          = { "sort" ~ (":" ~ sort_direction)? }
+trim          =  { "trim" ~ (":" ~ argument)? ~ (":" ~ direction)? }
+join          =  { "join" ~ ":" ~ argument }
+slice         =  { "slice" ~ ":" ~ range_spec }
+sort          =  { "sort" ~ (":" ~ sort_direction)? }
 reverse       = @{ "reverse" }
 unique        = @{ "unique" }
-pad           = { "pad" ~ ":" ~ number ~ (":" ~ pad_char)? ~ (":" ~ direction)? }
+pad           =  { "pad" ~ ":" ~ number ~ (":" ~ pad_char)? ~ (":" ~ direction)? }
 
 // Direction specifiers
 direction      = @{ "left" | "right" | "both" }
 sort_direction = @{ "asc" | "desc" }
-pad_char       = @{ simple_arg_content+ }
+pad_char       = @{ argument }
 
 // Map operation
 map_operation       = { "{" ~ map_operation_list ~ "}" }
@@ -95,68 +100,16 @@ map_inner_operation = {
 }
 
 // Map-specific operations that need special handling
-map_split      = { "split" ~ ":" ~ split_arg ~ (":" ~ range_spec)? }
-map_join       = { "join" ~ ":" ~ simple_arg }
-map_slice      = { "slice" ~ ":" ~ range_spec }
-map_sort       = { "sort" ~ (":" ~ sort_direction)? }
+map_split      =  { "split" ~ ":" ~ argument ~ (":" ~ range_spec)? }
+map_join       =  { "join" ~ ":" ~ argument }
+map_slice      =  { "slice" ~ ":" ~ range_spec }
+map_sort       =  { "sort" ~ (":" ~ sort_direction)? }
 map_unique     = @{ "unique" }
-map_filter     = { "filter" ~ ":" ~ map_regex_arg }
-map_filter_not = { "filter_not" ~ ":" ~ map_regex_arg }
+map_filter     =  { "filter" ~ ":" ~ argument }
+map_filter_not =  { "filter_not" ~ ":" ~ argument }
 
 // Map-specific regex extract
-map_regex_extract = { "regex_extract" ~ ":" ~ map_regex_arg ~ (":" ~ number)? }
-
-// Simplified argument handling - three types to handle specific cases
-simple_arg         = @{ simple_arg_content* }
-simple_arg_content =  { escaped_char | simple_normal_char }
-simple_normal_char =  { !(":" | "|" | "}" | "{" | "\\") ~ ANY }
-
-// Split args - need to handle pipes that aren't operations
-split_arg          = @{ (split_escaped_char | split_content)* }
-split_content      =  { !(":" ~ (number | range_part)) ~ !("|" ~ operation_keyword) ~ !("}" ~ EOI) ~ ANY }
-split_escaped_char =  { "\\" ~ ANY }
-
-// Regex args - need to handle pipes and braces in regex patterns
-regex_arg          = @{ (regex_escaped_char | regex_content)* }
-regex_content      =  { !(":" ~ (number | range_part)) ~ !("|" ~ operation_keyword) ~ !("}" ~ EOI) ~ ANY }
-regex_escaped_char =  { "\\" ~ ANY }
-
-// Map regex args - handle braces in regex patterns
-map_regex_arg          = @{ (map_regex_escaped_char | map_regex_brace | map_regex_content)* }
-map_regex_brace        =  { "{" ~ (!"}" ~ ANY)* ~ "}" }
-map_regex_content      =  { !(":" ~ number) ~ !("|" ~ operation_keyword) ~ !("{" | ("}" ~ ("|" | "}" | EOI))) ~ ANY }
-map_regex_escaped_char =  { "\\" ~ ANY }
-
-// Common escaped character handling
-escaped_char = { "\\" ~ ANY }
-
-// Operation keywords for lookahead (simplified list)
-operation_keyword = _{
-    "split"
-  | "upper"
-  | "lower"
-  | "trim"
-  | "append"
-  | "prepend"
-  | "surround"
-  | "quote"
-  | "join"
-  | "substring"
-  | "replace"
-  | "map"
-  | "filter"
-  | "filter_not"
-  | "slice"
-  | "sort"
-  | "reverse"
-  | "unique"
-  | "regex_extract"
-  | "strip_ansi"
-  | "pad"
-}
-
-// Range parts for lookahead
-range_part = _{ ".." | "..=" }
+map_regex_extract = { "regex_extract" ~ ":" ~ argument ~ (":" ~ number)? }
 
 // Sed strings
 sed_string       =  { "s/" ~ sed_pattern ~ "/" ~ sed_replacement ~ "/" ~ sed_flags? }

tests/multi_template_tests.rs

@@ -55,7 +55,7 @@ fn test_multi_template_caching_optimization() {
 fn test_multi_template_different_separators() {
     // Test multiple template sections with different separators
     let template =
-        MultiTemplate::parse("Comma: {split:,:0} Space: {split: :1} Pipe: {split:|:0}").unwrap();
+        MultiTemplate::parse("Comma: {split:,:0} Space: {split: :1} Pipe: {split:\\|:0}").unwrap();
     let result = template.format("a,b c|d").unwrap();
     assert_eq!(result, "Comma: a Space: c|d Pipe: a,b c");
 }

tests/template/complex_pipeline.rs

@@ -395,7 +395,7 @@ fn test_special_chars_pipeline() {
 
 #[test]
 fn test_escaped_pipes_pipeline() {
-    let result = process("test", r"{replace:s/test/a|b/|split:|:..|join:-}");
+    let result = process("test", r"{replace:s/test/a|b/|split:\|:..|join:-}");
     assert_eq!(result.unwrap(), "a-b");
 }
 

tests/template/simple_pipeline.rs

@@ -1289,7 +1289,7 @@ pub mod regex_extract_operations {
         assert_eq!(
             process(
                 "Version: 1.2.3-beta",
-                r"{regex_extract:Version: (\d+\.\d+\.\d+):1}"
+                r"{regex_extract:Version\: (\d+\.\d+\.\d+):1}"
             )
             .unwrap(),
             "1.2.3"