feat: support serialize floating point numbers without trailing zeros

Author: liuq19

.github/workflows/ci.yml

@@ -75,7 +75,7 @@ jobs:
       fail-fast: false
       matrix:
         san: ["address,leak"]
-        feature: ["", "arbitrary_precision", "sort_keys", "utf8_lossy"]
+        feature: ["", "arbitrary_precision", "sort_keys", "utf8_lossy", "non_trailing_zero"]
     name: Sanitize ${{matrix.san}} feature ${{matrix.feature}}
     runs-on: [self-hosted, Linux, amd64]
     steps:

Cargo.toml

@@ -10,7 +10,7 @@ license       = "Apache-2.0"
 name          = "sonic-rs"
 readme        = "README.md"
 repository    = "https://github.com/cloudwego/sonic-rs"
-version       = "0.5.2"
+version       = "0.5.3"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
@@ -54,3 +54,7 @@ utf8_lossy = []
 
 # Enable sanitize, maybe cause 30% performance-loss in serialize.
 sanitize = []
+
+# Serialize floating point numbers without trailing zeros if the float can be represented as an integer without loss of precision.
+# For example, `18.0` will be serialized as `18` instead of `18.0`.
+non_trailing_zero = []

scripts/test.sh

@@ -10,6 +10,8 @@ cargo test --features sort_keys
 
 cargo test --features utf8_lossy
 
+cargo test --features non_trailing_zero
+
 examples=$(cargo build --example 2>&1 | grep -v ":")
 
 for example in $examples; do

src/format.rs

@@ -147,6 +147,11 @@ pub trait Formatter {
     where
         W: ?Sized + Write,
     {
+        #[cfg(feature = "non_trailing_zero")]
+        if value.fract() == 0.0 && value <= (i64::MAX as f32) && value >= (i64::MIN as f32) {
+            return self.write_i64(writer, value as i64);
+        }
+
         let mut buffer = ryu::Buffer::new();
         let s = buffer.format_finite(value);
         writer.write_all(s.as_bytes())
@@ -158,6 +163,11 @@ pub trait Formatter {
     where
         W: ?Sized + Write,
     {
+        #[cfg(feature = "non_trailing_zero")]
+        if value.fract() == 0.0 && value <= (i64::MAX as f64) && value >= (i64::MIN as f64) {
+            return self.write_i64(writer, value as i64);
+        }
+
         let mut buffer = ryu::Buffer::new();
         let s = buffer.format_finite(value);
         writer.write_all(s.as_bytes())

src/serde/mod.rs

@@ -437,77 +437,6 @@ mod test {
         test_from_slice!(Data, &br#"{"content":[1,2,3,4,5]}"#[..]);
     }
 
-    use std::{
-        fmt::{Formatter, Result as FmtResult},
-        result::Result as StdResult,
-    };
-
-    fn my_deseirlize_seq<'de, D>(deserializer: D) -> StdResult<(i64, i64), D::Error>
-    where
-        D: serde::de::Deserializer<'de>,
-    {
-        struct TupleVisitor;
-
-        impl<'de> serde::de::Visitor<'de> for TupleVisitor {
-            type Value = (i64, i64);
-
-            fn expecting(&self, formatter: &mut Formatter) -> FmtResult {
-                formatter.write_str("expect an array")
-            }
-
-            fn visit_seq<S>(self, mut seq: S) -> StdResult<Self::Value, S::Error>
-            where
-                S: serde::de::SeqAccess<'de>,
-            {
-                let x = seq
-                    .next_element::<i64>()?
-                    .ok_or_else(|| serde::de::Error::invalid_length(0, &self))?;
-                let y = seq
-                    .next_element::<i64>()?
-                    .ok_or_else(|| serde::de::Error::invalid_length(1, &self))?;
-                Ok((x, y))
-            }
-        }
-
-        deserializer.deserialize_seq(TupleVisitor)
-    }
-
-    fn my_deseirlize_map<'de, D>(deserializer: D) -> StdResult<(String, i64), D::Error>
-    where
-        D: serde::de::Deserializer<'de>,
-    {
-        struct MapVisitor;
-
-        impl<'de> serde::de::Visitor<'de> for MapVisitor {
-            type Value = (String, i64);
-
-            fn expecting(&self, formatter: &mut Formatter) -> FmtResult {
-                formatter.write_str("expect an array")
-            }
-
-            fn visit_map<S>(self, mut map: S) -> StdResult<Self::Value, S::Error>
-            where
-                S: serde::de::MapAccess<'de>,
-            {
-                let x = map
-                    .next_key()?
-                    .ok_or_else(|| serde::de::Error::custom("miss a key"))?;
-                let y = map.next_value::<i64>()?;
-                Ok((x, y))
-            }
-        }
-
-        deserializer.deserialize_map(MapVisitor)
-    }
-
-    #[derive(serde::Deserialize, Debug, Eq, PartialEq)]
-    struct MyTuple {
-        #[serde(deserialize_with = "my_deseirlize_seq")]
-        seq: (i64, i64),
-        #[serde(deserialize_with = "my_deseirlize_map")]
-        map: (String, i64),
-    }
-
     #[test]
     fn test_serde_invalid_utf8() {
         let json = r#""王先生""#;
@@ -737,4 +666,27 @@ mod test {
             assert!(err.is_syntax());
         }
     }
+
+    #[test]
+    fn test_serialize_float_non_trailing_zero() {
+        use serde::Serialize;
+
+        #[derive(Serialize)]
+        struct FloatTest {
+            value: f64,
+        }
+
+        let test = FloatTest { value: 18.0 };
+        let json = to_string(&test).unwrap();
+
+        #[cfg(feature = "non_trailing_zero")]
+        assert_eq!(json, r#"{"value":18}"#);
+
+        #[cfg(not(feature = "non_trailing_zero"))]
+        assert_eq!(json, r#"{"value":18.0}"#);
+
+        let test = FloatTest { value: 18.1 };
+        let json = to_string(&test).unwrap();
+        assert_eq!(json, r#"{"value":18.1}"#);
+    }
 }