Skip to main content

rcp/
json.rs

1//! json.rs — a small, dependency-free JSON value type with parser and serializer.
2//!
3//! The RCP wire is JSON, and the SDK ships zero dependencies, so — like the C++
4//! SDK vendors nlohmann/json — the Rust SDK vendors this minimal implementation.
5//! Objects preserve insertion order (a `Vec` of pairs), matching the other SDKs.
6
7use std::fmt;
8
9/// A JSON value.
10#[derive(Clone, Debug, PartialEq)]
11pub enum Json {
12    Null,
13    Bool(bool),
14    Int(i64),
15    Float(f64),
16    Str(String),
17    Array(Vec<Json>),
18    Object(Vec<(String, Json)>),
19}
20
21impl Json {
22    /// An empty object.
23    pub fn object() -> Json {
24        Json::Object(Vec::new())
25    }
26
27    /// An empty array.
28    pub fn array() -> Json {
29        Json::Array(Vec::new())
30    }
31
32    // ── accessors ────────────────────────────────────────────────────────────
33    pub fn is_null(&self) -> bool {
34        matches!(self, Json::Null)
35    }
36
37    pub fn as_str(&self) -> Option<&str> {
38        match self {
39            Json::Str(s) => Some(s),
40            _ => None,
41        }
42    }
43
44    pub fn as_i64(&self) -> Option<i64> {
45        match self {
46            Json::Int(n) => Some(*n),
47            Json::Float(f) if f.fract() == 0.0 => Some(*f as i64),
48            _ => None,
49        }
50    }
51
52    pub fn as_f64(&self) -> Option<f64> {
53        match self {
54            Json::Int(n) => Some(*n as f64),
55            Json::Float(f) => Some(*f),
56            _ => None,
57        }
58    }
59
60    pub fn as_bool(&self) -> Option<bool> {
61        match self {
62            Json::Bool(b) => Some(*b),
63            _ => None,
64        }
65    }
66
67    pub fn as_array(&self) -> Option<&Vec<Json>> {
68        match self {
69            Json::Array(a) => Some(a),
70            _ => None,
71        }
72    }
73
74    pub fn as_object(&self) -> Option<&Vec<(String, Json)>> {
75        match self {
76            Json::Object(o) => Some(o),
77            _ => None,
78        }
79    }
80
81    /// Look up a key in an object (returns `None` for non-objects).
82    pub fn get(&self, key: &str) -> Option<&Json> {
83        match self {
84            Json::Object(o) => o.iter().find(|(k, _)| k == key).map(|(_, v)| v),
85            _ => None,
86        }
87    }
88
89    pub fn contains_key(&self, key: &str) -> bool {
90        self.get(key).is_some()
91    }
92
93    /// Convenience: the string at `key`, if present and a string.
94    pub fn get_str(&self, key: &str) -> Option<&str> {
95        self.get(key).and_then(|v| v.as_str())
96    }
97
98    /// Insert or replace `key` in an object. Converts `Null` into an object.
99    pub fn insert(&mut self, key: &str, value: impl Into<Json>) -> &mut Self {
100        if let Json::Null = self {
101            *self = Json::object();
102        }
103        if let Json::Object(o) = self {
104            let value = value.into();
105            if let Some(slot) = o.iter_mut().find(|(k, _)| k == key) {
106                slot.1 = value;
107            } else {
108                o.push((key.to_string(), value));
109            }
110        }
111        self
112    }
113
114    /// Push onto an array. Converts `Null` into an array.
115    pub fn push(&mut self, value: impl Into<Json>) -> &mut Self {
116        if let Json::Null = self {
117            *self = Json::array();
118        }
119        if let Json::Array(a) = self {
120            a.push(value.into());
121        }
122        self
123    }
124
125    // ── serialization ────────────────────────────────────────────────────────
126    /// Serialize to a compact JSON string (no whitespace).
127    pub fn dump(&self) -> String {
128        let mut s = String::new();
129        self.write_to(&mut s);
130        s
131    }
132
133    fn write_to(&self, out: &mut String) {
134        match self {
135            Json::Null => out.push_str("null"),
136            Json::Bool(true) => out.push_str("true"),
137            Json::Bool(false) => out.push_str("false"),
138            Json::Int(n) => out.push_str(&n.to_string()),
139            Json::Float(f) => {
140                if f.is_finite() {
141                    out.push_str(&f.to_string());
142                } else {
143                    out.push_str("null"); // NaN/Infinity are not valid JSON
144                }
145            }
146            Json::Str(s) => write_escaped(s, out),
147            Json::Array(a) => {
148                out.push('[');
149                for (i, v) in a.iter().enumerate() {
150                    if i > 0 {
151                        out.push(',');
152                    }
153                    v.write_to(out);
154                }
155                out.push(']');
156            }
157            Json::Object(o) => {
158                out.push('{');
159                for (i, (k, v)) in o.iter().enumerate() {
160                    if i > 0 {
161                        out.push(',');
162                    }
163                    write_escaped(k, out);
164                    out.push(':');
165                    v.write_to(out);
166                }
167                out.push('}');
168            }
169        }
170    }
171
172    /// Parse a JSON string.
173    pub fn parse(text: &str) -> Result<Json, String> {
174        let mut p = Parser {
175            b: text.as_bytes(),
176            i: 0,
177        };
178        p.skip_ws();
179        let v = p.parse_value()?;
180        p.skip_ws();
181        if p.i != p.b.len() {
182            return Err(format!("trailing data at byte {}", p.i));
183        }
184        Ok(v)
185    }
186}
187
188impl fmt::Display for Json {
189    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
190        f.write_str(&self.dump())
191    }
192}
193
194// ── From conversions (ergonomic construction) ───────────────────────────────
195impl From<bool> for Json {
196    fn from(b: bool) -> Json {
197        Json::Bool(b)
198    }
199}
200impl From<i64> for Json {
201    fn from(n: i64) -> Json {
202        Json::Int(n)
203    }
204}
205impl From<i32> for Json {
206    fn from(n: i32) -> Json {
207        Json::Int(n as i64)
208    }
209}
210impl From<usize> for Json {
211    fn from(n: usize) -> Json {
212        Json::Int(n as i64)
213    }
214}
215impl From<f64> for Json {
216    fn from(f: f64) -> Json {
217        Json::Float(f)
218    }
219}
220impl From<&str> for Json {
221    fn from(s: &str) -> Json {
222        Json::Str(s.to_string())
223    }
224}
225impl From<String> for Json {
226    fn from(s: String) -> Json {
227        Json::Str(s)
228    }
229}
230impl From<&String> for Json {
231    fn from(s: &String) -> Json {
232        Json::Str(s.clone())
233    }
234}
235impl<T: Into<Json>> From<Vec<T>> for Json {
236    fn from(v: Vec<T>) -> Json {
237        Json::Array(v.into_iter().map(Into::into).collect())
238    }
239}
240
241fn write_escaped(s: &str, out: &mut String) {
242    out.push('"');
243    for c in s.chars() {
244        match c {
245            '"' => out.push_str("\\\""),
246            '\\' => out.push_str("\\\\"),
247            '\n' => out.push_str("\\n"),
248            '\r' => out.push_str("\\r"),
249            '\t' => out.push_str("\\t"),
250            '\u{08}' => out.push_str("\\b"),
251            '\u{0c}' => out.push_str("\\f"),
252            c if (c as u32) < 0x20 => out.push_str(&format!("\\u{:04x}", c as u32)),
253            c => out.push(c),
254        }
255    }
256    out.push('"');
257}
258
259// ── parser ───────────────────────────────────────────────────────────────────
260struct Parser<'a> {
261    b: &'a [u8],
262    i: usize,
263}
264
265impl<'a> Parser<'a> {
266    fn skip_ws(&mut self) {
267        while self.i < self.b.len() && matches!(self.b[self.i], b' ' | b'\t' | b'\n' | b'\r') {
268            self.i += 1;
269        }
270    }
271
272    fn peek(&self) -> Option<u8> {
273        self.b.get(self.i).copied()
274    }
275
276    fn parse_value(&mut self) -> Result<Json, String> {
277        self.skip_ws();
278        match self.peek() {
279            Some(b'{') => self.parse_object(),
280            Some(b'[') => self.parse_array(),
281            Some(b'"') => Ok(Json::Str(self.parse_string()?)),
282            Some(b't') | Some(b'f') => self.parse_bool(),
283            Some(b'n') => self.parse_null(),
284            Some(c) if c == b'-' || c.is_ascii_digit() => self.parse_number(),
285            Some(c) => Err(format!("unexpected byte '{}' at {}", c as char, self.i)),
286            None => Err("unexpected end of input".to_string()),
287        }
288    }
289
290    fn expect(&mut self, lit: &[u8], value: Json) -> Result<Json, String> {
291        if self.b[self.i..].starts_with(lit) {
292            self.i += lit.len();
293            Ok(value)
294        } else {
295            Err(format!("invalid literal at {}", self.i))
296        }
297    }
298
299    fn parse_bool(&mut self) -> Result<Json, String> {
300        if self.peek() == Some(b't') {
301            self.expect(b"true", Json::Bool(true))
302        } else {
303            self.expect(b"false", Json::Bool(false))
304        }
305    }
306
307    fn parse_null(&mut self) -> Result<Json, String> {
308        self.expect(b"null", Json::Null)
309    }
310
311    fn parse_number(&mut self) -> Result<Json, String> {
312        let start = self.i;
313        let mut is_float = false;
314        while let Some(c) = self.peek() {
315            match c {
316                b'0'..=b'9' | b'-' | b'+' => self.i += 1,
317                b'.' | b'e' | b'E' => {
318                    is_float = true;
319                    self.i += 1;
320                }
321                _ => break,
322            }
323        }
324        let s = std::str::from_utf8(&self.b[start..self.i]).map_err(|e| e.to_string())?;
325        if !is_float {
326            if let Ok(n) = s.parse::<i64>() {
327                return Ok(Json::Int(n));
328            }
329        }
330        s.parse::<f64>()
331            .map(Json::Float)
332            .map_err(|_| format!("invalid number '{}'", s))
333    }
334
335    fn parse_string(&mut self) -> Result<String, String> {
336        self.i += 1; // opening quote
337        let mut out = String::new();
338        while let Some(c) = self.peek() {
339            self.i += 1;
340            match c {
341                b'"' => return Ok(out),
342                b'\\' => {
343                    let esc = self.peek().ok_or("unterminated escape")?;
344                    self.i += 1;
345                    match esc {
346                        b'"' => out.push('"'),
347                        b'\\' => out.push('\\'),
348                        b'/' => out.push('/'),
349                        b'n' => out.push('\n'),
350                        b'r' => out.push('\r'),
351                        b't' => out.push('\t'),
352                        b'b' => out.push('\u{08}'),
353                        b'f' => out.push('\u{0c}'),
354                        b'u' => {
355                            let cp = self.parse_hex4()?;
356                            if (0xD800..=0xDBFF).contains(&cp) {
357                                // high surrogate; expect a low surrogate escape
358                                if self.b[self.i..].starts_with(b"\\u") {
359                                    self.i += 2;
360                                    let lo = self.parse_hex4()?;
361                                    let c = 0x10000
362                                        + ((cp - 0xD800) << 10)
363                                        + (lo - 0xDC00);
364                                    out.push(char::from_u32(c).unwrap_or('\u{fffd}'));
365                                } else {
366                                    out.push('\u{fffd}');
367                                }
368                            } else {
369                                out.push(char::from_u32(cp).unwrap_or('\u{fffd}'));
370                            }
371                        }
372                        other => return Err(format!("bad escape \\{}", other as char)),
373                    }
374                }
375                // A byte >= 0x80 begins a multi-byte UTF-8 sequence; copy the
376                // remaining continuation bytes verbatim.
377                c if c >= 0x80 => {
378                    let n = if c >= 0xF0 {
379                        3
380                    } else if c >= 0xE0 {
381                        2
382                    } else {
383                        1
384                    };
385                    let seq_start = self.i - 1;
386                    self.i += n;
387                    let slice = &self.b[seq_start..self.i];
388                    out.push_str(std::str::from_utf8(slice).map_err(|e| e.to_string())?);
389                }
390                c => out.push(c as char),
391            }
392        }
393        Err("unterminated string".to_string())
394    }
395
396    fn parse_hex4(&mut self) -> Result<u32, String> {
397        if self.i + 4 > self.b.len() {
398            return Err("truncated \\u escape".to_string());
399        }
400        let s = std::str::from_utf8(&self.b[self.i..self.i + 4]).map_err(|e| e.to_string())?;
401        let cp = u32::from_str_radix(s, 16).map_err(|_| "bad \\u hex")?;
402        self.i += 4;
403        Ok(cp)
404    }
405
406    fn parse_array(&mut self) -> Result<Json, String> {
407        self.i += 1; // '['
408        let mut arr = Vec::new();
409        self.skip_ws();
410        if self.peek() == Some(b']') {
411            self.i += 1;
412            return Ok(Json::Array(arr));
413        }
414        loop {
415            arr.push(self.parse_value()?);
416            self.skip_ws();
417            match self.peek() {
418                Some(b',') => {
419                    self.i += 1;
420                }
421                Some(b']') => {
422                    self.i += 1;
423                    return Ok(Json::Array(arr));
424                }
425                _ => return Err(format!("expected ',' or ']' at {}", self.i)),
426            }
427        }
428    }
429
430    fn parse_object(&mut self) -> Result<Json, String> {
431        self.i += 1; // '{'
432        let mut obj = Vec::new();
433        self.skip_ws();
434        if self.peek() == Some(b'}') {
435            self.i += 1;
436            return Ok(Json::Object(obj));
437        }
438        loop {
439            self.skip_ws();
440            if self.peek() != Some(b'"') {
441                return Err(format!("expected object key at {}", self.i));
442            }
443            let key = self.parse_string()?;
444            self.skip_ws();
445            if self.peek() != Some(b':') {
446                return Err(format!("expected ':' at {}", self.i));
447            }
448            self.i += 1;
449            let val = self.parse_value()?;
450            obj.push((key, val));
451            self.skip_ws();
452            match self.peek() {
453                Some(b',') => {
454                    self.i += 1;
455                }
456                Some(b'}') => {
457                    self.i += 1;
458                    return Ok(Json::Object(obj));
459                }
460                _ => return Err(format!("expected ',' or '}}' at {}", self.i)),
461            }
462        }
463    }
464}
465
466/// Build a `Json::Object` from key/value pairs.
467///
468/// ```
469/// use rcp::obj;
470/// let j = obj(&[("k", 1.into()), ("t", "hi".into())]);
471/// assert_eq!(j.get("k").unwrap().as_i64(), Some(1));
472/// ```
473pub fn obj(pairs: &[(&str, Json)]) -> Json {
474    Json::Object(pairs.iter().map(|(k, v)| (k.to_string(), v.clone())).collect())
475}