diff --git a/src/core/segment_reader.rs b/src/core/segment_reader.rs
index 2c56d17cd..ef8fd38aa 100644
--- a/src/core/segment_reader.rs
+++ b/src/core/segment_reader.rs
@@ -414,8 +414,8 @@ impl<'a> Iterator for SegmentReaderAliveDocsIterator<'a> {
 #[cfg(test)]
 mod test {
     use core::Index;
+    use schema::{SchemaBuilder, Term, STORED, TEXT};
     use DocId;
-    use schema::{TEXT, STORED, Term, SchemaBuilder};
 
     #[test]
     fn test_alive_docs_iterator() {
@@ -448,6 +448,6 @@ mod test {
         index.load_searchers().unwrap();
         let searcher = index.searcher();
         let docs: Vec<DocId> = searcher.segment_reader(0).doc_ids_alive().collect();
-        assert_eq!(vec![0u32, 2u32],  docs);
+        assert_eq!(vec![0u32, 2u32], docs);
     }
 }
diff --git a/src/query/query.rs b/src/query/query.rs
index a9f3077bb..51e068b92 100644
--- a/src/query/query.rs
+++ b/src/query/query.rs
@@ -84,7 +84,8 @@ pub trait QueryClone {
 }
 
 impl<T> QueryClone for T
-where T: 'static + Query + Clone
+where
+    T: 'static + Query + Clone,
 {
     fn box_clone(&self) -> Box<Query> {
         Box::new(self.clone())
@@ -94,4 +95,4 @@ where T: 'static + Query + Clone
 #[allow(missing_docs)]
 mod downcast_impl {
     downcast!(super::Query);
-}
\ No newline at end of file
+}
diff --git a/src/tokenizer/stop_word_filter.rs b/src/tokenizer/stop_word_filter.rs
index 6e8f08476..f94ec632f 100644
--- a/src/tokenizer/stop_word_filter.rs
+++ b/src/tokenizer/stop_word_filter.rs
@@ -25,73 +25,76 @@ type StopWordHashSet = HashSet<String, StopWordHasher>;
 /// `TokenFilter` that removes stop words from a token stream
 #[derive(Clone)]
 pub struct StopWordFilter {
-  words: StopWordHashSet,
+    words: StopWordHashSet,
 }
 
 impl StopWordFilter {
-  /// Creates a `StopWordFilter` given a list of words to remove
-  pub fn remove(words: Vec<String>) -> StopWordFilter {
-    let mut set = StopWordHashSet::default();
+    /// Creates a `StopWordFilter` given a list of words to remove
+    pub fn remove(words: Vec<String>) -> StopWordFilter {
+        let mut set = StopWordHashSet::default();
 
-    for word in words {
-      set.insert(word);
+        for word in words {
+            set.insert(word);
+        }
+
+        StopWordFilter { words: set }
     }
-
-    StopWordFilter { words: set }
-  }
 }
 
 pub struct StopWordFilterStream<TailTokenStream>
 where
-  TailTokenStream: TokenStream,
+    TailTokenStream: TokenStream,
 {
-  words: StopWordHashSet,
-  tail: TailTokenStream,
+    words: StopWordHashSet,
+    tail: TailTokenStream,
 }
 
 impl<TailTokenStream> TokenFilter<TailTokenStream> for StopWordFilter
 where
-  TailTokenStream: TokenStream,
+    TailTokenStream: TokenStream,
 {
-  type ResultTokenStream = StopWordFilterStream<TailTokenStream>;
+    type ResultTokenStream = StopWordFilterStream<TailTokenStream>;
 
-  fn transform(&self, token_stream: TailTokenStream) -> Self::ResultTokenStream {
-    StopWordFilterStream::wrap(self.words.clone(), token_stream)
-  }
+    fn transform(&self, token_stream: TailTokenStream) -> Self::ResultTokenStream {
+        StopWordFilterStream::wrap(self.words.clone(), token_stream)
+    }
 }
 
 impl<TailTokenStream> StopWordFilterStream<TailTokenStream>
 where
-  TailTokenStream: TokenStream,
+    TailTokenStream: TokenStream,
 {
-  fn predicate(&self, token: &Token) -> bool {
-    !self.words.contains(&token.text)
-  }
+    fn predicate(&self, token: &Token) -> bool {
+        !self.words.contains(&token.text)
+    }
 
-  fn wrap(words: StopWordHashSet, tail: TailTokenStream) -> StopWordFilterStream<TailTokenStream> {
-    StopWordFilterStream { words, tail }
-  }
+    fn wrap(
+        words: StopWordHashSet,
+        tail: TailTokenStream,
+    ) -> StopWordFilterStream<TailTokenStream> {
+        StopWordFilterStream { words, tail }
+    }
 }
 
 impl<TailTokenStream> TokenStream for StopWordFilterStream<TailTokenStream>
 where
-  TailTokenStream: TokenStream,
+    TailTokenStream: TokenStream,
 {
-  fn token(&self) -> &Token {
-    self.tail.token()
-  }
-
-  fn token_mut(&mut self) -> &mut Token {
-    self.tail.token_mut()
-  }
-
-  fn advance(&mut self) -> bool {
-    while self.tail.advance() {
-      if self.predicate(self.tail.token()) {
-        return true;
-      }
+    fn token(&self) -> &Token {
+        self.tail.token()
     }
 
-    false
-  }
+    fn token_mut(&mut self) -> &mut Token {
+        self.tail.token_mut()
+    }
+
+    fn advance(&mut self) -> bool {
+        while self.tail.advance() {
+            if self.predicate(self.tail.token()) {
+                return true;
+            }
+        }
+
+        false
+    }
 }