Bump edition to 2021 and introduce rustfmt

1 files changed, 109 insertions, 94 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);
             }
         }
     }
 }
-