add support for num operations (#28)

* add support for num operations
* clean warnings

Author: gkorland

src/lib.rs

@@ -1,12 +1,12 @@
 #[macro_use]
 extern crate redismodule;
 
-use redismodule::{Context, RedisResult, NextArg, REDIS_OK, RedisError};
 use redismodule::native_types::RedisType;
+use redismodule::{Context, NextArg, RedisError, RedisResult, REDIS_OK};
 
 mod redisjson;
 
-use crate::redisjson::RedisJSON;
+use crate::redisjson::{Error, RedisJSON};
 
 static REDIS_JSON_TYPE: RedisType = RedisType::new("RedisJSON");
 
@@ -25,7 +25,7 @@ fn json_del(ctx: &Context, args: Vec<String>) -> RedisResult {
     let key = ctx.open_key_writable(&key);
     let deleted = match key.get_value::<RedisJSON>(&REDIS_JSON_TYPE)? {
         Some(doc) => doc.delete_path(&path)?,
-        None => 0
+        None => 0,
     };
     Ok(deleted.into())
 }
@@ -37,13 +37,12 @@ fn json_set(ctx: &Context, args: Vec<String>) -> RedisResult {
     let path = args.next_string()?;
     let value = args.next_string()?;
 
-    let set_option = args.next()
-        .map(|op| {
-            match op.to_uppercase().as_str() {
-                "NX" => Ok(SetOptions::NotExists),
-                "XX" => Ok(SetOptions::AlreadyExists),
-                _ => Err(RedisError::Str("ERR syntax error")),
-            }
+    let set_option = args
+        .next()
+        .map(|op| match op.to_uppercase().as_str() {
+            "NX" => Ok(SetOptions::NotExists),
+            "XX" => Ok(SetOptions::AlreadyExists),
+            _ => Err(RedisError::Str("ERR syntax error")),
         })
         .transpose()?;
 
@@ -73,63 +72,62 @@ fn json_get(ctx: &Context, args: Vec<String>) -> RedisResult {
     let mut path = loop {
         let arg = match args.next_string() {
             Ok(s) => s,
-            Err(_) => "$".to_owned() // path is optional
+            Err(_) => "$".to_owned(), // path is optional
         };
 
         match arg.as_str() {
-            "INDENT" => args.next(), // TODO add support
-            "NEWLINE" => args.next(), // TODO add support
-            "SPACE" => args.next(), // TODO add support
-            "NOESCAPE" => continue, // TODO add support
-            "." => break String::from("$"), // backward compatibility suuport
-            _ => break arg
+            "INDENT" => args.next(),        // TODO add support
+            "NEWLINE" => args.next(),       // TODO add support
+            "SPACE" => args.next(),         // TODO add support
+            "NOESCAPE" => continue,         // TODO add support
+            "." => break String::from("$"), // backward compatibility support
+            _ => break arg,
         };
     };
 
-    if path.starts_with(".") { // backward compatibility
+    if path.starts_with(".") {
+        // backward compatibility
         path.insert(0, '$');
     }
 
     let key = ctx.open_key_writable(&key);
 
     let value = match key.get_value::<RedisJSON>(&REDIS_JSON_TYPE)? {
         Some(doc) => doc.to_string(&path)?.into(),
-        None => ().into()
+        None => ().into(),
     };
 
     Ok(value)
 }
 
 fn json_mget(ctx: &Context, args: Vec<String>) -> RedisResult {
-
     if args.len() < 3 {
         return Err(RedisError::WrongArity);
     }
     if let Some(path) = args.last() {
         let mut path = path.clone();
-        if path.starts_with(".") { // backward compatibility
+        if path.starts_with(".") {
+            // backward compatibility
             path.insert(0, '$');
         }
-        let mut results: Vec<String> = Vec::with_capacity(args.len()-2);
-        for key in &args[1..args.len()-1] {
+        let mut results: Vec<String> = Vec::with_capacity(args.len() - 2);
+        for key in &args[1..args.len() - 1] {
             let redis_key = ctx.open_key_writable(&key);
             match redis_key.get_value::<RedisJSON>(&REDIS_JSON_TYPE)? {
                 Some(doc) => {
                     let result = doc.to_string(&path)?;
                     results.push(result);
-                },
+                }
                 None => {}
             };
-
         }
         Ok(results.into())
     } else {
         Err(RedisError::WrongArity)
     }
 }
 
-
-fn json_strlen(ctx: &Context, args: Vec<String>) -> RedisResult {
+fn json_str_len(ctx: &Context, args: Vec<String>) -> RedisResult {
     let mut args = args.into_iter().skip(1);
     let key = args.next_string()?;
     let path = args.next_string()?;
@@ -138,7 +136,7 @@ fn json_strlen(ctx: &Context, args: Vec<String>) -> RedisResult {
 
     let length = match key.get_value::<RedisJSON>(&REDIS_JSON_TYPE)? {
         Some(doc) => doc.str_len(&path)?.into(),
-        None => ().into()
+        None => ().into(),
     };
 
     Ok(length)
@@ -153,12 +151,107 @@ fn json_type(ctx: &Context, args: Vec<String>) -> RedisResult {
 
     let value = match key.get_value::<RedisJSON>(&REDIS_JSON_TYPE)? {
         Some(doc) => doc.get_type(&path)?.into(),
-        None => ().into()
+        None => ().into(),
     };
 
     Ok(value)
 }
 
+fn json_num_incrby(ctx: &Context, args: Vec<String>) -> RedisResult {
+    json_num_op(ctx, args, |num1, num2| num1 + num2)
+}
+
+fn json_num_multby(ctx: &Context, args: Vec<String>) -> RedisResult {
+    json_num_op(ctx, args, |num1, num2| num1 * num2)
+}
+
+fn json_num_powby(ctx: &Context, args: Vec<String>) -> RedisResult {
+    json_num_op(ctx, args, |num1, num2| num1.powf(num2))
+}
+
+fn json_num_op<F>(ctx: &Context, args: Vec<String>, fun: F) -> RedisResult
+    where F: Fn(f64, f64) -> f64 {
+    let mut args = args.into_iter().skip(1);
+
+    let key = args.next_string()?;
+    let path = args.next_string()?;
+    let number: f64 = args.next_string()?.parse()?;
+
+    let key = ctx.open_key_writable(&key);
+
+    match key.get_value::<RedisJSON>(&REDIS_JSON_TYPE)? {
+        Some(doc) => Ok(doc.num_op(&path, number, fun)?.into()),
+        None => Err("ERR could not perform this operation on a key that doesn't exist".into()),
+    }
+}
+
+fn json_str_append(_ctx: &Context, _args: Vec<String>) -> RedisResult {
+    Err("Command was not implemented".into())
+}
+
+fn json_arr_append(_ctx: &Context, _args: Vec<String>) -> RedisResult {
+    Err("Command was not implemented".into())
+}
+
+fn json_arr_index(_ctx: &Context, _args: Vec<String>) -> RedisResult {
+    Err("Command was not implemented".into())
+}
+
+fn json_arr_insert(_ctx: &Context, _args: Vec<String>) -> RedisResult {
+    Err("Command was not implemented".into())
+}
+
+fn json_arr_len(ctx: &Context, args: Vec<String>) -> RedisResult {
+    json_len(ctx, args, |doc, path| doc.arr_len(path))
+}
+
+fn json_arr_pop(_ctx: &Context, _args: Vec<String>) -> RedisResult {
+    Err("Command was not implemented".into())
+}
+
+fn json_arr_trim(_ctx: &Context, _args: Vec<String>) -> RedisResult {
+    Err("Command was not implemented".into())
+}
+
+fn json_obj_keys(_ctx: &Context, _args: Vec<String>) -> RedisResult {
+    Err("Command was not implemented".into())
+}
+
+fn json_obj_len(ctx: &Context, args: Vec<String>) -> RedisResult {
+    json_len(ctx, args, |doc, path| doc.obj_len(path))
+}
+
+fn json_debug(_ctx: &Context, _args: Vec<String>) -> RedisResult {
+    Err("Command was not implemented".into())
+}
+
+fn json_forget(_ctx: &Context, _args: Vec<String>) -> RedisResult {
+    Err("Command was not implemented".into())
+}
+
+fn json_resp(_ctx: &Context, _args: Vec<String>) -> RedisResult {
+    Err("Command was not implemented".into())
+}
+
+fn json_len<F: Fn(&RedisJSON, &String) -> Result<usize, Error>>(
+    ctx: &Context,
+    args: Vec<String>,
+    fun: F,
+) -> RedisResult {
+    let mut args = args.into_iter().skip(1);
+    let key = args.next_string()?;
+    let path = args.next_string()?;
+
+    let key = ctx.open_key_writable(&key);
+
+    let length = match key.get_value::<RedisJSON>(&REDIS_JSON_TYPE)? {
+        Some(doc) => fun(&doc, &path)?.into(),
+        None => ().into(),
+    };
+
+    Ok(length)
+}
+
 //////////////////////////////////////////////////////
 
 redis_module! {
@@ -168,11 +261,26 @@ redis_module! {
         REDIS_JSON_TYPE,
     ],
     commands: [
-        ["json.set", json_set, "write"],
         ["json.del", json_del, "write"],
         ["json.get", json_get, ""],
         ["json.mget", json_mget, ""],
-        ["json.strlen", json_strlen, ""],
+        ["json.set", json_set, "write"],
         ["json.type", json_type, ""],
+        ["json.numincrby", json_num_incrby, ""],
+        ["json.nummultby", json_num_multby, ""],
+        ["json.numpowby", json_num_powby, ""],
+        ["json.strappend", json_str_append, ""],
+        ["json.strlen", json_str_len, ""],
+        ["json.arrappend", json_arr_append, ""],
+        ["json.arrindex", json_arr_index, ""],
+        ["json.arrinsert", json_arr_insert, ""],
+        ["json.arrlen", json_arr_len, ""],
+        ["json.arrpop", json_arr_pop, ""],
+        ["json.arrtrim", json_arr_trim, ""],
+        ["json.objkeys", json_obj_keys, ""],
+        ["json.objlen", json_obj_len, ""],
+        ["json.debug", json_debug, ""],
+        ["json.forget", json_forget, ""],
+        ["json.resp", json_resp, ""],
     ],
 }