Implement FromStr for data types (#49)

* impl FromStr for types

* Add tests for FromStr impl

src/date.rs

@@ -1,4 +1,5 @@
 use std::fmt;
+use std::str::FromStr;
 
 use crate::numbers::int_parse_bytes;
 use crate::{get_digit_unchecked, DateTime, ParseError};
@@ -42,6 +43,17 @@ impl fmt::Display for Date {
     }
 }
 
+impl FromStr for Date {
+    type Err = ParseError;
+
+    #[inline]
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        // Delegate to parse_str, which is more permissive - users can call parse_str_rfc3339 directly instead if they
+        // want to be stricter
+        Self::parse_str(s)
+    }
+}
+
 // 2e10 if greater than this, the number is in ms, if less than or equal, it's in seconds
 // (in seconds this is 11th October 2603, in ms it's 20th August 1970)
 const MS_WATERSHED: i64 = 20_000_000_000;

src/datetime.rs

@@ -3,6 +3,7 @@ use crate::TimeConfigBuilder;
 use crate::{time::TimeConfig, Date, ParseError, Time};
 use std::cmp::Ordering;
 use std::fmt;
+use std::str::FromStr;
 use std::time::SystemTime;
 
 /// A DateTime
@@ -38,6 +39,17 @@ impl fmt::Display for DateTime {
     }
 }
 
+impl FromStr for DateTime {
+    type Err = ParseError;
+
+    #[inline]
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        // Delegate to parse_str, which is more permissive - users can call parse_str_rfc3339 directly instead if they
+        // want to be stricter
+        Self::parse_str(s)
+    }
+}
+
 impl PartialOrd for DateTime {
     /// Compare two datetimes by inequality.
     ///

src/duration.rs

@@ -1,5 +1,6 @@
 use std::cmp::Ordering;
 use std::fmt;
+use std::str::FromStr;
 
 use crate::{time::TimeConfig, ParseError, Time, TimeConfigBuilder};
 
@@ -94,6 +95,15 @@ impl fmt::Display for Duration {
     }
 }
 
+impl FromStr for Duration {
+    type Err = ParseError;
+
+    #[inline]
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        Self::parse_str(s)
+    }
+}
+
 impl Duration {
     fn to_hms(&self) -> (u32, u32, u32) {
         let hours = self.second / 3600;

src/time.rs

@@ -1,6 +1,7 @@
 use std::cmp::Ordering;
 use std::default::Default;
 use std::fmt;
+use std::str::FromStr;
 
 use crate::{get_digit, get_digit_unchecked, ConfigError, ParseError};
 
@@ -74,6 +75,15 @@ impl fmt::Display for Time {
     }
 }
 
+impl FromStr for Time {
+    type Err = ParseError;
+
+    #[inline]
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        Self::parse_str(s)
+    }
+}
+
 impl PartialOrd for Time {
     /// Compare two times by inequality.
     ///

tests/main.rs

@@ -1,5 +1,6 @@
 use std::fs::File;
 use std::io::Read;
+use std::str::FromStr;
 
 use chrono::{Datelike, FixedOffset as ChronoFixedOffset, NaiveDate, NaiveDateTime, Timelike, Utc as ChronoUtc};
 use strum::EnumMessage;
@@ -33,11 +34,37 @@ macro_rules! expect_ok_or_error {
     };
 }
 
+/// macro for comparing a type's `from_str` and `parse_str` methods
+macro_rules! expect_fromstr_matches_parse_str {
+    ($type:ty, $name:ident, ok, $_expected:expr, $example:expr) => {
+        paste::item! {
+            #[test]
+            fn [< expect_ $name _fromstr_matches_parse_str_ok >]() {
+                expect_fromstr_matches_parse_str!(@body $type, $example);
+            }
+        }
+    };
+    ($type:ty, $name:ident, err, $error:expr, $example:expr) => {
+        paste::item! {
+            #[test]
+            fn [< expect_ $name _fromstr_matches_parse_str_ $error:snake _error >]() {
+                expect_fromstr_matches_parse_str!(@body $type, $example);
+            }
+        }
+    };
+    (@body $type:ty, $example:expr) => {{
+        let fromstr = <$type>::from_str($example);
+        let parse_str = <$type>::parse_str($example);
+        assert_eq!(fromstr, parse_str, "fromstr: {fromstr:?}, parse_str: {parse_str:?}");
+    }};
+}
+
 /// macro to define many tests for expected values
 macro_rules! param_tests {
     ($type:ty, $($name:ident: $ok_or_err:ident => $input:literal, $expected:expr;)*) => {
         $(
             expect_ok_or_error!($type, $name, $ok_or_err, $input, $expected);
+            expect_fromstr_matches_parse_str!($type, $name, $ok_or_err, $expected, $input);
         )*
     }
 }