Bump edition to 2021 and introduce rustfmt

3 files changed, 285 insertions, 296 deletions

diff --git a/src/parser/iterator.rs b/src/parser/iterator.rs
index 21bf8d5..06ecc2b 100644
--- a/src/parser/iterator.rs
+++ b/src/parser/iterator.rs
@@ -2,26 +2,29 @@ use nom::branch::alt;
 use nom::bytes::complete::tag;
 use nom::character::complete::{multispace0, multispace1};
 use nom::combinator::{complete, map, opt};
-use nom::IResult;
 use nom::sequence::tuple;
+use nom::IResult;
 
-use error::Result;
-use error::Error;
-use parser::timetype::*;
-use timetype::IntoTimeType;
-use timetype;
-use iter;
+use crate::error::Error;
+use crate::error::Result;
+use crate::iter;
+use crate::timetype;
+use crate::timetype::IntoTimeType;
+
+use super::timetype::*;
 
 pub fn iter_spec(i: &[u8]) -> IResult<&[u8], Iterspec> {
     complete(alt((
         map(tag("secondly"), |_| Iterspec::Secondly),
         map(tag("minutely"), |_| Iterspec::Minutely),
-        map(tag("hourly"),   |_| Iterspec::Hourly),
-        map(tag("daily"),    |_| Iterspec::Daily),
-        map(tag("weekly"),   |_| Iterspec::Weekly),
-        map(tag("monthly"),  |_| Iterspec::Monthly),
-        map(tag("yearly"),   |_| Iterspec::Yearly),
-        map(tuple((tag("every"), integer, unit_parser)), |(_, number, unit)| Iterspec::Every(number, unit))
+        map(tag("hourly"), |_| Iterspec::Hourly),
+        map(tag("daily"), |_| Iterspec::Daily),
+        map(tag("weekly"), |_| Iterspec::Weekly),
+        map(tag("monthly"), |_| Iterspec::Monthly),
+        map(tag("yearly"), |_| Iterspec::Yearly),
+        map(tuple((tag("every"), integer, unit_parser)), |(_, number, unit)| {
+            Iterspec::Every(number, unit)
+        }),
     )))(i)
 }
 
@@ -41,25 +44,31 @@ pub fn until_spec(i: &[u8]) -> IResult<&[u8], UntilSpec> {
     complete(alt((
         map(
             tuple((tag("until"), multispace1, exact_date_parser)),
-            |(_, _, exact)| UntilSpec::Exact(exact)
+            |(_, _, exact)| UntilSpec::Exact(exact),
         ),
-        map(
-            tuple((integer, multispace1, tag("times"))),
-            |(num, _, _)| UntilSpec::Times(num)
-        )
+        map(tuple((integer, multispace1, tag("times"))), |(num, _, _)| {
+            UntilSpec::Times(num)
+        }),
     )))(i)
 }
 
 #[derive(Debug, PartialEq, Eq)]
 pub enum UntilSpec {
     Exact(ExactDate),
-    Times(i64)
+    Times(i64),
 }
 
 pub fn iterator(i: &[u8]) -> IResult<&[u8], Iterator> {
     map(
-        tuple((multispace0, date, multispace0, iter_spec, multispace0, opt(complete(until_spec)))),
-        |(_, d, _, spec, _, until)| { Iterator(d, spec, until) },
+        tuple((
+            multispace0,
+            date,
+            multispace0,
+            iter_spec,
+            multispace0,
+            opt(complete(until_spec)),
+        )),
+        |(_, d, _, spec, _, until)| Iterator(d, spec, until),
     )(i)
 }
 
@@ -74,37 +83,38 @@ impl Iterator {
         let unit_to_amount = |i, unit| match unit {
             Unit::Second => timetype::TimeType::seconds(i),
             Unit::Minute => timetype::TimeType::minutes(i),
-            Unit::Hour   => timetype::TimeType::hours(i),
-            Unit::Day    => timetype::TimeType::days(i),
-            Unit::Week   => timetype::TimeType::weeks(i),
-            Unit::Month  => timetype::TimeType::months(i),
-            Unit::Year   => timetype::TimeType::years(i),
+            Unit::Hour => timetype::TimeType::hours(i),
+            Unit::Day => timetype::TimeType::days(i),
+            Unit::Week => timetype::TimeType::weeks(i),
+            Unit::Month => timetype::TimeType::months(i),
+            Unit::Year => timetype::TimeType::years(i),
         };
 
         let recur = match self.1 {
             Iterspec::Every(i, unit) => unit_to_amount(i, unit),
             Iterspec::Secondly => unit_to_amount(1, Unit::Second),
             Iterspec::Minutely => unit_to_amount(1, Unit::Minute),
-            Iterspec::Hourly   => unit_to_amount(1, Unit::Hour),
-            Iterspec::Daily    => unit_to_amount(1, Unit::Day),
-            Iterspec::Weekly   => unit_to_amount(1, Unit::Week),
-            Iterspec::Monthly  => unit_to_amount(1, Unit::Month),
-            Iterspec::Yearly   => unit_to_amount(1, Unit::Year),
+            Iterspec::Hourly => unit_to_amount(1, Unit::Hour),
+            Iterspec::Daily => unit_to_amount(1, Unit::Day),
+            Iterspec::Weekly => unit_to_amount(1, Unit::Week),
+            Iterspec::Monthly => unit_to_amount(1, Unit::Month),
+            Iterspec::Yearly => unit_to_amount(1, Unit::Year),
         };
 
-        let into_ndt = |e: timetype::TimeType| e.calculate()?
-            .get_moment()
-            .ok_or(Error::NotADateInsideIterator)
-            .map_err(Error::from)
-            .map(Clone::clone);
+        let into_ndt = |e: timetype::TimeType| {
+            e.calculate()?
+                .get_moment()
+                .ok_or(Error::NotADateInsideIterator)
+                .map_err(Error::from)
+                .map(Clone::clone)
+        };
 
         match self.2 {
             Some(UntilSpec::Exact(e)) => {
                 let base = into_ndt(self.0.into_timetype()?)?;
-                let e    = into_ndt(e.into_timetype()?)?;
+                let e = into_ndt(e.into_timetype()?)?;
 
-                iter::Iter::build(base, recur)
-                    .map(|it| UserIterator::UntilIterator(it.until(e)))
+                iter::Iter::build(base, recur).map(|it| UserIterator::UntilIterator(it.until(e)))
             },
 
             Some(UntilSpec::Times(i)) => {
@@ -116,8 +126,7 @@ impl Iterator {
 
             None => {
                 let base = into_ndt(self.0.into_timetype()?)?;
-                iter::Iter::build(base, recur)
-                    .map(UserIterator::Iterator)
+                iter::Iter::build(base, recur).map(UserIterator::Iterator)
             },
         }
     }
@@ -126,35 +135,37 @@ impl Iterator {
 // names are hard
 #[derive(Debug)]
 pub enum UserIterator<I>
-    where I: ::std::iter::Iterator<Item = Result<timetype::TimeType>>
+where
+    I: std::iter::Iterator<Item = Result<timetype::TimeType>>,
 {
     Iterator(iter::Iter),
     TimesIter(iter::TimesIter<I>),
-    UntilIterator(iter::UntilIter<I>)
+    UntilIterator(iter::UntilIter<I>),
 }
 
-impl<I> ::std::iter::Iterator for UserIterator<I>
-    where I: ::std::iter::Iterator<Item = Result<timetype::TimeType>>
+impl<I> std::iter::Iterator for UserIterator<I>
+where
+    I: std::iter::Iterator<Item = Result<timetype::TimeType>>,
 {
     type Item = Result<timetype::TimeType>;
 
     fn next(&mut self) -> Option<Self::Item> {
         match *self {
-            UserIterator::Iterator(ref mut i)      => i.next(),
-            UserIterator::TimesIter(ref mut i)     => i.next(),
+            UserIterator::Iterator(ref mut i) => i.next(),
+            UserIterator::TimesIter(ref mut i) => i.next(),
             UserIterator::UntilIterator(ref mut i) => i.next(),
         }
     }
 }
 
-
 #[cfg(test)]
 mod tests {
     use std::iter::Iterator;
-    use super::*;
 
-    use chrono::Timelike;
     use chrono::Datelike;
+    use chrono::Timelike;
+
+    use super::*;
 
     #[test]
     fn test_iterspec() {
@@ -165,7 +176,10 @@ mod tests {
         assert_eq!(iter_spec(&b"weekly"[..]), Ok((&b""[..], Iterspec::Weekly)));
         assert_eq!(iter_spec(&b"monthly"[..]), Ok((&b""[..], Iterspec::Monthly)));
         assert_eq!(iter_spec(&b"yearly"[..]), Ok((&b""[..], Iterspec::Yearly)));
-        assert_eq!(iter_spec(&b"every 5min"[..]), Ok((&b""[..], Iterspec::Every(5, Unit::Minute))));
+        assert_eq!(
+            iter_spec(&b"every 5min"[..]),
+            Ok((&b""[..], Iterspec::Every(5, Unit::Minute)))
+        );
     }
 
     #[test]
@@ -175,18 +189,19 @@ mod tests {
         let (_, i) = res.unwrap();
         println!("{:#?}", i);
 
-        let ui : Result<UserIterator<iter::Iter>> = i.into_user_iterator();
+        let ui: Result<UserIterator<iter::Iter>> = i.into_user_iterator();
         assert!(ui.is_ok(), "Not okay: {:#?}", ui);
         let mut ui = ui.unwrap();
 
-        for hour in 0..10 { // 10 is randomly chosen (fair dice roll... )
+        for hour in 0..10 {
+            // 10 is randomly chosen (fair dice roll... )
             let n = ui.next().unwrap();
             assert!(n.is_ok(), "Not ok: {:#?}", n);
             let tt = n.unwrap();
-            assert_eq!(tt.get_moment().unwrap().year()  , 2017);
-            assert_eq!(tt.get_moment().unwrap().month() , 1);
-            assert_eq!(tt.get_moment().unwrap().day()   , 1);
-            assert_eq!(tt.get_moment().unwrap().hour()  , hour);
+            assert_eq!(tt.get_moment().unwrap().year(), 2017);
+            assert_eq!(tt.get_moment().unwrap().month(), 1);
+            assert_eq!(tt.get_moment().unwrap().day(), 1);
+            assert_eq!(tt.get_moment().unwrap().hour(), hour);
             assert_eq!(tt.get_moment().unwrap().minute(), 0);
             assert_eq!(tt.get_moment().unwrap().second(), 0);
         }
@@ -199,7 +214,7 @@ mod tests {
         let (_, i) = res.unwrap();
         println!("{:#?}", i);
 
-        let ui : Result<UserIterator<iter::Iter>> = i.into_user_iterator();
+        let ui: Result<UserIterator<iter::Iter>> = i.into_user_iterator();
         assert!(ui.is_ok(), "Not okay: {:#?}", ui);
         let mut ui = ui.unwrap();
 
@@ -207,10 +222,10 @@ mod tests {
             let n = ui.next().unwrap();
             assert!(n.is_ok(), "Not ok: {:#?}", n);
             let tt = n.unwrap();
-            assert_eq!(tt.get_moment().unwrap().year()  , 2017);
-            assert_eq!(tt.get_moment().unwrap().month() , 1);
-            assert_eq!(tt.get_moment().unwrap().day()   , 1);
-            assert_eq!(tt.get_moment().unwrap().hour()  , 0);
+            assert_eq!(tt.get_moment().unwrap().year(), 2017);
+            assert_eq!(tt.get_moment().unwrap().month(), 1);
+            assert_eq!(tt.get_moment().unwrap().day(), 1);
+            assert_eq!(tt.get_moment().unwrap().hour(), 0);
             assert_eq!(tt.get_moment().unwrap().minute(), min);
             assert_eq!(tt.get_moment().unwrap().second(), 0);
         }
@@ -223,7 +238,7 @@ mod tests {
         let (_, i) = res.unwrap();
         println!("{:#?}", i);
 
-        let ui : Result<UserIterator<iter::Iter>> = i.into_user_iterator();
+        let ui: Result<UserIterator<iter::Iter>> = i.into_user_iterator();
         assert!(ui.is_ok(), "Not okay: {:#?}", ui);
         let mut ui = ui.unwrap();
 
@@ -231,10 +246,10 @@ mod tests {
             let n = ui.next().unwrap();
             assert!(n.is_ok(), "Not ok: {:#?}", n);
             let tt = n.unwrap();
-            assert_eq!(tt.get_moment().unwrap().year()  , 2017);
-            assert_eq!(tt.get_moment().unwrap().month() , 1);
-            assert_eq!(tt.get_moment().unwrap().day()   , day);
-            assert_eq!(tt.get_moment().unwrap().hour()  , 0);
+            assert_eq!(tt.get_moment().unwrap().year(), 2017);
+            assert_eq!(tt.get_moment().unwrap().month(), 1);
+            assert_eq!(tt.get_moment().unwrap().day(), day);
+            assert_eq!(tt.get_moment().unwrap().hour(), 0);
             assert_eq!(tt.get_moment().unwrap().minute(), 0);
             assert_eq!(tt.get_moment().unwrap().second(), 0);
         }
@@ -247,7 +262,7 @@ mod tests {
         let (_, i) = res.unwrap();
         println!("{:#?}", i);
 
-        let ui : Result<UserIterator<iter::Iter>> = i.into_user_iterator();
+        let ui: Result<UserIterator<iter::Iter>> = i.into_user_iterator();
         assert!(ui.is_ok(), "Not okay: {:#?}", ui);
         let mut ui = ui.unwrap();
 
@@ -255,10 +270,10 @@ mod tests {
             let n = ui.next().unwrap();
             assert!(n.is_ok(), "Not ok: {:#?}", n);
             let tt = n.unwrap();
-            assert_eq!(tt.get_moment().unwrap().year()  , 2017);
-            assert_eq!(tt.get_moment().unwrap().month() , 1);
-            assert_eq!(tt.get_moment().unwrap().day()   , 1 + (week * 7));
-            assert_eq!(tt.get_moment().unwrap().hour()  , 0);
+            assert_eq!(tt.get_moment().unwrap().year(), 2017);
+            assert_eq!(tt.get_moment().unwrap().month(), 1);
+            assert_eq!(tt.get_moment().unwrap().day(), 1 + (week * 7));
+            assert_eq!(tt.get_moment().unwrap().hour(), 0);
             assert_eq!(tt.get_moment().unwrap().minute(), 0);
             assert_eq!(tt.get_moment().unwrap().second(), 0);
         }
@@ -279,12 +294,13 @@ mod tests {
         let (_, i) = res.unwrap();
         println!("{:#?}", i);
 
-        let ui : Result<UserIterator<iter::Iter>> = i.into_user_iterator();
+        let ui: Result<UserIterator<iter::Iter>> = i.into_user_iterator();
         assert!(ui.is_ok(), "Not okay: {:#?}", ui);
         let mut ui = ui.unwrap();
         println!("Okay: {:#?}", ui);
 
-        for hour in 0..10 { // 10 is randomly chosen (fair dice roll... )
+        for hour in 0..10 {
+            // 10 is randomly chosen (fair dice roll... )
             if hour > 4 {
                 let n = ui.next();
                 assert!(n.is_none(), "Is Some, should be None: {:?}", n);
@@ -293,10 +309,10 @@ mod tests {
                 let n = ui.next().unwrap();
                 assert!(n.is_ok(), "Not ok: {:#?}", n);
                 let tt = n.unwrap();
-                assert_eq!(tt.get_moment().unwrap().year()  , 2017);
-                assert_eq!(tt.get_moment().unwrap().month() , 1);
-                assert_eq!(tt.get_moment().unwrap().day()   , 1);
-                assert_eq!(tt.get_moment().unwrap().hour()  , hour);
+                assert_eq!(tt.get_moment().unwrap().year(), 2017);
+                assert_eq!(tt.get_moment().unwrap().month(), 1);
+                assert_eq!(tt.get_moment().unwrap().day(), 1);
+                assert_eq!(tt.get_moment().unwrap().hour(), hour);
                 assert_eq!(tt.get_moment().unwrap().minute(), 0);
                 assert_eq!(tt.get_moment().unwrap().second(), 0);
             }
@@ -310,7 +326,7 @@ mod tests {
         let (_, i) = res.unwrap();
         println!("{:#?}", i);
 
-        let ui : Result<UserIterator<iter::Iter>> = i.into_user_iterator();
+        let ui: Result<UserIterator<iter::Iter>> = i.into_user_iterator();
         assert!(ui.is_ok(), "Not okay: {:#?}", ui);
         let mut ui = ui.unwrap();
 
@@ -323,10 +339,10 @@ mod tests {
                 let n = ui.next().unwrap();
                 assert!(n.is_ok(), "Not ok: {:#?}", n);
                 let tt = n.unwrap();
-                assert_eq!(tt.get_moment().unwrap().year()  , 2017);
-                assert_eq!(tt.get_moment().unwrap().month() , 1);
-                assert_eq!(tt.get_moment().unwrap().day()   , 1);
-                assert_eq!(tt.get_moment().unwrap().hour()  , 0);
+                assert_eq!(tt.get_moment().unwrap().year(), 2017);
+                assert_eq!(tt.get_moment().unwrap().month(), 1);
+                assert_eq!(tt.get_moment().unwrap().day(), 1);
+                assert_eq!(tt.get_moment().unwrap().hour(), 0);
                 assert_eq!(tt.get_moment().unwrap().minute(), min);
                 assert_eq!(tt.get_moment().unwrap().second(), 0);
             }
@@ -340,7 +356,7 @@ mod tests {
         let (_, i) = res.unwrap();
         println!("{:#?}", i);
 
-        let ui : Result<UserIterator<iter::Iter>> = i.into_user_iterator();
+        let ui: Result<UserIterator<iter::Iter>> = i.into_user_iterator();
         assert!(ui.is_ok(), "Not okay: {:#?}", ui);
         let mut ui = ui.unwrap();
 
@@ -353,10 +369,10 @@ mod tests {
                 let n = ui.next().unwrap();
                 assert!(n.is_ok(), "Not ok: {:#?}", n);
                 let tt = n.unwrap();
-                assert_eq!(tt.get_moment().unwrap().year()  , 2017);
-                assert_eq!(tt.get_moment().unwrap().month() , 1);
-                assert_eq!(tt.get_moment().unwrap().day()   , day);
-                assert_eq!(tt.get_moment().unwrap().hour()  , 0);
+                assert_eq!(tt.get_moment().unwrap().year(), 2017);
+                assert_eq!(tt.get_moment().unwrap().month(), 1);
+                assert_eq!(tt.get_moment().unwrap().day(), day);
+                assert_eq!(tt.get_moment().unwrap().hour(), 0);
                 assert_eq!(tt.get_moment().unwrap().minute(), 0);
                 assert_eq!(tt.get_moment().unwrap().second(), 0);
             }
@@ -370,7 +386,7 @@ mod tests {
         let (_, i) = res.unwrap();
         println!("{:#?}", i);
 
-        let ui : Result<UserIterator<iter::Iter>> = i.into_user_iterator();
+        let ui: Result<UserIterator<iter::Iter>> = i.into_user_iterator();
         assert!(ui.is_ok(), "Not okay: {:#?}", ui);
         let mut ui = ui.unwrap();
 
@@ -383,14 +399,13 @@ mod tests {
                 let n = ui.next().unwrap();
                 assert!(n.is_ok(), "Not ok: {:#?}", n);
                 let tt = n.unwrap();
-                assert_eq!(tt.get_moment().unwrap().year()  , 2017);
-                assert_eq!(tt.get_moment().unwrap().month() , 1);
-                assert_eq!(tt.get_moment().unwrap().day()   , 1 + (week * 7));
-                assert_eq!(tt.get_moment().unwrap().hour()  , 0);
+                assert_eq!(tt.get_moment().unwrap().year(), 2017);
+                assert_eq!(tt.get_moment().unwrap().month(), 1);
+                assert_eq!(tt.get_moment().unwrap().day(), 1 + (week * 7));
+                assert_eq!(tt.get_moment().unwrap().hour(), 0);
                 assert_eq!(tt.get_moment().unwrap().minute(), 0);
                 assert_eq!(tt.get_moment().unwrap().second(), 0);
             }
         }
     }
 }
-
diff --git a/src/parser/mod.rs b/src/parser/mod.rs
index 8d326ec..7ab2af4 100644
--- a/src/parser/mod.rs
+++ b/src/parser/mod.rs
@@ -47,24 +47,25 @@ use nom::branch::alt;
 use nom::combinator::{complete, map};
 use nom::IResult;
 
-mod timetype;
-mod iterator;
+use iterator::iterator;
+use timetype::timetype;
+
+use crate::error::Error;
+use crate::error::Result;
+use crate::iter::Iter;
+use crate::timetype::IntoTimeType;
 
-use error::Result;
-use error::Error;
-use iter::Iter;
-use timetype::IntoTimeType;
-use parser::timetype::{timetype};
-use parser::iterator::{iterator};
+mod iterator;
+mod timetype;
 
 pub enum Parsed {
     Iterator(Result<iterator::UserIterator<Iter>>),
-    TimeType(::timetype::TimeType)
+    TimeType(crate::timetype::TimeType),
 }
 
 fn do_parse(input: &[u8]) -> IResult<&[u8], Result<Parsed>> {
     complete(alt((
-        map(iterator, |it| (Ok(Parsed::Iterator(it.into_user_iterator())))),
+        map(iterator, |it| Ok(Parsed::Iterator(it.into_user_iterator()))),
         map(timetype, |tt| tt.into_timetype().map(Parsed::TimeType)),
     )))(input)
 }
@@ -77,4 +78,3 @@ pub fn parse(s: &str) -> Result<Parsed> {
         Err(nom::Err::Incomplete(_)) => Err(Error::UnknownParserError),
     }
 }
-
diff --git a/src/parser/timetype.rs b/src/parser/timetype.rs
index b957434..904fcc9 100644
--- a/src/parser/timetype.rs
+++ b/src/parser/timetype.rs
@@ -6,63 +6,35 @@ use nom::branch::alt;
 use nom::bytes::complete::tag;
 use nom::character::complete::{digit1, multispace0, multispace1};
 use nom::combinator::{complete, map, map_opt, opt};
-use nom::IResult;
 use nom::sequence::{delimited, tuple};
+use nom::IResult;
 
-use error::Error;
-use error::Result;
-use timetype;
-use timetype::IntoTimeType;
+use crate::error::Error;
+use crate::error::Result;
+use crate::timetype::IntoTimeType;
 
 pub fn integer(input: &[u8]) -> IResult<&[u8], i64> {
-    map_opt(
-        delimited(multispace0, digit1, multispace0),
-        |digit| str::from_utf8(digit).ok().and_then(|s| s.parse().ok()),
-    )(input)
+    map_opt(delimited(multispace0, digit1, multispace0), |digit| {
+        str::from_utf8(digit).ok().and_then(|s| s.parse().ok())
+    })(input)
 }
 
 // WARNING: Order is important here. Long tags first, shorter tags later
 pub fn unit_parser(input: &[u8]) -> IResult<&[u8], Unit> {
     complete(alt((
-        map(alt((
-            tag("seconds"),
-            tag("second"),
-            tag("secs"),
-            tag("sec"),
-            tag("s"), )
-        ), |_| Unit::Second),
-        map(alt((
-            tag("minutes"),
-            tag("minute"),
-            tag("mins"),
-            tag("min"),
-        )), |_| Unit::Minute),
-        map(alt((
-            tag("hours"),
-            tag("hour"),
-            tag("hrs"),
-            tag("hr"),
-        )), |_| Unit::Hour),
-        map(alt((
-            tag("days"),
-            tag("day"),
-            tag("d"),
-        )), |_| Unit::Day),
-        map(alt((
-            tag("weeks"),
-            tag("week"),
-            tag("w"),
-        )), |_| Unit::Week),
-        map(alt((
-            tag("months"),
-            tag("month"),
-        )), |_| Unit::Month),
-        map(alt((
-            tag("years"),
-            tag("year"),
-            tag("yrs"),
-        )), |_| Unit::Year),
-    ))(input)
+        map(
+            alt((tag("seconds"), tag("second"), tag("secs"), tag("sec"), tag("s"))),
+            |_| Unit::Second,
+        ),
+        map(alt((tag("minutes"), tag("minute"), tag("mins"), tag("min"))), |_| {
+            Unit::Minute
+        }),
+        map(alt((tag("hours"), tag("hour"), tag("hrs"), tag("hr"))), |_| Unit::Hour),
+        map(alt((tag("days"), tag("day"), tag("d"))), |_| Unit::Day),
+        map(alt((tag("weeks"), tag("week"), tag("w"))), |_| Unit::Week),
+        map(alt((tag("months"), tag("month"))), |_| Unit::Month),
+        map(alt((tag("years"), tag("year"), tag("yrs"))), |_| Unit::Year),
+    )))(input)
 }
 
 #[derive(Debug, PartialEq, Eq)]
@@ -92,20 +64,17 @@ impl From<UnitAlias> for Unit {
         match val {
             UnitAlias::Secondly => Unit::Second,
             UnitAlias::Minutely => Unit::Minute,
-            UnitAlias::Hourly   => Unit::Hour,
-            UnitAlias::Daily    => Unit::Day,
-            UnitAlias::Weekly   => Unit::Week,
-            UnitAlias::Monthly  => Unit::Month,
-            UnitAlias::Yearly   => Unit::Year,
+            UnitAlias::Hourly => Unit::Hour,
+            UnitAlias::Daily => Unit::Day,
+            UnitAlias::Weekly => Unit::Week,
+            UnitAlias::Monthly => Unit::Month,
+            UnitAlias::Yearly => Unit::Year,
         }
     }
 }
 
 pub fn operator_parser(input: &[u8]) -> IResult<&[u8], Operator> {
-    alt((
-        map(tag("+"), |_| Operator::Plus),
-        map(tag("-"), |_| Operator::Minus),
-    ))(input)
+    alt((map(tag("+"), |_| Operator::Plus), map(tag("-"), |_| Operator::Minus)))(input)
 }
 
 #[derive(Debug, PartialEq, Eq)]
@@ -137,30 +106,30 @@ pub fn amount_parser(input: &[u8]) -> IResult<&[u8], Amount> {
 pub struct Amount(i64, Unit);
 
 impl IntoTimeType for Amount {
-    fn into_timetype(self) -> Result<timetype::TimeType> {
+    fn into_timetype(self) -> Result<crate::timetype::TimeType> {
         Ok(match self.1 {
-            Unit::Second => timetype::TimeType::seconds(self.0),
-            Unit::Minute => timetype::TimeType::minutes(self.0),
-            Unit::Hour   => timetype::TimeType::hours(self.0),
-            Unit::Day    => timetype::TimeType::days(self.0),
-            Unit::Week   => timetype::TimeType::weeks(self.0),
-            Unit::Month  => timetype::TimeType::months(self.0),
-            Unit::Year   => timetype::TimeType::years(self.0),
+            Unit::Second => crate::timetype::TimeType::seconds(self.0),
+            Unit::Minute => crate::timetype::TimeType::minutes(self.0),
+            Unit::Hour => crate::timetype::TimeType::hours(self.0),
+            Unit::Day => crate::timetype::TimeType::days(self.0),
+            Unit::Week => crate::timetype::TimeType::weeks(self.0),
+            Unit::Month => crate::timetype::TimeType::months(self.0),
+            Unit::Year => crate::timetype::TimeType::years(self.0),
         })
     }
 }
 
 pub fn amount_expr_next(input: &[u8]) -> IResult<&[u8], (Operator, Box<AmountExpr>)> {
-    map(
-        tuple((operator_parser, multispace0, amount_expr)),
-        |(op, _, amexp)| (op, Box::new(amexp)),
-    )(input)
+    map(tuple((operator_parser, multispace0, amount_expr)), |(op, _, amexp)| {
+        (op, Box::new(amexp))
+    })(input)
 }
 
 pub fn amount_expr(input: &[u8]) -> IResult<&[u8], AmountExpr> {
-    map(tuple((
-        amount_parser, multispace0, opt(complete(amount_expr_next)),
-    )), |(amount, _, next)| AmountExpr { amount, next })(input)
+    map(
+        tuple((amount_parser, multispace0, opt(complete(amount_expr_next)))),
+        |(amount, _, next)| AmountExpr { amount, next },
+    )(input)
 }
 
 #[derive(Debug, PartialEq, Eq)]
@@ -170,7 +139,7 @@ pub struct AmountExpr {
 }
 
 impl IntoTimeType for AmountExpr {
-    fn into_timetype(self) -> Result<timetype::TimeType> {
+    fn into_timetype(self) -> Result<crate::timetype::TimeType> {
         let mut amount = self.amount.into_timetype()?;
 
         if let Some((op, other_amonut_expr)) = self.next {
@@ -202,38 +171,34 @@ pub enum ExactDate {
     Yesterday,
     Tomorrow,
     Iso8601Date(iso8601::Date),
-    Iso8601DateTime(iso8601::DateTime)
+    Iso8601DateTime(iso8601::DateTime),
 }
 
 impl IntoTimeType for ExactDate {
-    fn into_timetype(self) -> Result<timetype::TimeType> {
+    fn into_timetype(self) -> Result<crate::timetype::TimeType> {
         match self {
-            ExactDate::Today     => Ok(timetype::TimeType::today()),
-            ExactDate::Yesterday => Ok(timetype::TimeType::today() - timetype::TimeType::days(1)),
-            ExactDate::Tomorrow  => Ok(timetype::TimeType::today() + timetype::TimeType::days(1)),
-            ExactDate::Iso8601Date(date) => {
-                match date {
-                    iso8601::Date::YMD { year, month, day } => NaiveDate::from_ymd_opt(year, month, day)
-                        .and_then(|ndt| ndt.and_hms_opt(0, 0, 0))
-                        .ok_or(Error::OutOfBounds(year, month, day, 0, 0, 0))
-                        .map(timetype::TimeType::moment),
-
-                    iso8601::Date::Week { year, ww, d } => NaiveDate::from_ymd_opt(year, 1, 1)
-                        .and_then(|ndt| ndt.and_hms_opt(0, 0, 0))
-                        .ok_or(Error::OutOfBounds(year, 1, 1, 0,  0, 0))
-                        .map(timetype::TimeType::moment)
-                        .map(|m| {
-                            m
-                            + timetype::TimeType::weeks(ww as i64)
-                            + timetype::TimeType::days(d as i64)
-                        }),
-
-                    iso8601::Date::Ordinal { year, ddd } => NaiveDate::from_ymd_opt(year, 1, 1)
-                        .and_then(|ndt| ndt.and_hms_opt(0, 0, 0))
-                        .ok_or(Error::OutOfBounds(year, 1, 1, 0, 0, 0))
-                        .map(timetype::TimeType::moment)
-                        .map(|m| m + timetype::TimeType::days(ddd as i64)),
-                }
+            ExactDate::Today => Ok(crate::timetype::TimeType::today()),
+            ExactDate::Yesterday => Ok(crate::timetype::TimeType::today() - crate::timetype::TimeType::days(1)),
+            ExactDate::Tomorrow => Ok(crate::timetype::TimeType::today() + crate::timetype::TimeType::days(1)),
+            ExactDate::Iso8601Date(date) => match date {
+                iso8601::Date::YMD { year, month, day } => NaiveDate::from_ymd_opt(year, month, day)
+                    .and_then(|ndt| ndt.and_hms_opt(0, 0, 0))
+                    .ok_or(Error::OutOfBounds(year, month, day, 0, 0, 0))
+                    .map(crate::timetype::TimeType::moment),
+
+                iso8601::Date::Week { year, ww, d } => NaiveDate::from_ymd_opt(year, 1, 1)
+                    .and_then(|ndt| ndt.and_hms_opt(0, 0, 0))
+                    .ok_or(Error::OutOfBounds(year, 1, 1, 0, 0, 0))
+                    .map(crate::timetype::TimeType::moment)
+                    .map(|m| {
+                        m + crate::timetype::TimeType::weeks(ww as i64) + crate::timetype::TimeType::days(d as i64)
+                    }),
+
+                iso8601::Date::Ordinal { year, ddd } => NaiveDate::from_ymd_opt(year, 1, 1)
+                    .and_then(|ndt| ndt.and_hms_opt(0, 0, 0))
+                    .ok_or(Error::OutOfBounds(year, 1, 1, 0, 0, 0))
+                    .map(crate::timetype::TimeType::moment)
+                    .map(|m| m + crate::timetype::TimeType::days(ddd as i64)),
             },
             ExactDate::Iso8601DateTime(iso8601::DateTime { date, time }) => {
                 let (hour, minute, second) = (time.hour, time.minute, time.second);
@@ -242,31 +207,29 @@ impl IntoTimeType for ExactDate {
                     iso8601::Date::YMD { year, month, day } => NaiveDate::from_ymd_opt(year, month, day)
                         .and_then(|ndt| ndt.and_hms_opt(hour, minute, second))
                         .ok_or(Error::OutOfBounds(year, month, day, hour, minute, second))
-                        .map(timetype::TimeType::moment),
+                        .map(crate::timetype::TimeType::moment),
 
                     iso8601::Date::Week { year, ww, d } => NaiveDate::from_ymd_opt(year, 1, 1)
                         .and_then(|ndt| ndt.and_hms_opt(0, 0, 0))
                         .ok_or(Error::OutOfBounds(year, 1, 1, 0, 0, 0))
-                        .map(timetype::TimeType::moment)
+                        .map(crate::timetype::TimeType::moment)
                         .map(|m| {
-                            m
-                            + timetype::TimeType::weeks(ww as i64)
-                            + timetype::TimeType::days(d as i64)
-                            + timetype::TimeType::hours(hour as i64)
-                            + timetype::TimeType::minutes(minute as i64)
-                            + timetype::TimeType::seconds(second as i64)
+                            m + crate::timetype::TimeType::weeks(ww as i64)
+                                + crate::timetype::TimeType::days(d as i64)
+                                + crate::timetype::TimeType::hours(hour as i64)
+                                + crate::timetype::TimeType::minutes(minute as i64)
+                                + crate::timetype::TimeType::seconds(second as i64)
                         }),
 
                     iso8601::Date::Ordinal { year, ddd } => NaiveDate::from_ymd_opt(year, 1, 1)
                         .and_then(|ndt| ndt.and_hms_opt(0, 0, 0))
                         .ok_or(Error::OutOfBounds(year, 1, 1, 0, 0, 0))
-                        .map(timetype::TimeType::moment)
+                        .map(crate::timetype::TimeType::moment)
                         .map(|m| {
-                            m
-                            + timetype::TimeType::days(ddd as i64)
-                            + timetype::TimeType::hours(hour as i64)
-                            + timetype::TimeType::minutes(minute as i64)
-                            + timetype::TimeType::seconds(second as i64)
+                            m + crate::timetype::TimeType::days(ddd as i64)
+                                + crate::timetype::TimeType::hours(hour as i64)
+                                + crate::timetype::TimeType::minutes(minute as i64)
+                                + crate::timetype::TimeType::seconds(second as i64)
                         }),
                 }
             },
@@ -276,8 +239,12 @@ impl IntoTimeType for ExactDate {
 
 pub fn date(input: &[u8]) -> IResult<&[u8], Date> {
     map(
-        tuple((exact_date_parser,
-               opt(complete(map(tuple((multispace1, operator_parser, multispace1, amount_expr)), |(_, op, _, a)| (op, a))))
+        tuple((
+            exact_date_parser,
+            opt(complete(map(
+                tuple((multispace1, operator_parser, multispace1, amount_expr)),
+                |(_, op, _, a)| (op, a),
+            ))),
         )),
         |(exact, o)| Date(exact, o),
     )(input)
@@ -287,12 +254,12 @@ pub fn date(input: &[u8]) -> IResult<&[u8], Date> {
 pub struct Date(ExactDate, Option<(Operator, AmountExpr)>);
 
 impl IntoTimeType for Date {
-    fn into_timetype(self) -> Result<timetype::TimeType> {
-        let base : timetype::TimeType = self.0.into_timetype()?;
+    fn into_timetype(self) -> Result<crate::timetype::TimeType> {
+        let base: crate::timetype::TimeType = self.0.into_timetype()?;
         match self.1 {
-            Some((Operator::Plus,  amount)) => Ok(base + amount.into_timetype()?),
+            Some((Operator::Plus, amount)) => Ok(base + amount.into_timetype()?),
             Some((Operator::Minus, amount)) => Ok(base - amount.into_timetype()?),
-            None                            => Ok(base),
+            None => Ok(base),
         }
     }
 }
@@ -304,15 +271,14 @@ pub enum TimeType {
 }
 
 impl IntoTimeType for TimeType {
-    fn into_timetype(self) -> Result<timetype::TimeType> {
+    fn into_timetype(self) -> Result<crate::timetype::TimeType> {
         match self {
-            TimeType::Date(d)       => d.into_timetype(),
+            TimeType::Date(d) => d.into_timetype(),
             TimeType::AmountExpr(a) => a.into_timetype(),
         }
     }
 }
 
-
 // Main entry function for timetype parser
 //
 // # Notice
@@ -321,18 +287,15 @@ impl IntoTimeType for TimeType {
 // parser::TimeType can be `Into::into()`ed.
 //
 pub fn timetype(input: &[u8]) -> IResult<&[u8], TimeType> {
-    alt((
-        map(date, TimeType::Date),
-        map(amount_expr, TimeType::AmountExpr),
-    ))(input)
+    alt((map(date, TimeType::Date), map(amount_expr, TimeType::AmountExpr)))(input)
 }
 
 #[cfg(test)]
 mod tests {
-    use super::*;
-
-    use chrono::Timelike;
     use chrono::Datelike;
+    use chrono::Timelike;
+
+    use super::*;
 
     #[test]
     fn test_integer() {
@@ -405,38 +368,52 @@ mod tests {
         assert_eq!(amount_parser(&b"yearly"[..]), Ok((&b""[..], Amount(1, Unit::Year))));
     }
 
-
     #[test]
     fn test_amountexpr_next() {
-        assert_eq!(amount_expr_next(&b"+ 12minutes"[..]),
-                   Ok((&b""[..],
+        assert_eq!(
+            amount_expr_next(&b"+ 12minutes"[..]),
+            Ok((
+                &b""[..],
                 (
                     Operator::Plus,
-                    Box::new(AmountExpr { amount: Amount(12, Unit::Minute), next: None })
+                    Box::new(AmountExpr {
+                        amount: Amount(12, Unit::Minute),
+                        next: None
+                    })
                 )
-        )));
+            ))
+        );
     }
 
     #[test]
     fn test_amountexpr() {
-        assert_eq!(amount_expr(&b"5minutes"[..]),
-                   Ok((&b""[..],
-                          AmountExpr {
-                              amount: Amount(5, Unit::Minute),
-                              next: None
-                          })
-        ));
-
-        assert_eq!(amount_expr(&b"5min + 12min"[..]),
-                   Ok((&b""[..],
-                      AmountExpr {
-                          amount: Amount(5, Unit::Minute),
-                          next: Some((Operator::Plus, Box::new(
-                                      AmountExpr {
-                                          amount: Amount(12, Unit::Minute),
-                                          next: None
-                                      })))
-                      })));
+        assert_eq!(
+            amount_expr(&b"5minutes"[..]),
+            Ok((
+                &b""[..],
+                AmountExpr {
+                    amount: Amount(5, Unit::Minute),
+                    next: None
+                }
+            ))
+        );
+
+        assert_eq!(
+            amount_expr(&b"5min + 12min"[..]),
+            Ok((
+                &b""[..],
+                AmountExpr {
+                    amount: Amount(5, Unit::Minute),
+                    next: Some((
+                        Operator::Plus,
+                        Box::new(AmountExpr {
+                            amount: Amount(12, Unit::Minute),
+                            next: None
+                        })
+                    ))
+                }
+            ))
+        );
     }
 
     #[test]
@@ -447,19 +424,17 @@ mod tests {
 
         match res.unwrap().1 {
             ExactDate::Iso8601DateTime(_) => panic!("Unexpected enum variant"),
-            ExactDate::Iso8601Date(d) => {
-                match d {
-                    Date::YMD { year, month, day } => {
-                        assert_eq!(year, 2017);
-                        assert_eq!(month, 1);
-                        assert_eq!(day, 1)
-                    },
-                    _ => panic!("Unexpected enum variant"),
-                }
+            ExactDate::Iso8601Date(d) => match d {
+                Date::YMD { year, month, day } => {
+                    assert_eq!(year, 2017);
+                    assert_eq!(month, 1);
+                    assert_eq!(day, 1)