cargo fmt

2 files changed, 23 insertions, 60 deletions

diff --git a/cli/src/main.rs b/cli/src/main.rs
index a01ee94..9a5b091 100644
--- a/cli/src/main.rs
+++ b/cli/src/main.rs
@@ -1,5 +1,5 @@
 use chrono::NaiveDate;
-use money_cli::search::{Search, parse_filters};
+use money_cli::search::{parse_filters, Search};
 use money_cli::store::Store;
 use money_cli::transaction::{Transaction, TransactionKind};
 use rust_decimal::Decimal;
diff --git a/cli/src/search.rs b/cli/src/search.rs
index c01e9c6..aa0c278 100644
--- a/cli/src/search.rs
+++ b/cli/src/search.rs
@@ -140,14 +140,8 @@ impl Constraint {
                 preceded(tag("amount:"), parse_comparison),
                 |(amount, comparison)| Constraint::AmountCompare(amount, comparison),
             ),
-            map(
-                tag("week"),
-                |_| Constraint::Filters(this_week()),
-            ),
-            map(
-                tag("month"),
-                |_| Constraint::Filters(this_month()),
-            ),
+            map(tag("week"), |_| Constraint::Filters(this_week())),
+            map(tag("month"), |_| Constraint::Filters(this_month())),
             map(
                 delimited(char('('), separated_list0(space1, Filter::parse), char(')')),
                 Constraint::Filters,
@@ -178,8 +172,14 @@ fn this_week() -> Vec<Filter> {
 fn this_month() -> Vec<Filter> {
     let start_of_month = today().with_day(1).unwrap();
     let start_of_next_month = match start_of_month.month() {
-        12 => start_of_month.with_year(start_of_month.year() + 1).unwrap().with_month(1).unwrap(),
-        _ => start_of_month.with_month(start_of_month.month() + 1).unwrap(),
+        12 => start_of_month
+            .with_year(start_of_month.year() + 1)
+            .unwrap()
+            .with_month(1)
+            .unwrap(),
+        _ => start_of_month
+            .with_month(start_of_month.month() + 1)
+            .unwrap(),
     };
     filter_between(start_of_month, start_of_next_month)
 }
@@ -299,11 +299,7 @@ mod test {
     }
 
     fn ids(search: &Search) -> Vec<u32> {
-        search
-            .get()
-            .iter()
-            .map(|t| transaction_id(t))
-            .collect()
+        search.get().iter().map(|t| transaction_id(t)).collect()
     }
 
     #[test]
@@ -328,10 +324,7 @@ mod test {
         let category_filter = Filter::Intersect(Constraint::Category("C1".to_string()));
         search = search.apply(category_filter);
         assert_eq!(search.get().len(), 2);
-        assert_eq!(
-            ids(&search),
-            vec![0, 1],
-        );
+        assert_eq!(ids(&search), vec![0, 1]);
     }
 
     #[test]
@@ -363,28 +356,19 @@ mod test {
         let before_filter = Filter::Intersect(Constraint::Before(date.clone()));
         search_before = search_before.apply(before_filter);
         assert_eq!(search_before.get().len(), 1);
-        assert_eq!(
-            ids(&search_before),
-            vec![0],
-        );
+        assert_eq!(ids(&search_before), vec![0]);
 
         let mut search_after = search.clone();
         let after_filter = Filter::Intersect(Constraint::After(date.clone()));
         search_after = search_after.apply(after_filter);
         assert_eq!(search_after.get().len(), 3);
-        assert_eq!(
-            ids(&search_after),
-            vec![1, 2, 3],
-        );
+        assert_eq!(ids(&search_after), vec![1, 2, 3]);
 
         let mut search_on = search.clone();
         let on_filter = Filter::Intersect(Constraint::On(date.clone()));
         search_on = search_on.apply(on_filter);
         assert_eq!(search_on.get().len(), 1);
-        assert_eq!(
-            ids(&search_on),
-            vec![1],
-        );
+        assert_eq!(ids(&search_on), vec![1]);
     }
 
     #[test]
@@ -415,10 +399,7 @@ mod test {
             Filter::Intersect(Constraint::AmountCompare(160.into(), Comparison::Less));
         search_less = search_less.apply(less_filter);
         assert_eq!(search_less.get().len(), 1);
-        assert_eq!(
-            ids(&search_less),
-            vec![0],
-        );
+        assert_eq!(ids(&search_less), vec![0]);
 
         let mut search_less_eq = search.clone();
         let less_eq_filter = Filter::Intersect(Constraint::AmountCompare(
@@ -427,29 +408,20 @@ mod test {
         ));
         search_less_eq = search_less_eq.apply(less_eq_filter);
         assert_eq!(search_less_eq.get().len(), 2);
-        assert_eq!(
-            ids(&search_less_eq),
-            vec![0, 1],
-        );
+        assert_eq!(ids(&search_less_eq), vec![0, 1]);
 
         let mut search_eq = search.clone();
         let eq_filter = Filter::Intersect(Constraint::AmountCompare(160.into(), Comparison::Equal));
         search_eq = search_eq.apply(eq_filter);
         assert_eq!(search_eq.get().len(), 1);
-        assert_eq!(
-            ids(&search_eq),
-            vec![1],
-        );
+        assert_eq!(ids(&search_eq), vec![1]);
 
         let mut search_greater = search.clone();
         let greater_filter =
             Filter::Intersect(Constraint::AmountCompare(160.into(), Comparison::Greater));
         search_greater = search_greater.apply(greater_filter);
         assert_eq!(search_greater.get().len(), 2);
-        assert_eq!(
-            ids(&search_greater),
-            vec![2, 3],
-        );
+        assert_eq!(ids(&search_greater), vec![2, 3]);
 
         let mut search_greater_eq = search.clone();
         let greater_eq_filter = Filter::Intersect(Constraint::AmountCompare(
@@ -458,10 +430,7 @@ mod test {
         ));
         search_greater_eq = search_greater_eq.apply(greater_eq_filter);
         assert_eq!(search_greater_eq.get().len(), 3);
-        assert_eq!(
-            ids(&search_greater_eq),
-            vec![1, 2, 3],
-        );
+        assert_eq!(ids(&search_greater_eq), vec![1, 2, 3]);
     }
 
     #[test]
@@ -497,10 +466,7 @@ mod test {
         search_filters_1 = search_filters_1.apply(Filter::Intersect(c1.clone()));
         search_filters_1 = search_filters_1.apply(Filter::Union(amount_150.clone()));
         assert_eq!(search_filters_1.get().len(), 3);
-        assert_eq!(
-            ids(&search_filters_1),
-            vec![0, 1, 2],
-        );
+        assert_eq!(ids(&search_filters_1), vec![0, 1, 2]);
 
         // Wrap an intersect in a union.
         let mut search_filters_2 = search.clone();
@@ -508,9 +474,6 @@ mod test {
         search_filters_2 = search_filters_2.apply(Filter::Intersect(c1));
         search_filters_2 = search_filters_2.apply(Filter::Union(inner_filters));
         assert_eq!(search_filters_2.get().len(), 3);
-        assert_eq!(
-            ids(&search_filters_2),
-            vec![0, 1, 2],
-        );
+        assert_eq!(ids(&search_filters_2), vec![0, 1, 2]);
     }
 }