Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "json_dotpath"
-version = "1.1.0"
+version = "1.0.2"
 authors = ["Ondřej Hruška <ondra@ondrovo.com>"]
 edition = "2018"
 license = "MIT"
@@ -16,4 +16,5 @@ categories = [
 serde = "1"
 serde_derive = "1"
 serde_json = "1"
-thiserror = "1"
+failure = "0.1.7"
+failure_derive = "0.1.7"

README.md

@@ -4,14 +4,6 @@ Access members of nested JSON arrays and objects using "dotted paths".
 
 ## Changes
 
-### 1.1.0
-
-Added `dot_has()` and `dot_has_checked()`
-
-### 1.0.3
-
-Replaced `failure` with `thiserror`, implement `std::error::Error` for the error type.
-
 ### 1.0.0
 
 The API changed to return `Result<Option<T>>` instead of panicking internally on error.
@@ -67,8 +59,6 @@ Five principal methods are added by the `DotPaths` trait to `serde_json::Value`,
 - `dot_remove(path)` - remove a value by path
 - `dot_get_or(path, def)` - get value, or a custom default
 - `dot_get_or_default(path)` - get value, or `Default::default()`
-- `dot_has_checked(path)` - checks if a path is valid and a value exists there
-- `dot_has(path)` - the same as above, but errors silently become `false`
 
 All methods are generic and take care of serializing and deserializing the stored / retrieved
 data. `dot_get_mut()` is an exception and returns `&mut Value`.
@@ -124,7 +114,7 @@ See unit tests for more examples.
 
 ### Special handling of Null
 
-JSON null can transparently become an array or object by setting it's members (even nested), 
+JSON null in an object can transparently become an array or object by setting it's members (even nested), 
 as if it was an empty array or object. Whether it should become an array or object depends on the key used to index into it.
 
 - numeric key turns null into an array (only `0` and the special array operators are allowed, 
@@ -132,8 +122,6 @@ as if it was an empty array or object. Whether it should become an array or obje
 - any other key turns it into a map
 - any key starting with an escape creates a map as well (e.g. `\0.aaa` turns `null` into `{"0": {"aaa": …} }` )
 
-JSON null is considered an empty value and is transformed into `Ok(None)` when retrieved, 
+JSON null is considered an empty value and is transformed into `Ok(None)` when retrieved, as it can not be deserialized.
-as it can not be deserialized.
 
-Setting a value to `Value::Null` works as expected and places a JSON null in the object, the same
+Setting a value to `Value::Null` works as expected and places a JSON null in the object.
-applies when getting a mutable reference.

src/lib.rs

@@ -2,34 +2,41 @@ use serde::de::DeserializeOwned;
 use serde::Serialize;
 use serde_json::{Map, Value};
 use std::mem;
-use thiserror::Error;
 
 #[cfg(test)]
 #[macro_use]
 extern crate serde_derive;
+#[macro_use]
+extern crate failure;
 
 /// Errors from dot_path methods
-#[derive(Debug, Error)]
+#[derive(Debug, Fail)]
 pub enum Error {
     /// Path hit a value in the JSON object that is not array or map
     /// and could not continue the traversal.
     ///
     /// (e.g. `foo.bar` in `{"foo": 123}`)
-    #[error("Unexpected value reached while traversing path")]
+    #[fail(display = "Unexpected value reached while traversing path")]
     BadPathElement,
 
     /// Array index out of range
-    #[error("Invalid array index: {0}")]
+    #[fail(display = "Invalid array index: {}", _0)]
     BadIndex(usize),
 
     /// Invalid (usually empty) key used in Map or Array.
     /// If the key is valid but out of bounds, `BadIndex` will be used.
-    #[error("Invalid key: {0}")]
+    #[fail(display = "Invalid key: {}", _0)]
     InvalidKey(String),
 
     /// Error serializing or deserializing a value
-    #[error("Invalid array or map key")]
+    #[fail(display = "Invalid array or map key")]
-    SerdeError(#[from] serde_json::Error),
+    SerdeError(#[fail(cause)] serde_json::Error),
+}
+
+impl From<serde_json::Error> for Error {
+    fn from(e: serde_json::Error) -> Self {
+        Error::SerdeError(e)
+    }
 }
 
 use crate::Error::{BadIndex, BadPathElement, InvalidKey};
@@ -112,27 +119,6 @@ pub trait DotPaths {
         self.dot_get_or(path, T::default())
     }
 
-    /// Check if a value exists under a dotted path.
-    /// Returns error if the path is invalid, a string key was used to index into an array.
-    ///
-    /// # Special symbols
-    /// - `>` ... last element of an array
-    /// - `<` ... first element of an array (same as `0`)
-    fn dot_has_checked(&self, path: &str) -> Result<bool>;
-
-    /// Check if a value exists under a dotted path.
-    /// Returns false also when the path is invalid.
-    ///
-    /// Use `dot_has_checked` if you want to distinguish non-existent values from path errors.
-    ///
-    /// # Special symbols
-    /// - `>` ... last element of an array
-    /// - `<` ... first element of an array (same as `0`)
-    fn dot_has(&self, path: &str) -> bool {
-        self.dot_has_checked(path)
-            .unwrap_or_default()
-    }
-
     /// Get a mutable reference to an item
     ///
     /// If the path does not exist but a value on the path can be created (i.e. because the path
@@ -250,22 +236,6 @@ impl DotPaths for serde_json::Value {
         }
     }
 
-    fn dot_has_checked(&self, path: &str) -> Result<bool> {
-        match self {
-            Value::Array(vec) => vec.dot_has_checked(path),
-            Value::Object(map) => map.dot_has_checked(path),
-            Value::Null => Ok(false),
-            _ => {
-                if path.is_empty() {
-                    Ok(true)
-                } else {
-                    // Path continues, but we can't traverse into a scalar
-                    Ok(false)
-                }
-            }
-        }
-    }
-
     fn dot_get_mut(&mut self, path: &str) -> Result<&mut Value> {
         match self {
             Value::Array(vec) => vec.dot_get_mut(path),
@@ -298,7 +268,7 @@ impl DotPaths for serde_json::Value {
             Value::Object(map) => map.dot_replace(path, value),
             Value::Null => {
                 // spawn new
-                *self = new_by_path_root(path, value)?;
+                mem::replace(self, new_by_path_root(path, value)?);
                 Ok(None)
             }
             _ => {
@@ -403,26 +373,6 @@ impl DotPaths for serde_json::Map<String, serde_json::Value> {
         }
     }
 
-    fn dot_has_checked(&self, path: &str) -> Result<bool> {
-        let (my, sub) = path_split(path);
-
-        if my.is_empty() {
-            return Err(InvalidKey(my));
-        }
-
-        if let Some(sub_path) = sub {
-            match self.get(&my).null_to_none() {
-                None => Ok(false),
-                Some(child) => child.dot_has_checked(sub_path),
-            }
-        } else {
-            match self.get(&my).null_to_none() {
-                None => Ok(false),
-                Some(_) => Ok(true),
-            }
-        }
-    }
-
     #[allow(clippy::collapsible_if)]
     fn dot_get_mut(&mut self, path: &str) -> Result<&mut Value> {
         let (my, sub) = path_split(path);
@@ -573,43 +523,6 @@ impl DotPaths for Vec<serde_json::Value> {
         }
     }
 
-    fn dot_has_checked(&self, path: &str) -> Result<bool> {
-        let (my, sub) = path_split(path);
-
-        if my.is_empty() {
-            return Err(InvalidKey(my));
-        }
-
-        if self.is_empty() {
-            return Ok(false);
-        }
-
-        let index: usize = match my.as_str() {
-            ">" => self.len() - 1, // non-empty checked above
-            "<" => 0,
-            _ => my.parse().map_err(|_| {
-                InvalidKey(my)
-            })?,
-        };
-
-        if index >= self.len() {
-            return Ok(false);
-        }
-
-        if let Some(subpath) = sub {
-            match self.get(index).null_to_none() {
-                None => Ok(false),
-                Some(child) => child.dot_has_checked(subpath),
-            }
-        } else {
-            match self.get(index).null_to_none() {
-                // null is reported as unset
-                None => Ok(false),
-                Some(_) => Ok(true),
-            }
-        }
-    }
-
     #[allow(clippy::collapsible_if)]
     fn dot_get_mut(&mut self, path: &str) -> Result<&mut Value> {
         let (my, sub) = path_split(path);
@@ -1195,7 +1108,7 @@ mod tests {
         // Borrow Null as mutable
         let mut obj = Value::Null;
         let m = obj.dot_get_mut("").unwrap();
-        *m = Value::from(123);
+        std::mem::replace(m, Value::from(123));
         assert_eq!(Value::from(123), obj);
 
         // Create a parents path
@@ -1237,30 +1150,6 @@ mod tests {
         assert_eq!(json!([{"foo": {"bar": {"dog": "cat"}}}]), Value::Array(obj));
     }
 
-    #[test]
-    fn has() {
-        let value = json!({
-            "one": "two",
-            "x": [1, 2, {"foo": 123}]
-        });
-        assert!(value.dot_has("one"));
-        assert!(!value.dot_has("two"));
-        assert!(value.dot_has("x"));
-        assert!(value.dot_has("x.0"));
-        assert!(value.dot_has("x.<"));
-        assert!(value.dot_has("x.>"));
-        assert!(value.dot_has("x.>.foo"));
-        assert!(!value.dot_has("x.banana"));
-        assert!(!value.dot_has("x.>.foo.bar"));
-        assert!(value.dot_has_checked("x.banana").is_err());
-
-        if let Ok(false) = value.dot_has_checked("x.9999") {
-            //
-        } else {
-            panic!("dot_has_checked failed");
-        }
-    }
-
     #[test]
     fn stamps() {
         let mut stamps = Value::Null;