272 lines
9.1 KiB
Rust
272 lines
9.1 KiB
Rust
//! 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<W>(&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<W>(&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<W>(&mut self, writer: &mut W) -> io::Result<()>
|
||
where
|
||
W: ?Sized + io::Write,
|
||
{
|
||
self.inner.begin_array(writer)
|
||
}
|
||
|
||
fn end_array<W>(&mut self, writer: &mut W) -> io::Result<()>
|
||
where
|
||
W: ?Sized + io::Write,
|
||
{
|
||
self.inner.end_array(writer)
|
||
}
|
||
|
||
fn begin_array_value<W>(&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<W>(&mut self, writer: &mut W) -> io::Result<()>
|
||
where
|
||
W: ?Sized + io::Write,
|
||
{
|
||
self.inner.end_array_value(writer)
|
||
}
|
||
|
||
fn begin_object<W>(&mut self, writer: &mut W) -> io::Result<()>
|
||
where
|
||
W: ?Sized + io::Write,
|
||
{
|
||
self.inner.begin_object(writer)
|
||
}
|
||
|
||
fn end_object<W>(&mut self, writer: &mut W) -> io::Result<()>
|
||
where
|
||
W: ?Sized + io::Write,
|
||
{
|
||
self.inner.end_object(writer)
|
||
}
|
||
|
||
fn begin_object_key<W>(&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<W>(&mut self, writer: &mut W) -> io::Result<()>
|
||
where
|
||
W: ?Sized + io::Write,
|
||
{
|
||
self.inner.begin_object_value(writer)
|
||
}
|
||
|
||
fn end_object_value<W>(&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<T: Serialize + ?Sized>(value: &T) -> Result<String, serde_json::Error> {
|
||
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(<serde_json::Error as serde::ser::Error>::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<W>(&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<W>(&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<T: Serialize + ?Sized>(value: &T) -> Result<String, serde_json::Error> {
|
||
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(<serde_json::Error as serde::ser::Error>::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<String, serde_json::Error> {
|
||
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);
|
||
}
|
||
}
|