Skip to main content

weirdnet_plugin/
json.rs

1//! A small JSON value with a parser and a writer: what the host and plugins exchange.
2use std::fmt::{self, Write as _};
3
4/// A JSON value. Objects keep their key order.
5#[derive(Debug, Clone, PartialEq, Default)]
6pub enum Json {
7    #[default]
8    Null,
9    Bool(bool),
10    Num(f64),
11    Str(String),
12    Arr(Vec<Json>),
13    Obj(Vec<(String, Json)>),
14}
15
16impl Json {
17    /// An empty object.
18    pub fn obj() -> Json {
19        Json::Obj(Vec::new())
20    }
21    /// Add or replace a key (on objects; anything else becomes an object).
22    pub fn with(mut self, key: &str, v: impl Into<Json>) -> Json {
23        self.set(key, v);
24        self
25    }
26    pub fn set(&mut self, key: &str, v: impl Into<Json>) {
27        if !matches!(self, Json::Obj(_)) {
28            *self = Json::obj();
29        }
30        if let Json::Obj(o) = self {
31            let v = v.into();
32            match o.iter_mut().find(|(k, _)| k == key) {
33                Some(slot) => slot.1 = v,
34                None => o.push((key.to_string(), v)),
35            }
36        }
37    }
38    pub fn get(&self, key: &str) -> Option<&Json> {
39        match self {
40            Json::Obj(o) => o.iter().find(|(k, _)| k == key).map(|(_, v)| v),
41            _ => None,
42        }
43    }
44    pub fn is_null(&self) -> bool {
45        matches!(self, Json::Null)
46    }
47    pub fn as_f64(&self) -> Option<f64> {
48        match self {
49            Json::Num(n) => Some(*n),
50            Json::Bool(b) => Some(if *b { 1.0 } else { 0.0 }),
51            Json::Str(s) => s.trim().parse().ok(),
52            _ => None,
53        }
54    }
55    pub fn as_i64(&self) -> Option<i64> {
56        self.as_f64().map(|f| f as i64)
57    }
58    pub fn as_bool(&self) -> Option<bool> {
59        match self {
60            Json::Bool(b) => Some(*b),
61            Json::Num(n) => Some(*n != 0.0),
62            _ => None,
63        }
64    }
65    pub fn as_str(&self) -> Option<&str> {
66        match self {
67            Json::Str(s) => Some(s),
68            _ => None,
69        }
70    }
71    pub fn as_array(&self) -> Option<&[Json]> {
72        match self {
73            Json::Arr(a) => Some(a),
74            _ => None,
75        }
76    }
77    pub fn as_object(&self) -> Option<&[(String, Json)]> {
78        match self {
79            Json::Obj(o) => Some(o),
80            _ => None,
81        }
82    }
83    /// Text for tables: strings as they are, numbers without a trailing `.0`, null empty.
84    pub fn text(&self) -> String {
85        match self {
86            Json::Null => String::new(),
87            Json::Str(s) => s.clone(),
88            other => other.to_string(),
89        }
90    }
91
92    /// Parse JSON text.
93    pub fn parse(s: &str) -> Result<Json, String> {
94        let mut p = Parser { b: s.as_bytes(), i: 0 };
95        p.ws();
96        let v = p.value(0)?;
97        p.ws();
98        if p.i != p.b.len() {
99            return Err(format!("unexpected text at byte {}", p.i));
100        }
101        Ok(v)
102    }
103}
104
105impl From<f64> for Json {
106    fn from(v: f64) -> Self {
107        Json::Num(v)
108    }
109}
110impl From<i64> for Json {
111    fn from(v: i64) -> Self {
112        Json::Num(v as f64)
113    }
114}
115impl From<usize> for Json {
116    fn from(v: usize) -> Self {
117        Json::Num(v as f64)
118    }
119}
120impl From<bool> for Json {
121    fn from(v: bool) -> Self {
122        Json::Bool(v)
123    }
124}
125impl From<&str> for Json {
126    fn from(v: &str) -> Self {
127        Json::Str(v.to_string())
128    }
129}
130impl From<String> for Json {
131    fn from(v: String) -> Self {
132        Json::Str(v)
133    }
134}
135impl<T: Into<Json>> From<Vec<T>> for Json {
136    fn from(v: Vec<T>) -> Self {
137        Json::Arr(v.into_iter().map(Into::into).collect())
138    }
139}
140impl<T: Into<Json>> From<Option<T>> for Json {
141    fn from(v: Option<T>) -> Self {
142        v.map(Into::into).unwrap_or(Json::Null)
143    }
144}
145
146fn write_str(f: &mut fmt::Formatter<'_>, s: &str) -> fmt::Result {
147    f.write_char('"')?;
148    for c in s.chars() {
149        match c {
150            '"' => f.write_str("\\\"")?,
151            '\\' => f.write_str("\\\\")?,
152            '\n' => f.write_str("\\n")?,
153            '\r' => f.write_str("\\r")?,
154            '\t' => f.write_str("\\t")?,
155            c if (c as u32) < 0x20 => write!(f, "\\u{:04x}", c as u32)?,
156            c => f.write_char(c)?,
157        }
158    }
159    f.write_char('"')
160}
161
162impl fmt::Display for Json {
163    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
164        match self {
165            Json::Null => f.write_str("null"),
166            Json::Bool(b) => write!(f, "{b}"),
167            Json::Num(n) if !n.is_finite() => f.write_str("null"),
168            Json::Num(n) if n.fract() == 0.0 && n.abs() < 9.0e15 => write!(f, "{}", *n as i64),
169            Json::Num(n) => write!(f, "{n}"),
170            Json::Str(s) => write_str(f, s),
171            Json::Arr(a) => {
172                f.write_char('[')?;
173                for (i, v) in a.iter().enumerate() {
174                    if i > 0 {
175                        f.write_char(',')?;
176                    }
177                    write!(f, "{v}")?;
178                }
179                f.write_char(']')
180            }
181            Json::Obj(o) => {
182                f.write_char('{')?;
183                for (i, (k, v)) in o.iter().enumerate() {
184                    if i > 0 {
185                        f.write_char(',')?;
186                    }
187                    write_str(f, k)?;
188                    write!(f, ":{v}")?;
189                }
190                f.write_char('}')
191            }
192        }
193    }
194}
195
196struct Parser<'a> {
197    b: &'a [u8],
198    i: usize,
199}
200
201impl Parser<'_> {
202    fn ws(&mut self) {
203        while self.i < self.b.len() && matches!(self.b[self.i], b' ' | b'\n' | b'\r' | b'\t') {
204            self.i += 1;
205        }
206    }
207    fn err<T>(&self, what: &str) -> Result<T, String> {
208        Err(format!("{what} at byte {}", self.i))
209    }
210    fn eat(&mut self, lit: &str) -> bool {
211        if self.b[self.i..].starts_with(lit.as_bytes()) {
212            self.i += lit.len();
213            true
214        } else {
215            false
216        }
217    }
218    fn value(&mut self, depth: usize) -> Result<Json, String> {
219        if depth > 128 {
220            return self.err("nested too deeply");
221        }
222        self.ws();
223        let Some(&c) = self.b.get(self.i) else { return self.err("unexpected end") };
224        match c {
225            b'n' if self.eat("null") => Ok(Json::Null),
226            b't' if self.eat("true") => Ok(Json::Bool(true)),
227            b'f' if self.eat("false") => Ok(Json::Bool(false)),
228            b'"' => self.string().map(Json::Str),
229            b'[' => {
230                self.i += 1;
231                let mut v = Vec::new();
232                self.ws();
233                if self.eat("]") {
234                    return Ok(Json::Arr(v));
235                }
236                loop {
237                    v.push(self.value(depth + 1)?);
238                    self.ws();
239                    if self.eat(",") {
240                        continue;
241                    }
242                    if self.eat("]") {
243                        return Ok(Json::Arr(v));
244                    }
245                    return self.err("expected , or ]");
246                }
247            }
248            b'{' => {
249                self.i += 1;
250                let mut o = Vec::new();
251                self.ws();
252                if self.eat("}") {
253                    return Ok(Json::Obj(o));
254                }
255                loop {
256                    self.ws();
257                    if self.b.get(self.i) != Some(&b'"') {
258                        return self.err("expected a key");
259                    }
260                    let k = self.string()?;
261                    self.ws();
262                    if !self.eat(":") {
263                        return self.err("expected :");
264                    }
265                    let v = self.value(depth + 1)?;
266                    o.push((k, v));
267                    self.ws();
268                    if self.eat(",") {
269                        continue;
270                    }
271                    if self.eat("}") {
272                        return Ok(Json::Obj(o));
273                    }
274                    return self.err("expected , or }");
275                }
276            }
277            b'-' | b'0'..=b'9' => {
278                let start = self.i;
279                while self.i < self.b.len() && matches!(self.b[self.i], b'-' | b'+' | b'.' | b'e' | b'E' | b'0'..=b'9') {
280                    self.i += 1;
281                }
282                let s = std::str::from_utf8(&self.b[start..self.i]).unwrap_or("");
283                s.parse::<f64>().map(Json::Num).map_err(|_| format!("bad number `{s}` at byte {start}"))
284            }
285            _ => self.err("unexpected character"),
286        }
287    }
288    fn hex4(&mut self) -> Result<u32, String> {
289        let h = self.b.get(self.i..self.i + 4).ok_or("short \\u escape")?;
290        let s = std::str::from_utf8(h).map_err(|_| "bad \\u escape")?;
291        self.i += 4;
292        u32::from_str_radix(s, 16).map_err(|_| "bad \\u escape".to_string())
293    }
294    fn string(&mut self) -> Result<String, String> {
295        self.i += 1;
296        let mut out = String::new();
297        loop {
298            let start = self.i;
299            while self.i < self.b.len() && self.b[self.i] != b'"' && self.b[self.i] != b'\\' {
300                self.i += 1;
301            }
302            out.push_str(std::str::from_utf8(&self.b[start..self.i]).map_err(|_| "invalid UTF-8".to_string())?);
303            match self.b.get(self.i) {
304                None => return self.err("unterminated string"),
305                Some(b'"') => {
306                    self.i += 1;
307                    return Ok(out);
308                }
309                _ => {
310                    self.i += 1;
311                    let Some(&e) = self.b.get(self.i) else { return self.err("unterminated escape") };
312                    self.i += 1;
313                    match e {
314                        b'"' => out.push('"'),
315                        b'\\' => out.push('\\'),
316                        b'/' => out.push('/'),
317                        b'b' => out.push('\u{8}'),
318                        b'f' => out.push('\u{c}'),
319                        b'n' => out.push('\n'),
320                        b'r' => out.push('\r'),
321                        b't' => out.push('\t'),
322                        b'u' => {
323                            let mut c = self.hex4()?;
324                            if (0xD800..0xDC00).contains(&c) && self.eat("\\u") {
325                                let lo = self.hex4()?;
326                                c = 0x10000 + ((c - 0xD800) << 10) + (lo.wrapping_sub(0xDC00) & 0x3FF);
327                            }
328                            out.push(char::from_u32(c).unwrap_or('\u{FFFD}'));
329                        }
330                        _ => return self.err("bad escape"),
331                    }
332                }
333            }
334        }
335    }
336}
337
338#[cfg(test)]
339mod tests {
340    use super::Json;
341
342    #[test]
343    fn round_trip() {
344        let s = r#"{"a":[1,2.5,-3e2,true,null],"b":"x\"y\n\u00e9\ud83d\ude00","c":{}}"#;
345        let v = Json::parse(s).unwrap();
346        assert_eq!(v.get("a").unwrap().as_array().unwrap()[2].as_f64(), Some(-300.0));
347        assert_eq!(v.get("b").unwrap().as_str(), Some("x\"y\né😀"));
348        let again = Json::parse(&v.to_string()).unwrap();
349        assert_eq!(v, again);
350        assert!(Json::parse("[1,").is_err());
351        assert!(Json::parse("{} x").is_err());
352        assert_eq!(Json::Num(f64::NAN).to_string(), "null");
353        assert_eq!(Json::obj().with("k", 2.0).with("k", "v").to_string(), r#"{"k":"v"}"#);
354    }
355}