1use std::collections::{BTreeMap, HashMap};
2use std::fmt::Write as _;
3
4use crate::value::{Value, aver_repr, list_from_vec, list_view};
5
6mod parser;
7
8#[derive(Debug, Clone, PartialEq)]
9pub enum JsonValue {
10 Null,
11 Bool(bool),
12 Int(i64),
13 Float(f64),
14 String(String),
15 Array(Vec<JsonValue>),
16 Object(BTreeMap<String, JsonValue>),
17}
18
19pub fn parse_json(input: &str) -> Result<JsonValue, String> {
20 parser::parse_json(input)
21}
22
23pub fn json_to_string(value: &JsonValue) -> String {
24 let mut out = String::new();
25 write_json_compact(&mut out, value);
26 out
27}
28
29pub fn format_json(value: &JsonValue) -> String {
30 let mut out = String::new();
31 write_json_pretty(&mut out, value, 0);
32 out
33}
34
35fn get_required<'a>(
36 obj: &'a BTreeMap<String, JsonValue>,
37 key: &str,
38 path: &str,
39) -> Result<&'a JsonValue, String> {
40 obj.get(key)
41 .ok_or_else(|| format!("{}: missing required field '{}'", path, key))
42}
43
44fn expect_object<'a>(
45 value: &'a JsonValue,
46 path: &str,
47) -> Result<&'a BTreeMap<String, JsonValue>, String> {
48 match value {
49 JsonValue::Object(obj) => Ok(obj),
50 _ => Err(format!("{} must be an object", path)),
51 }
52}
53
54fn parse_array<'a>(value: &'a JsonValue, path: &str) -> Result<&'a Vec<JsonValue>, String> {
55 match value {
56 JsonValue::Array(arr) => Ok(arr),
57 _ => Err(format!("{} must be an array", path)),
58 }
59}
60
61fn parse_string<'a>(value: &'a JsonValue, path: &str) -> Result<&'a str, String> {
62 match value {
63 JsonValue::String(s) => Ok(s),
64 _ => Err(format!("{} must be a string", path)),
65 }
66}
67
68pub fn values_to_json(values: &[Value]) -> Result<Vec<JsonValue>, String> {
69 values.iter().map(value_to_json).collect()
70}
71
72pub fn values_to_json_lossy(values: &[Value]) -> Vec<JsonValue> {
73 values.iter().map(value_to_json_lossy).collect()
74}
75
76pub fn json_values_to_values(values: &[JsonValue]) -> Result<Vec<Value>, String> {
77 values.iter().map(json_to_value).collect()
78}
79
80pub fn value_to_json(value: &Value) -> Result<JsonValue, String> {
81 if let Some(items) = list_view(value) {
82 let mut arr = Vec::with_capacity(items.len());
83 for item in items.iter() {
84 arr.push(value_to_json(item)?);
85 }
86 return Ok(JsonValue::Array(arr));
87 }
88
89 match value {
90 Value::Int(i) => Ok(JsonValue::Int(*i)),
91 Value::Float(f) => {
92 if !f.is_finite() {
93 return Err("cannot serialize non-finite float (NaN/inf)".to_string());
94 }
95 Ok(JsonValue::Float(*f))
96 }
97 Value::Str(s) => Ok(JsonValue::String(s.clone())),
98 Value::Bool(b) => Ok(JsonValue::Bool(*b)),
99 Value::Unit => Ok(JsonValue::Null),
100 Value::Ok(inner) => Ok(wrap_marker("$ok", value_to_json(inner)?)),
101 Value::Err(inner) => Ok(wrap_marker("$err", value_to_json(inner)?)),
102 Value::Some(inner) => Ok(wrap_marker("$some", value_to_json(inner)?)),
103 Value::None => Ok(wrap_marker("$none", JsonValue::Bool(true))),
104 Value::List(_) => unreachable!("handled via list_view above"),
105 Value::Tuple(items) => {
106 let mut arr = Vec::with_capacity(items.len());
107 for item in items {
108 arr.push(value_to_json(item)?);
109 }
110 Ok(wrap_marker("$tuple", JsonValue::Array(arr)))
111 }
112 Value::Map(entries) => {
113 if entries.keys().all(|k| matches!(k, Value::Str(_))) {
114 let mut obj = BTreeMap::new();
115 for (k, v) in entries {
116 let Value::Str(key) = k else {
117 unreachable!("checked above");
118 };
119 obj.insert(key.clone(), value_to_json(v)?);
120 }
121 Ok(JsonValue::Object(obj))
122 } else {
123 let mut pairs = Vec::with_capacity(entries.len());
124 for (k, v) in entries {
125 pairs.push(JsonValue::Array(vec![value_to_json(k)?, value_to_json(v)?]));
126 }
127 Ok(wrap_marker("$map", JsonValue::Array(pairs)))
128 }
129 }
130 Value::Record { type_name, fields } => {
131 let mut fields_obj = BTreeMap::new();
132 for (name, field_value) in fields.iter() {
133 fields_obj.insert(name.clone(), value_to_json(field_value)?);
134 }
135 let mut payload = BTreeMap::new();
136 payload.insert("type".to_string(), JsonValue::String(type_name.clone()));
137 payload.insert("fields".to_string(), JsonValue::Object(fields_obj));
138 Ok(wrap_marker("$record", JsonValue::Object(payload)))
139 }
140 Value::Variant {
141 type_name,
142 variant,
143 fields,
144 } => {
145 let mut field_vals = Vec::with_capacity(fields.len());
146 for field in fields.iter() {
147 field_vals.push(value_to_json(field)?);
148 }
149 let mut payload = BTreeMap::new();
150 payload.insert("type".to_string(), JsonValue::String(type_name.clone()));
151 payload.insert("name".to_string(), JsonValue::String(variant.clone()));
152 payload.insert("fields".to_string(), JsonValue::Array(field_vals));
153 Ok(wrap_marker("$variant", JsonValue::Object(payload)))
154 }
155 Value::Vector(vec) => {
156 let mut arr = Vec::with_capacity(vec.len());
157 for item in vec.iter() {
158 arr.push(value_to_json(item)?);
159 }
160 Ok(wrap_marker("$vector", JsonValue::Array(arr)))
161 }
162 Value::Fn(_) | Value::Builtin(_) | Value::Namespace { .. } => Err(format!(
163 "cannot serialize non-replay-safe value: {}",
164 aver_repr(value)
165 )),
166 }
167}
168
169pub fn json_to_value(json: &JsonValue) -> Result<Value, String> {
170 match json {
171 JsonValue::Null => Ok(Value::Unit),
172 JsonValue::Bool(b) => Ok(Value::Bool(*b)),
173 JsonValue::Int(i) => Ok(Value::Int(*i)),
174 JsonValue::Float(f) => Ok(Value::Float(*f)),
175 JsonValue::String(s) => Ok(Value::Str(s.clone())),
176 JsonValue::Array(items) => {
177 let mut out = Vec::with_capacity(items.len());
178 for item in items {
179 out.push(json_to_value(item)?);
180 }
181 Ok(list_from_vec(out))
182 }
183 JsonValue::Object(obj) => {
184 if let Some((marker, payload)) = marker_single_key(obj) {
185 return decode_marker(marker, payload);
186 }
187 let mut map = HashMap::with_capacity(obj.len());
188 for (k, v) in obj {
189 map.insert(Value::Str(k.clone()), json_to_value(v)?);
190 }
191 Ok(Value::Map(map))
192 }
193 }
194}
195
196pub fn first_diff_path(expected: &JsonValue, got: &JsonValue) -> Option<String> {
197 first_diff_path_inner(expected, got, "$")
198}
199
200pub fn value_to_json_lossy(value: &Value) -> JsonValue {
201 match value_to_json(value) {
202 Ok(v) => v,
203 Err(_) => {
204 let mut obj = BTreeMap::new();
205 obj.insert("$opaque".to_string(), JsonValue::String(aver_repr(value)));
206 JsonValue::Object(obj)
207 }
208 }
209}
210
211fn wrap_marker(name: &str, value: JsonValue) -> JsonValue {
212 let mut obj = BTreeMap::new();
213 obj.insert(name.to_string(), value);
214 JsonValue::Object(obj)
215}
216
217fn marker_single_key(obj: &BTreeMap<String, JsonValue>) -> Option<(&str, &JsonValue)> {
218 if obj.len() != 1 {
219 return None;
220 }
221 obj.iter().next().map(|(k, v)| (k.as_str(), v))
222}
223
224fn decode_marker(marker: &str, payload: &JsonValue) -> Result<Value, String> {
225 match marker {
226 "$ok" => Ok(Value::Ok(Box::new(json_to_value(payload)?))),
227 "$err" => Ok(Value::Err(Box::new(json_to_value(payload)?))),
228 "$some" => Ok(Value::Some(Box::new(json_to_value(payload)?))),
229 "$none" => Ok(Value::None),
230 "$tuple" => decode_tuple(payload),
231 "$map" => decode_map(payload),
232 "$record" => decode_record(payload),
233 "$variant" => decode_variant(payload),
234 _ => Err(format!("unknown replay marker '{}'", marker)),
235 }
236}
237
238fn decode_tuple(payload: &JsonValue) -> Result<Value, String> {
239 let items = parse_array(payload, "$tuple")?;
240 let mut out = Vec::with_capacity(items.len());
241 for item in items {
242 out.push(json_to_value(item)?);
243 }
244 Ok(Value::Tuple(out))
245}
246
247fn decode_map(payload: &JsonValue) -> Result<Value, String> {
248 let pairs = parse_array(payload, "$map")?;
249 let mut out = HashMap::with_capacity(pairs.len());
250 for (idx, pair_json) in pairs.iter().enumerate() {
251 let pair = parse_array(pair_json, &format!("$map[{}]", idx))?;
252 if pair.len() != 2 {
253 return Err(format!("$map[{}] must be a 2-element array", idx));
254 }
255 let key = json_to_value(&pair[0])?;
256 let value = json_to_value(&pair[1])?;
257 out.insert(key, value);
258 }
259 Ok(Value::Map(out))
260}
261
262fn decode_record(payload: &JsonValue) -> Result<Value, String> {
263 let obj = expect_object(payload, "$record")?;
264 let type_name =
265 parse_string(get_required(obj, "type", "$record")?, "$record.type")?.to_string();
266 let fields_obj = expect_object(get_required(obj, "fields", "$record")?, "$record.fields")?;
267 let mut fields = Vec::with_capacity(fields_obj.len());
268 for (key, field_val) in fields_obj {
269 fields.push((key.clone(), json_to_value(field_val)?));
270 }
271 Ok(Value::Record {
272 type_name,
273 fields: fields.into(),
274 })
275}
276
277fn decode_variant(payload: &JsonValue) -> Result<Value, String> {
278 let obj = expect_object(payload, "$variant")?;
279 let type_name =
280 parse_string(get_required(obj, "type", "$variant")?, "$variant.type")?.to_string();
281 let variant =
282 parse_string(get_required(obj, "name", "$variant")?, "$variant.name")?.to_string();
283 let fields_arr = parse_array(get_required(obj, "fields", "$variant")?, "$variant.fields")?;
284 let mut fields = Vec::with_capacity(fields_arr.len());
285 for val in fields_arr {
286 fields.push(json_to_value(val)?);
287 }
288 Ok(Value::Variant {
289 type_name,
290 variant,
291 fields: fields.into(),
292 })
293}
294
295fn first_diff_path_inner(expected: &JsonValue, got: &JsonValue, path: &str) -> Option<String> {
296 match (expected, got) {
297 (JsonValue::Object(a), JsonValue::Object(b)) => {
298 let mut keys = a.keys().chain(b.keys()).cloned().collect::<Vec<_>>();
299 keys.sort();
300 keys.dedup();
301 for key in keys {
302 let next_path = if path == "$" {
303 format!("$.{}", key)
304 } else {
305 format!("{}.{}", path, key)
306 };
307 match (a.get(&key), b.get(&key)) {
308 (Some(av), Some(bv)) => {
309 if let Some(diff) = first_diff_path_inner(av, bv, &next_path) {
310 return Some(diff);
311 }
312 }
313 _ => return Some(next_path),
314 }
315 }
316 None
317 }
318 (JsonValue::Array(a), JsonValue::Array(b)) => {
319 if a.len() != b.len() {
320 return Some(format!("{}[len]", path));
321 }
322 for (idx, (av, bv)) in a.iter().zip(b.iter()).enumerate() {
323 let next_path = format!("{}[{}]", path, idx);
324 if let Some(diff) = first_diff_path_inner(av, bv, &next_path) {
325 return Some(diff);
326 }
327 }
328 None
329 }
330 _ => {
331 if expected == got {
332 None
333 } else {
334 Some(path.to_string())
335 }
336 }
337 }
338}
339
340fn write_json_compact(out: &mut String, value: &JsonValue) {
341 match value {
342 JsonValue::Null => out.push_str("null"),
343 JsonValue::Bool(true) => out.push_str("true"),
344 JsonValue::Bool(false) => out.push_str("false"),
345 JsonValue::Int(i) => {
346 let _ = write!(out, "{}", i);
347 }
348 JsonValue::Float(f) => out.push_str(&format_float(*f)),
349 JsonValue::String(s) => write_json_string(out, s),
350 JsonValue::Array(arr) => {
351 out.push('[');
352 for (idx, item) in arr.iter().enumerate() {
353 if idx > 0 {
354 out.push(',');
355 }
356 write_json_compact(out, item);
357 }
358 out.push(']');
359 }
360 JsonValue::Object(obj) => {
361 out.push('{');
362 for (idx, (k, v)) in obj.iter().enumerate() {
363 if idx > 0 {
364 out.push(',');
365 }
366 write_json_string(out, k);
367 out.push(':');
368 write_json_compact(out, v);
369 }
370 out.push('}');
371 }
372 }
373}
374
375fn write_json_pretty(out: &mut String, value: &JsonValue, indent: usize) {
376 match value {
377 JsonValue::Array(arr) => {
378 if arr.is_empty() {
379 out.push_str("[]");
380 return;
381 }
382 out.push_str("[\n");
383 for (idx, item) in arr.iter().enumerate() {
384 push_indent(out, indent + 2);
385 write_json_pretty(out, item, indent + 2);
386 if idx + 1 < arr.len() {
387 out.push(',');
388 }
389 out.push('\n');
390 }
391 push_indent(out, indent);
392 out.push(']');
393 }
394 JsonValue::Object(obj) => {
395 if obj.is_empty() {
396 out.push_str("{}");
397 return;
398 }
399 out.push_str("{\n");
400 for (idx, (k, v)) in obj.iter().enumerate() {
401 push_indent(out, indent + 2);
402 write_json_string(out, k);
403 out.push_str(": ");
404 write_json_pretty(out, v, indent + 2);
405 if idx + 1 < obj.len() {
406 out.push(',');
407 }
408 out.push('\n');
409 }
410 push_indent(out, indent);
411 out.push('}');
412 }
413 _ => write_json_compact(out, value),
414 }
415}
416
417fn push_indent(out: &mut String, indent: usize) {
418 for _ in 0..indent {
419 out.push(' ');
420 }
421}
422
423fn write_json_string(out: &mut String, s: &str) {
424 out.push('"');
425 for ch in s.chars() {
426 match ch {
427 '"' => out.push_str("\\\""),
428 '\\' => out.push_str("\\\\"),
429 '\n' => out.push_str("\\n"),
430 '\r' => out.push_str("\\r"),
431 '\t' => out.push_str("\\t"),
432 '\u{08}' => out.push_str("\\b"),
433 '\u{0C}' => out.push_str("\\f"),
434 c if c < '\u{20}' => {
435 let _ = write!(out, "\\u{:04X}", c as u32);
436 }
437 c => out.push(c),
438 }
439 }
440 out.push('"');
441}
442
443fn format_float(f: f64) -> String {
444 let mut s = format!("{}", f);
445 if !s.contains('.') && !s.contains('e') && !s.contains('E') {
446 s.push_str(".0");
447 }
448 s
449}