feat(parser): add shorthand support {n..m}

Author: lalvarezt-bw

src/pipeline/mod.rs

@@ -656,10 +656,7 @@ mod tests {
     fn test_escaped_pipe() {
         let input = "foo|bar";
         // Replace pipe with dash
-        assert_eq!(
-            process(input, r"{replace:s/\|/-/}").unwrap(),
-            "foo-bar"
-        );
+        assert_eq!(process(input, r"{replace:s/\|/-/}").unwrap(), "foo-bar");
         // Replace with escaped pipe in replacement
         assert_eq!(
             process(input, r"{replace:s/\|/\\\|/}").unwrap(),
@@ -676,15 +673,9 @@ mod tests {
     fn test_escaped_pipe_in_args() {
         let input = "a|b|c";
         // Split by pipe and join with dash
-        assert_eq!(
-            process(input, r"{split:\|:..|join:-}").unwrap(),
-            "a-b-c"
-        );
+        assert_eq!(process(input, r"{split:\|:..|join:-}").unwrap(), "a-b-c");
         // Split by pipe and join with pipe
-        assert_eq!(
-            process(input, r"{split:\|:..|join:\|}").unwrap(),
-            "a|b|c"
-        );
+        assert_eq!(process(input, r"{split:\|:..|join:\|}").unwrap(), "a|b|c");
         // Split by pipe and append/prepend with pipes
         assert_eq!(
             process(input, r"{split:\|:..|append:\|y|join:,}").unwrap(),
@@ -806,4 +797,36 @@ mod tests {
             "A-B-C"
         );
     }
+
+    #[test]
+    fn test_shorthand_index() {
+        let input = "a b c d e";
+        // Test shorthand index
+        assert_eq!(process(input, "{1}").unwrap(), "b");
+        assert_eq!(process(input, "{-1}").unwrap(), "e");
+        assert_eq!(process(input, "{0}").unwrap(), "a");
+
+        // Test shorthand ranges
+        assert_eq!(process(input, "{1..3}").unwrap(), "b c");
+        assert_eq!(process(input, "{1..=3}").unwrap(), "b c d");
+        assert_eq!(process(input, "{..2}").unwrap(), "a b");
+        assert_eq!(process(input, "{2..}").unwrap(), "c d e");
+        assert_eq!(process(input, "{..=2}").unwrap(), "a b c");
+        assert_eq!(process(input, "{..}").unwrap(), "a b c d e");
+        assert_eq!(process(input, "{-2..}").unwrap(), "d e");
+        assert_eq!(process(input, "{-3..-1}").unwrap(), "c d");
+        assert_eq!(process(input, "{-3..=-1}").unwrap(), "c d e");
+
+        // Test with empty input
+        assert_eq!(process("", "{1}").unwrap(), "");
+        assert_eq!(process("", "{1..3}").unwrap(), "");
+        assert_eq!(process("", "{..}").unwrap(), "");
+
+        // Test with single word
+        assert_eq!(process("word", "{0}").unwrap(), "word");
+        assert_eq!(process("word", "{1}").unwrap(), "word");
+        assert_eq!(process("word", "{..}").unwrap(), "word");
+        assert_eq!(process("word", "{0..}").unwrap(), "word");
+        assert_eq!(process("word", "{..1}").unwrap(), "word");
+    }
 }

src/pipeline/parser.rs

@@ -27,6 +27,20 @@ pub fn parse_template(template: &str) -> Result<Vec<StringOp>, String> {
 fn parse_operation(pair: pest::iterators::Pair<Rule>) -> Result<StringOp, String> {
     let inner = pair.into_inner().next().unwrap();
     match inner.as_rule() {
+        Rule::shorthand_range => {
+            let range = parse_range_spec(inner)?;
+            Ok(StringOp::Split {
+                sep: " ".to_string(),
+                range,
+            })
+        }
+        Rule::shorthand_index => {
+            let idx = inner.as_str().parse().unwrap();
+            Ok(StringOp::Split {
+                sep: " ".to_string(),
+                range: RangeSpec::Index(idx),
+            })
+        }
         Rule::split => {
             let mut parts = inner.into_inner();
             let sep = unescape(parts.next().unwrap().as_str());
@@ -139,4 +153,3 @@ fn unescape(s: &str) -> String {
     }
     out
 }
-

src/pipeline/template.pest

@@ -5,6 +5,8 @@ template = { "{" ~ operation_list? ~ "}" }
 operation_list = { operation ~ ("|" ~ operation)* }
 
 operation = {
+    shorthand_range |
+    shorthand_index |
     split |
     join |
     slice |
@@ -17,6 +19,16 @@ operation = {
     prepend
 }
 
+shorthand_index = { number }
+shorthand_range = {
+    range_to_inclusive |
+    range_to |
+    range_inclusive |
+    range_exclusive |
+    range_from |
+    range_full
+}
+
 split = { "split" ~ ":" ~ arg ~ ":" ~ range_spec? }
 join = { "join" ~ ":" ~ arg }
 slice = { "slice" ~ ":" ~ range_spec }
@@ -54,4 +66,4 @@ range_to_inclusive = { "..=" ~ number }
 range_full = { ".." }
 index = { number }
 
-number = @{ "-"? ~ ASCII_DIGIT+ } 
+number = @{ "-"? ~ ASCII_DIGIT+ }