Struct DiffBuilder

pub struct DiffBuilder { /* private fields */ }

Builder for Diff.

Implementations

impl DiffBuilder

pub fn ignore_paths(&mut self, value: Vec<IgnorePath>) -> &mut Self

An array of paths to ignore. Use DiffBuilder::ignore_path to add them in a more convenient way.

pub fn equate_empty_arrays(&mut self, value: bool) -> &mut Self

If true arrays with a length of zero will be equal, regardless of whether they are nil.

pub fn approx_float_eq_epsilon(&mut self, value: f64) -> &mut Self

If not zero a float comparison will be done using approx::relative_eq. It’s useful when you want to ignore small differences, e.g. 0.19999999999999 ~ 0.2.

pub fn approx_date_time_eq_duration(&mut self, value: Duration) -> &mut Self

An acceptable duration difference for the JSON string values that are valid timestamps. Date approximation will only be executed when this value is not zero and a string value is a valid rfc3339 date.

pub fn source(&mut self, value: Value) -> &mut Self

Source JSON value that will be compared with Diff::target.

Examples found in repository

examples/simple_object_diff.rs (line 13)

fn main() {
    let obj1 = serde_json::json!({
        "user": "John",
        "age": 31
    });

    let obj2 = serde_json::json!({
        "user": "John",
        "age": 33
    });

    let diff = sjdiff::DiffBuilder::default()
        .source(obj1)
        .target(obj2)
        .build()
        .unwrap();
    let diff = diff.compare();

    serde_json::to_writer_pretty(std::io::stdout(), &diff).unwrap();
}

examples/ignore_with_rhai_script.rs (line 40)

fn main() {
    let obj1 = serde_json::json!({
            "users": [
                {
                    "name": "Joe",
                    "age": 43,
                },
                {
                    "name": "Ana",
                    "age": 33,
                    "animals": {
                        "type": "dog"
                    }
                },
            ]
        });

    let obj2 = serde_json::json!({
            "users": [
                {
                    "name": "Joe",
                    "age": 43,
                },
                {
                    "name": "Ana",
                    "age": 33,
                    "animals": {
                        "type": "cat"
                    }
                },
            ]
        });

    let script = r#"
        let res = target.value_by_path("users.[_].age", curr_path);
        res == 33
        "#;

    let diff = sjdiff::DiffBuilder::default()
        .source(obj1)
        .target(obj2)
        .ignore_path_with_condition("users.[_].animals.type", sjdiff::IgnorePathCondition::Rhai(script.to_string()))
        .build();
    let diff = diff.unwrap().compare();
    print!("{:?}", diff);
}

pub fn target(&mut self, value: Value) -> &mut Self

Target JSON value that will be compared with Diff::source.

Examples found in repository

examples/simple_object_diff.rs (line 14)

fn main() {
    let obj1 = serde_json::json!({
        "user": "John",
        "age": 31
    });

    let obj2 = serde_json::json!({
        "user": "John",
        "age": 33
    });

    let diff = sjdiff::DiffBuilder::default()
        .source(obj1)
        .target(obj2)
        .build()
        .unwrap();
    let diff = diff.compare();

    serde_json::to_writer_pretty(std::io::stdout(), &diff).unwrap();
}

examples/ignore_with_rhai_script.rs (line 41)

fn main() {
    let obj1 = serde_json::json!({
            "users": [
                {
                    "name": "Joe",
                    "age": 43,
                },
                {
                    "name": "Ana",
                    "age": 33,
                    "animals": {
                        "type": "dog"
                    }
                },
            ]
        });

    let obj2 = serde_json::json!({
            "users": [
                {
                    "name": "Joe",
                    "age": 43,
                },
                {
                    "name": "Ana",
                    "age": 33,
                    "animals": {
                        "type": "cat"
                    }
                },
            ]
        });

    let script = r#"
        let res = target.value_by_path("users.[_].age", curr_path);
        res == 33
        "#;

    let diff = sjdiff::DiffBuilder::default()
        .source(obj1)
        .target(obj2)
        .ignore_path_with_condition("users.[_].animals.type", sjdiff::IgnorePathCondition::Rhai(script.to_string()))
        .build();
    let diff = diff.unwrap().compare();
    print!("{:?}", diff);
}

pub fn build(&self) -> Result<Diff, DiffBuilderError>

Builds a new Diff.

Errors

If a required field has not been initialized.

Examples found in repository

examples/simple_object_diff.rs (line 15)

fn main() {
    let obj1 = serde_json::json!({
        "user": "John",
        "age": 31
    });

    let obj2 = serde_json::json!({
        "user": "John",
        "age": 33
    });

    let diff = sjdiff::DiffBuilder::default()
        .source(obj1)
        .target(obj2)
        .build()
        .unwrap();
    let diff = diff.compare();

    serde_json::to_writer_pretty(std::io::stdout(), &diff).unwrap();
}

examples/ignore_with_rhai_script.rs (line 43)

fn main() {
    let obj1 = serde_json::json!({
            "users": [
                {
                    "name": "Joe",
                    "age": 43,
                },
                {
                    "name": "Ana",
                    "age": 33,
                    "animals": {
                        "type": "dog"
                    }
                },
            ]
        });

    let obj2 = serde_json::json!({
            "users": [
                {
                    "name": "Joe",
                    "age": 43,
                },
                {
                    "name": "Ana",
                    "age": 33,
                    "animals": {
                        "type": "cat"
                    }
                },
            ]
        });

    let script = r#"
        let res = target.value_by_path("users.[_].age", curr_path);
        res == 33
        "#;

    let diff = sjdiff::DiffBuilder::default()
        .source(obj1)
        .target(obj2)
        .ignore_path_with_condition("users.[_].animals.type", sjdiff::IgnorePathCondition::Rhai(script.to_string()))
        .build();
    let diff = diff.unwrap().compare();
    print!("{:?}", diff);
}

impl DiffBuilder

pub fn ignore_path(&mut self, path: &str) -> &mut Self

Set a JSON path using a string format that you want to ignore during the comparison. A string path will be parsed to IgnorePath and appended to Diff::ignore_paths.

Examples

a.[_].c will ignore c key in any element of array a:

{
    "a": [{"b": "3", "c": "4"}]
}

[_] means any index.

and a.[1].c will ignore c key in the element with index 1.

address.zip will ignore zip key in the address:

{
    "address": {
}

NOTE: if the element is missing in the source or target and you added it to ignore paths, the result diff will still show it as a missing one. Use DiffBuilder::ignore_path_with_missing with ignore_missing set to true instead.

pub fn ignore_path_with_missing( &mut self, path: &str, ignore_missing: bool, ) -> &mut Self

Adds a path to the ignored ones. ignore_missing indicates whether the element should be ignored if it’s missing in the source or target. See documentation for DiffBuilder::ignore_path for usage examples.

pub fn ignore_path_with_condition( &mut self, path: &str, condition: IgnorePathCondition, ) -> &mut Self

Does the same as DiffBuilder::ignore_path but you can pass a custom script as a condition. See the example ignore_with_rhai_script.rs to learn how to use it.

Examples found in repository

examples/ignore_with_rhai_script.rs (line 42)

fn main() {
    let obj1 = serde_json::json!({
            "users": [
                {
                    "name": "Joe",
                    "age": 43,
                },
                {
                    "name": "Ana",
                    "age": 33,
                    "animals": {
                        "type": "dog"
                    }
                },
            ]
        });

    let obj2 = serde_json::json!({
            "users": [
                {
                    "name": "Joe",
                    "age": 43,
                },
                {
                    "name": "Ana",
                    "age": 33,
                    "animals": {
                        "type": "cat"
                    }
                },
            ]
        });

    let script = r#"
        let res = target.value_by_path("users.[_].age", curr_path);
        res == 33
        "#;

    let diff = sjdiff::DiffBuilder::default()
        .source(obj1)
        .target(obj2)
        .ignore_path_with_condition("users.[_].animals.type", sjdiff::IgnorePathCondition::Rhai(script.to_string()))
        .build();
    let diff = diff.unwrap().compare();
    print!("{:?}", diff);
}

Trait Implementations

impl Clone for DiffBuilder

fn clone(&self) -> DiffBuilder

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Default for DiffBuilder

fn default() -> Self

Returns the “default value” for a type.