change delete to remove key and open some tests (#40)

* change delete to remove key and open some tests

Author: gkorland

Cargo.lock

@@ -10,5 +10,5 @@ crate-type = ["cdylib"]
 [dependencies]
 serde_json = "1.0"
 libc = "0.2"
-jsonpath_lib = "0.2.3"	
+jsonpath_lib = { git="https://github.com/gkorland/jsonpath.git", branch="reaplce_with_ownership_parser" }
 redismodule = { git = "https://github.com/RedisLabsModules/redismodule-rs.git", branch = "master" }

Cargo.toml

@@ -7,10 +7,11 @@ use serde_json::{Number, Value};
 use std::{i64, usize};
 
 mod index;
+mod nodevisitor;
 mod redisjson;
 
 use crate::index::Index;
-use crate::redisjson::{Error, RedisJSON};
+use crate::redisjson::{Error, RedisJSON, SetOptions};
 
 static JSON_TYPE_ENCODING_VERSION: i32 = 2;
 static JSON_TYPE_NAME: &str = "ReJSON-RL";
@@ -32,12 +33,6 @@ static REDIS_JSON_TYPE: RedisType = RedisType::new(
     },
 );
 
-#[derive(Debug, PartialEq)]
-pub enum SetOptions {
-    NotExists,
-    AlreadyExists,
-}
-
 ///
 /// Backwards compatibility convertor for RedisJSON 1.x clients
 ///
@@ -101,12 +96,14 @@ fn json_set(ctx: &Context, args: Vec<String>) -> RedisResult {
     let current = key.get_value::<RedisJSON>(&REDIS_JSON_TYPE)?;
 
     match (current, set_option) {
-        (Some(_), Some(SetOptions::NotExists)) => Ok(().into()),
-        (Some(ref mut doc), _) => {
-            doc.set_value(&value, &path)?;
-            REDIS_OK
+        (Some(ref mut doc), ref op) => {
+            if doc.set_value(&value, &path, op)? {
+                REDIS_OK
+            } else {
+                Ok(RedisValue::None)
+            }
         }
-        (None, Some(SetOptions::AlreadyExists)) => Ok(().into()),
+        (None, Some(SetOptions::AlreadyExists)) => Ok(RedisValue::None),
         (None, _) => {
             let doc = RedisJSON::from_str(&value)?;
             if path == "$" {
@@ -153,7 +150,7 @@ fn json_get(ctx: &Context, args: Vec<String>) -> RedisResult {
 
     let value = match key.get_value::<RedisJSON>(&REDIS_JSON_TYPE)? {
         Some(doc) => doc.to_string(&path)?.into(),
-        None => ().into(),
+        None => RedisValue::None,
     };
 
     Ok(value)
@@ -205,10 +202,13 @@ fn json_type(ctx: &Context, args: Vec<String>) -> RedisResult {
 
     let key = ctx.open_key(&key);
 
-    let value = match key.get_value::<RedisJSON>(&REDIS_JSON_TYPE)? {
-        Some(doc) => doc.get_type(&path)?.into(),
-        None => ().into(),
-    };
+    let value = key.get_value::<RedisJSON>(&REDIS_JSON_TYPE)?.map_or_else(
+        || RedisValue::None,
+        |doc| match doc.get_type(&path) {
+            Ok(s) => s.into(),
+            Err(_) => RedisValue::None,
+        },
+    );
 
     Ok(value)
 }
@@ -551,7 +551,7 @@ fn json_obj_keys(ctx: &Context, args: Vec<String>) -> RedisResult {
 
     let value = match key.get_value::<RedisJSON>(&REDIS_JSON_TYPE)? {
         Some(doc) => doc.obj_keys(&path)?.into(),
-        None => ().into(),
+        None => RedisValue::None,
     };
 
     Ok(value)
@@ -587,7 +587,7 @@ fn json_resp(ctx: &Context, args: Vec<String>) -> RedisResult {
     let key = ctx.open_key(&key);
     match key.get_value::<RedisJSON>(&REDIS_JSON_TYPE)? {
         Some(doc) => Ok(resp_serialize(doc.get_doc(&path)?)),
-        None => Ok(().into()),
+        None => Ok(RedisValue::None),
     }
 }
 
@@ -635,7 +635,7 @@ fn json_len<F: Fn(&RedisJSON, &String) -> Result<usize, Error>>(
     let key = ctx.open_key(&key);
     let length = match key.get_value::<RedisJSON>(&REDIS_JSON_TYPE)? {
         Some(doc) => fun(&doc, &path)?.into(),
-        None => ().into(),
+        None => RedisValue::None,
     };
 
     Ok(length)

src/lib.rs

@@ -0,0 +1,48 @@
+use jsonpath_lib::parser::{NodeVisitor, ParseToken};
+use jsonpath_lib::Parser;
+
+#[derive(Debug, PartialEq)]
+enum VisitStatus {
+    NotValid,
+    PartialValid,
+    Valid,
+}
+
+pub struct NodeVisitorImpl {
+    valid: VisitStatus,
+    last_token: Option<ParseToken>,
+}
+
+impl NodeVisitorImpl {
+    ///
+    /// Checks if path is static & valid
+    /// 
+    pub fn check(input: &str) -> Result<bool, String> {
+        let node = Parser::compile(input)?;
+        let mut visitor = NodeVisitorImpl {
+            valid: VisitStatus::PartialValid,
+            last_token: None,
+        };
+        visitor.visit(&node);
+        Ok(visitor.valid == VisitStatus::Valid)
+    }
+}
+
+impl NodeVisitor for NodeVisitorImpl {
+    fn visit_token(&mut self, token: &ParseToken) {
+        if self.valid != VisitStatus::NotValid {
+            self.valid = match (&self.last_token, token) {
+                (None, ParseToken::Absolute) => VisitStatus::PartialValid,
+                (Some(ParseToken::Absolute), ParseToken::In) => VisitStatus::PartialValid,
+                (Some(ParseToken::In), ParseToken::Key(_)) => VisitStatus::Valid,
+                (Some(ParseToken::Key(_)), ParseToken::In) => VisitStatus::PartialValid,
+                (Some(ParseToken::Key(_)), ParseToken::Array) => VisitStatus::PartialValid,
+                (Some(ParseToken::Array), ParseToken::Number(_)) => VisitStatus::PartialValid,
+                (Some(ParseToken::Number(_)), ParseToken::ArrayEof) => VisitStatus::PartialValid,
+                (Some(ParseToken::ArrayEof), ParseToken::In) => VisitStatus::PartialValid,
+                _ => VisitStatus::NotValid,
+            };
+            self.last_token = Some(token.clone());
+        }
+    }
+}