selectors: rustfmt

6 files changed, 136 insertions, 44 deletions

diff --git a/src/selectors/cal.rs b/src/selectors/cal.rs
index 4fe86d7..d3ee761 100644
--- a/src/selectors/cal.rs
+++ b/src/selectors/cal.rs
@@ -4,7 +4,7 @@ use super::*;
 use crate::khevent::KhEvent;
 
 pub struct CalendarFilter {
-  cal_names: Vec<String>
+  cal_names: Vec<String>,
 }
 
 impl SelectFilter for CalendarFilter {
@@ -18,17 +18,20 @@ impl SelectFilter for CalendarFilter {
   }
 
   fn includes(&self, event: &KhEvent) -> bool {
-    event.get_path()
+    event
+      .get_path()
       .and_then(|path| path.parent())
       .map(|path| path.to_string_lossy().to_lowercase())
-      .map(|path| self.cal_names.iter().any(|cal| path.contains(cal)) )
+      .map(|path| self.cal_names.iter().any(|cal| path.contains(cal)))
       .unwrap_or(false)
   }
 }
 
 impl Default for CalendarFilter {
   fn default() -> CalendarFilter {
-    CalendarFilter { cal_names: Vec::new() }
+    CalendarFilter {
+      cal_names: Vec::new(),
+    }
   }
 }
 
@@ -41,21 +44,33 @@ mod tests {
   #[test]
   fn test_cal_first() {
     let path1 = PathBuf::from("test/cal1/event1.ics");
-    let filtered = test_filter_event(&testdata::TEST_EVENT_MULTIDAY, Some(&path1), &["cal", "cal1", "cal", "cal2"]);
+    let filtered = test_filter_event(
+      &testdata::TEST_EVENT_MULTIDAY,
+      Some(&path1),
+      &["cal", "cal1", "cal", "cal2"],
+    );
     assert!(filtered);
   }
 
   #[test]
   fn test_cal_second() {
     let path2 = PathBuf::from("test/cal2/event2.ics");
-    let filtered = test_filter_event(&testdata::TEST_EVENT_MULTIDAY, Some(&path2), &["cal", "cal1", "cal", "cal2"]);
+    let filtered = test_filter_event(
+      &testdata::TEST_EVENT_MULTIDAY,
+      Some(&path2),
+      &["cal", "cal1", "cal", "cal2"],
+    );
     assert!(filtered);
   }
 
   #[test]
   fn test_cal_negative() {
     let path3 = PathBuf::from("test/cal3/event3.ics");
-    let filtered = test_filter_event(&testdata::TEST_EVENT_MULTIDAY, Some(&path3), &["cal", "cal1", "cal", "cal2"]);
+    let filtered = test_filter_event(
+      &testdata::TEST_EVENT_MULTIDAY,
+      Some(&path3),
+      &["cal", "cal1", "cal", "cal2"],
+    );
     assert!(!filtered);
   }
 }
diff --git a/src/selectors/daterange.rs b/src/selectors/daterange.rs
index 78769ef..e4d31b4 100644
--- a/src/selectors/daterange.rs
+++ b/src/selectors/daterange.rs
@@ -21,7 +21,10 @@ impl SelectFilterFrom {
   }
 
   fn from_date(date: Option<Date<Local>>) -> Self {
-    Self { date, bucket: date.map(misc::get_bucket_for_date)  }
+    Self {
+      date,
+      bucket: date.map(misc::get_bucket_for_date),
+    }
   }
 
   pub fn combine_with(self, other: &Self) -> Self {
@@ -40,7 +43,10 @@ impl SelectFilterTo {
   }
 
   fn from_date(date: Option<Date<Local>>) -> Self {
-    Self { date, bucket: date.map(misc::get_bucket_for_date)  }
+    Self {
+      date,
+      bucket: date.map(misc::get_bucket_for_date),
+    }
   }
 
   pub fn combine_with(self, other: &Self) -> Self {
@@ -101,32 +107,48 @@ mod tests {
   fn test_from_ends_before() {
     // DTSTART: 2007-06-28
     // DTEND: 2007-07-09
-    let filtered = test_filter_event(&testdata::TEST_EVENT_MULTIDAY, None, &["from", "2007-08-01"]);
+    let filtered = test_filter_event(
+      &testdata::TEST_EVENT_MULTIDAY,
+      None,
+      &["from", "2007-08-01"],
+    );
     assert_eq!(false, filtered)
   }
   #[test]
   fn test_from_begins_after() {
-    let filtered = test_filter_event(&testdata::TEST_EVENT_MULTIDAY, None, &["from", "2007-06-01"]);
+    let filtered = test_filter_event(
+      &testdata::TEST_EVENT_MULTIDAY,
+      None,
+      &["from", "2007-06-01"],
+    );
     assert_eq!(true, filtered);
   }
   #[test]
   fn test_from_begins_before_ends_after() {
-    let filtered = test_filter_event(&testdata::TEST_EVENT_MULTIDAY, None, &["from", "2007-07-01"]);
+    let filtered = test_filter_event(
+      &testdata::TEST_EVENT_MULTIDAY,
+      None,
+      &["from", "2007-07-01"],
+    );
     assert_eq!(true, filtered);
   }
   #[test]
   fn test_from_week_before() {
-    let filtered = test_filter_event(&testdata::TEST_EVENT_MULTIDAY, None, &["from", "2007-W17" ]);
+    let filtered = test_filter_event(&testdata::TEST_EVENT_MULTIDAY, None, &["from", "2007-W17"]);
     assert_eq!(true, filtered);
   }
   #[test]
   fn test_from_week_after() {
-    let filtered = test_filter_event(&testdata::TEST_EVENT_MULTIDAY, None, &["from", "2007-W30" ]);
+    let filtered = test_filter_event(&testdata::TEST_EVENT_MULTIDAY, None, &["from", "2007-W30"]);
     assert_eq!(false, filtered);
   }
   #[test]
   fn test_from_redundant() {
-    let filtered = test_filter_event(&testdata::TEST_EVENT_MULTIDAY, None, &["from", "2007-06-01", "from", "2007-08-01"]);
+    let filtered = test_filter_event(
+      &testdata::TEST_EVENT_MULTIDAY,
+      None,
+      &["from", "2007-06-01", "from", "2007-08-01"],
+    );
     assert_eq!(false, filtered);
   }
   #[test]
@@ -146,17 +168,21 @@ mod tests {
   }
   #[test]
   fn test_to_week_before() {
-    let filtered = test_filter_event(&testdata::TEST_EVENT_MULTIDAY, None, &["to", "2007-W17" ]);
+    let filtered = test_filter_event(&testdata::TEST_EVENT_MULTIDAY, None, &["to", "2007-W17"]);
     assert_eq!(false, filtered);
   }
   #[test]
   fn test_to_week_after() {
-    let filtered = test_filter_event(&testdata::TEST_EVENT_MULTIDAY, None, &["to", "2007-W30" ]);
+    let filtered = test_filter_event(&testdata::TEST_EVENT_MULTIDAY, None, &["to", "2007-W30"]);
     assert_eq!(true, filtered);
   }
   #[test]
   fn test_to_begins_redundant() {
-    let filtered = test_filter_event(&testdata::TEST_EVENT_MULTIDAY, None, &["to", "2007-06-01", "to", "2007-08-01"]);
+    let filtered = test_filter_event(
+      &testdata::TEST_EVENT_MULTIDAY,
+      None,
+      &["to", "2007-06-01", "to", "2007-08-01"],
+    );
     assert_eq!(false, filtered);
   }
 }
diff --git a/src/selectors/grep.rs b/src/selectors/grep.rs
index d0dd327..29dd956 100644
--- a/src/selectors/grep.rs
+++ b/src/selectors/grep.rs
@@ -4,10 +4,10 @@ use super::*;
 use crate::khevent::KhEvent;
 
 pub struct GrepFilter {
-  terms: Vec<String>
+  terms: Vec<String>,
 }
 
-impl SelectFilter for GrepFilter  {
+impl SelectFilter for GrepFilter {
   fn add_term(&mut self, it: &mut dyn Iterator<Item = &&str>) {
     let term = it.next().unwrap();
     self.terms.push(term.to_lowercase());
@@ -52,7 +52,11 @@ mod tests {
 
   #[test]
   fn test_grep() {
-    let filtered = test_filter_event(&testdata::TEST_EVENT_MULTIDAY, None, &["grep", "International"]);
+    let filtered = test_filter_event(
+      &testdata::TEST_EVENT_MULTIDAY,
+      None,
+      &["grep", "International"],
+    );
     assert_eq!(true, filtered);
   }
 
@@ -64,19 +68,31 @@ mod tests {
 
   #[test]
   fn test_grep_description() {
-    let filtered = test_filter_event(&testdata::TEST_EVENT_ONE_MEETING, None, &["grep", "interoperability"]);
+    let filtered = test_filter_event(
+      &testdata::TEST_EVENT_ONE_MEETING,
+      None,
+      &["grep", "interoperability"],
+    );
     assert_eq!(true, filtered);
   }
 
   #[test]
   fn test_grep_case() {
-    let filtered = test_filter_event(&testdata::TEST_EVENT_MULTIDAY, None, &["grep", "InTeRnAtIOnAl"]);
+    let filtered = test_filter_event(
+      &testdata::TEST_EVENT_MULTIDAY,
+      None,
+      &["grep", "InTeRnAtIOnAl"],
+    );
     assert_eq!(true, filtered);
   }
 
   #[test]
   fn test_grep_negative() {
-    let filtered = test_filter_event(&testdata::TEST_EVENT_MULTIDAY, None, &["grep", "nonexistent term"]);
+    let filtered = test_filter_event(
+      &testdata::TEST_EVENT_MULTIDAY,
+      None,
+      &["grep", "nonexistent term"],
+    );
     assert_eq!(false, filtered);
   }
 }
diff --git a/src/selectors/mod.rs b/src/selectors/mod.rs
index 7092cd0..659e09c 100644
--- a/src/selectors/mod.rs
+++ b/src/selectors/mod.rs
@@ -1,19 +1,19 @@
 use std::collections::HashMap;
 
-use crate::khline::{KhLine,khlines_to_events};
 use crate::khevent::KhEvent;
+use crate::khline::{khlines_to_events, KhLine};
 
-use self::daterange::{SelectFilterFrom,SelectFilterTo};
 use self::cal::CalendarFilter;
+use self::daterange::{SelectFilterFrom, SelectFilterTo};
 use self::grep::GrepFilter;
 use self::prop::PropFilter;
 use self::range::RangeFilter;
 
 mod cal;
+pub mod daterange;
 mod grep;
 mod prop;
 mod range;
-pub mod daterange;
 #[cfg(test)]
 mod test;
 
@@ -69,25 +69,31 @@ impl SelectFilters {
             filter.add_term(&mut it);
           } else if let Ok(parsed_range) = term.parse::<RangeFilter>() {
             if !with_range {
-              return Err("Range selector not allowed here!".to_string())
+              return Err("Range selector not allowed here!".to_string());
             }
             if range.is_some() {
-              return Err("Duplicate range selector!".to_string())
+              return Err("Duplicate range selector!".to_string());
             }
             range = Some(parsed_range);
           } else {
-            return Err("select [from|to|in|on|grep|cal parameter]+".to_string())
+            return Err("select [from|to|in|on|grep|cal parameter]+".to_string());
           }
         }
       }
     }
 
-    let others = others.drain()
+    let others = others
+      .drain()
       .map(|x| x.1)
       .filter(|filter| filter.is_not_empty())
       .collect();
 
-    Ok(SelectFilters { from, to, range, others })
+    Ok(SelectFilters {
+      from,
+      to,
+      range,
+      others,
+    })
   }
 
   fn line_is_from(&self, event: &KhEvent) -> bool {
@@ -117,7 +123,10 @@ impl SelectFilters {
   }
 
   pub fn is_selected_index(&self, index: usize, event: &KhEvent) -> bool {
-    self.filter_index(index) && self.line_is_from(event) && self.line_is_to(event) && self.others(event)
+    self.filter_index(index)
+      && self.line_is_from(event)
+      && self.line_is_to(event)
+      && self.others(event)
   }
 
   pub fn filter_khlines(
diff --git a/src/selectors/prop.rs b/src/selectors/prop.rs
index b9b566e..ae9da02 100644
--- a/src/selectors/prop.rs
+++ b/src/selectors/prop.rs
@@ -5,16 +5,18 @@ use super::*;
 use crate::khevent::KhEvent;
 
 pub struct PropFilter {
-  terms: HashMap<String,Vec<String>>
+  terms: HashMap<String, Vec<String>>,
 }
 
-impl SelectFilter for PropFilter  {
+impl SelectFilter for PropFilter {
   fn add_term(&mut self, it: &mut dyn Iterator<Item = &&str>) {
     let term = it.next().unwrap().to_uppercase();
     let value = it.next().unwrap();
-    self.terms.entry(term)
+    self
+      .terms
+      .entry(term)
       .and_modify(|x| x.push(value.to_lowercase()))
-      .or_insert_with(|| vec!(value.to_lowercase()));
+      .or_insert_with(|| vec![value.to_lowercase()]);
   }
 
   fn is_not_empty(&self) -> bool {
@@ -36,7 +38,9 @@ impl SelectFilter for PropFilter  {
 
 impl Default for PropFilter {
   fn default() -> Self {
-    PropFilter { terms: HashMap::new() }
+    PropFilter {
+      terms: HashMap::new(),
+    }
   }
 }
 
@@ -47,19 +51,31 @@ mod tests {
 
   #[test]
   fn test_prop() {
-    let filtered = test_filter_event(&testdata::TEST_EVENT_MULTIDAY, None, &["prop", "TRANSP", "TRANSPARENT"]);
+    let filtered = test_filter_event(
+      &testdata::TEST_EVENT_MULTIDAY,
+      None,
+      &["prop", "TRANSP", "TRANSPARENT"],
+    );
     assert_eq!(true, filtered);
   }
 
   #[test]
   fn test_prop_nocase() {
-    let filtered = test_filter_event(&testdata::TEST_EVENT_MULTIDAY, None, &["prop", "tRaNsP", "tRaNsPaReNt"]);
+    let filtered = test_filter_event(
+      &testdata::TEST_EVENT_MULTIDAY,
+      None,
+      &["prop", "tRaNsP", "tRaNsPaReNt"],
+    );
     assert_eq!(true, filtered);
   }
 
   #[test]
   fn test_prop_negative() {
-    let filtered = test_filter_event(&testdata::TEST_EVENT_MULTIDAY, None, &["prop", "TRANSP", "nonexistent term"]);
+    let filtered = test_filter_event(
+      &testdata::TEST_EVENT_MULTIDAY,
+      None,
+      &["prop", "TRANSP", "nonexistent term"],
+    );
     assert_eq!(false, filtered);
   }
 }
diff --git a/src/selectors/range.rs b/src/selectors/range.rs
index b1c3a3d..5052ecc 100644
--- a/src/selectors/range.rs
+++ b/src/selectors/range.rs
@@ -15,12 +15,22 @@ impl FromStr for RangeFilter {
   type Err = ();
 
   fn from_str(s: &str) -> Result<RangeFilter, Self::Err> {
-    let bounds: Vec<usize> = s.splitn(2, ':').map(|x| x.parse::<usize>()).flatten().collect();
+    let bounds: Vec<usize> = s
+      .splitn(2, ':')
+      .map(|x| x.parse::<usize>())
+      .flatten()
+      .collect();
     if bounds.len() == 2 {
-      return Ok(RangeFilter { from: bounds[0], to: bounds[1] });
+      return Ok(RangeFilter {
+        from: bounds[0],
+        to: bounds[1],
+      });
     }
     if let Ok(index) = s.parse::<usize>() {
-      return Ok(RangeFilter { from: index, to: index });
+      return Ok(RangeFilter {
+        from: index,
+        to: index,
+      });
     }
     Err(())
   }