nu_json/
builder.rs

1use serde::ser;
2
3use crate::value::{self, Map, Value};
4
5/// This structure provides a simple interface for constructing a JSON array.
6pub struct ArrayBuilder {
7    array: Vec<Value>,
8}
9
10impl Default for ArrayBuilder {
11    fn default() -> Self {
12        Self::new()
13    }
14}
15
16impl ArrayBuilder {
17    /// Construct an `ObjectBuilder`.
18    pub fn new() -> ArrayBuilder {
19        ArrayBuilder { array: Vec::new() }
20    }
21
22    /// Return the constructed `Value`.
23    pub fn unwrap(self) -> Value {
24        Value::Array(self.array)
25    }
26
27    /// Insert a value into the array.
28    pub fn push<T: ser::Serialize>(mut self, v: T) -> ArrayBuilder {
29        self.array
30            .push(value::to_value(&v).expect("failed to serialize"));
31        self
32    }
33
34    /// Creates and passes an `ArrayBuilder` into a closure, then inserts the resulting array into
35    /// this array.
36    pub fn push_array<F>(mut self, f: F) -> ArrayBuilder
37    where
38        F: FnOnce(ArrayBuilder) -> ArrayBuilder,
39    {
40        let builder = ArrayBuilder::new();
41        self.array.push(f(builder).unwrap());
42        self
43    }
44
45    /// Creates and passes an `ArrayBuilder` into a closure, then inserts the resulting object into
46    /// this array.
47    pub fn push_object<F>(mut self, f: F) -> ArrayBuilder
48    where
49        F: FnOnce(ObjectBuilder) -> ObjectBuilder,
50    {
51        let builder = ObjectBuilder::new();
52        self.array.push(f(builder).unwrap());
53        self
54    }
55}
56
57/// This structure provides a simple interface for constructing a JSON object.
58pub struct ObjectBuilder {
59    object: Map<String, Value>,
60}
61
62impl Default for ObjectBuilder {
63    fn default() -> Self {
64        Self::new()
65    }
66}
67
68impl ObjectBuilder {
69    /// Construct an `ObjectBuilder`.
70    pub fn new() -> ObjectBuilder {
71        ObjectBuilder { object: Map::new() }
72    }
73
74    /// Return the constructed `Value`.
75    pub fn unwrap(self) -> Value {
76        Value::Object(self.object)
77    }
78
79    /// Insert a key-value pair into the object.
80    pub fn insert<S, V>(mut self, key: S, value: V) -> ObjectBuilder
81    where
82        S: Into<String>,
83        V: ser::Serialize,
84    {
85        self.object.insert(
86            key.into(),
87            value::to_value(&value).expect("failed to serialize"),
88        );
89        self
90    }
91
92    /// Creates and passes an `ObjectBuilder` into a closure, then inserts the resulting array into
93    /// this object.
94    pub fn insert_array<S, F>(mut self, key: S, f: F) -> ObjectBuilder
95    where
96        S: Into<String>,
97        F: FnOnce(ArrayBuilder) -> ArrayBuilder,
98    {
99        let builder = ArrayBuilder::new();
100        self.object.insert(key.into(), f(builder).unwrap());
101        self
102    }
103
104    /// Creates and passes an `ObjectBuilder` into a closure, then inserts the resulting object into
105    /// this object.
106    pub fn insert_object<S, F>(mut self, key: S, f: F) -> ObjectBuilder
107    where
108        S: Into<String>,
109        F: FnOnce(ObjectBuilder) -> ObjectBuilder,
110    {
111        let builder = ObjectBuilder::new();
112        self.object.insert(key.into(), f(builder).unwrap());
113        self
114    }
115}