Replace float_deserialize feature with deserialize_via_float method

Author: FSMaxB

Cargo.toml

@@ -15,7 +15,6 @@ optional = true
 default-features = false
 
 [features]
-float_deserialize = ["serde"]
 default = ["std"]
 "rust_1.81" = []
 std = []

README.md

@@ -34,7 +34,7 @@ implementations of `std::error::Error` for `ParseIntError` and
 without the `std` feature.
 
 Deserialization can be routed through `f64` instead of `u64` with the
-`float_deserialize` feature. This will still not deserialize numbers with a
+`(U)Int::deserialize_via_float` methods. This will still not deserialize numbers with a
 non-zero fractional component. Please be aware that
 `serde_json` doesn't losslessly parse large floats with a fractional part by
 default (even if the fractional part is `.0`). To fix that, enable its 

src/int.rs

@@ -433,6 +433,42 @@ impl Int {
         Self::new_saturating(self.0.saturating_pow(exp))
     }
 
+    /// Deserialization function for use with `#[serde(deserialize_with = ...)]` that performs
+    /// deserialization through `f64` instead of `i64`.
+    /// This allows deserializing from numbers with a fractional component like `.0`.
+    ///
+    /// # Example
+    /// ```rs
+    /// use serde::Deserialize;
+    /// use js_int::Int;
+    ///
+    /// #[derive(Deserialize)]
+    /// struct Point {
+    ///     #[serde(deserialize_with = "Int::deserialize_via_float")]
+    ///     x: Int;
+    ///     #[serde(deserialize_with = "Int::deserialize_via_float")]
+    ///     y: Int;
+    /// }
+    #[cfg(feature = "serde")]
+    pub fn deserialize_via_float<'de, D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        const EXPECTING: &str =
+            "a number between -2^53 + 1 and 2^53 - 1 without fractional component";
+
+        let val = f64::deserialize(deserializer)?;
+
+        if val > MAX_SAFE_INT as f64
+            || val < MIN_SAFE_INT as f64
+            || !super::is_acceptable_float(val)
+        {
+            Err(D::Error::invalid_value(Unexpected::Float(val), &EXPECTING))
+        } else {
+            Ok(Self(val as i64))
+        }
+    }
+
     // TODO: wrapping_* methods, overflowing_* methods
 }
 
@@ -576,34 +612,14 @@ impl<'de> Deserialize<'de> for Int {
     where
         D: Deserializer<'de>,
     {
-        #[cfg(not(feature = "float_deserialize"))]
-        {
-            let val = i64::deserialize(deserializer)?;
-
-            Self::new(val).ok_or_else(|| {
-                D::Error::invalid_value(
-                    Unexpected::Signed(val),
-                    &"an integer between -2^53 + 1 and 2^53 - 1",
-                )
-            })
-        }
-
-        #[cfg(feature = "float_deserialize")]
-        {
-            const EXPECTING: &str =
-                "a number between -2^53 + 1 and 2^53 - 1 without fractional component";
+        let val = i64::deserialize(deserializer)?;
 
-            let val = f64::deserialize(deserializer)?;
-
-            if val > MAX_SAFE_INT as f64
-                || val < MIN_SAFE_INT as f64
-                || !super::is_acceptable_float(val)
-            {
-                Err(D::Error::invalid_value(Unexpected::Float(val), &EXPECTING))
-            } else {
-                Ok(Self(val as i64))
-            }
-        }
+        Self::new(val).ok_or_else(|| {
+            D::Error::invalid_value(
+                Unexpected::Signed(val),
+                &"an integer between -2^53 + 1 and 2^53 - 1",
+            )
+        })
     }
 }
 

src/lib.rs

@@ -28,9 +28,6 @@
 //! * `serde`: Serialization and deserialization support via [serde](https://serde.rs). Disabled by
 //!   default. You can use `js_int` + `serde` in `#![no_std]` contexts if you use
 //!   `default-features = false` for both.
-//! * `float_deserialize`: Deserialize via `f64`, not via `u64`. If the input has a fraction,
-//!   deserialization will fail.
-//! * `lax_deserialize`: Like `float_deserialize`, but if the input has a fraction, it is
 //!   deserialized with the fractional part discarded.
 //!   Please be aware that `serde_json` doesn't losslessly parse large floats with a fractional part
 //!   by default (even if the fractional part is `.0`). To fix that, enable its `float_roundtrip`
@@ -59,7 +56,6 @@ pub use self::{
     uint::{UInt, MAX_SAFE_UINT},
 };
 
-#[cfg(feature = "float_deserialize")]
 #[inline(always)]
 pub(crate) fn is_acceptable_float(float: f64) -> bool {
     !float.is_nan() && float.fract() == 0.0

src/uint.rs

@@ -5,10 +5,7 @@ use core::{
     str::FromStr,
 };
 
-use crate::{
-    error::{ParseIntError, ParseIntErrorKind, TryFromIntError},
-    MAX_SAFE_INT,
-};
+use crate::{error::{ParseIntError, ParseIntErrorKind, TryFromIntError}, MAX_SAFE_INT};
 #[cfg(feature = "serde")]
 use serde::{
     de::{Error as _, Unexpected},
@@ -414,6 +411,39 @@ impl UInt {
         Self::new_saturating(self.0.saturating_pow(exp))
     }
 
+    /// Deserialization function for use with `#[serde(deserialize_with = ...)]` that performs
+    /// deserialization through `f64` instead of `u64`.
+    /// This allows deserializing from numbers with a fractional component like `.0`.
+    ///
+    /// # Example
+    /// ```rs
+    /// use serde::Deserialize;
+    /// use js_int::UInt;
+    ///
+    /// #[derive(Deserialize)]
+    /// struct Point {
+    ///     #[serde(deserialize_with = "UInt::deserialize_via_float")]
+    ///     x: UInt;
+    ///     #[serde(deserialize_with = "UInt::deserialize_via_float")]
+    ///     y: UInt;
+    /// }
+    /// ```
+    #[cfg(feature = "serde")]
+    pub fn deserialize_via_float<'de, D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        const EXPECTING: &str = "a number between 0 and 2^53 - 1 without fractional component";
+
+        let val = f64::deserialize(deserializer)?;
+
+        if val < 0.0 || val > MAX_SAFE_UINT as f64 || !super::is_acceptable_float(val) {
+            Err(D::Error::invalid_value(Unexpected::Float(val), &EXPECTING))
+        } else {
+            Ok(Self(val as u64))
+        }
+    }
+
     // TODO: wrapping_* methods, overflowing_* methods
 }
 
@@ -571,30 +601,14 @@ impl<'de> Deserialize<'de> for UInt {
     where
         D: Deserializer<'de>,
     {
-        #[cfg(not(feature = "float_deserialize"))]
-        {
-            let val = u64::deserialize(deserializer)?;
-
-            Self::new(val).ok_or_else(|| {
-                D::Error::invalid_value(
-                    Unexpected::Unsigned(val),
-                    &"an integer between 0 and 2^53 - 1",
-                )
-            })
-        }
-
-        #[cfg(feature = "float_deserialize")]
-        {
-            const EXPECTING: &str = "a number between 0 and 2^53 - 1 without fractional component";
-
-            let val = f64::deserialize(deserializer)?;
-
-            if val < 0.0 || val > MAX_SAFE_UINT as f64 || !super::is_acceptable_float(val) {
-                Err(D::Error::invalid_value(Unexpected::Float(val), &EXPECTING))
-            } else {
-                Ok(Self(val as u64))
-            }
-        }
+        let val = u64::deserialize(deserializer)?;
+
+        Self::new(val).ok_or_else(|| {
+            D::Error::invalid_value(
+                Unexpected::Unsigned(val),
+                &"an integer between 0 and 2^53 - 1",
+            )
+        })
     }
 }
 

tests/int.rs

@@ -28,7 +28,6 @@ fn deserialize() {
 }
 
 #[test]
-#[cfg_attr(feature = "float_deserialize", ignore)]
 fn dont_deserialize_integral_float() {
     assert!(deserialize_from(-10.0).is_err());
     assert!(deserialize_from(-0.0).is_err());
@@ -45,26 +44,31 @@ fn dont_deserialize_fractional_float() {
 }
 
 #[test]
-#[cfg_attr(not(feature = "float_deserialize"), ignore)]
 fn deserialize_integral_float() {
-    assert_eq!(deserialize_from(-10.0).unwrap(), int!(-10));
-    assert_eq!(deserialize_from(-0.0).unwrap(), int!(0));
-    assert_eq!(deserialize_from(1.0).unwrap(), int!(1));
-    assert_eq!(deserialize_from(9007199254740991.0).unwrap(), Int::MAX);
-    assert!(deserialize_from(9007199254740992.0).is_err());
+    assert_eq!(deserialize_via_float(-10.0).unwrap(), int!(-10));
+    assert_eq!(deserialize_via_float(-0.0).unwrap(), int!(0));
+    assert_eq!(deserialize_via_float(1.0).unwrap(), int!(1));
+    assert_eq!(deserialize_via_float(9007199254740991.0).unwrap(), Int::MAX);
+    assert!(deserialize_via_float(9007199254740992.0).is_err());
     // NOTE: This still ends up as integral because the .49 exceeds the representable range of f64
     assert_eq!(
-        deserialize_from(9007199254740991.49).unwrap(),
+        deserialize_via_float(9007199254740991.49).unwrap(),
         Int::try_from(9007199254740991i64).unwrap()
     );
 
-    assert!(deserialize_from(f64::NAN).is_err());
-    assert!(deserialize_from(f64::INFINITY).is_err());
-    assert!(deserialize_from(f64::NEG_INFINITY).is_err());
+    assert!(deserialize_via_float(f64::NAN).is_err());
+    assert!(deserialize_via_float(f64::INFINITY).is_err());
+    assert!(deserialize_via_float(f64::NEG_INFINITY).is_err());
+
+    fn deserialize_via_float<'de, Value: IntoDeserializer<'de>>(
+        value: Value,
+    ) -> Result<Int, serde::de::value::Error> {
+        Int::deserialize_via_float(value.into_deserializer())
+    }
 }
 
 fn deserialize_from<'de, Value: IntoDeserializer<'de>>(
     value: Value,
 ) -> Result<Int, serde::de::value::Error> {
     Int::deserialize(value.into_deserializer())
-}
+}

tests/uint.rs

@@ -24,7 +24,6 @@ fn deserialize() {
 }
 
 #[test]
-#[cfg_attr(feature = "float_deserialize", ignore)]
 fn dont_deserialize_integral_float() {
     assert!(deserialize_from(1.0).is_err());
     assert!(deserialize_from(9007199254740991.0).is_err());
@@ -38,20 +37,24 @@ fn dont_deserialize_fractional_float() {
 }
 
 #[test]
-#[cfg_attr(not(feature = "float_deserialize"), ignore)]
 fn deserialize_integral_float() {
-    assert_eq!(deserialize_from(1.0).unwrap(), uint!(1));
-    assert_eq!(deserialize_from(9007199254740991.0).unwrap(), UInt::MAX);
-    assert!(deserialize_from(9007199254740992.0).is_err());
+    assert_eq!(deserialize_via_float(1.0).unwrap(), uint!(1));
+    assert_eq!(deserialize_via_float(9007199254740991.0).unwrap(), UInt::MAX);
+    assert!(deserialize_via_float(9007199254740992.0).is_err());
     // NOTE: This still ends up as integral because the .49 exceeds the representable range of f64
     assert_eq!(
-        deserialize_from(9007199254740991.49).unwrap(),
+        deserialize_via_float(9007199254740991.49).unwrap(),
         UInt::try_from(9007199254740991i64).unwrap()
     );
 
-    assert!(deserialize_from(f64::NAN).is_err());
-    assert!(deserialize_from(f64::INFINITY).is_err());
-    assert!(deserialize_from(f64::NEG_INFINITY).is_err());
+    assert!(deserialize_via_float(f64::NAN).is_err());
+    assert!(deserialize_via_float(f64::INFINITY).is_err());
+    assert!(deserialize_via_float(f64::NEG_INFINITY).is_err());
+
+    fn deserialize_via_float<'de, Value: IntoDeserializer<'de>>(value: Value) -> Result<UInt, serde::de::value::Error>
+    {
+        UInt::deserialize_via_float(value.into_deserializer())
+    }
 }
 
 fn deserialize_from<'de, Value: IntoDeserializer<'de>>(