//! JSON output with JavaScript number semantics. //! //! `JSON.stringify(value, null, 2)` and `serde_json`'s pretty printer agree on everything //! (two-space indent, `": "`, `[]` and `{}` for empty containers, raw non-ASCII, `\u00XX` //! control escapes) except finite floats: JavaScript prints `1523` for `1523.0` and `1e+21` //! for `1e21`, `serde_json` prints `1523.0` and `1e21`. The documents of the repository carry //! integer-valued coordinates as floats, so the archive attachment and the generated seed //! files need the JavaScript form (review I.2, D-R11). use std::io; use serde::Serialize; use serde_json::ser::{Formatter, PrettyFormatter}; /// Formats a finite `f64` exactly as ECMAScript `Number::toString(10)` does. /// /// Non-finite values have no JSON form (`JSON.stringify` writes `null`): same here. pub fn js_number(value: f64) -> String { if !value.is_finite() { return "null".to_owned(); } if value == 0.0 { return "0".to_owned(); } let (digits, point) = shortest_digits(value.abs()); let mut out = String::with_capacity(digits.len() + 8); if value.is_sign_negative() { out.push('-'); } write_decimal(&mut out, &digits, point); out } /// Shortest round-trip digits of a positive finite value and the position `n` of the /// decimal point relative to the first digit (ECMAScript's `n`): value = 0.d₁d₂… × 10ⁿ. /// /// The digits come from `zmij`, which picks among the shortest candidates the one closest to /// the value and, on an exact tie, the even one: ECMAScript's rule. Rust's `{:e}` rounds a /// tie upward (`840.16925048828125` → `…813`, R5.1b F1). zmij prints either a plain decimal /// (`840.1692504882812`, `1523.0`, `0.001`) or a mantissa and an exponent (`1e21`, /// `1.5e-7`); both read back the same way here. fn shortest_digits(value: f64) -> (String, i32) { let mut buffer = zmij::Buffer::new(); let printed = buffer.format_finite(value); let (mantissa, exponent) = printed.split_once(['e', 'E']).unwrap_or((printed, "0")); let exponent: i32 = exponent.parse().unwrap_or(0); let (integer, fraction) = mantissa.split_once('.').unwrap_or((mantissa, "")); let mut point = i32::try_from(integer.len()).unwrap_or(i32::MAX) + exponent; let all: String = format!("{integer}{fraction}"); let leading = all.len() - all.trim_start_matches('0').len(); point -= i32::try_from(leading).unwrap_or(0); let digits = all.trim_matches('0').to_owned(); (digits, point) } /// ECMAScript Number::toString steps 6 to 10 for `k` digits and point position `n`. fn write_decimal(out: &mut String, digits: &str, n: i32) { let k = i32::try_from(digits.len()).unwrap_or(i32::MAX); if k <= n && n <= 21 { out.push_str(digits); out.extend(std::iter::repeat_n('0', (n - k).unsigned_abs() as usize)); } else if 0 < n && n <= 21 { let (integer, fraction) = digits.split_at(n.unsigned_abs() as usize); out.push_str(integer); out.push('.'); out.push_str(fraction); } else if -6 < n && n <= 0 { out.push_str("0."); out.extend(std::iter::repeat_n('0', n.unsigned_abs() as usize)); out.push_str(digits); } else { let (first, rest) = digits.split_at(1); out.push_str(first); if !rest.is_empty() { out.push('.'); out.push_str(rest); } let exponent = n - 1; out.push('e'); out.push(if exponent < 0 { '-' } else { '+' }); out.push_str(&exponent.unsigned_abs().to_string()); } } /// `serde_json`'s pretty formatter with JavaScript float printing. pub struct JsPrettyFormatter<'a> { inner: PrettyFormatter<'a>, } impl Default for JsPrettyFormatter<'_> { fn default() -> Self { Self { inner: PrettyFormatter::new(), } } } impl Formatter for JsPrettyFormatter<'_> { fn write_f32(&mut self, writer: &mut W, value: f32) -> io::Result<()> where W: ?Sized + io::Write, { writer.write_all(js_number(f64::from(value)).as_bytes()) } fn write_f64(&mut self, writer: &mut W, value: f64) -> io::Result<()> where W: ?Sized + io::Write, { writer.write_all(js_number(value).as_bytes()) } fn begin_array(&mut self, writer: &mut W) -> io::Result<()> where W: ?Sized + io::Write, { self.inner.begin_array(writer) } fn end_array(&mut self, writer: &mut W) -> io::Result<()> where W: ?Sized + io::Write, { self.inner.end_array(writer) } fn begin_array_value(&mut self, writer: &mut W, first: bool) -> io::Result<()> where W: ?Sized + io::Write, { self.inner.begin_array_value(writer, first) } fn end_array_value(&mut self, writer: &mut W) -> io::Result<()> where W: ?Sized + io::Write, { self.inner.end_array_value(writer) } fn begin_object(&mut self, writer: &mut W) -> io::Result<()> where W: ?Sized + io::Write, { self.inner.begin_object(writer) } fn end_object(&mut self, writer: &mut W) -> io::Result<()> where W: ?Sized + io::Write, { self.inner.end_object(writer) } fn begin_object_key(&mut self, writer: &mut W, first: bool) -> io::Result<()> where W: ?Sized + io::Write, { self.inner.begin_object_key(writer, first) } fn begin_object_value(&mut self, writer: &mut W) -> io::Result<()> where W: ?Sized + io::Write, { self.inner.begin_object_value(writer) } fn end_object_value(&mut self, writer: &mut W) -> io::Result<()> where W: ?Sized + io::Write, { self.inner.end_object_value(writer) } } /// Serialises `value` as `JSON.stringify(value, null, 2)` would (no trailing newline). pub fn to_js_pretty(value: &T) -> Result { let mut buffer = Vec::new(); let mut serializer = serde_json::Serializer::with_formatter(&mut buffer, JsPrettyFormatter::default()); value.serialize(&mut serializer)?; String::from_utf8(buffer).map_err(::custom) } /// `serde_json`'s compact formatter with JavaScript float printing (`JSON.stringify(value)`). #[derive(Default)] pub struct JsCompactFormatter; impl Formatter for JsCompactFormatter { fn write_f32(&mut self, writer: &mut W, value: f32) -> io::Result<()> where W: ?Sized + io::Write, { writer.write_all(js_number(f64::from(value)).as_bytes()) } fn write_f64(&mut self, writer: &mut W, value: f64) -> io::Result<()> where W: ?Sized + io::Write, { writer.write_all(js_number(value).as_bytes()) } } /// Serialises `value` as `JSON.stringify(value)` would. pub fn to_js_compact(value: &T) -> Result { let mut buffer = Vec::new(); let mut serializer = serde_json::Serializer::with_formatter(&mut buffer, JsCompactFormatter); value.serialize(&mut serializer)?; String::from_utf8(buffer).map_err(::custom) } /// Parses JSON text and re-emits it in the JavaScript pretty form, keeping the key order. pub fn pretty_js_round_trip(text: &str) -> Result { let value: serde_json::Value = serde_json::from_str(text)?; to_js_pretty(&value) } #[cfg(test)] mod tests { use super::*; #[test] fn integer_valued_floats_print_without_a_fraction() { assert_eq!(js_number(1523.0), "1523"); assert_eq!(js_number(-7.0), "-7"); assert_eq!( js_number(123_456_789_012_345_680_000.0), "123456789012345680000" ); } #[test] fn fractions_and_small_values_follow_the_javascript_thresholds() { assert_eq!(js_number(0.85), "0.85"); assert_eq!(js_number(1_715.428_571_428_571_3), "1715.4285714285713"); assert_eq!(js_number(0.000_001), "0.000001"); assert_eq!(js_number(0.000_000_1), "1e-7"); assert_eq!(js_number(1e21), "1e+21"); assert_eq!(js_number(1.5e300), "1.5e+300"); assert_eq!(js_number(5e-324), "5e-324"); } #[test] fn zero_and_non_finite_values() { assert_eq!(js_number(0.0), "0"); assert_eq!(js_number(-0.0), "0"); assert_eq!(js_number(f64::NAN), "null"); assert_eq!(js_number(f64::INFINITY), "null"); } #[test] fn compact_output_prints_floats_as_javascript() { let value = serde_json::json!({"a": [1.0, 0.5, 1e21], "b": "\u{1}"}); assert_eq!( to_js_compact(&value).ok().as_deref(), Some(r#"{"a":[1,0.5,1e+21],"b":"\u0001"}"#) ); } #[test] fn pretty_output_matches_the_javascript_shape() { let text = r#"{"b":[1,2.0,{"c":[]}],"a":{},"d":"é\u0001","e":-0.0}"#; let expected = "{\n \"b\": [\n 1,\n 2,\n {\n \"c\": []\n }\n ],\n \"a\": {},\n \"d\": \"é\\u0001\",\n \"e\": 0\n}"; let Ok(actual) = pretty_js_round_trip(text) else { panic!("round trip failed"); }; assert_eq!(actual, expected); } }