feat(serde): add truncate-float-to-int feature for float to integer conversion

Author: Icemic

Cargo.toml

@@ -17,6 +17,7 @@ features = ["chrono", "bigint"]
 bigint = ["num-bigint", "num-traits"]
 default = ["chrono", "serde", "bigint"]
 serde = ["thiserror", "dep:serde"]
+truncate-float-to-int = []
 
 [dependencies]
 anyhow = {version = "1"}

README.md

@@ -47,6 +47,7 @@ The crate supports the following features:
 - `chrono`: _(default enabled)._ chrono integration
   - adds a `JsValue::Date` variant that can be (de)serialized to/from a JS `Date`
 - `bigint`: _(default enabled)._ arbitrary precision integer support via [num-bigint](https://github.com/rust-num/num-bigint)
+- `truncate-float-to-int`: _(default disabled)._ when enabled, float values will be truncated to integers when converting to integer types. When disabled, only float with zero fractional part will be converted to integer types, otherwise an error will be returned. 
 
 ## Installation
 

src/serde/de.rs

@@ -163,11 +163,23 @@ impl<'de> Deserializer<'de> {
 
         let value = current.to_float()?;
 
-        if !value.is_finite() || value.fract() != 0.0 {
-            return Err(Error::ExpectedInteger);
+        #[cfg(feature = "truncate-float-to-int")]
+        {
+            if !value.is_finite() {
+                return Err(Error::ExpectedInteger);
+            }
+
+            Ok(value.trunc())
         }
 
-        Ok(value)
+        #[cfg(not(feature = "truncate-float-to-int"))]
+        {
+            if !value.is_finite() || value.fract() != 0.0 {
+                return Err(Error::ExpectedInteger);
+            }
+
+            Ok(value)
+        }
     }
 
     fn parse_signed_integer(&self) -> Result<i64> {

tests/serde.rs

@@ -221,13 +221,15 @@ fn serde_ser_map() {
     assert!(json_str.contains("\"c\":3"));
 }
 
-fn parse_from_js<T: serde::de::DeserializeOwned>(value: Value) -> T {
+fn parse_from_js_result<T: serde::de::DeserializeOwned>(value: Value) -> quickjs_rusty::serde::Result<T> {
     let context = Context::builder().build().unwrap();
-    // use our to_js function to convert rust value to js value
-    // now it is a js value in quickjs context
     let js_value = to_js(unsafe { context.context_raw() }, &value).unwrap();
 
-    match from_js::<T>(unsafe { context.context_raw() }, &js_value) {
+    from_js::<T>(unsafe { context.context_raw() }, &js_value)
+}
+
+fn parse_from_js<T: serde::de::DeserializeOwned>(value: Value) -> T {
+    match parse_from_js_result(value) {
         Ok(v) => v,
         Err(err) => {
             panic!("{}", err);
@@ -294,6 +296,34 @@ fn serde_de_float_with_integer_value_to_i32() {
     assert_eq!(parse_from_js::<i32>(value), -1234);
 }
 
+#[cfg(not(feature = "truncate-float-to-int"))]
+#[test]
+fn serde_de_float_with_fractional_value_to_u32_rejects() {
+    let value = json!(1450.9);
+    assert!(parse_from_js_result::<u32>(value).is_err());
+}
+
+#[cfg(not(feature = "truncate-float-to-int"))]
+#[test]
+fn serde_de_float_with_fractional_value_to_i32_rejects() {
+    let value = json!(-1234.9);
+    assert!(parse_from_js_result::<i32>(value).is_err());
+}
+
+#[cfg(feature = "truncate-float-to-int")]
+#[test]
+fn serde_de_float_with_fractional_value_to_u32_truncates() {
+    let value = json!(1450.9);
+    assert_eq!(parse_from_js::<u32>(value), 1450);
+}
+
+#[cfg(feature = "truncate-float-to-int")]
+#[test]
+fn serde_de_float_with_fractional_value_to_i32_truncates() {
+    let value = json!(-1234.9);
+    assert_eq!(parse_from_js::<i32>(value), -1234);
+}
+
 #[test]
 fn serde_de_option_none() {
     let value = json!(None::<()>);