Cargo fmt

39 files changed, 584 insertions, 466 deletions

diff --git a/examples/basic_search.rs b/examples/basic_search.rs
index f96fedf..5195bd2 100644
--- a/examples/basic_search.rs
+++ b/examples/basic_search.rs
@@ -232,4 +232,3 @@ fn main() -> tantivy::Result<()> {
 
     Ok(())
 }
-
diff --git a/examples/custom_collector.rs b/examples/custom_collector.rs
index 5af31ce..0d19a83 100644
--- a/examples/custom_collector.rs
+++ b/examples/custom_collector.rs
@@ -13,23 +13,22 @@ extern crate tempdir;
 // Importing tantivy...
 #[macro_use]
 extern crate tantivy;
+use tantivy::collector::{Collector, SegmentCollector};
+use tantivy::fastfield::FastFieldReader;
 use tantivy::query::QueryParser;
-use tantivy::schema::{FAST, TEXT, INT_INDEXED, Schema};
+use tantivy::schema::Field;
+use tantivy::schema::{Schema, FAST, INT_INDEXED, TEXT};
 use tantivy::Index;
-use tantivy::collector::{Collector, SegmentCollector};
 use tantivy::SegmentReader;
-use tantivy::schema::Field;
-use tantivy::fastfield::FastFieldReader;
 
 #[derive(Default)]
 struct Stats {
     count: usize,
     sum: f64,
-    squared_sum: f64
+    squared_sum: f64,
 }
 
 impl Stats {
-
     pub fn count(&self) -> usize {
         self.count
     }
@@ -56,10 +55,8 @@ impl Stats {
     }
 }
 
-
-
 struct StatsCollector {
-    field: Field
+    field: Field,
 }
 
 impl StatsCollector {
@@ -75,11 +72,15 @@ impl Collector for StatsCollector {
 
     type Child = StatsSegmentCollector;
 
-    fn for_segment(&self, _segment_local_id: u32, segment: &SegmentReader) -> tantivy::Result<StatsSegmentCollector> {
+    fn for_segment(
+        &self,
+        _segment_local_id: u32,
+        segment: &SegmentReader,
+    ) -> tantivy::Result<StatsSegmentCollector> {
         let fast_field_reader = segment.fast_field_reader(self.field)?;
         Ok(StatsSegmentCollector {
             fast_field_reader,
-            stats: Stats::default()
+            stats: Stats::default(),
         })
     }
 
@@ -101,7 +102,6 @@ impl Collector for StatsCollector {
     }
 }
 
-
 struct StatsSegmentCollector {
     fast_field_reader: FastFieldReader<u64>,
     stats: Stats,
@@ -122,7 +122,6 @@ impl SegmentCollector for StatsSegmentCollector {
     }
 }
 
-
 fn main() -> tantivy::Result<()> {
     // # Defining the schema
     //
@@ -186,4 +185,3 @@ fn main() -> tantivy::Result<()> {
 
     Ok(())
 }
-
diff --git a/examples/stop_words.rs b/examples/stop_words.rs
index f7318cd..7eba72b 100644
--- a/examples/stop_words.rs
+++ b/examples/stop_words.rs
@@ -105,7 +105,7 @@ fn main() -> tantivy::Result<()> {
     // stop words are applied on the query as well.
     // The following will be equivalent to `title:frankenstein`
     let query = query_parser.parse_query("title:\"the Frankenstein\"")?;
-    let top_docs = searcher.search(&query,  &TopDocs::with_limit(10))?;
+    let top_docs = searcher.search(&query, &TopDocs::with_limit(10))?;
 
     for (score, doc_address) in top_docs {
         let retrieved_doc = searcher.doc(doc_address)?;
diff --git a/src/collector/count_collector.rs b/src/collector/count_collector.rs
index 0af8b23..ea2a1d9 100644
--- a/src/collector/count_collector.rs
+++ b/src/collector/count_collector.rs
@@ -1,10 +1,10 @@
 use super::Collector;
+use collector::SegmentCollector;
 use DocId;
 use Result;
 use Score;
 use SegmentLocalId;
 use SegmentReader;
-use collector::SegmentCollector;
 
 /// `CountCollector` collector only counts how many
 /// documents match the query.
@@ -56,9 +56,7 @@ use collector::SegmentCollector;
 /// ```
 pub struct Count;
 
-
 impl Collector for Count {
-
     type Fruit = usize;
 
     type Child = SegmentCountCollector;
@@ -76,13 +74,11 @@ impl Collector for Count {
     }
 }
 
-
 #[derive(Default)]
 pub struct SegmentCountCollector {
     count: usize,
 }
 
-
 impl SegmentCollector for SegmentCountCollector {
     type Fruit = usize;
 
@@ -95,12 +91,11 @@ impl SegmentCollector for SegmentCountCollector {
     }
 }
 
-
 #[cfg(test)]
 mod tests {
     use super::{Count, SegmentCountCollector};
-    use collector::SegmentCollector;
     use collector::Collector;
+    use collector::SegmentCollector;
 
     #[test]
     fn test_count_collect_does_not_requires_scoring() {
@@ -129,7 +124,6 @@ mod tests {
             count_collector.collect(1u32, 1f32);
             assert_eq!(count_collector.harvest(), 2);
         }
-
     }
 
 }
diff --git a/src/collector/facet_collector.rs b/src/collector/facet_collector.rs
index 9c8bc31..2937a7c 100644
--- a/src/collector/facet_collector.rs
+++ b/src/collector/facet_collector.rs
@@ -1,8 +1,10 @@
 use collector::Collector;
+use collector::SegmentCollector;
 use docset::SkipResult;
 use fastfield::FacetReader;
 use schema::Facet;
 use schema::Field;
+use std::cmp::Ordering;
 use std::collections::btree_map;
 use std::collections::BTreeMap;
 use std::collections::BTreeSet;
@@ -10,13 +12,11 @@ use std::collections::BinaryHeap;
 use std::collections::Bound;
 use std::iter::Peekable;
 use std::{u64, usize};
-use std::cmp::Ordering;
 use DocId;
 use Result;
 use Score;
 use SegmentLocalId;
 use SegmentReader;
-use collector::SegmentCollector;
 
 struct Hit<'a> {
     count: u64,
@@ -223,7 +223,7 @@ impl FacetCollector {
     pub fn for_field(field: Field) -> FacetCollector {
         FacetCollector {
             field,
-            facets: BTreeSet::default()
+            facets: BTreeSet::default(),
         }
     }
 
@@ -260,7 +260,11 @@ impl Collector for FacetCollector {
 
     type Child = FacetSegmentCollector;
 
-    fn for_segment(&self, _: SegmentLocalId, reader: &SegmentReader) -> Result<FacetSegmentCollector> {
+    fn for_segment(
+        &self,
+        _: SegmentLocalId,
+        reader: &SegmentReader,
+    ) -> Result<FacetSegmentCollector> {
         let facet_reader = reader.facet_reader(self.field)?;
 
         let mut collapse_mapping = Vec::new();
@@ -335,21 +339,18 @@ impl Collector for FacetCollector {
 }
 
 impl SegmentCollector for FacetSegmentCollector {
-
     type Fruit = FacetCounts;
 
-
     fn collect(&mut self, doc: DocId, _: Score) {
         self.reader.facet_ords(doc, &mut self.facet_ords_buf);
         let mut previous_collapsed_ord: usize = usize::MAX;
         for &facet_ord in &self.facet_ords_buf {
             let collapsed_ord = self.collapse_mapping[facet_ord as usize];
-            self.counts[collapsed_ord] +=
-                if collapsed_ord == previous_collapsed_ord {
-                    0
-                } else {
-                    1
-                };
+            self.counts[collapsed_ord] += if collapsed_ord == previous_collapsed_ord {
+                0
+            } else {
+                1
+            };
             previous_collapsed_ord = collapsed_ord;
         }
     }
@@ -451,9 +452,9 @@ mod tests {
     use core::Index;
     use query::AllQuery;
     use rand::distributions::Uniform;
-    use rand::{thread_rng, Rng};
-    use schema::{Field, Document, Facet, Schema};
     use rand::prelude::SliceRandom;
+    use rand::{thread_rng, Rng};
+    use schema::{Document, Facet, Field, Schema};
     use std::iter;
 
     #[test]
@@ -482,7 +483,7 @@ mod tests {
         index_writer.commit().unwrap();
         index.load_searchers().unwrap();
         let searcher = index.searcher();
-        let mut facet_collector= FacetCollector::for_field(facet_field);
+        let mut facet_collector = FacetCollector::for_field(facet_field);
         facet_collector.add_facet(Facet::from("/top1"));
         let counts = searcher.search(&AllQuery, &facet_collector).unwrap();
 
diff --git a/src/collector/mod.rs b/src/collector/mod.rs
index 8db4da5..776b8a5 100644
--- a/src/collector/mod.rs
+++ b/src/collector/mod.rs
@@ -85,12 +85,12 @@ See the `custom_collector` example.
 
 */
 
+use downcast;
 use DocId;
 use Result;
 use Score;
 use SegmentLocalId;
 use SegmentReader;
-use downcast;
 
 mod count_collector;
 pub use self::count_collector::Count;
@@ -132,13 +132,12 @@ impl<T> Fruit for T where T: Send + downcast::Any {}
 ///
 /// Segments are not guaranteed to be visited in any specific order.
 pub trait Collector: Sync {
-
     /// `Fruit` is the type for the result of our collection.
     /// e.g. `usize` for the `Count` collector.
     type Fruit: Fruit;
 
     /// Type of the `SegmentCollector` associated to this collector.
-    type Child: SegmentCollector<Fruit=Self::Fruit>;
+    type Child: SegmentCollector<Fruit = Self::Fruit>;
 
     /// `set_segment` is called before beginning to enumerate
     /// on this segment.
@@ -156,7 +155,6 @@ pub trait Collector: Sync {
     fn merge_fruits(&self, segment_fruits: Vec<Self::Fruit>) -> Result<Self::Fruit>;
 }
 
-
 /// The `SegmentCollector` is the trait in charge of defining the
 /// collect operation at the scale of the segment.
 ///
@@ -177,11 +175,10 @@ pub trait SegmentCollector: 'static {
 // -----------------------------------------------
 // Tuple implementations.
 
-
 impl<Left, Right> Collector for (Left, Right)
 where
     Left: Collector,
-    Right: Collector
+    Right: Collector,
 {
     type Fruit = (Left::Fruit, Right::Fruit);
     type Child = (Left::Child, Right::Child);
@@ -196,22 +193,27 @@ where
         self.0.requires_scoring() || self.1.requires_scoring()
     }
 
-    fn merge_fruits(&self, children: Vec<(Left::Fruit, Right::Fruit)>) -> Result<(Left::Fruit, Right::Fruit)> {
+    fn merge_fruits(
+        &self,
+        children: Vec<(Left::Fruit, Right::Fruit)>,
+    ) -> Result<(Left::Fruit, Right::Fruit)> {
         let mut left_fruits = vec![];
         let mut right_fruits = vec![];
         for (left_fruit, right_fruit) in children {
             left_fruits.push(left_fruit);
             right_fruits.push(right_fruit);
         }
-        Ok((self.0.merge_fruits(left_fruits)?,
-            self.1.merge_fruits(right_fruits)?))
+        Ok((
+            self.0.merge_fruits(left_fruits)?,
+            self.1.merge_fruits(right_fruits)?,
+        ))
     }
 }
 
 impl<Left, Right> SegmentCollector for (Left, Right)
-    where
-        Left: SegmentCollector,
-        Right: SegmentCollector
+where
+    Left: SegmentCollector,
+    Right: SegmentCollector,
 {
     type Fruit = (Left::Fruit, Right::Fruit);
 
@@ -228,9 +230,10 @@ impl<Left, Right> SegmentCollector for (Left, Right)
 // 3-Tuple
 
 impl<One, Two, Three> Collector for (One, Two, Three)
-    where One: Collector,
-          Two: Collector,
-          Three: Collector
+where
+    One: Collector,
+    Two: Collector,
+    Three: Collector,
 {
     type Fruit = (One::Fruit, Two::Fruit, Three::Fruit);
     type Child = (One::Child, Two::Child, Three::Child);
@@ -243,9 +246,7 @@ impl<One, Two, Three> Collector for (One, Two, Three)
     }
 
     fn requires_scoring(&self) -> bool {
-        self.0.requires_scoring() ||
-        self.1.requires_scoring() ||
-        self.2.requires_scoring()
+        self.0.requires_scoring() || self.1.requires_scoring() || self.2.requires_scoring()
     }
 
     fn merge_fruits(&self, children: Vec<Self::Fruit>) -> Result<Self::Fruit> {
@@ -257,17 +258,19 @@ impl<One, Two, Three> Collector for (One, Two, Three)
             two_fruits.push(two_fruit);
             three_fruits.push(three_fruit);
         }
-        Ok((self.0.merge_fruits(one_fruits)?,
+        Ok((
+            self.0.merge_fruits(one_fruits)?,
             self.1.merge_fruits(two_fruits)?,
-            self.2.merge_fruits(three_fruits)?))
+            self.2.merge_fruits(three_fruits)?,
+        ))
     }
 }
 
 impl<One, Two, Three> SegmentCollector for (One, Two, Three)
-    where
-        One: SegmentCollector,
-        Two: SegmentCollector,
-        Three: SegmentCollector
+where
+    One: SegmentCollector,
+    Two: SegmentCollector,
+    Three: SegmentCollector,
 {
     type Fruit = (One::Fruit, Two::Fruit, Three::Fruit);
 
@@ -282,14 +285,14 @@ impl<One, Two, Three> SegmentCollector for (One, Two, Three)
     }
 }
 
-
 // 4-Tuple
 
 impl<One, Two, Three, Four> Collector for (One, Two, Three, Four)
-    where One: Collector,
-          Two: Collector,
-          Three: Collector,
-          Four: Collector
+where
+    One: Collector,
+    Two: Collector,
+    Three: Collector,
+    Four: Collector,
 {
     type Fruit = (One::Fruit, Two::Fruit, Three::Fruit, Four::Fruit);
     type Child = (One::Child, Two::Child, Three::Child, Four::Child);
@@ -303,10 +306,10 @@ impl<One, Two, Three, Four> Collector for (One, Two, Three, Four)
     }
 
     fn requires_scoring(&self) -> bool {
-        self.0.requires_scoring() ||
-        self.1.requires_scoring() ||
-        self.2.requires_scoring() ||
-        self.3.requires_scoring()
+        self.0.requires_scoring()
+            || self.1.requires_scoring()
+            || self.2.requires_scoring()
+            || self.3.requires_scoring()
     }
 
     fn merge_fruits(&self, children: Vec<Self::Fruit>) -> Result<Self::Fruit> {
@@ -320,19 +323,21 @@ impl<One, Two, Three, Four> Collector for (One, Two, Three, Four)
             three_fruits.push(three_fruit);
             four_fruits.push(four_fruit);
         }
-        Ok((self.0.merge_fruits(one_fruits)?,
+        Ok((
+            self.0.merge_fruits(one_fruits)?,
             self.1.merge_fruits(two_fruits)?,
             self.2.merge_fruits(three_fruits)?,
-            self.3.merge_fruits(four_fruits)?))
+            self.3.merge_fruits(four_fruits)?,
+        ))
     }
 }
 
 impl<One, Two, Three, Four> SegmentCollector for (One, Two, Three, Four)
-    where
-        One: SegmentCollector,
-        Two: SegmentCollector,
-        Three: SegmentCollector,
-        Four: SegmentCollector
+where
+    One: SegmentCollector,
+    Two: SegmentCollector,
+    Three: SegmentCollector,
+    Four: SegmentCollector,
 {
     type Fruit = (One::Fruit, Two::Fruit, Three::Fruit, Four::Fruit);
 
@@ -344,7 +349,12 @@ impl<One, Two, Three, Four> SegmentCollector for (One, Two, Three, Four)
     }
 
     fn harvest(self) -> <Self as SegmentCollector>::Fruit {
-        (self.0.harvest(), self.1.harvest(), self.2.harvest(), self.3.harvest())
+        (
+            self.0.harvest(),
+            self.1.harvest(),
+            self.2.harvest(),
+            self.3.harvest(),
+        )
     }
 }
 
@@ -353,6 +363,5 @@ mod downcast_impl {
     downcast!(super::Fruit);
 }
 
-
 #[cfg(test)]
 pub mod tests;
diff --git a/src/collector/multi_collector.rs b/src/collector/multi_collector.rs
index 24f951e..1fb119f 100644
--- a/src/collector/multi_collector.rs
+++ b/src/collector/multi_collector.rs
@@ -1,28 +1,30 @@
 use super::Collector;
 use super::SegmentCollector;
+use collector::Fruit;
+use downcast::Downcast;
+use std::marker::PhantomData;
 use DocId;
-use Score;
 use Result;
+use Score;
 use SegmentLocalId;
 use SegmentReader;
-use downcast::Downcast;
-use collector::Fruit;
-use std::marker::PhantomData;
 use TantivyError;
 
-
 pub struct MultiFruit {
-    sub_fruits: Vec<Option<Box<Fruit>>>
+    sub_fruits: Vec<Option<Box<Fruit>>>,
 }
 
-
 pub struct CollectorWrapper<TCollector: Collector>(TCollector);
 
 impl<TCollector: Collector> Collector for CollectorWrapper<TCollector> {
     type Fruit = Box<Fruit>;
     type Child = Box<BoxableSegmentCollector>;
 
-    fn for_segment(&self, segment_local_id: u32, reader: &SegmentReader) -> Result<Box<BoxableSegmentCollector>> {
+    fn for_segment(
+        &self,
+        segment_local_id: u32,
+        reader: &SegmentReader,
+    ) -> Result<Box<BoxableSegmentCollector>> {
         let child = self.0.for_segment(segment_local_id, reader)?;
         Ok(Box::new(SegmentCollectorWrapper(child)))
     }
@@ -32,7 +34,8 @@ impl<TCollector: Collector> Collector for CollectorWrapper<TCollector> {
     }
 
     fn merge_fruits(&self, children: Vec<<Self as Collector>::Fruit>) -> Result<Box<Fruit>> {
-        let typed_fruit: Vec<TCollector::Fruit> = children.into_iter()
+        let typed_fruit: Vec<TCollector::Fruit> = children
+            .into_iter()
             .map(|untyped_fruit| {
                 Downcast::<TCollector::Fruit>::downcast(untyped_fruit)
                     .map(|boxed_but_typed| *boxed_but_typed)
@@ -40,16 +43,13 @@ impl<TCollector: Collector> Collector for CollectorWrapper<TCollector> {
                         let err_msg = format!("Failed to cast child collector fruit. {:?}", e);
                         TantivyError::InvalidArgument(err_msg)
                     })
-            })
-            .collect::<Result<_>>()?;
+            }).collect::<Result<_>>()?;
         let merged_fruit = self.0.merge_fruits(typed_fruit)?;
         Ok(Box::new(merged_fruit))
     }
 }
 
-
 impl SegmentCollector for Box<BoxableSegmentCollector> {
-
     type Fruit = Box<Fruit>;
 
     fn collect(&mut self, doc: u32, score: f32) {
@@ -66,13 +66,11 @@ pub trait BoxableSegmentCollector {
     fn harvest_from_box(self: Box<Self>) -> Box<Fruit>;
 }
 
-
-
 pub struct SegmentCollectorWrapper<TSegmentCollector: SegmentCollector>(TSegmentCollector);
 
-
-impl<TSegmentCollector: SegmentCollector> BoxableSegmentCollector for SegmentCollectorWrapper<TSegmentCollector> {
-
+impl<TSegmentCollector: SegmentCollector> BoxableSegmentCollector
+    for SegmentCollectorWrapper<TSegmentCollector>
+{
     fn collect(&mut self, doc: u32, score: f32) {
         self.0.collect(doc, score);
     }
@@ -84,16 +82,13 @@ impl<TSegmentCollector: SegmentCollector> BoxableSegmentCollector for SegmentCol
 
 pub struct FruitHandle<TFruit: Fruit> {
     pos: usize,
-    _phantom: PhantomData<TFruit>
+    _phantom: PhantomData<TFruit>,
 }
 
 impl<TFruit: Fruit> FruitHandle<TFruit> {
     pub fn extract(self, fruits: &mut MultiFruit) -> TFruit {
-        let boxed_fruit = fruits.sub_fruits[self.pos]
-            .take()
-            .expect("");
-        *Downcast::<TFruit>::downcast(boxed_fruit)
-            .expect("Failed")
+        let boxed_fruit = fruits.sub_fruits[self.pos].take().expect("");
+        *Downcast::<TFruit>::downcast(boxed_fruit).expect("Failed")
     }
 }
 
@@ -153,25 +148,29 @@ impl<TFruit: Fruit> FruitHandle<TFruit> {
 /// }
 /// ```
 pub struct MultiCollector<'a> {
-    collector_wrappers: Vec<Box<Collector<Child=Box<BoxableSegmentCollector>,Fruit=Box<Fruit>> + 'a>>
+    collector_wrappers:
+        Vec<Box<Collector<Child = Box<BoxableSegmentCollector>, Fruit = Box<Fruit>> + 'a>>,
 }
 
 impl<'a> MultiCollector<'a> {
-
     /// Create a new `MultiCollector`
     pub fn new() -> MultiCollector<'a> {
         MultiCollector {
-            collector_wrappers: Vec::new()
+            collector_wrappers: Vec::new(),
         }
     }
 
     /// Add a new collector to our `MultiCollector`.
-    pub fn add_collector<'b: 'a, TCollector: Collector + 'b>(&mut self, collector: TCollector) -> FruitHandle<TCollector::Fruit> {
+    pub fn add_collector<'b: 'a, TCollector: Collector + 'b>(
+        &mut self,
+        collector: TCollector,
+    ) -> FruitHandle<TCollector::Fruit> {
         let pos = self.collector_wrappers.len();
-        self.collector_wrappers.push(Box::new(CollectorWrapper(collector)));
+        self.collector_wrappers
+            .push(Box::new(CollectorWrapper(collector)));
         FruitHandle {
             pos,
-            _phantom: PhantomData
+            _phantom: PhantomData,
         }
     }
 }
@@ -180,30 +179,27 @@ impl<'a> Collector for MultiCollector<'a> {
     type Fruit = MultiFruit;
     type Child = MultiCollectorChild;
 
-    fn for_segment(&self, segment_local_id: SegmentLocalId, segment: &SegmentReader) -> Result<MultiCollectorChild> {
-        let children = self.collector_wrappers
+    fn for_segment(
+        &self,
+        segment_local_id: SegmentLocalId,
+        segment: &SegmentReader,
+    ) -> Result<MultiCollectorChild> {
+        let children = self
+            .collector_wrappers
             .iter()
-            .map(|collector_wrapper| {
-                collector_wrapper.for_segment(segment_local_id, segment)
-            })
+            .map(|collector_wrapper| collector_wrapper.for_segment(segment_local_id, segment))
             .collect::<Result<Vec<_>>>()?;
-        Ok(MultiCollectorChild {
-            children
-        })
+        Ok(MultiCollectorChild { children })
     }
 
     fn requires_scoring(&self) -> bool {
-        self.collector_wrappers
-            .iter()
-            .any(|c| c.requires_scoring())
+        self.collector_wrappers.iter().any(|c| c.requires_scoring())
     }
 
-    fn merge_fruits(&self, segments_multifruits: Vec<MultiFruit>)
-        -> Result<MultiFruit> {
-        let mut segment_fruits_list: Vec<Vec<Box<Fruit>>> =
-            (0..self.collector_wrappers.len())
-                .map(|_| Vec::with_capacity(segments_multifruits.len()))
-                .collect::<Vec<_>>();
+    fn merge_fruits(&self, segments_multifruits: Vec<MultiFruit>) -> Result<MultiFruit> {
+        let mut segment_fruits_list: Vec<Vec<Box<Fruit>>> = (0..self.collector_wrappers.len())
+            .map(|_| Vec::with_capacity(segments_multifruits.len()))
+            .collect::<Vec<_>>();
         for segment_multifruit in segments_multifruits {
             for (idx, segment_fruit_opt) in segment_multifruit.sub_fruits.into_iter().enumerate() {
                 if let Some(segment_fruit) = segment_fruit_opt {
@@ -211,21 +207,19 @@ impl<'a> Collector for MultiCollector<'a> {
                 }
             }
         }
-        let sub_fruits = self.collector_wrappers
+        let sub_fruits = self
+            .collector_wrappers
             .iter()
             .zip(segment_fruits_list)
-            .map(|(child_collector, segment_fruits)|
+            .map(|(child_collector, segment_fruits)| {
                 Ok(Some(child_collector.merge_fruits(segment_fruits)?))
-            )
-            .collect::<Result<_>>()?;
+            }).collect::<Result<_>>()?;
         Ok(MultiFruit { sub_fruits })
     }
-
 }
 
-
 pub struct MultiCollectorChild {
-    children: Vec<Box<BoxableSegmentCollector>>
+    children: Vec<Box<BoxableSegmentCollector>>,
 }
 
 impl SegmentCollector for MultiCollectorChild {
@@ -239,25 +233,25 @@ impl SegmentCollector for MultiCollectorChild {
 
     fn harvest(self) -> MultiFruit {
         MultiFruit {
-            sub_fruits: self.children
+            sub_fruits: self
+                .children
                 .into_iter()
-                .map(|child| Some(child.harvest()) )
-                .collect()
+                .map(|child| Some(child.harvest()))
+                .collect(),
         }
     }
 }
 
-
 #[cfg(test)]
 mod tests {
 
     use super::*;
     use collector::{Count, TopDocs};
-    use schema::{TEXT, Schema};
     use query::TermQuery;
+    use schema::IndexRecordOption;
+    use schema::{Schema, TEXT};
     use Index;
     use Term;
-    use schema::IndexRecordOption;
 
     #[test]
     fn test_multi_collector() {
@@ -291,4 +285,3 @@ mod tests {
         assert_eq!(topdocs_handler.extract(&mut multifruits).len(), 2);
     }
 }
-
diff --git a/src/collector/tests.rs b/src/collector/tests.rs
index d67ff14..cc8bcff 100644
--- a/src/collector/tests.rs
+++ b/src/collector/tests.rs
@@ -3,10 +3,10 @@ use core::SegmentReader;
 use fastfield::BytesFastFieldReader;
 use fastfield::FastFieldReader;
 use schema::Field;
+use DocAddress;
 use DocId;
 use Score;
 use SegmentLocalId;
-use DocAddress;
 
 /// Stores all of the doc ids.
 /// This collector is only used for tests.
@@ -24,12 +24,12 @@ pub struct TestSegmentCollector {
 #[derive(Default)]
 pub struct TestFruit {
     docs: Vec<DocAddress>,
-    scores: Vec<Score>
+    scores: Vec<Score>,
 }
 
 impl TestFruit {
     /// Return the list of matching documents exhaustively.
-    pub fn docs(&self) ->&[DocAddress] {
+    pub fn docs(&self) -> &[DocAddress] {
         &self.docs[..]
     }
 
@@ -42,10 +42,14 @@ impl Collector for TestCollector {
     type Fruit = TestFruit;
     type Child = TestSegmentCollector;
 
-    fn for_segment(&self, segment_id: SegmentLocalId, _reader: &SegmentReader) -> Result<TestSegmentCollector> {
+    fn for_segment(
+        &self,
+        segment_id: SegmentLocalId,
+        _reader: &SegmentReader,
+    ) -> Result<TestSegmentCollector> {
         Ok(TestSegmentCollector {
             segment_id,
-            fruit: TestFruit::default()
+            fruit: TestFruit::default(),
         })
     }
 
@@ -54,13 +58,13 @@ impl Collector for TestCollector {
     }