From 5d36195f2d8af6b9a09d4c9f291458d8ea82f2a1 Mon Sep 17 00:00:00 2001
From: Alan Du <alanhdu@gmail.com>
Date: Thu, 1 Jun 2017 23:22:35 +0100
Subject: [PATCH] Store fractional seconds as a u32 instead of a f64

Drops precision down to the nanoseconds
---
 src/datetime.rs                    | 47 +++++++++++++++---------------
 tests/parser.rs                    |  2 +-
 tests/valid/datetime-truncate.json |  2 +-
 3 files changed, 25 insertions(+), 26 deletions(-)

diff --git a/src/datetime.rs b/src/datetime.rs
index 810a4d7..83b5c0b 100644
--- a/src/datetime.rs
+++ b/src/datetime.rs
@@ -55,7 +55,7 @@ struct Time {
     hour: u8,
     minute: u8,
     second: u8,
-    secfract: f64,
+    nanosecond: u32,
 }
 
 #[derive(PartialEq, Clone)]
@@ -97,9 +97,9 @@ impl fmt::Display for Date {
 impl fmt::Display for Time {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(f, "{:02}:{:02}:{:02}", self.hour, self.minute, self.second)?;
-        if self.secfract != 0.0 {
-            let s = format!("{}", self.secfract);
-            write!(f, "{}", s.trim_left_matches("0"))?;
+        if self.nanosecond != 0 {
+            let s = format!("{:09}", self.nanosecond);
+            write!(f, ".{}", s.trim_right_matches('0'))?;
         }
         Ok(())
     }
@@ -199,41 +199,37 @@ impl FromStr for Datetime {
             let s1 = digit(&mut chars)?;
             let s2 = digit(&mut chars)?;
 
-            let secfract = if chars.clone().next() == Some('.') {
+            let mut nanosecond = 0;
+            if chars.clone().next() == Some('.') {
                 chars.next();
-                let mut first = true;
                 let whole = chars.as_str();
+
                 let mut end = whole.len();
-                for (i, c) in whole.char_indices() {
-                    match c {
-                        '0' ... '9' => {}
+                for (i, byte) in whole.bytes().enumerate() {
+                    match byte {
+                        b'0' ... b'9' => {
+                            if i < 9 {
+                                let p = 10_u32.pow(8 - i as u32);
+                                nanosecond += p * (byte - b'0') as u32;
+                            }
+                        }
                         _ => {
                             end = i;
-                            break
+                            break;
                         }
                     }
-                    first = false;
                 }
-                if first {
+                if end == 0 {
                     return Err(DatetimeParseError { _private: () })
                 }
                 chars = whole[end..].chars();
-
-                // truncate to picoseconds precision
-                let last = if end > 12 { 12 } else { end };
-                match format!("0.{}", &whole[..last]).parse() {
-                    Ok(f) => f,
-                    Err(_) => return Err(DatetimeParseError { _private: () }),
-                }
-            } else {
-                0.0
-            };
+            }
 
             let time = Time {
                 hour: h1 * 10 + h2,
                 minute: m1 * 10 + m2,
                 second: s1 * 10 + s2,
-                secfract: secfract,
+                nanosecond: nanosecond,
             };
 
             if time.hour > 24 {
@@ -242,7 +238,10 @@ impl FromStr for Datetime {
             if time.minute > 59 {
                 return Err(DatetimeParseError { _private: () })
             }
-            if time.second > 60 {
+            if time.second > 59 {
+                return Err(DatetimeParseError { _private: () })
+            }
+            if time.nanosecond > 999_999_999 {
                 return Err(DatetimeParseError { _private: () })
             }
 
diff --git a/tests/parser.rs b/tests/parser.rs
index 2db2cfb..2282416 100644
--- a/tests/parser.rs
+++ b/tests/parser.rs
@@ -463,7 +463,7 @@ fn datetimes() {
     t!("2016-09-09T09:09:09Z");
     t!("2016-09-09T09:09:09.1Z");
     t!("2016-09-09T09:09:09.2+10:00");
-    t!("2016-09-09T09:09:09.0123456789-02:00");
+    t!("2016-09-09T09:09:09.123456789-02:00");
     bad!("foo = 2016-09-09T09:09:09.Z", "failed to parse date");
     bad!("foo = 2016-9-09T09:09:09Z", "failed to parse date");
     bad!("foo = 2016-09-09T09:09:09+2:00", "failed to parse date");
diff --git a/tests/valid/datetime-truncate.json b/tests/valid/datetime-truncate.json
index 34a432f..8c512e1 100644
--- a/tests/valid/datetime-truncate.json
+++ b/tests/valid/datetime-truncate.json
@@ -1,6 +1,6 @@
 {
     "bestdayever": {
         "type": "datetime",
-        "value": "1987-07-05T17:45:00.123456789012Z"
+        "value": "1987-07-05T17:45:00.123456789Z"
     }
 }