add slice

Author: besok

src/parser/grammar/json_path_9535.pest

@@ -11,8 +11,11 @@ root = _{"$"}
 name_selector = {string}
 wildcard_selector   = _{"*"}
 index_selector   = {int}
-int = _{ "0" | ("-"? ~ DIGIT1 ~ DIGIT*) }
-slice_selector = { int? ~ S ~ ":" ~ S ~ int? ~ S ~ (":" ~ S ~ int?)? }
+int = { "0" | ("-"? ~ DIGIT1 ~ DIGIT*) }
+step = {":" ~ S ~ int?}
+start = {int}
+end = {int}
+slice_selector = { start? ~ S ~ ":" ~ S ~ end? ~ S ~ step? }
 filter_selector = {"?"~ S ~ logical_expr_or}
 logical_expr_or = {logical_expr_and ~ S ~ ("||" ~ S ~ logical_expr_and)*}
 logical_expr_and = {atom_expr ~ S ~ ("&&" ~ S ~ atom_expr)*}

src/parser/macros2.rs

@@ -36,4 +36,32 @@ macro_rules! singular_query {
     ($($segment:tt)*) => {
         SingularQuery::Root(q_segments!($($segment)*))
     };
+}
+
+#[macro_export]
+macro_rules! slice {
+    () => {
+        (None, None, None)
+    };
+    ($start:expr) => {
+        (Some($start), None, None)
+    };
+    ($start:expr, $end:expr) => {
+        (Some($start), Some($end), None)
+    };
+    ($start:expr,, $step:expr) => {
+        (Some($start), None, Some($step))
+    };
+    (,, $step:expr) => {
+        (None, None, Some($step))
+    };
+    (, $end:expr) => {
+        (None, Some($end), None)
+    };
+    (, $end:expr,$step:expr ) => {
+        (None, Some($end), Some($step))
+    };
+    ($start:expr, $end:expr, $step:expr) => {
+        (Some($start), Some($end), Some($step))
+    }
 }

src/parser/parser2.rs

@@ -47,6 +47,36 @@ pub fn singular_query_segments(rule:Pair<Rule>) -> Parsed<Vec<SingularQuerySegme
     }
     Ok(segments)
 }
+fn validate_range(val: i64) -> Result<i64, JsonPathParserError> {
+    if val > MAX_VAL || val < MIN_VAL {
+        Err(JsonPathParserError::InvalidJsonPath(format!("Value {} is out of range", val)))
+    } else {
+        Ok(val)
+    }
+}
+pub fn slice_selector(rule:Pair<Rule>) -> Parsed<(Option<i64>, Option<i64>, Option<i64>)> {
+    let mut start = None;
+    let mut end = None;
+    let mut step = None;
+    let get_int = |r:Pair<Rule>| r.as_str().parse::<i64>().map_err(|e|(e,"int"));
+
+    for r in rule.into_inner(){
+        match r.as_rule(){
+            Rule::start => start = Some(validate_range(get_int(r)?)?),
+            Rule::end => end = Some(validate_range(get_int(r)?)?),
+            Rule::step => step ={
+                if let Some(int) =  r.into_inner().next(){
+                    Some(validate_range(get_int(int)?)?)
+                } else {
+                    None
+                }
+            },
+
+            _ => return Err(r.into())
+        }
+    }
+    Ok((start,end,step))
+}
 
 pub fn singular_query(rule:Pair<Rule>) -> Parsed<SingularQuery>{
     let query = child(rule)?;
@@ -91,6 +121,7 @@ fn child(rule:Pair<Rule>) -> Parsed<Pair<Rule>> {
     let rule_as_str = rule.as_str().to_string();
     rule.into_inner().next().ok_or(JsonPathParserError::EmptyInner(rule_as_str))
 }
+
 fn children(rule:Pair<Rule>) -> Pairs<Rule> {
     rule.into_inner()
 }

src/parser/tests.rs

@@ -5,8 +5,8 @@ use std::fmt::Debug;
 use pest::error::Error;
 use pest::iterators::Pair;
 use pest::Parser;
-use crate::{lit, q_segments, q_segment, singular_query};
-use crate::parser::parser2::{literal, singular_query, singular_query_segments, Rule};
+use crate::{lit, q_segments, q_segment, singular_query, slice};
+use crate::parser::parser2::{literal, singular_query, singular_query_segments, slice_selector, Rule};
 use std::panic;
 
 struct TestPair<T> {
@@ -111,5 +111,22 @@ fn singular_query_test(){
         .assert("$.a.b.c",singular_query!(a b c))
         .assert("$[\"a\"].b[3]",singular_query!([a] b [3]))
 
+    ;
+}
+
+#[test]
+fn slice_selector_test(){
+    TestPair::new(Rule::slice_selector, slice_selector)
+        .assert(":",slice!())
+        .assert("::",slice!())
+        .assert("1:",slice!(1))
+        .assert("1:1",slice!(1,1))
+        .assert("1:1:1",slice!(1,1,1))
+        .assert(":1:1",slice!(,1,1))
+        .assert("::1",slice!(,,1))
+        .assert("1::1",slice!(1,,1))
+        .assert_fail("-0:")
+        .assert_fail("9007199254740995")
+
     ;
 }