json-patch 4.1.0

RFC 6902, JavaScript Object Notation (JSON) Patch
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127

use json_patch::{AddOperation, Patch, PatchOperation, RemoveOperation};
use jsonptr::PointerBuf;
use rand::distributions::Alphanumeric;
use rand::prelude::*;
use serde_json::{Map, Value};

pub struct Params {
    pub array_size: usize,
    pub map_size: usize,
    pub value_size: usize,
    pub depth: usize,
    pub key_size: usize,
}

impl Default for Params {
    fn default() -> Self {
        Params {
            array_size: 6,
            map_size: 6,
            value_size: 100,
            depth: 8,
            key_size: 20,
        }
    }
}

fn rand_str<R: Rng>(rng: &mut R, max_len: usize) -> String {
    let len = rng.gen::<usize>() % max_len + 1;
    rng.sample_iter(&Alphanumeric)
        .take(len)
        .map(char::from)
        .collect()
}

fn rand_literal<R: Rng>(rng: &mut R, value_size: usize) -> Value {
    match rng.gen::<u32>() % 4 {
        0 => Value::Null,
        1 => Value::String(rand_str(rng, value_size)),
        2 => Value::Bool(false),
        3 => Value::from(rng.gen::<u64>()),
        _ => panic!(),
    }
}

impl Params {
    pub fn gen<R: Rng>(&self, rng: &mut R) -> Value {
        self.gen_internal(self.depth, rng)
    }

    fn gen_internal<R: Rng>(&self, depth: usize, rng: &mut R) -> Value {
        if depth == 0 {
            rand_literal(rng, self.value_size)
        } else if rng.gen::<bool>() {
            // Generate random array
            let len = (rng.gen::<usize>() % self.array_size) + 1;
            let vec: Vec<Value> = (0..len)
                .map(|_| self.gen_internal(depth - 1, rng))
                .collect();
            Value::from(vec)
        } else {
            // Generate random object
            let len = (rng.gen::<usize>() % self.map_size) + 1;
            let map: Map<String, Value> = (0..len)
                .map(|_| {
                    (
                        rand_str(rng, self.key_size),
                        self.gen_internal(depth - 1, rng),
                    )
                })
                .collect();
            Value::from(map)
        }
    }
}

pub fn gen_add_remove_patches<R: Rng>(
    value: &Value,
    rnd: &mut R,
    patches: usize,
    operations: usize,
) -> Vec<Patch> {
    let leaves = all_leaves(value);
    let mut vec = Vec::new();
    for _ in 0..patches {
        let mut ops = Vec::new();
        for _ in 0..operations {
            let path = leaves.choose(rnd).unwrap();
            ops.push(PatchOperation::Remove(RemoveOperation {
                path: (*path).clone(),
            }));
            ops.push(PatchOperation::Add(AddOperation {
                path: (*path).clone(),
                value: Value::Null,
            }));
        }
        vec.push(Patch(ops));
    }
    vec
}

fn all_leaves(value: &Value) -> Vec<PointerBuf> {
    let mut result = Vec::new();
    collect_leaves(value, &mut PointerBuf::new(), &mut result);
    result
}

fn collect_leaves(value: &Value, prefix: &mut PointerBuf, result: &mut Vec<PointerBuf>) {
    match *value {
        Value::Array(ref arr) => {
            for (idx, val) in arr.iter().enumerate() {
                prefix.push_back(idx);
                collect_leaves(val, prefix, result);
                prefix.pop_back();
            }
        }
        Value::Object(ref map) => {
            for (key, val) in map.iter() {
                prefix.push_back(key);
                collect_leaves(val, prefix, result);
                prefix.pop_back();
            }
        }
        _ => {
            result.push(prefix.clone());
        }
    }
}