Minor refactoring (#1266)

Author: fulmicoton

bitpacker/src/bitpacker.rs

@@ -1,4 +1,5 @@
-use std::{convert::TryInto, io};
+use std::convert::TryInto;
+use std::io;
 
 pub struct BitPacker {
     mini_buffer: u64,

bitpacker/src/blocked_bitpacker.rs

@@ -1,12 +1,11 @@
+use super::bitpacker::BitPacker;
+use super::compute_num_bits;
 use crate::{minmax, BitUnpacker};
 
-use super::{bitpacker::BitPacker, compute_num_bits};
-
 const BLOCK_SIZE: usize = 128;
 
 /// `BlockedBitpacker` compresses data in blocks of
 /// 128 elements, while keeping an index on it
-///
 #[derive(Debug, Clone)]
 pub struct BlockedBitpacker {
     // bitpacked blocks

bitpacker/src/lib.rs

@@ -1,8 +1,7 @@
 mod bitpacker;
 mod blocked_bitpacker;
 
-pub use crate::bitpacker::BitPacker;
-pub use crate::bitpacker::BitUnpacker;
+pub use crate::bitpacker::{BitPacker, BitUnpacker};
 pub use crate::blocked_bitpacker::BlockedBitpacker;
 
 /// Computes the number of bits that will be used for bitpacking.

common/src/bitset.rs

@@ -1,8 +1,8 @@
-use ownedbytes::OwnedBytes;
 use std::convert::TryInto;
 use std::io::Write;
-use std::u64;
-use std::{fmt, io};
+use std::{fmt, io, u64};
+
+use ownedbytes::OwnedBytes;
 
 #[derive(Clone, Copy, Eq, PartialEq)]
 pub struct TinySet(u64);
@@ -187,7 +187,6 @@ fn num_buckets(max_val: u32) -> u32 {
 
 impl BitSet {
     /// serialize a `BitSet`.
-    ///
     pub fn serialize<T: Write>(&self, writer: &mut T) -> io::Result<()> {
         writer.write_all(self.max_value.to_le_bytes().as_ref())?;
         for tinyset in self.tinysets.iter().cloned() {
@@ -353,7 +352,6 @@ impl ReadOnlyBitSet {
     }
 
     /// Iterate the tinyset on the fly from serialized data.
-    ///
     #[inline]
     fn iter_tinysets(&self) -> impl Iterator<Item = TinySet> + '_ {
         self.data.chunks_exact(8).map(move |chunk| {
@@ -363,7 +361,6 @@ impl ReadOnlyBitSet {
     }
 
     /// Iterate over the positions of the elements.
-    ///
     #[inline]
     pub fn iter(&self) -> impl Iterator<Item = u32> + '_ {
         self.iter_tinysets()
@@ -415,14 +412,14 @@ impl<'a> From<&'a BitSet> for ReadOnlyBitSet {
 #[cfg(test)]
 mod tests {
 
-    use super::BitSet;
-    use super::ReadOnlyBitSet;
-    use super::TinySet;
+    use std::collections::HashSet;
+
     use ownedbytes::OwnedBytes;
     use rand::distributions::Bernoulli;
     use rand::rngs::StdRng;
     use rand::{Rng, SeedableRng};
-    use std::collections::HashSet;
+
+    use super::{BitSet, ReadOnlyBitSet, TinySet};
 
     #[test]
     fn test_read_serialized_bitset_full_multi() {
@@ -710,10 +707,10 @@ mod tests {
 #[cfg(all(test, feature = "unstable"))]
 mod bench {
 
-    use super::BitSet;
-    use super::TinySet;
     use test;
 
+    use super::{BitSet, TinySet};
+
     #[bench]
     fn bench_tinyset_pop(b: &mut test::Bencher) {
         b.iter(|| {

common/src/lib.rs

@@ -104,11 +104,12 @@ pub fn u64_to_f64(val: u64) -> f64 {
 #[cfg(test)]
 pub mod test {
 
-    use super::{f64_to_u64, i64_to_u64, u64_to_f64, u64_to_i64};
-    use super::{BinarySerializable, FixedSize};
-    use proptest::prelude::*;
     use std::f64;
 
+    use proptest::prelude::*;
+
+    use super::{f64_to_u64, i64_to_u64, u64_to_f64, u64_to_i64, BinarySerializable, FixedSize};
+
     fn test_i64_converter_helper(val: i64) {
         assert_eq!(u64_to_i64(i64_to_u64(val)), val);
     }
@@ -157,10 +158,10 @@ pub mod test {
     #[test]
     fn test_f64_order() {
         assert!(!(f64_to_u64(f64::NEG_INFINITY)..f64_to_u64(f64::INFINITY))
-            .contains(&f64_to_u64(f64::NAN))); //nan is not a number
-        assert!(f64_to_u64(1.5) > f64_to_u64(1.0)); //same exponent, different mantissa
-        assert!(f64_to_u64(2.0) > f64_to_u64(1.0)); //same mantissa, different exponent
-        assert!(f64_to_u64(2.0) > f64_to_u64(1.5)); //different exponent and mantissa
+            .contains(&f64_to_u64(f64::NAN))); // nan is not a number
+        assert!(f64_to_u64(1.5) > f64_to_u64(1.0)); // same exponent, different mantissa
+        assert!(f64_to_u64(2.0) > f64_to_u64(1.0)); // same mantissa, different exponent
+        assert!(f64_to_u64(2.0) > f64_to_u64(1.5)); // different exponent and mantissa
         assert!(f64_to_u64(1.0) > f64_to_u64(-1.0)); // pos > neg
         assert!(f64_to_u64(-1.5) < f64_to_u64(-1.0));
         assert!(f64_to_u64(-2.0) < f64_to_u64(1.0));

common/src/serialize.rs

@@ -1,10 +1,9 @@
-use crate::Endianness;
-use crate::VInt;
+use std::io::{Read, Write};
+use std::{fmt, io};
+
 use byteorder::{ReadBytesExt, WriteBytesExt};
-use std::fmt;
-use std::io;
-use std::io::Read;
-use std::io::Write;
+
+use crate::{Endianness, VInt};
 
 /// Trait for a simple binary serialization.
 pub trait BinarySerializable: fmt::Debug + Sized {
@@ -202,8 +201,7 @@ impl BinarySerializable for String {
 #[cfg(test)]
 pub mod test {
 
-    use super::VInt;
-    use super::*;
+    use super::{VInt, *};
     use crate::serialize::BinarySerializable;
     pub fn fixed_size_test<O: BinarySerializable + FixedSize + Default>() {
         let mut buffer = Vec::new();

common/src/vint.rs

@@ -1,8 +1,9 @@
-use super::BinarySerializable;
-use byteorder::{ByteOrder, LittleEndian};
 use std::io;
-use std::io::Read;
-use std::io::Write;
+use std::io::{Read, Write};
+
+use byteorder::{ByteOrder, LittleEndian};
+
+use super::BinarySerializable;
 
 ///   Wrapper over a `u64` that serializes as a variable int.
 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
@@ -174,9 +175,7 @@ impl BinarySerializable for VInt {
 #[cfg(test)]
 mod tests {
 
-    use super::serialize_vint_u32;
-    use super::BinarySerializable;
-    use super::VInt;
+    use super::{serialize_vint_u32, BinarySerializable, VInt};
 
     fn aux_test_vint(val: u64) {
         let mut v = [14u8; 10];

common/src/writer.rs

@@ -54,7 +54,8 @@ impl<W: TerminatingWrite> TerminatingWrite for CountingWriter<W> {
     }
 }
 
-/// Struct used to prevent from calling [`terminate_ref`](trait.TerminatingWrite.html#tymethod.terminate_ref) directly
+/// Struct used to prevent from calling
+/// [`terminate_ref`](trait.TerminatingWrite.html#tymethod.terminate_ref) directly
 ///
 /// The point is that while the type is public, it cannot be built by anyone
 /// outside of this module.
@@ -64,9 +65,7 @@ pub struct AntiCallToken(());
 pub trait TerminatingWrite: Write {
     /// Indicate that the writer will no longer be used. Internally call terminate_ref.
     fn terminate(mut self) -> io::Result<()>
-    where
-        Self: Sized,
-    {
+    where Self: Sized {
         self.terminate_ref(AntiCallToken(()))
     }
 
@@ -97,9 +96,10 @@ impl<'a> TerminatingWrite for &'a mut Vec<u8> {
 #[cfg(test)]
 mod test {
 
-    use super::CountingWriter;
     use std::io::Write;
 
+    use super::CountingWriter;
+
     #[test]
     fn test_counting_writer() {
         let buffer: Vec<u8> = vec![];

examples/basic_search.rs

@@ -91,8 +91,8 @@ fn main() -> tantivy::Result<()> {
     old_man_doc.add_text(title, "The Old Man and the Sea");
     old_man_doc.add_text(
         body,
-        "He was an old man who fished alone in a skiff in the Gulf Stream and \
-         he had gone eighty-four days now without taking a fish.",
+        "He was an old man who fished alone in a skiff in the Gulf Stream and he had gone \
+         eighty-four days now without taking a fish.",
     );
 
     // ... and add it to the `IndexWriter`.

examples/custom_collector.rs

@@ -12,8 +12,7 @@
 use tantivy::collector::{Collector, SegmentCollector};
 use tantivy::fastfield::{DynamicFastFieldReader, FastFieldReader};
 use tantivy::query::QueryParser;
-use tantivy::schema::Field;
-use tantivy::schema::{Schema, FAST, INDEXED, TEXT};
+use tantivy::schema::{Field, Schema, FAST, INDEXED, TEXT};
 use tantivy::{doc, Index, Score, SegmentReader};
 
 #[derive(Default)]