expose Difference, introduce owned types DifferenceBuf PathBuf KeyBuf

Author: B-2U

src/diff.rs

@@ -201,7 +201,7 @@ impl<'a, 'b> DiffFolder<'a, 'b> {
 }
 
 #[derive(Debug, PartialEq)]
-pub(crate) struct Difference<'a> {
+pub struct Difference<'a> {
     path: Path<'a>,
     lhs: Option<&'a Value>,
     rhs: Option<&'a Value>,
@@ -252,6 +252,32 @@ impl<'a> fmt::Display for Difference<'a> {
     }
 }
 
+impl Difference<'_> {
+    /// Returns a string representation of the difference, suitable for display.
+    pub fn display(&self) -> String {
+        self.to_string()
+    }
+}
+
+#[derive(Debug, PartialEq)]
+pub struct DifferenceBuf {
+    path: PathBuf,
+    lhs: Option<Value>,
+    rhs: Option<Value>,
+    config: Config,
+}
+
+impl<'a> From<Difference<'a>> for DifferenceBuf {
+    fn from(diff: Difference<'a>) -> Self {
+        DifferenceBuf {
+            path: PathBuf::from(diff.path),
+            lhs: diff.lhs.cloned(),
+            rhs: diff.rhs.cloned(),
+            config: diff.config.clone(),
+        }
+    }
+}
+
 #[derive(Debug, Clone, PartialEq)]
 enum Path<'a> {
     Root,
@@ -285,12 +311,41 @@ impl<'a> fmt::Display for Path<'a> {
     }
 }
 
+#[derive(Debug, Clone, PartialEq)]
+enum PathBuf {
+    Root,
+    Keys(Vec<KeyBuf>),
+}
+
+impl<'a> From<Path<'a>> for PathBuf {
+    fn from(path: Path<'a>) -> Self {
+        match path {
+            Path::Root => PathBuf::Root,
+            Path::Keys(keys) => PathBuf::Keys(keys.into_iter().map(KeyBuf::from).collect()),
+        }
+    }
+}
 #[derive(Debug, Copy, Clone, PartialEq)]
 enum Key<'a> {
     Idx(usize),
     Field(&'a str),
 }
 
+#[derive(Debug, Clone, PartialEq)]
+enum KeyBuf {
+    Idx(usize),
+    Field(String),
+}
+
+impl<'a> From<Key<'a>> for KeyBuf {
+    fn from(key: Key<'a>) -> Self {
+        match key {
+            Key::Idx(idx) => KeyBuf::Idx(idx),
+            Key::Field(field) => KeyBuf::Field(field.to_owned()),
+        }
+    }
+}
+
 impl<'a> fmt::Display for Key<'a> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self {

src/lib.rs

@@ -155,6 +155,8 @@
 use diff::diff;
 use serde::Serialize;
 
+use crate::diff::DifferenceBuf;
+
 mod core_ext;
 mod diff;
 
@@ -251,18 +253,59 @@ macro_rules! assert_json_eq {
 #[macro_export]
 macro_rules! assert_json_matches {
     ($lhs:expr, $rhs:expr, $config:expr $(,)?) => {{
-        if let Err(error) = $crate::assert_json_matches_no_panic(&$lhs, &$rhs, $config) {
+        if let Err(error) = $crate::assert_json_matches_no_panic_to_string(&$lhs, &$rhs, $config) {
             panic!("\n\n{}\n\n", error);
         }
     }};
 }
 
+/// Compares two JSON values without panicking.
+///
+/// Returns a `Result` containing either `Ok(())` if the values match,
+/// or an `Err` with a `Vec<DifferenceBuf>` describing the differences.
+///
+/// # Note:
+///
+/// This function performs some cloning and may be less efficient.
+///
+/// If you only need a string error message, use [`assert_json_matches_no_panic_to_string`] or the assertion macros.
+pub fn assert_json_matches_no_panic<Lhs, Rhs>(
+    lhs: &Lhs,
+    rhs: &Rhs,
+    config: Config,
+) -> Result<(), Vec<DifferenceBuf>>
+where
+    Lhs: Serialize,
+    Rhs: Serialize,
+{
+    let lhs = serde_json::to_value(lhs).unwrap_or_else(|err| {
+        panic!(
+            "Couldn't convert left hand side value to JSON. Serde error: {}",
+            err
+        )
+    });
+    let rhs = serde_json::to_value(rhs).unwrap_or_else(|err| {
+        panic!(
+            "Couldn't convert right hand side value to JSON. Serde error: {}",
+            err
+        )
+    });
+
+    let diffs = diff(&lhs, &rhs, config);
+    let diffs: Vec<DifferenceBuf> = diffs.into_iter().map(|d| d.into()).collect();
+
+    if diffs.is_empty() {
+        Ok(())
+    } else {
+        Err(diffs)
+    }
+}
 /// Compares two JSON values without panicking.
 ///
 /// Instead it returns a `Result` where the error is the message that would be passed to `panic!`.
 /// This is might be useful if you want to control how failures are reported and don't want to deal
 /// with panics.
-pub fn assert_json_matches_no_panic<Lhs, Rhs>(
+pub fn assert_json_matches_no_panic_to_string<Lhs, Rhs>(
     lhs: &Lhs,
     rhs: &Rhs,
     config: Config,
@@ -651,10 +694,10 @@ mod tests {
     }
 
     fn test_partial_match(lhs: Value, rhs: Value) -> Result<(), String> {
-        assert_json_matches_no_panic(&lhs, &rhs, Config::new(CompareMode::Inclusive))
+        assert_json_matches_no_panic_to_string(&lhs, &rhs, Config::new(CompareMode::Inclusive))
     }
 
     fn test_exact_match(lhs: Value, rhs: Value) -> Result<(), String> {
-        assert_json_matches_no_panic(&lhs, &rhs, Config::new(CompareMode::Strict))
+        assert_json_matches_no_panic_to_string(&lhs, &rhs, Config::new(CompareMode::Strict))
     }
 }

tests/integration_test.rs

@@ -1,6 +1,6 @@
-use assert_json_diff::{
-    assert_json_eq, assert_json_include, assert_json_matches, assert_json_matches_no_panic,
-    CompareMode, Config, NumericMode,
+use json_diff::{
+    assert_json_eq, assert_json_include, assert_json_matches,
+    assert_json_matches_no_panic_to_string, CompareMode, Config, NumericMode,
 };
 use serde::Serialize;
 use serde_json::json;
@@ -79,14 +79,14 @@ fn can_fail_with_exact_match() {
 
 #[test]
 fn inclusive_match_without_panicking() {
-    assert!(assert_json_matches_no_panic(
+    assert!(assert_json_matches_no_panic_to_string(
         &json!({ "a": 1, "b": 2 }),
         &json!({ "b": 2}),
         Config::new(CompareMode::Inclusive,).numeric_mode(NumericMode::Strict),
     )
     .is_ok());
 
-    assert!(assert_json_matches_no_panic(
+    assert!(assert_json_matches_no_panic_to_string(
         &json!({ "a": 1, "b": 2 }),
         &json!("foo"),
         Config::new(CompareMode::Inclusive,).numeric_mode(NumericMode::Strict),
@@ -96,14 +96,14 @@ fn inclusive_match_without_panicking() {
 
 #[test]
 fn exact_match_without_panicking() {
-    assert!(assert_json_matches_no_panic(
+    assert!(assert_json_matches_no_panic_to_string(
         &json!([1, 2, 3]),
         &json!([1, 2, 3]),
         Config::new(CompareMode::Strict).numeric_mode(NumericMode::Strict)
     )
     .is_ok());
 
-    assert!(assert_json_matches_no_panic(
+    assert!(assert_json_matches_no_panic_to_string(
         &json!([1, 2, 3]),
         &json!("foo"),
         Config::new(CompareMode::Strict).numeric_mode(NumericMode::Strict)