fix: Serialize full i128/u128 range

Author: tyranron

src/ser.rs

@@ -109,21 +109,7 @@ impl<'a> ser::Serializer for &'a mut ConfigSerializer {
     }
 
     fn serialize_i128(self, v: i128) -> Result<Self::Ok> {
-        if v > i64::MAX.into() {
-            Err(ConfigError::Message(format!(
-                "value {} is greater than the max {}",
-                v,
-                i64::MAX
-            )))
-        } else if v < i64::MIN.into() {
-            Err(ConfigError::Message(format!(
-                "value {} is less than the min {}",
-                v,
-                i64::MIN
-            )))
-        } else {
-            self.serialize_i64(v as i64)
-        }
+        self.serialize_primitive(v)
     }
 
     fn serialize_u8(self, v: u8) -> Result<Self::Ok> {
@@ -139,27 +125,11 @@ impl<'a> ser::Serializer for &'a mut ConfigSerializer {
     }
 
     fn serialize_u64(self, v: u64) -> Result<Self::Ok> {
-        if v > (i64::MAX as u64) {
-            Err(ConfigError::Message(format!(
-                "value {} is greater than the max {}",
-                v,
-                i64::MAX
-            )))
-        } else {
-            self.serialize_i64(v as i64)
-        }
+        self.serialize_primitive(v)
     }
 
     fn serialize_u128(self, v: u128) -> Result<Self::Ok> {
-        if v > (i64::MAX as u128) {
-            Err(ConfigError::Message(format!(
-                "value {} is greater than the max {}",
-                v,
-                i64::MAX
-            )))
-        } else {
-            self.serialize_i64(v as i64)
-        }
+        self.serialize_primitive(v)
     }
 
     fn serialize_f32(self, v: f32) -> Result<Self::Ok> {

src/value.rs

@@ -276,21 +276,21 @@ impl Value {
                 ConfigError::invalid_type(
                     self.origin,
                     Unexpected::I128(value),
-                    "an signed 64 bit or less integer",
+                    "a signed 64 bit or less integer",
                 )
             }),
             ValueKind::U64(value) => value.try_into().map_err(|_| {
                 ConfigError::invalid_type(
                     self.origin,
                     Unexpected::U64(value),
-                    "an signed 64 bit or less integer",
+                    "a signed 64 bit or less integer",
                 )
             }),
             ValueKind::U128(value) => value.try_into().map_err(|_| {
                 ConfigError::invalid_type(
                     self.origin,
                     Unexpected::U128(value),
-                    "an signed 64 bit or less integer",
+                    "a signed 64 bit or less integer",
                 )
             }),
 

tests/testsuite/i128.rs

@@ -1,13 +1,13 @@
 #![cfg(feature = "preserve_order")]
 
-use serde::Deserialize;
+use serde::{Deserialize, Serialize};
 
-#[derive(Debug, Deserialize, Eq, PartialEq)]
+#[derive(Debug, Deserialize, Eq, PartialEq, Serialize)]
 struct Container<T> {
     inner: T,
 }
 
-#[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq)]
+#[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq, Serialize)]
 struct I128 {
     val: i128,
 }
@@ -33,4 +33,7 @@ fn test_deserialize_i128_min() {
 
     let deserialized = built.clone().try_deserialize::<Container<I128>>().unwrap();
     assert_eq!(deserialized, container);
+
+    let serialized = config::Config::try_from(&container).unwrap();
+    assert_eq!(serialized.cache, built.cache);
 }

tests/testsuite/u128.rs

@@ -1,13 +1,13 @@
 #![cfg(feature = "preserve_order")]
 
-use serde::Deserialize;
+use serde::{Deserialize, Serialize};
 
-#[derive(Debug, Deserialize, Eq, PartialEq)]
+#[derive(Debug, Deserialize, Eq, PartialEq, Serialize)]
 struct Container<T> {
     inner: T,
 }
 
-#[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq)]
+#[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq, Serialize)]
 struct U128 {
     val: u128,
 }
@@ -33,4 +33,7 @@ fn test_deserialize_u128_min() {
 
     let deserialized = built.clone().try_deserialize::<Container<U128>>().unwrap();
     assert_eq!(deserialized, container);
+
+    let serialized = config::Config::try_from(&container).unwrap();
+    assert_eq!(serialized.cache, built.cache);
 }