Apply rustfmt to the code base (sunchao#189)

alecmocatta · Nov 11, 2018 · e071f62 · e071f62
1 parent 0240298
commit e071f62
Show file tree

Hide file tree

Showing 45 changed files with 6,301 additions and 4,635 deletions.
diff --git a/.travis.yml b/.travis.yml
@@ -35,10 +35,12 @@ rust:
 
 before_script:
   - pip install 'travis-cargo<0.2' --user && export PATH=$HOME/.local/bin:$PATH
+  - rustup component add rustfmt-preview
   - cargo install cargo-travis || echo "Skipping cargo-travis installation as it is already cached"
   - export PATH=$HOME/.cargo/bin:$PATH
 
 script:
+  - cargo fmt --all -- --check
   - cargo build
   - cargo test
   - cargo doc --no-deps

diff --git a/benches/codec.rs b/benches/codec.rs
@@ -22,12 +22,9 @@ extern crate lazy_static;
 extern crate test;
 use test::Bencher;
 
-use std::env;
-use std::fs::File;
+use std::{env, fs::File};
 
-use parquet::basic::Compression;
-use parquet::file::reader::*;
-use parquet::compression::*;
+use parquet::{basic::Compression, compression::*, file::reader::*};
 
 // 10k rows written in page v2 with type:
 //
@@ -73,9 +70,7 @@ macro_rules! compress {
     #[bench]
     fn $fname(bench: &mut Bencher) {
       lazy_static! {
-        static ref DATA: Vec<u8> = {
-          get_pages_bytes($col_idx)
-        };
+        static ref DATA: Vec<u8> = { get_pages_bytes($col_idx) };
       }
 
       let mut codec = create_codec($codec).unwrap().unwrap();
@@ -85,7 +80,7 @@ macro_rules! compress {
         codec.compress(&DATA[..], &mut v).unwrap();
       })
     }
-  }
+  };
 }
 
 macro_rules! decompress {
@@ -110,7 +105,7 @@ macro_rules! decompress {
         let _ = codec.decompress(&COMPRESSED_PAGES[..], &mut v).unwrap();
       })
     }
-  }
+  };
 }
 
 compress!(compress_brotli_binary, Compression::BROTLI, 0);

diff --git a/benches/common.rs b/benches/common.rs
@@ -21,9 +21,11 @@ extern crate rand;
 use rand::{thread_rng, Rng};
 use std::rc::Rc;
 
-use parquet::basic::*;
-use parquet::data_type::*;
-use parquet::schema::types::{Type as SchemaType, ColumnDescriptor, ColumnPath};
+use parquet::{
+  basic::*,
+  data_type::*,
+  schema::types::{ColumnDescriptor, ColumnPath, Type as SchemaType},
+};
 
 macro_rules! gen_random_ints {
   ($fname:ident, $limit:expr) => {
@@ -36,7 +38,7 @@ macro_rules! gen_random_ints {
       let bytes = values.len() * ::std::mem::size_of::<i32>();
       (bytes, values)
     }
-  }
+  };
 }
 
 gen_random_ints!(gen_10, 10);

diff --git a/benches/decoding.rs b/benches/decoding.rs
@@ -28,20 +28,22 @@ use common::*;
 
 use std::rc::Rc;
 
-use parquet::basic::*;
-use parquet::data_type::*;
-use parquet::decoding::*;
-use parquet::encoding::*;
-use parquet::memory::{ByteBufferPtr, MemTracker};
+use parquet::{
+  basic::*,
+  data_type::*,
+  decoding::*,
+  encoding::*,
+  memory::{ByteBufferPtr, MemTracker},
+};
 
 macro_rules! plain {
   ($fname:ident, $num_values:expr, $batch_size:expr, $ty:ident, $pty:expr,
    $gen_data_fn:expr) => {
     #[bench]
     fn $fname(bench: &mut Bencher) {
       let mem_tracker = Rc::new(MemTracker::new());
-      let mut encoder = PlainEncoder::<$ty>::new(
-        Rc::new(col_desc(0, $pty)), mem_tracker, vec![]);
+      let mut encoder =
+        PlainEncoder::<$ty>::new(Rc::new(col_desc(0, $pty)), mem_tracker, vec![]);
 
       let (_, values) = $gen_data_fn($num_values);
       encoder.put(&values[..]).expect("put() should be OK");
@@ -50,7 +52,7 @@ macro_rules! plain {
       let decoder = PlainDecoder::<$ty>::new(0);
       bench_decoding(bench, $num_values, $batch_size, buffer, Box::new(decoder));
     }
-  }
+  };
 }
 
 macro_rules! dict {
@@ -59,23 +61,27 @@ macro_rules! dict {
     #[bench]
     fn $fname(bench: &mut Bencher) {
       let mem_tracker = Rc::new(MemTracker::new());
-      let mut encoder = DictEncoder::<$ty>::new(
-        Rc::new(col_desc(0, $pty)), mem_tracker);
+      let mut encoder = DictEncoder::<$ty>::new(Rc::new(col_desc(0, $pty)), mem_tracker);
 
       let (_, values) = $gen_data_fn($num_values);
       encoder.put(&values[..]).expect("put() should be OK");
       let mut dict_decoder = PlainDecoder::<$ty>::new(0);
-      dict_decoder.set_data(
-        encoder.write_dict().expect("write_dict() should be OK"),
-        encoder.num_entries()).expect("set_data() should be OK");
+      dict_decoder
+        .set_data(
+          encoder.write_dict().expect("write_dict() should be OK"),
+          encoder.num_entries(),
+        )
+        .expect("set_data() should be OK");
 
       let buffer = encoder.flush_buffer().expect("flush_buffer() should be OK");
       let mut decoder = DictDecoder::<$ty>::new();
-      decoder.set_dict(Box::new(dict_decoder)).expect("set_dict() should be OK");
+      decoder
+        .set_dict(Box::new(dict_decoder))
+        .expect("set_dict() should be OK");
 
       bench_decoding(bench, $num_values, $batch_size, buffer, Box::new(decoder));
     }
-  }
+  };
 }
 
 macro_rules! delta_bit_pack {
@@ -91,47 +97,117 @@ macro_rules! delta_bit_pack {
       let decoder = DeltaBitPackDecoder::<$ty>::new();
       bench_decoding(bench, $num_values, $batch_size, buffer, Box::new(decoder));
     }
-  }
+  };
 }
 
 fn bench_decoding<T: DataType>(
   bench: &mut Bencher,
   num_values: usize,
   batch_size: usize,
   buffer: ByteBufferPtr,
-  mut decoder: Box<Decoder<T>>
-) {
+  mut decoder: Box<Decoder<T>>,
+)
+{
   bench.bytes = buffer.len() as u64;
   bench.iter(|| {
-    decoder.set_data(buffer.clone(), num_values).expect("set_data() should be OK");
+    decoder
+      .set_data(buffer.clone(), num_values)
+      .expect("set_data() should be OK");
     let mut values = vec![T::T::default(); batch_size];
     loop {
       if decoder.get(&mut values[..]).expect("get() should be OK") < batch_size {
-        break
+        break;
       }
     }
   })
 }
 
 plain!(plain_i32_1k_32, 1024, 32, Int32Type, Type::INT32, gen_1000);
 plain!(plain_i32_1k_64, 1024, 64, Int32Type, Type::INT32, gen_1000);
-plain!(plain_i32_1k_128, 1024, 128, Int32Type, Type::INT32, gen_1000);
+plain!(
+  plain_i32_1k_128,
+  1024,
+  128,
+  Int32Type,
+  Type::INT32,
+  gen_1000
+);
 plain!(plain_i32_1m_32, 1024, 32, Int32Type, Type::INT32, gen_1000);
 plain!(plain_i32_1m_64, 1024, 64, Int32Type, Type::INT32, gen_1000);
-plain!(plain_i32_1m_128, 1024, 128, Int32Type, Type::INT32, gen_1000);
-plain!(plain_str_1m_128, 1024, 128, ByteArrayType, Type::BYTE_ARRAY, gen_test_strs);
+plain!(
+  plain_i32_1m_128,
+  1024,
+  128,
+  Int32Type,
+  Type::INT32,
+  gen_1000
+);
+plain!(
+  plain_str_1m_128,
+  1024,
+  128,
+  ByteArrayType,
+  Type::BYTE_ARRAY,
+  gen_test_strs
+);
 
 dict!(dict_i32_1k_32, 1024, 32, Int32Type, Type::INT32, gen_1000);
 dict!(dict_i32_1k_64, 1024, 64, Int32Type, Type::INT32, gen_1000);
 dict!(dict_i32_1k_128, 1024, 128, Int32Type, Type::INT32, gen_1000);
-dict!(dict_i32_1m_32, 1024 * 1024, 32, Int32Type, Type::INT32, gen_1000);
-dict!(dict_i32_1m_64, 1024 * 1024, 64, Int32Type, Type::INT32, gen_1000);
-dict!(dict_i32_1m_128, 1024 * 1024, 128, Int32Type, Type::INT32, gen_1000);
-dict!(dict_str_1m_128, 1024 * 1024, 128, ByteArrayType, Type::BYTE_ARRAY, gen_test_strs);
+dict!(
+  dict_i32_1m_32,
+  1024 * 1024,
+  32,
+  Int32Type,
+  Type::INT32,
+  gen_1000
+);
+dict!(
+  dict_i32_1m_64,
+  1024 * 1024,
+  64,
+  Int32Type,
+  Type::INT32,
+  gen_1000
+);
+dict!(
+  dict_i32_1m_128,
+  1024 * 1024,
+  128,
+  Int32Type,
+  Type::INT32,
+  gen_1000
+);
+dict!(
+  dict_str_1m_128,
+  1024 * 1024,
+  128,
+  ByteArrayType,
+  Type::BYTE_ARRAY,
+  gen_test_strs
+);
 
 delta_bit_pack!(delta_bit_pack_i32_1k_32, 1024, 32, Int32Type, gen_1000);
 delta_bit_pack!(delta_bit_pack_i32_1k_64, 1024, 64, Int32Type, gen_1000);
 delta_bit_pack!(delta_bit_pack_i32_1k_128, 1024, 128, Int32Type, gen_1000);
-delta_bit_pack!(delta_bit_pack_i32_1m_32, 1024 * 1024, 32, Int32Type, gen_1000);
-delta_bit_pack!(delta_bit_pack_i32_1m_64, 1024 * 1024, 64, Int32Type, gen_1000);
-delta_bit_pack!(delta_bit_pack_i32_1m_128, 1024 * 1024, 128, Int32Type, gen_1000);
+delta_bit_pack!(
+  delta_bit_pack_i32_1m_32,
+  1024 * 1024,
+  32,
+  Int32Type,
+  gen_1000
+);
+delta_bit_pack!(
+  delta_bit_pack_i32_1m_64,
+  1024 * 1024,
+  64,
+  Int32Type,
+  gen_1000
+);
+delta_bit_pack!(
+  delta_bit_pack_i32_1m_128,
+  1024 * 1024,
+  128,
+  Int32Type,
+  gen_1000
+);