Fixing rustfmt.toml and applying formatting...

rustfmt.toml

@@ -1,4 +1 @@
 reorder_imports = true
-max_width = 100
-ideal_width = 100
-trailing_comma = always

src/backup.rs

@@ -13,9 +13,8 @@
 // limitations under the License.
 //
 
-
-use {DB, Error};
 use ffi;
+use {Error, DB};
 
 use libc::{c_int, uint32_t};
 use std::ffi::CString;
@@ -64,8 +63,7 @@ impl BackupEngine {
     pub fn create_new_backup(&mut self, db: &DB) -> Result<(), Error> {
         unsafe {
             ffi_try!(ffi::rocksdb_backup_engine_create_new_backup(
-                self.inner,
-                db.inner,
+                self.inner, db.inner,
             ));
             Ok(())
         }

src/checkpoint.rs

@@ -13,14 +13,13 @@
 // limitations under the License.
 //
 
-///! Implementation of bindings to RocksDB Checkpoint[1] API
-///
-/// [1]: https://github.com/facebook/rocksdb/wiki/Checkpoints
-
-use {DB, Error};
 use ffi;
 use std::ffi::CString;
 use std::path::Path;
+///! Implementation of bindings to RocksDB Checkpoint[1] API
+///
+/// [1]: https://github.com/facebook/rocksdb/wiki/Checkpoints
+use {Error, DB};
 
 /// Undocumented parameter for `ffi::rocksdb_checkpoint_create` function. Zero by default.
 const LOG_SIZE_FOR_FLUSH: u64 = 0_u64;
@@ -45,9 +44,7 @@ impl Checkpoint {
             return Err(Error::new("Could not create checkpoint object.".to_owned()));
         }
 
-        Ok(Checkpoint {
-            inner: checkpoint,
-        })
+        Ok(Checkpoint { inner: checkpoint })
     }
 
     /// Creates new physical DB checkpoint in directory specified by `path`.
@@ -57,14 +54,17 @@ impl Checkpoint {
             Ok(c) => c,
             Err(_) => {
                 return Err(Error::new(
-                    "Failed to convert path to CString when creating DB checkpoint"
-                        .to_owned(),
+                    "Failed to convert path to CString when creating DB checkpoint".to_owned(),
                 ));
             }
         };
 
         unsafe {
-            ffi_try!(ffi::rocksdb_checkpoint_create(self.inner, cpath.as_ptr(), LOG_SIZE_FOR_FLUSH,));
+            ffi_try!(ffi::rocksdb_checkpoint_create(
+                self.inner,
+                cpath.as_ptr(),
+                LOG_SIZE_FOR_FLUSH,
+            ));
 
             Ok(())
         }

src/compaction_filter.rs

@@ -32,7 +32,6 @@ pub enum Decision {
     Change(&'static [u8]),
 }
 
-
 /// Function to filter compaction with.
 ///
 /// This function takes the level of compaction, the key, and the existing value
@@ -46,8 +45,7 @@ impl<F> CompactionFilterFn for F
 where
     F: FnMut(u32, &[u8], &[u8]) -> Decision,
     F: Send + 'static,
-{
-}
+{}
 
 pub struct CompactionFilterCallback<F>
 where
@@ -117,7 +115,7 @@ fn test_filter(level: u32, key: &[u8], value: &[u8]) -> Decision {
 
 #[test]
 fn compaction_filter_test() {
-    use {DB, Options};
+    use {Options, DB};
 
     let path = "_rust_rocksdb_filtertest";
     let mut opts = Options::default();
@@ -133,5 +131,4 @@ fn compaction_filter_test() {
         assert!(db.get(b"_k").unwrap().is_none());
         assert_eq!(&*db.get(b"%k").unwrap().unwrap(), b"secret");
     }
-
 }

src/comparator.rs

@@ -13,7 +13,6 @@
 // limitations under the License.
 //
 
-
 use libc::{c_char, c_int, c_void, size_t};
 use std::cmp::Ordering;
 use std::ffi::CString;

src/db.rs

@@ -13,13 +13,13 @@
 // limitations under the License.
 //
 
-
-use {DB, Error, Options, WriteOptions, ColumnFamily, ColumnFamilyDescriptor};
 use ffi;
 use ffi_util::opt_bytes_to_ptr;
+use {ColumnFamily, ColumnFamilyDescriptor, Error, Options, WriteOptions, DB};
 
 use libc::{self, c_char, c_int, c_uchar, c_void, size_t};
 use std::collections::BTreeMap;
+use std::ffi::CStr;
 use std::ffi::CString;
 use std::fmt;
 use std::fs;
@@ -28,7 +28,6 @@ use std::path::Path;
 use std::ptr;
 use std::slice;
 use std::str;
-use std::ffi::CStr;
 
 pub fn new_bloom_filter(bits: c_int) -> *mut ffi::rocksdb_filterpolicy_t {
     unsafe { ffi::rocksdb_filterpolicy_create_bloom(bits) }
@@ -150,7 +149,6 @@ pub struct DBRawIterator {
     inner: *mut ffi::rocksdb_iterator_t,
 }
 
-
 /// An iterator over a database or column family, with specifiable
 /// ranges and direction.
 ///
@@ -201,7 +199,11 @@ pub enum IteratorMode<'a> {
 
 impl DBRawIterator {
     fn new(db: &DB, readopts: &ReadOptions) -> DBRawIterator {
-        unsafe { DBRawIterator { inner: ffi::rocksdb_create_iterator(db.inner, readopts.inner) } }
+        unsafe {
+            DBRawIterator {
+                inner: ffi::rocksdb_create_iterator(db.inner, readopts.inner),
+            }
+        }
     }
 
     fn new_cf(
@@ -581,10 +583,13 @@ impl<'a> Drop for Snapshot<'a> {
 
 impl ColumnFamilyDescriptor {
     // Create a new column family descriptor with the specified name and options.
-    pub fn new<S>(name: S, options: Options) -> Self where S: Into<String> {
+    pub fn new<S>(name: S, options: Options) -> Self
+    where
+        S: Into<String>,
+    {
         ColumnFamilyDescriptor {
             name: name.into(),
-            options
+            options,
         }
     }
 }
@@ -606,13 +611,21 @@ impl DB {
     ///
     /// Column families opened using this function will be created with default `Options`.
     pub fn open_cf<P: AsRef<Path>>(opts: &Options, path: P, cfs: &[&str]) -> Result<DB, Error> {
-        let cfs_v = cfs.to_vec().iter().map(|name| ColumnFamilyDescriptor::new(*name, Options::default())).collect();
+        let cfs_v = cfs
+            .to_vec()
+            .iter()
+            .map(|name| ColumnFamilyDescriptor::new(*name, Options::default()))
+            .collect();
 
         DB::open_cf_descriptors(opts, path, cfs_v)
     }
 
     /// Open a database with the given database options and column family names/options.
-    pub fn open_cf_descriptors<P: AsRef<Path>>(opts: &Options, path: P, cfs: Vec<ColumnFamilyDescriptor>) -> Result<DB, Error> {
+    pub fn open_cf_descriptors<P: AsRef<Path>>(
+        opts: &Options,
+        path: P,
+        cfs: Vec<ColumnFamilyDescriptor>,
+    ) -> Result<DB, Error> {
         let path = path.as_ref();
         let cpath = match CString::new(path.to_string_lossy().as_bytes()) {
             Ok(c) => c,
@@ -646,7 +659,7 @@ impl DB {
             if !cfs_v.iter().any(|cf| cf.name == "default") {
                 cfs_v.push(ColumnFamilyDescriptor {
                     name: String::from("default"),
-                    options: Options::default()
+                    options: Options::default(),
                 });
             }
             // We need to store our CStrings in an intermediate vector
@@ -661,7 +674,8 @@ impl DB {
             // These handles will be populated by DB.
             let mut cfhandles: Vec<_> = cfs_v.iter().map(|_| ptr::null_mut()).collect();
 
-            let mut cfopts: Vec<_> = cfs_v.iter()
+            let mut cfopts: Vec<_> = cfs_v
+                .iter()
                 .map(|cf| cf.options.inner as *const _)
                 .collect();
 
@@ -672,7 +686,8 @@ impl DB {
                     cfs_v.len() as c_int,
                     cfnames.as_mut_ptr(),
                     cfopts.as_mut_ptr(),
-                    cfhandles.as_mut_ptr(),));
+                    cfhandles.as_mut_ptr(),
+                ));
             }
 
             for handle in &cfhandles {
@@ -731,7 +746,6 @@ impl DB {
         }
     }
 
-
     pub fn destroy<P: AsRef<Path>>(opts: &Options, path: P) -> Result<(), Error> {
         let cpath = CString::new(path.as_ref().to_string_lossy().as_bytes()).unwrap();
         unsafe {
@@ -929,11 +943,16 @@ impl DB {
     pub fn prefix_iterator_cf<'a>(
         &self,
         cf_handle: ColumnFamily,
-        prefix: &'a [u8]
+        prefix: &'a [u8],
     ) -> Result<DBIterator, Error> {
         let mut opts = ReadOptions::default();
         opts.set_prefix_same_as_start(true);
-        DBIterator::new_cf(self, cf_handle, &opts, IteratorMode::From(prefix, Direction::Forward))
+        DBIterator::new_cf(
+            self,
+            cf_handle,
+            &opts,
+            IteratorMode::From(prefix, Direction::Forward),
+        )
     }
 
     pub fn raw_iterator(&self) -> DBRawIterator {
@@ -1207,7 +1226,9 @@ impl WriteBatch {
 
 impl Default for WriteBatch {
     fn default() -> WriteBatch {
-        WriteBatch { inner: unsafe { ffi::rocksdb_writebatch_create() } }
+        WriteBatch {
+            inner: unsafe { ffi::rocksdb_writebatch_create() },
+        }
     }
 }
 
@@ -1268,21 +1289,21 @@ impl ReadOptions {
     }
 
     pub fn set_prefix_same_as_start(&mut self, v: bool) {
-        unsafe {
-            ffi::rocksdb_readoptions_set_prefix_same_as_start(self.inner, v as c_uchar)
-        }
+        unsafe { ffi::rocksdb_readoptions_set_prefix_same_as_start(self.inner, v as c_uchar) }
     }
 
     pub fn set_total_order_seek(&mut self, v: bool) {
-        unsafe {
-            ffi::rocksdb_readoptions_set_total_order_seek(self.inner, v as c_uchar)
-        }
+        unsafe { ffi::rocksdb_readoptions_set_total_order_seek(self.inner, v as c_uchar) }
     }
 }
 
 impl Default for ReadOptions {
     fn default() -> ReadOptions {
-        unsafe { ReadOptions { inner: ffi::rocksdb_readoptions_create() } }
+        unsafe {
+            ReadOptions {
+                inner: ffi::rocksdb_readoptions_create(),
+            }
+        }
     }
 }
 
@@ -1352,7 +1373,6 @@ fn test_db_vector() {
     assert_eq!(&*v, &ctrl[..]);
 }
 
-
 #[test]
 fn external() {
     let path = "_rust_rocksdb_externaltest";

src/db_options.rs

@@ -18,14 +18,17 @@ use std::path::Path;
 
 use libc::{self, c_int, c_uchar, c_uint, c_void, size_t, uint64_t};
 
-use ffi;
-use {BlockBasedOptions, BlockBasedIndexType, DBCompactionStyle, DBCompressionType, DBRecoveryMode, MemtableFactory,
-     Options, WriteOptions};
-use compaction_filter::{self, CompactionFilterCallback, CompactionFilterFn, filter_callback};
+use compaction_filter::{self, filter_callback, CompactionFilterCallback, CompactionFilterFn};
 use comparator::{self, ComparatorCallback, CompareFn};
-use merge_operator::{self, MergeFn, MergeOperatorCallback, full_merge_callback,
-                     partial_merge_callback};
+use ffi;
+use merge_operator::{
+    self, full_merge_callback, partial_merge_callback, MergeFn, MergeOperatorCallback,
+};
 use slice_transform::SliceTransform;
+use {
+    BlockBasedIndexType, BlockBasedOptions, DBCompactionStyle, DBCompressionType, DBRecoveryMode,
+    MemtableFactory, Options, WriteOptions,
+};
 
 pub fn new_cache(capacity: size_t) -> *mut ffi::rocksdb_cache_t {
     unsafe { ffi::rocksdb_cache_create_lru(capacity) }
@@ -189,7 +192,10 @@ impl Options {
     /// ```
     pub fn create_missing_column_families(&mut self, create_missing_cfs: bool) {
         unsafe {
-            ffi::rocksdb_options_set_create_missing_column_families(self.inner, create_missing_cfs as c_uchar);
+            ffi::rocksdb_options_set_create_missing_column_families(
+                self.inner,
+                create_missing_cfs as c_uchar,
+            );
         }
     }
 
@@ -256,14 +262,19 @@ impl Options {
     /// Default: `0`
     pub fn set_compaction_readahead_size(&mut self, compaction_readahead_size: usize) {
         unsafe {
-            ffi::rocksdb_options_compaction_readahead_size(self.inner, compaction_readahead_size as usize);
+            ffi::rocksdb_options_compaction_readahead_size(
+                self.inner,
+                compaction_readahead_size as usize,
+            );
         }
     }
 
-    pub fn set_merge_operator(&mut self, name: &str,
+    pub fn set_merge_operator(
+        &mut self,
+        name: &str,
         full_merge_fn: MergeFn,
-                              partial_merge_fn: Option<MergeFn>) {
-
+        partial_merge_fn: Option<MergeFn>,
+    ) {
         let cb = Box::new(MergeOperatorCallback {
             name: CString::new(name.as_bytes()).unwrap(),
             full_merge_fn: full_merge_fn,
@@ -283,8 +294,10 @@ impl Options {
         }
     }
 
-    #[deprecated(since = "0.5.0",
-                 note = "add_merge_operator has been renamed to set_merge_operator")]
+    #[deprecated(
+        since = "0.5.0",
+        note = "add_merge_operator has been renamed to set_merge_operator"
+    )]
     pub fn add_merge_operator(&mut self, name: &str, merge_fn: MergeFn) {
         self.set_merge_operator(name, merge_fn, None);
     }
@@ -343,14 +356,13 @@ impl Options {
     }
 
     pub fn set_prefix_extractor(&mut self, prefix_extractor: SliceTransform) {
-        unsafe {
-            ffi::rocksdb_options_set_prefix_extractor(
-                self.inner, prefix_extractor.inner
-            )
-        }
+        unsafe { ffi::rocksdb_options_set_prefix_extractor(self.inner, prefix_extractor.inner) }
     }
 
-    #[deprecated(since = "0.5.0", note = "add_comparator has been renamed to set_comparator")]
+    #[deprecated(
+        since = "0.5.0",
+        note = "add_comparator has been renamed to set_comparator"
+    )]
     pub fn add_comparator(&mut self, name: &str, compare_fn: CompareFn) {
         self.set_comparator(name, compare_fn);
     }
@@ -532,8 +544,10 @@ impl Options {
     /// let mut opts = Options::default();
     /// opts.set_allow_os_buffer(false);
     /// ```
-    #[deprecated(since = "0.7.0",
-                 note = "replaced with set_use_direct_reads/set_use_direct_io_for_flush_and_compaction methods")]
+    #[deprecated(
+        since = "0.7.0",
+        note = "replaced with set_use_direct_reads/set_use_direct_io_for_flush_and_compaction methods"
+    )]
     pub fn set_allow_os_buffer(&mut self, is_allow: bool) {
         self.set_use_direct_reads(!is_allow);
         self.set_use_direct_io_for_flush_and_compaction(!is_allow);
@@ -844,7 +858,6 @@ impl Options {
         }
     }
 
-
     /// Sets the maximum number of concurrent background compaction jobs, submitted to
     /// the default LOW priority thread pool.
     /// We first try to schedule compactions based on
@@ -1049,9 +1062,7 @@ impl Options {
     ///
     /// Default: `true`
     pub fn set_advise_random_on_open(&mut self, advise: bool) {
-        unsafe {
-            ffi::rocksdb_options_set_advise_random_on_open(self.inner, advise as c_uchar)
-        }
+        unsafe { ffi::rocksdb_options_set_advise_random_on_open(self.inner, advise as c_uchar) }
     }
 
     /// Sets the number of levels for this database.

src/lib.rs

@@ -54,17 +54,18 @@ mod ffi_util;
 
 pub mod backup;
 pub mod checkpoint;
-mod comparator;
-pub mod merge_operator;
 pub mod compaction_filter;
+mod comparator;
 mod db;
 mod db_options;
+pub mod merge_operator;
 mod slice_transform;
 
 pub use compaction_filter::Decision as CompactionDecision;
-pub use db::{DBCompactionStyle, DBCompressionType, DBIterator, DBRawIterator, DBRecoveryMode,
-             DBVector, ReadOptions, Direction, IteratorMode, Snapshot, WriteBatch,
-             new_bloom_filter};
+pub use db::{
+    new_bloom_filter, DBCompactionStyle, DBCompressionType, DBIterator, DBRawIterator,
+    DBRecoveryMode, DBVector, Direction, IteratorMode, ReadOptions, Snapshot, WriteBatch,
+};
 
 pub use slice_transform::SliceTransform;
 
@@ -155,8 +156,14 @@ pub enum BlockBasedIndexType {
 /// See https://github.com/facebook/rocksdb/wiki/MemTable for more information.
 pub enum MemtableFactory {
     Vector,
-    HashSkipList { bucket_count: usize, height: i32, branching_factor: i32 },
-    HashLinkList { bucket_count: usize }
+    HashSkipList {
+        bucket_count: usize,
+        height: i32,
+        branching_factor: i32,
+    },
+    HashLinkList {
+        bucket_count: usize,
+    },
 }
 
 /// Database-wide options around performance and behavior.
@@ -222,7 +229,6 @@ pub struct WriteOptions {
     inner: *mut ffi::rocksdb_writeoptions_t,
 }
 
-
 /// An opaque type used to represent a column family. Returned from some functions, and used
 /// in others
 #[derive(Copy, Clone)]

src/merge_operator.rs

@@ -53,7 +53,6 @@
 //! }
 //! ```
 
-
 use libc::{self, c_char, c_int, c_void, size_t};
 use std::ffi::CString;
 use std::mem;
@@ -92,11 +91,13 @@ pub unsafe extern "C" fn full_merge_callback(
     let cb = &mut *(raw_cb as *mut MergeOperatorCallback);
     let operands = &mut MergeOperands::new(operands_list, operands_list_len, num_operands);
     let key = slice::from_raw_parts(raw_key as *const u8, key_len as usize);
-	let oldval = 
-		if existing_value == ptr::null() {
+    let oldval = if existing_value == ptr::null() {
         None
     } else {
-			Some(slice::from_raw_parts(existing_value as *const u8, existing_value_len as usize))
+        Some(slice::from_raw_parts(
+            existing_value as *const u8,
+            existing_value_len as usize,
+        ))
     };
     if let Some(mut result) = (cb.full_merge_fn)(key, oldval, operands) {
         result.shrink_to_fit();
@@ -141,7 +142,6 @@ pub unsafe extern "C" fn partial_merge_callback(
     }
 }
 
-
 pub struct MergeOperands {
     operands_list: *const *const c_char,
     operands_list_len: *const size_t,
@@ -222,7 +222,7 @@ mod test {
 
     #[test]
     fn mergetest() {
-		use {DB, Options};
+        use {Options, DB};
 
         let path = "_rust_rocksdb_mergetest";
         let mut opts = Options::default();
@@ -239,12 +239,10 @@ mod test {
             let m = db.merge(b"k1", b"h");
             assert!(m.is_ok());
             match db.get(b"k1") {
-				Ok(Some(value)) => {
-					match value.to_utf8() {
+                Ok(Some(value)) => match value.to_utf8() {
                     Some(v) => println!("retrieved utf8 value: {}", v),
                     None => println!("did not read valid utf-8 out of the db"),
-					}
-				}
+                },
                 Err(_) => println!("error reading value"),
                 _ => panic!("value not present"),
             }
@@ -259,25 +257,24 @@ mod test {
     }
 
     unsafe fn to_slice<T: Sized>(p: &T) -> &[u8] {
-		::std::slice::from_raw_parts(
-			(p as *const T) as *const u8,
-			::std::mem::size_of::<T>(),
-			)
+        ::std::slice::from_raw_parts((p as *const T) as *const u8, ::std::mem::size_of::<T>())
     }
 
     fn from_slice<T: Sized>(s: &[u8]) -> Option<&T> {
         if ::std::mem::size_of::<T>() != s.len() {
-			println!("slice {:?} is len {}, but T is size {}", s, s.len(), ::std::mem::size_of::<T>());
+            println!(
+                "slice {:?} is len {}, but T is size {}",
+                s,
+                s.len(),
+                ::std::mem::size_of::<T>()
+            );
             None
         } else {
-			unsafe {
-				Some(::std::mem::transmute(s.as_ptr()))
-			}
+            unsafe { Some(::std::mem::transmute(s.as_ptr())) }
         }
     }
 
     #[repr(packed)]
-
     #[derive(Copy, Clone, Debug)]
     struct ValueCounts {
         num_a: u32,
@@ -306,16 +303,15 @@ mod test {
         existing_val: Option<&[u8]>,
         operands: &mut MergeOperands,
     ) -> Option<Vec<u8>> {
-
-		let mut counts : ValueCounts = 
-			if let Some(v) = existing_val {
+        let mut counts: ValueCounts = if let Some(v) = existing_val {
             from_slice::<ValueCounts>(v).unwrap().clone()
         } else {
             ValueCounts {
                 num_a: 0,
                 num_b: 0,
                 num_c: 0,
-					num_d: 0 }
+                num_d: 0,
+            }
         };
 
         for op in operands {
@@ -335,9 +331,9 @@ mod test {
 
     #[test]
     fn counting_mergetest() {
-		use std::thread;
         use std::sync::Arc;
-		use {DB, Options, DBCompactionStyle};
+        use std::thread;
+        use {DBCompactionStyle, Options, DB};
 
         let path = "_rust_rocksdb_partial_mergetest";
         let mut opts = Options::default();
@@ -345,7 +341,11 @@ mod test {
         opts.set_compaction_style(DBCompactionStyle::Universal);
         opts.set_min_write_buffer_number_to_merge(10);
 
-		opts.set_merge_operator("sort operator", test_counting_full_merge, Some(test_counting_partial_merge));
+        opts.set_merge_operator(
+            "sort operator",
+            test_counting_full_merge,
+            Some(test_counting_partial_merge),
+        );
         {
             let db = Arc::new(DB::open(&opts, path).unwrap());
             let _ = db.delete(b"k1");
@@ -421,8 +421,7 @@ mod test {
             h3.join().unwrap();
             h1.join().unwrap();
             match db.get(b"k2") {
-				Ok(Some(value)) => {
-					match from_slice::<ValueCounts>(&*value) {
+                Ok(Some(value)) => match from_slice::<ValueCounts>(&*value) {
                     Some(v) => unsafe {
                         assert_eq!(v.num_a, 1000);
                         assert_eq!(v.num_b, 500);
@@ -430,14 +429,12 @@ mod test {
                         assert_eq!(v.num_d, 500);
                     },
                     None => panic!("Failed to get ValueCounts from db"),
-					}
-				}
+                },
                 Err(e) => panic!("error reading value {:?}", e),
                 _ => panic!("value not present"),
             }
             match db.get(b"k1") {
-				Ok(Some(value)) => {
-					match from_slice::<ValueCounts>(&*value) {
+                Ok(Some(value)) => match from_slice::<ValueCounts>(&*value) {
                     Some(v) => unsafe {
                         assert_eq!(v.num_a, 3);
                         assert_eq!(v.num_b, 2);
@@ -445,8 +442,7 @@ mod test {
                         assert_eq!(v.num_d, 1);
                     },
                     None => panic!("Failed to get ValueCounts from db"),
-					}
-				}
+                },
                 Err(e) => panic!("error reading value {:?}", e),
                 _ => panic!("value not present"),
             }

src/slice_transform.rs

@@ -52,7 +52,6 @@ impl SliceTransform {
                 mem::transmute(cb),
                 Some(slice_transform_destructor_callback),
                 Some(transform_callback),
-
                 // this is ugly, but I can't get the compiler
                 // not to barf with "expected fn pointer, found fn item"
                 // without this. sorry.
@@ -61,31 +60,24 @@ impl SliceTransform {
                 } else {
                     None
                 },
-
                 // this None points to the deprecated InRange callback
                 None,
                 Some(slice_transform_name_callback),
             )
         };
 
-        SliceTransform {
-            inner: st
-        }
+        SliceTransform { inner: st }
     }
 
     pub fn create_fixed_prefix(len: size_t) -> SliceTransform {
         SliceTransform {
-            inner: unsafe {
-                ffi::rocksdb_slicetransform_create_fixed_prefix(len)
-            },
+            inner: unsafe { ffi::rocksdb_slicetransform_create_fixed_prefix(len) },
         }
     }
 
     pub fn create_noop() -> SliceTransform {
         SliceTransform {
-            inner: unsafe {
-                ffi::rocksdb_slicetransform_create_noop()
-            },
+            inner: unsafe { ffi::rocksdb_slicetransform_create_noop() },
         }
     }
 }
@@ -99,16 +91,12 @@ pub struct TransformCallback {
     pub in_domain_fn: Option<InDomainFn>,
 }
 
-pub unsafe extern "C" fn slice_transform_destructor_callback(
-    raw_cb: *mut c_void
-) {
+pub unsafe extern "C" fn slice_transform_destructor_callback(raw_cb: *mut c_void) {
     let transform: Box<TransformCallback> = mem::transmute(raw_cb);
     drop(transform);
 }
 
-pub unsafe extern "C" fn slice_transform_name_callback(
-    raw_cb: *mut c_void
-) -> *const c_char {
+pub unsafe extern "C" fn slice_transform_name_callback(raw_cb: *mut c_void) -> *const c_char {
     let cb = &mut *(raw_cb as *mut TransformCallback);
     cb.name.as_ptr()
 }

tests/test_checkpoint.rs

@@ -14,7 +14,7 @@
 //
 extern crate rocksdb;
 
-use rocksdb::{checkpoint::Checkpoint, DB, Options};
+use rocksdb::{checkpoint::Checkpoint, Options, DB};
 use std::fs::remove_dir_all;
 
 #[test]

tests/test_column_family.rs

@@ -15,7 +15,7 @@
 extern crate rocksdb;
 mod util;
 
-use rocksdb::{DB, MergeOperands, Options, ColumnFamilyDescriptor};
+use rocksdb::{ColumnFamilyDescriptor, MergeOperands, Options, DB};
 use util::DBPath;
 
 #[test]
@@ -42,16 +42,15 @@ pub fn test_column_family() {
         let mut opts = Options::default();
         opts.set_merge_operator("test operator", test_provided_merge, None);
         match DB::open(&opts, &n) {
-            Ok(_db) => {
-                panic!("should not have opened DB successfully without \
+            Ok(_db) => panic!(
+                "should not have opened DB successfully without \
                         specifying column
-            families")
-            }
-            Err(e) => {
-                assert!(e.to_string()
-                    .starts_with("Invalid argument: You have to open all \
-                                  column families."))
-            }
+            families"
+            ),
+            Err(e) => assert!(e.to_string().starts_with(
+                "Invalid argument: You have to open all \
+                 column families."
+            )),
         }
     }
 
@@ -76,11 +75,9 @@ pub fn test_column_family() {
     }
 
     // TODO should be able to use writebatch ops with a cf
-    {
-    }
+    {}
     // TODO should be able to iterate over a cf
-    {
-    }
+    {}
     // should b able to drop a cf
     {
         let mut db = DB::open_cf(&Options::default(), &n, &["cf1"]).unwrap();
@@ -136,12 +133,10 @@ fn test_merge_operator() {
         println!("m is {:?}", m);
         // TODO assert!(m.is_ok());
         match db.get(b"k1") {
-            Ok(Some(value)) => {
-                match value.to_utf8() {
+            Ok(Some(value)) => match value.to_utf8() {
                 Some(v) => println!("retrieved utf8 value: {}", v),
                 None => println!("did not read valid utf-8 out of the db"),
-                }
-            }
+            },
             Err(_) => println!("error reading value"),
             _ => panic!("value not present!"),
         }
@@ -151,13 +146,13 @@ fn test_merge_operator() {
         assert!(db.delete(b"k1").is_ok());
         assert!(db.get(b"k1").unwrap().is_none());
     }
-
 }
 
-fn test_provided_merge(_: &[u8],
+fn test_provided_merge(
+    _: &[u8],
     existing_val: Option<&[u8]>,
-                       operands: &mut MergeOperands)
-                       -> Option<Vec<u8>> {
+    operands: &mut MergeOperands,
+) -> Option<Vec<u8>> {
     let nops = operands.size_hint().0;
     let mut result: Vec<u8> = Vec::with_capacity(nops);
     match existing_val {
@@ -192,7 +187,10 @@ pub fn test_column_family_with_options() {
         match DB::open_cf_descriptors(&opts, &n, cfs) {
             Ok(_db) => println!("created db with column family descriptors succesfully"),
             Err(e) => {
-                panic!("could not create new database with column family descriptors: {}", e);
+                panic!(
+                    "could not create new database with column family descriptors: {}",
+                    e
+                );
             }
         }
     }
@@ -208,7 +206,10 @@ pub fn test_column_family_with_options() {
         match DB::open_cf_descriptors(&opts, &n, cfs) {
             Ok(_db) => println!("succesfully re-opened database with column family descriptors"),
             Err(e) => {
-                panic!("unable to re-open database with column family descriptors: {}", e);
+                panic!(
+                    "unable to re-open database with column family descriptors: {}",
+                    e
+                );
             }
         }
     }

tests/test_iterator.rs

@@ -15,7 +15,7 @@
 extern crate rocksdb;
 mod util;
 
-use rocksdb::{DB, Direction, IteratorMode, MemtableFactory, Options};
+use rocksdb::{Direction, IteratorMode, MemtableFactory, Options, DB};
 use util::DBPath;
 
 fn cba(input: &Box<[u8]>) -> Box<[u8]> {
@@ -41,7 +41,11 @@ pub fn test_iterator() {
         assert!(p.is_ok());
         let p = db.put(&*k3, &*v3);
         assert!(p.is_ok());
-        let expected = vec![(cba(&k1), cba(&v1)), (cba(&k2), cba(&v2)), (cba(&k3), cba(&v3))];
+        let expected = vec![
+            (cba(&k1), cba(&v1)),
+            (cba(&k2), cba(&v2)),
+            (cba(&k3), cba(&v3)),
+        ];
         {
             let iterator1 = db.iterator(IteratorMode::Start);
             assert_eq!(iterator1.collect::<Vec<_>>(), expected);
@@ -103,10 +107,12 @@ pub fn test_iterator() {
         let old_iterator = db.iterator(IteratorMode::Start);
         let p = db.put(&*k4, &*v4);
         assert!(p.is_ok());
-        let expected2 = vec![(cba(&k1), cba(&v1)),
+        let expected2 = vec![
+            (cba(&k1), cba(&v1)),
             (cba(&k2), cba(&v2)),
             (cba(&k3), cba(&v3)),
-                             (cba(&k4), cba(&v4))];
+            (cba(&k4), cba(&v4)),
+        ];
         {
             assert_eq!(old_iterator.collect::<Vec<_>>(), expected);
         }
@@ -116,7 +122,11 @@ pub fn test_iterator() {
         }
         {
             let iterator1 = db.iterator(IteratorMode::From(b"k2", Direction::Forward));
-            let expected = vec![(cba(&k2), cba(&v2)), (cba(&k3), cba(&v3)), (cba(&k4), cba(&v4))];
+            let expected = vec![
+                (cba(&k2), cba(&v2)),
+                (cba(&k3), cba(&v3)),
+                (cba(&k4), cba(&v4)),
+            ];
             assert_eq!(iterator1.collect::<Vec<_>>(), expected);
         }
         {
@@ -157,7 +167,9 @@ pub fn test_iterator() {
     }
 }
 
-fn key(k: &[u8]) -> Box<[u8]> { k.to_vec().into_boxed_slice() }
+fn key(k: &[u8]) -> Box<[u8]> {
+    k.to_vec().into_boxed_slice()
+}
 
 #[test]
 pub fn test_prefix_iterator() {

tests/test_multithreaded.rs

@@ -16,11 +16,10 @@ extern crate rocksdb;
 mod util;
 
 use rocksdb::DB;
-use std::thread;
 use std::sync::Arc;
+use std::thread;
 use util::DBPath;
 
-
 const N: usize = 100_000;
 
 #[test]

tests/test_raw_iterator.rs

@@ -51,7 +51,6 @@ pub fn test_forwards_iteration() {
     }
 }
 
-
 #[test]
 pub fn test_seek_last() {
     let n = DBPath::new("backwards_iteration");
@@ -85,7 +84,6 @@ pub fn test_seek_last() {
     }
 }
 
-
 #[test]
 pub fn test_seek() {
     let n = DBPath::new("seek");
@@ -111,7 +109,6 @@ pub fn test_seek() {
     }
 }
 
-
 #[test]
 pub fn test_seek_to_nonexistant() {
     let n = DBPath::new("seek_to_nonexistant");

tests/test_rocksdb_options.rs

@@ -15,7 +15,7 @@
 extern crate rocksdb;
 mod util;
 
-use rocksdb::{DB, Options};
+use rocksdb::{Options, DB};
 use util::DBPath;
 
 #[test]

tests/test_slice_transform.rs

@@ -1,7 +1,7 @@
 extern crate rocksdb;
 mod util;
 
-use rocksdb::{DB, Options, SliceTransform};
+use rocksdb::{Options, SliceTransform, DB};
 use util::DBPath;
 
 #[test]
@@ -34,7 +34,9 @@ pub fn test_slice_transform() {
             input.iter().cloned().collect::<Vec<_>>().into_boxed_slice()
         }
 
-        fn key(k: &[u8]) -> Box<[u8]> { k.to_vec().into_boxed_slice() }
+        fn key(k: &[u8]) -> Box<[u8]> {
+            k.to_vec().into_boxed_slice()
+        }
 
         {
             let expected = vec![(cba(&a1), cba(&a1)), (cba(&a2), cba(&a2))];

tests/util/mod.rs

@@ -1,13 +1,13 @@
 extern crate rocksdb;
 
+use std::path::{Path, PathBuf};
 use std::time::{SystemTime, UNIX_EPOCH};
-use std::path::{PathBuf, Path};
 
-use rocksdb::{DB, Options};
+use rocksdb::{Options, DB};
 
 /// Ensures that DB::Destroy is called for this database when DBPath is dropped.
 pub struct DBPath {
-    path: PathBuf
+    path: PathBuf,
 }
 
 impl DBPath {
@@ -22,7 +22,9 @@ impl DBPath {
             current_time.subsec_nanos()
         );
 
-        DBPath { path: PathBuf::from(path) }
+        DBPath {
+            path: PathBuf::from(path),
+        }
     }
 }
 
@@ -38,4 +40,3 @@ impl AsRef<Path> for DBPath {
         &self.path
     }
 }
-