fix #53 stop==(-1 or 0) is the default stop (#54)

* fix #53 stop==(-1 or 0) is the default stop

Author: gkorland

src/lib.rs

@@ -431,8 +431,8 @@ fn json_arr_index(ctx: &Context, args: Vec<String>) -> RedisResult {
     let key = args.next_string()?;
     let path = backwards_compat_path(args.next_string()?);
     let json_scalar = args.next_string()?;
-    let start = args.next().map(|v| v.parse()).unwrap_or(Ok(0))?;
-    let end = args.next().map(|v| v.parse()).unwrap_or(Ok(usize::MAX))?;
+    let start: i64 = args.next().map(|v| v.parse()).unwrap_or(Ok(0))?;
+    let end: i64 = args.next().map(|v| v.parse()).unwrap_or(Ok(i64::MAX))?;
 
     args.done()?; // TODO: Add to other functions as well to terminate args list
 

src/redisjson.rs

@@ -218,21 +218,25 @@ impl RedisJSON {
             .map(|obj| obj.keys().collect())
     }
 
-    pub fn arr_index(
-        &self,
-        path: &str,
-        scalar: &str,
-        start: usize,
-        end: usize,
-    ) -> Result<i64, Error> {
+    pub fn arr_index(&self, path: &str, scalar: &str, start: i64, end: i64) -> Result<i64, Error> {
         if let Value::Array(arr) = self.get_doc(path)? {
+            // end=-1/0 means INFINITY to support backward with RedisJSON
+            if arr.is_empty() || end < -1 { 
+                return Ok(-1);
+            }
             match serde_json::from_str(scalar)? {
                 Value::Array(_) | Value::Object(_) => Ok(-1),
                 v => {
-                    let mut start = start.max(0);
-                    let end = end.min(arr.len() - 1);
-                    start = end.min(start);
-
+                    let end: usize = if end == 0 || end == -1 {
+                        // default end of array
+                        arr.len() - 1
+                    } else {
+                        (end as usize).min(arr.len() - 1)
+                    };
+                    let start = start.max(0) as usize;
+                    if end < start {
+                        return Ok(-1);
+                    }
                     let slice = &arr[start..=end];
                     match slice.iter().position(|r| r == &v) {
                         Some(i) => Ok((start + i) as i64),