1use std::collections::{BTreeMap, HashMap};
2use std::fmt::Write as _;
3
4use crate::value::{Value, aver_repr, list_slice};
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 match value {
82 Value::Int(i) => Ok(JsonValue::Int(*i)),
83 Value::Float(f) => {
84 if !f.is_finite() {
85 return Err("cannot serialize non-finite float (NaN/inf)".to_string());
86 }
87 Ok(JsonValue::Float(*f))
88 }
89 Value::Str(s) => Ok(JsonValue::String(s.clone())),
90 Value::Bool(b) => Ok(JsonValue::Bool(*b)),
91 Value::Unit => Ok(JsonValue::Null),
92 Value::Ok(inner) => Ok(wrap_marker("$ok", value_to_json(inner)?)),
93 Value::Err(inner) => Ok(wrap_marker("$err", value_to_json(inner)?)),
94 Value::Some(inner) => Ok(wrap_marker("$some", value_to_json(inner)?)),
95 Value::None => Ok(wrap_marker("$none", JsonValue::Bool(true))),
96 Value::List(_) | Value::ListSlice { .. } => {
97 let items =
98 list_slice(value).ok_or_else(|| "invalid list representation".to_string())?;
99 let mut arr = Vec::with_capacity(items.len());
100 for item in items {
101 arr.push(value_to_json(item)?);
102 }
103 Ok(JsonValue::Array(arr))
104 }
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 {
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 {
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::Fn { .. } | Value::Builtin(_) | Value::Namespace { .. } => Err(format!(
156 "cannot serialize non-replay-safe value: {}",
157 aver_repr(value)
158 )),
159 }
160}
161
162pub fn json_to_value(json: &JsonValue) -> Result<Value, String> {
163 match json {
164 JsonValue::Null => Ok(Value::Unit),
165 JsonValue::Bool(b) => Ok(Value::Bool(*b)),
166 JsonValue::Int(i) => Ok(Value::Int(*i)),
167 JsonValue::Float(f) => Ok(Value::Float(*f)),
168 JsonValue::String(s) => Ok(Value::Str(s.clone())),
169 JsonValue::Array(items) => {
170 let mut out = Vec::with_capacity(items.len());
171 for item in items {
172 out.push(json_to_value(item)?);
173 }
174 Ok(Value::List(out))
175 }
176 JsonValue::Object(obj) => {
177 if let Some((marker, payload)) = marker_single_key(obj) {
178 return decode_marker(marker, payload);
179 }
180 let mut map = HashMap::with_capacity(obj.len());
181 for (k, v) in obj {
182 map.insert(Value::Str(k.clone()), json_to_value(v)?);
183 }
184 Ok(Value::Map(map))
185 }
186 }
187}
188
189pub fn first_diff_path(expected: &JsonValue, got: &JsonValue) -> Option<String> {
190 first_diff_path_inner(expected, got, "$")
191}
192
193pub fn value_to_json_lossy(value: &Value) -> JsonValue {
194 match value_to_json(value) {
195 Ok(v) => v,
196 Err(_) => {
197 let mut obj = BTreeMap::new();
198 obj.insert("$opaque".to_string(), JsonValue::String(aver_repr(value)));
199 JsonValue::Object(obj)
200 }
201 }
202}
203
204fn wrap_marker(name: &str, value: JsonValue) -> JsonValue {
205 let mut obj = BTreeMap::new();
206 obj.insert(name.to_string(), value);
207 JsonValue::Object(obj)
208}
209
210fn marker_single_key(obj: &BTreeMap<String, JsonValue>) -> Option<(&str, &JsonValue)> {
211 if obj.len() != 1 {
212 return None;
213 }
214 obj.iter().next().map(|(k, v)| (k.as_str(), v))
215}
216
217fn decode_marker(marker: &str, payload: &JsonValue) -> Result<Value, String> {
218 match marker {
219 "$ok" => Ok(Value::Ok(Box::new(json_to_value(payload)?))),
220 "$err" => Ok(Value::Err(Box::new(json_to_value(payload)?))),
221 "$some" => Ok(Value::Some(Box::new(json_to_value(payload)?))),
222 "$none" => Ok(Value::None),
223 "$tuple" => decode_tuple(payload),
224 "$map" => decode_map(payload),
225 "$record" => decode_record(payload),
226 "$variant" => decode_variant(payload),
227 _ => Err(format!("unknown replay marker '{}'", marker)),
228 }
229}
230
231fn decode_tuple(payload: &JsonValue) -> Result<Value, String> {
232 let items = parse_array(payload, "$tuple")?;
233 let mut out = Vec::with_capacity(items.len());
234 for item in items {
235 out.push(json_to_value(item)?);
236 }
237 Ok(Value::Tuple(out))
238}
239
240fn decode_map(payload: &JsonValue) -> Result<Value, String> {
241 let pairs = parse_array(payload, "$map")?;
242 let mut out = HashMap::with_capacity(pairs.len());
243 for (idx, pair_json) in pairs.iter().enumerate() {
244 let pair = parse_array(pair_json, &format!("$map[{}]", idx))?;
245 if pair.len() != 2 {
246 return Err(format!("$map[{}] must be a 2-element array", idx));
247 }
248 let key = json_to_value(&pair[0])?;
249 let value = json_to_value(&pair[1])?;
250 out.insert(key, value);
251 }
252 Ok(Value::Map(out))
253}
254
255fn decode_record(payload: &JsonValue) -> Result<Value, String> {
256 let obj = expect_object(payload, "$record")?;
257 let type_name =
258 parse_string(get_required(obj, "type", "$record")?, "$record.type")?.to_string();
259 let fields_obj = expect_object(get_required(obj, "fields", "$record")?, "$record.fields")?;
260 let mut fields = Vec::with_capacity(fields_obj.len());
261 for (key, field_val) in fields_obj {
262 fields.push((key.clone(), json_to_value(field_val)?));
263 }
264 Ok(Value::Record { type_name, fields })
265}
266
267fn decode_variant(payload: &JsonValue) -> Result<Value, String> {
268 let obj = expect_object(payload, "$variant")?;
269 let type_name =
270 parse_string(get_required(obj, "type", "$variant")?, "$variant.type")?.to_string();
271 let variant =
272 parse_string(get_required(obj, "name", "$variant")?, "$variant.name")?.to_string();
273 let fields_arr = parse_array(get_required(obj, "fields", "$variant")?, "$variant.fields")?;
274 let mut fields = Vec::with_capacity(fields_arr.len());
275 for val in fields_arr {
276 fields.push(json_to_value(val)?);
277 }
278 Ok(Value::Variant {
279 type_name,
280 variant,
281 fields,
282 })
283}
284
285fn first_diff_path_inner(expected: &JsonValue, got: &JsonValue, path: &str) -> Option<String> {
286 match (expected, got) {
287 (JsonValue::Object(a), JsonValue::Object(b)) => {
288 let mut keys = a.keys().chain(b.keys()).cloned().collect::<Vec<_>>();
289 keys.sort();
290 keys.dedup();
291 for key in keys {
292 let next_path = if path == "$" {
293 format!("$.{}", key)
294 } else {
295 format!("{}.{}", path, key)
296 };
297 match (a.get(&key), b.get(&key)) {
298 (Some(av), Some(bv)) => {
299 if let Some(diff) = first_diff_path_inner(av, bv, &next_path) {
300 return Some(diff);
301 }
302 }
303 _ => return Some(next_path),
304 }
305 }
306 None
307 }
308 (JsonValue::Array(a), JsonValue::Array(b)) => {
309 if a.len() != b.len() {
310 return Some(format!("{}[len]", path));
311 }
312 for (idx, (av, bv)) in a.iter().zip(b.iter()).enumerate() {
313 let next_path = format!("{}[{}]", path, idx);
314 if let Some(diff) = first_diff_path_inner(av, bv, &next_path) {
315 return Some(diff);
316 }
317 }
318 None
319 }
320 _ => {
321 if expected == got {
322 None
323 } else {
324 Some(path.to_string())
325 }
326 }
327 }
328}
329
330fn write_json_compact(out: &mut String, value: &JsonValue) {
331 match value {
332 JsonValue::Null => out.push_str("null"),
333 JsonValue::Bool(true) => out.push_str("true"),
334 JsonValue::Bool(false) => out.push_str("false"),
335 JsonValue::Int(i) => {
336 let _ = write!(out, "{}", i);
337 }
338 JsonValue::Float(f) => out.push_str(&format_float(*f)),
339 JsonValue::String(s) => write_json_string(out, s),
340 JsonValue::Array(arr) => {
341 out.push('[');
342 for (idx, item) in arr.iter().enumerate() {
343 if idx > 0 {
344 out.push(',');
345 }
346 write_json_compact(out, item);
347 }
348 out.push(']');
349 }
350 JsonValue::Object(obj) => {
351 out.push('{');
352 for (idx, (k, v)) in obj.iter().enumerate() {
353 if idx > 0 {
354 out.push(',');
355 }
356 write_json_string(out, k);
357 out.push(':');
358 write_json_compact(out, v);
359 }
360 out.push('}');
361 }
362 }
363}
364
365fn write_json_pretty(out: &mut String, value: &JsonValue, indent: usize) {
366 match value {
367 JsonValue::Array(arr) => {
368 if arr.is_empty() {
369 out.push_str("[]");
370 return;
371 }
372 out.push_str("[\n");
373 for (idx, item) in arr.iter().enumerate() {
374 push_indent(out, indent + 2);
375 write_json_pretty(out, item, indent + 2);
376 if idx + 1 < arr.len() {
377 out.push(',');
378 }
379 out.push('\n');
380 }
381 push_indent(out, indent);
382 out.push(']');
383 }
384 JsonValue::Object(obj) => {
385 if obj.is_empty() {
386 out.push_str("{}");
387 return;
388 }
389 out.push_str("{\n");
390 for (idx, (k, v)) in obj.iter().enumerate() {
391 push_indent(out, indent + 2);
392 write_json_string(out, k);
393 out.push_str(": ");
394 write_json_pretty(out, v, indent + 2);
395 if idx + 1 < obj.len() {
396 out.push(',');
397 }
398 out.push('\n');
399 }
400 push_indent(out, indent);
401 out.push('}');
402 }
403 _ => write_json_compact(out, value),
404 }
405}
406
407fn push_indent(out: &mut String, indent: usize) {
408 for _ in 0..indent {
409 out.push(' ');
410 }
411}
412
413fn write_json_string(out: &mut String, s: &str) {
414 out.push('"');
415 for ch in s.chars() {
416 match ch {
417 '"' => out.push_str("\\\""),
418 '\\' => out.push_str("\\\\"),
419 '\n' => out.push_str("\\n"),
420 '\r' => out.push_str("\\r"),
421 '\t' => out.push_str("\\t"),
422 '\u{08}' => out.push_str("\\b"),
423 '\u{0C}' => out.push_str("\\f"),
424 c if c < '\u{20}' => {
425 let _ = write!(out, "\\u{:04X}", c as u32);
426 }
427 c => out.push(c),
428 }
429 }
430 out.push('"');
431}
432
433fn format_float(f: f64) -> String {
434 let mut s = format!("{}", f);
435 if !s.contains('.') && !s.contains('e') && !s.contains('E') {
436 s.push_str(".0");
437 }
438 s
439}