Files
faunosteo/crates/core/src/json.rs
T

272 lines
9.1 KiB
Rust
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
//! 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);
}
}