Merge pull request #117 from lpbak/issue_114

Closes #114

Author: maciejhirsz

src/number.rs

@@ -50,19 +50,44 @@ impl Number {
     ///
     /// ```
     /// # use json::number::Number;
-    /// let pi = Number::from_parts(true, 3141592653589793, -15);
+    /// let pi = unsafe { Number::from_parts_unchecked(true, 3141592653589793, -15) };
     ///
     /// assert_eq!(pi, 3.141592653589793);
     /// ```
+    ///
+    /// While this method is marked unsafe, it doesn't actually perform any unsafe operations.
+    /// THe goal of the 'unsafe' is to deter from using this method in favor of its safe equivalent
+    /// `from_parts`, at least in context when the associated performance cost is negligible.
     #[inline]
-    pub fn from_parts(positive: bool, mantissa: u64, exponent: i16) -> Self {
+    pub unsafe fn from_parts_unchecked(positive: bool, mantissa: u64, exponent: i16) -> Self {
         Number {
             category: positive as u8,
             exponent: exponent,
             mantissa: mantissa,
         }
     }
 
+    /// Construct a new `Number` from parts, stripping unnecessary trailing zeroes.
+    /// This can't create a NaN value.
+    ///
+    /// ```
+    /// # use json::number::Number;
+    /// let one = Number::from_parts(true, 1000, -3);
+    /// let (positive, mantissa, exponent) = one.as_parts();
+    ///
+    /// assert_eq!(true, positive);
+    /// assert_eq!(1, mantissa);
+    /// assert_eq!(0, exponent);
+    /// ```
+    #[inline]
+    pub fn from_parts(positive: bool, mut mantissa: u64, mut exponent: i16) -> Self {
+        while exponent < 0 && mantissa % 10 == 0 {
+            exponent += 1;
+            mantissa /= 10;
+        }
+        unsafe { Number::from_parts_unchecked(positive, mantissa, exponent) }
+    }
+
     /// Reverse to `from_parts` - obtain parts from an existing `Number`.
     ///
     /// ```

src/parser.rs

@@ -323,7 +323,7 @@ macro_rules! expect_fraction {
 
         loop {
             if $parser.is_eof() {
-                result = Number::from_parts(true, $num, $e);
+                result = unsafe { Number::from_parts_unchecked(true, $num, $e) };
                 break;
             }
             let ch = $parser.read_byte();
@@ -352,7 +352,7 @@ macro_rules! expect_fraction {
                     break;
                 }
                 _ => {
-                    result = Number::from_parts(true, $num, $e);
+                    result = unsafe { Number::from_parts_unchecked(true, $num, $e) };
                     break;
                 }
             }
@@ -568,7 +568,7 @@ impl<'a> Parser<'a> {
         let mut e = 0i16;
         loop {
             if self.is_eof() {
-                return Ok(Number::from_parts(true, num, e));
+                return Ok(unsafe { Number::from_parts_unchecked(true, num, e) });
             }
             let ch = self.read_byte();
             match ch {
@@ -593,7 +593,7 @@ impl<'a> Parser<'a> {
             }
         }
 
-        Ok(Number::from_parts(true, num, e))
+        Ok(unsafe { Number::from_parts_unchecked(true, num, e) })
     }
 
     // Called in the rare case that a number with `e` notation has been
@@ -631,7 +631,7 @@ impl<'a> Parser<'a> {
             }
         }
 
-        Ok(Number::from_parts(true, num, (big_e.saturating_add(e * sign))))
+        Ok(unsafe { Number::from_parts_unchecked(true, num, (big_e.saturating_add(e * sign))) })
     }
 
     // Parse away!

tests/number.rs

@@ -12,12 +12,12 @@ fn is_nan() {
 #[test]
 fn is_zero() {
     assert!(Number::from(0).is_zero());
-    assert!(Number::from_parts(true, 0, 0).is_zero());
-    assert!(Number::from_parts(true, 0, 100).is_zero());
-    assert!(Number::from_parts(true, 0, -100).is_zero());
-    assert!(Number::from_parts(false, 0, 0).is_zero());
-    assert!(Number::from_parts(false, 0, 100).is_zero());
-    assert!(Number::from_parts(false, 0, -100).is_zero());
+    assert!(unsafe { Number::from_parts_unchecked(true, 0, 0).is_zero() });
+    assert!(unsafe { Number::from_parts_unchecked(true, 0, 100).is_zero() });
+    assert!(unsafe { Number::from_parts_unchecked(true, 0, -100).is_zero() });
+    assert!(unsafe { Number::from_parts_unchecked(false, 0, 0).is_zero() });
+    assert!(unsafe { Number::from_parts_unchecked(false, 0, 100).is_zero() });
+    assert!(unsafe { Number::from_parts_unchecked(false, 0, -100).is_zero() });
     assert!(!Number::from(f64::NAN).is_zero());
 }
 
@@ -30,66 +30,66 @@ fn is_empty() {
 #[test]
 fn eq() {
     assert_eq!(
-        Number::from_parts(true, 500, 0),
-        Number::from_parts(true, 500, 0)
+        unsafe { Number::from_parts_unchecked(true, 500, 0) },
+        unsafe { Number::from_parts_unchecked(true, 500, 0) }
     );
 }
 
 #[test]
 fn eq_normalize_left_positive() {
     assert_eq!(
-        Number::from_parts(true, 5, 2),
-        Number::from_parts(true, 500, 0)
+        unsafe { Number::from_parts_unchecked(true, 5, 2) },
+        unsafe { Number::from_parts_unchecked(true, 500, 0) }
     );
 }
 
 #[test]
 fn eq_normalize_left_negative() {
     assert_eq!(
-        Number::from_parts(true, 5, -2),
-        Number::from_parts(true, 500, -4)
+        unsafe { Number::from_parts_unchecked(true, 5, -2) },
+        unsafe { Number::from_parts_unchecked(true, 500, -4) }
     );
 }
 
 #[test]
 fn eq_normalize_right_positive() {
     assert_eq!(
-        Number::from_parts(true, 500, 0),
-        Number::from_parts(true, 5, 2)
+        unsafe { Number::from_parts_unchecked(true, 500, 0) },
+        unsafe { Number::from_parts_unchecked(true, 5, 2) }
     );
 }
 
 #[test]
 fn eq_normalize_right_negative() {
     assert_eq!(
-        Number::from_parts(true, 500, -4),
-        Number::from_parts(true, 5, -2)
+        unsafe { Number::from_parts_unchecked(true, 500, -4) },
+        unsafe { Number::from_parts_unchecked(true, 5, -2) }
     );
 }
 
 #[test]
 fn from_small_float() {
-    assert_eq!(Number::from(0.05), Number::from_parts(true, 5, -2));
+    assert_eq!(Number::from(0.05), unsafe { Number::from_parts_unchecked(true, 5, -2) });
 }
 
 #[test]
 fn from_very_small_float() {
-    assert_eq!(Number::from(5e-50), Number::from_parts(true, 5, -50));
+    assert_eq!(Number::from(5e-50), unsafe { Number::from_parts_unchecked(true, 5, -50) });
 }
 
 #[test]
 fn from_big_float() {
-    assert_eq!(Number::from(500), Number::from_parts(true, 500, 0));
+    assert_eq!(Number::from(500), unsafe { Number::from_parts_unchecked(true, 500, 0) });
 }
 
 #[test]
 fn from_very_big_float() {
-    assert_eq!(Number::from(5e50), Number::from_parts(true, 5, 50));
+    assert_eq!(Number::from(5e50), unsafe { Number::from_parts_unchecked(true, 5, 50) });
 }
 
 #[test]
 fn into_very_small_float() {
-    let number = Number::from_parts(true, 2225073858507201136, -326);
+    let number = unsafe { Number::from_parts_unchecked(true, 2225073858507201136, -326) };
 
     assert_eq!(f64::from(number), 2.225073858507201e-308);
 }
@@ -124,5 +124,5 @@ fn as_fixed_point_i64() {
 
 #[test]
 fn convert_f64_precision() {
-    assert_eq!(Number::from_parts(true, 4750000000000001, -18), 0.004750000000000001);
+    assert_eq!(unsafe { Number::from_parts_unchecked(true, 4750000000000001, -18) }, 0.004750000000000001);
 }

tests/parse.rs

@@ -47,14 +47,14 @@ fn parse_very_long_float() {
     assert_eq!(parsed.as_f64().unwrap(), 2.225073858507201e-308);
 
     // Exhausts u64
-    assert_eq!(parsed, Number::from_parts(true, 2225073858507201136, -326));
+    assert_eq!(parsed, unsafe { Number::from_parts_unchecked(true, 2225073858507201136, -326) });
 }
 
 #[test]
 fn parse_very_long_exponent() {
     let parsed = parse("1e999999999999999999999999999999999999999999999999999999999999").unwrap();
 
-    assert_eq!(parsed, Number::from_parts(true, 1, 32767));
+    assert_eq!(parsed, unsafe { Number::from_parts_unchecked(true, 1, 32767) });
 }
 
 #[test]

tests/print_dec.rs

@@ -4,18 +4,36 @@ use json::number::Number;
 
 #[test]
 fn issue_107() {
-    let n = Number::from_parts(true, 1, -32768);
+    let n = unsafe { Number::from_parts_unchecked(true, 1, -32768) };
     assert_eq!(format!("{}", n), "1e-32768");
 }
 
 #[test]
 fn issue_108_exponent_positive() {
-    let n = Number::from_parts(true, 10_000_000_000_000_000_001, -18);
+    let n = unsafe { Number::from_parts_unchecked(true, 10_000_000_000_000_000_001, -18) };
     assert_eq!(format!("{}", n), "1.0000000000000000001e+1");
 }
 
 #[test]
 fn issue_108_exponent_0() {
-    let n = Number::from_parts(true, 10_000_000_000_000_000_001, -19);
+    let n = unsafe { Number::from_parts_unchecked(true, 10_000_000_000_000_000_001, -19) };
     assert_eq!(format!("{}", n), "1.0000000000000000001");
 }
+
+#[test]
+fn trailing_zeroes_int() {
+    let n = Number::from_parts(true, 100, -1);
+    assert_eq!(format!("{}", n), "10");
+}
+
+#[test]
+fn trailing_zeroes_fp() {
+    let n = Number::from_parts(true, 100, -3);
+    assert_eq!(format!("{}", n), "0.1");
+}
+
+#[test]
+fn trailing_zeroes_small_fp() {
+    let n = Number::from_parts(true, 100, -302);
+    assert_eq!(format!("{}", n), "1e-300");
+}