Format with cargo fmt

Author: gavrie

build.rs

@@ -1,5 +1,5 @@
-extern crate cc;
 extern crate bindgen;
+extern crate cc;
 
 //use std::env;
 //use std::path::PathBuf;
@@ -24,4 +24,4 @@ fn main() {
     bindings
         .write_to_file("src/redisraw/bindings.rs")
         .expect("failed to write bindings to file");
-}
+}

examples/data_type.rs

@@ -1,8 +1,8 @@
 #[macro_use]
 extern crate redismodule;
 
-use redismodule::{Context, RedisResult, NextArg};
 use redismodule::native_types::RedisType;
+use redismodule::{Context, NextArg, RedisResult};
 
 #[derive(Debug)]
 struct MyType {
@@ -26,7 +26,7 @@ fn alloc_set(ctx: &Context, args: Vec<String>) -> RedisResult {
         }
         None => {
             let value = MyType {
-                data: "A".repeat(size as usize)
+                data: "A".repeat(size as usize),
             };
 
             key.set_value(&MY_REDIS_TYPE, value)?;
@@ -48,7 +48,7 @@ fn alloc_get(ctx: &Context, args: Vec<String>) -> RedisResult {
             let _ = value;
             "some value".into()
         }
-        None => ().into()
+        None => ().into(),
     };
 
     Ok(value)

examples/hello.rs

@@ -1,7 +1,7 @@
 #[macro_use]
 extern crate redismodule;
 
-use redismodule::{Context, RedisResult, RedisError, parse_integer};
+use redismodule::{parse_integer, Context, RedisError, RedisResult};
 
 fn hello_mul(_: &Context, args: Vec<String>) -> RedisResult {
     if args.len() < 2 {
@@ -24,7 +24,7 @@ fn hello_mul(_: &Context, args: Vec<String>) -> RedisResult {
 
 //////////////////////////////////////////////////////
 
-redis_module!{
+redis_module! {
     name: "hello",
     version: 1,
     data_types: [],
@@ -42,10 +42,7 @@ mod tests {
     fn run_hello_mul(args: &[&str]) -> RedisResult {
         hello_mul(
             &Context::dummy(),
-            args
-                .iter()
-                .map(|v| String::from(*v))
-                .collect(),
+            args.iter().map(|v| String::from(*v)).collect(),
         )
     }
 
@@ -55,12 +52,15 @@ mod tests {
 
         match result {
             Ok(RedisValue::Array(v)) => {
-                assert_eq!(v, vec![10, 20, 30, 6000]
-                    .into_iter()
-                    .map(RedisValue::Integer)
-                    .collect::<Vec<_>>());
+                assert_eq!(
+                    v,
+                    vec![10, 20, 30, 6000]
+                        .into_iter()
+                        .map(RedisValue::Integer)
+                        .collect::<Vec<_>>()
+                );
             }
-            _ => assert!(false, "Bad result: {:?}", result)
+            _ => assert!(false, "Bad result: {:?}", result),
         }
     }
 
@@ -72,8 +72,7 @@ mod tests {
             Err(RedisError::String(s)) => {
                 assert_eq!(s, "Couldn't parse as integer: xx");
             }
-            _ => assert!(false, "Bad result: {:?}", result)
+            _ => assert!(false, "Bad result: {:?}", result),
         }
     }
 }
-

src/alloc.rs

@@ -1,6 +1,6 @@
+use std::alloc::{GlobalAlloc, Layout, System};
 use std::os::raw::c_void;
-use std::alloc::{System, GlobalAlloc, Layout};
-use std::sync::atomic::{AtomicBool, ATOMIC_BOOL_INIT, Ordering::SeqCst};
+use std::sync::atomic::{AtomicBool, Ordering::SeqCst, ATOMIC_BOOL_INIT};
 
 use crate::raw;
 

src/context.rs

@@ -1,11 +1,11 @@
-use std::ptr;
-use std::os::raw::c_long;
 use std::ffi::CString;
+use std::os::raw::c_long;
+use std::ptr;
 
+use crate::key::{RedisKey, RedisKeyWritable};
 use crate::raw;
 use crate::LogLevel;
-use crate::key::{RedisKey, RedisKeyWritable};
-use crate::{RedisString, RedisError, RedisValue, RedisResult};
+use crate::{RedisError, RedisResult, RedisString, RedisValue};
 
 /// Redis is a structure that's designed to give us a high-level interface to
 /// the Redis module API by abstracting away the raw C FFI calls.
@@ -19,7 +19,9 @@ impl Context {
     }
 
     pub fn dummy() -> Self {
-        Self { ctx: ptr::null_mut() }
+        Self {
+            ctx: ptr::null_mut(),
+        }
     }
 
     pub fn log(&self, level: LogLevel, message: &str) {
@@ -33,7 +35,8 @@ impl Context {
     }
 
     pub fn call(&self, command: &str, args: &[&str]) -> RedisResult {
-        let terminated_args: Vec<RedisString> = args.iter()
+        let terminated_args: Vec<RedisString> = args
+            .iter()
             .map(|s| RedisString::create(self.ctx, s))
             .collect();
 
@@ -48,13 +51,15 @@ impl Context {
         match r {
             Ok(RedisValue::Integer(v)) => unsafe {
                 raw::RedisModule_ReplyWithLongLong.unwrap()(self.ctx, v).into()
-            }
+            },
 
             Ok(RedisValue::String(s)) => unsafe {
                 raw::RedisModule_ReplyWithString.unwrap()(
                     self.ctx,
-                    RedisString::create(self.ctx, s.as_ref()).inner).into()
-            }
+                    RedisString::create(self.ctx, s.as_ref()).inner,
+                )
+                .into()
+            },
 
             Ok(RedisValue::Array(array)) => {
                 unsafe {
@@ -72,21 +77,21 @@ impl Context {
 
             Ok(RedisValue::None) => unsafe {
                 raw::RedisModule_ReplyWithNull.unwrap()(self.ctx).into()
-            }
+            },
 
             Err(RedisError::WrongArity) => unsafe {
                 raw::RedisModule_WrongArity.unwrap()(self.ctx).into()
-            }
+            },
 
             Err(RedisError::String(s)) => unsafe {
                 let msg = CString::new(s).unwrap();
                 raw::RedisModule_ReplyWithError.unwrap()(self.ctx, msg.as_ptr()).into()
-            }
+            },
 
             Err(RedisError::Str(s)) => unsafe {
                 let msg = CString::new(s).unwrap();
                 raw::RedisModule_ReplyWithError.unwrap()(self.ctx, msg.as_ptr()).into()
-            }
+            },
         }
     }
 

src/error.rs

@@ -1,7 +1,7 @@
 use std;
 use std::error;
 use std::fmt;
-use std::fmt::{Display};
+use std::fmt::Display;
 
 #[derive(Debug)]
 pub enum Error {

src/key.rs

@@ -1,18 +1,18 @@
+use std::fmt::Debug;
+use std::os::raw::c_void;
 use std::ptr;
 use std::string;
-use std::os::raw::c_void;
-use std::fmt::Debug;
 
 use libc::size_t;
 
-use crate::raw;
 use crate::error::Error;
-use crate::RedisString;
-use crate::native_types::RedisType;
 use crate::from_byte_string;
-use crate::RedisResult;
-use crate::RedisError;
 use crate::native_types::redis_log;
+use crate::native_types::RedisType;
+use crate::raw;
+use crate::RedisError;
+use crate::RedisResult;
+use crate::RedisString;
 
 /// `RedisKey` is an abstraction over a Redis key that allows readonly
 /// operations.
@@ -86,8 +86,7 @@ pub struct RedisKeyWritable {
 impl RedisKeyWritable {
     pub fn open(ctx: *mut raw::RedisModuleCtx, key: &str) -> RedisKeyWritable {
         let key_str = RedisString::create(ctx, key);
-        let key_inner =
-            raw::open_key(ctx, key_str.inner, to_raw_mode(KeyMode::ReadWrite));
+        let key_inner = raw::open_key(ctx, key_str.inner, to_raw_mode(KeyMode::ReadWrite));
         RedisKeyWritable {
             ctx,
             key_inner,
@@ -138,31 +137,26 @@ impl RedisKeyWritable {
     pub fn is_empty(&self) -> bool {
         use raw::KeyType;
 
-        let key_type: KeyType = unsafe {
-            raw::RedisModule_KeyType.unwrap()(self.key_inner)
-        }.into();
+        let key_type: KeyType = unsafe { raw::RedisModule_KeyType.unwrap()(self.key_inner) }.into();
 
         key_type == KeyType::Empty
     }
 
     fn verify_type(&self, redis_type: &RedisType) -> RedisResult {
         use raw::KeyType;
 
-        let key_type: KeyType = unsafe {
-            raw::RedisModule_KeyType.unwrap()(self.key_inner)
-        }.into();
+        let key_type: KeyType = unsafe { raw::RedisModule_KeyType.unwrap()(self.key_inner) }.into();
 
         redis_log(self.ctx, format!("key type: {:?}", key_type).as_str());
 
         if key_type != KeyType::Empty {
             // The key exists; check its type
-            let raw_type = unsafe {
-                raw::RedisModule_ModuleTypeGetType.unwrap()(self.key_inner)
-            };
+            let raw_type = unsafe { raw::RedisModule_ModuleTypeGetType.unwrap()(self.key_inner) };
 
             if raw_type != *redis_type.raw_type.borrow() {
                 return Err(RedisError::String(format!(
-                    "Existing key has wrong Redis type")));
+                    "Existing key has wrong Redis type"
+                )));
             }
 
             redis_log(self.ctx, "Existing key is of the correct type");
@@ -173,17 +167,19 @@ impl RedisKeyWritable {
         Ok("OK".into())
     }
 
-    pub fn get_value<T: Debug>(&self, redis_type: &RedisType) -> Result<Option<&mut T>, RedisError> {
+    pub fn get_value<T: Debug>(
+        &self,
+        redis_type: &RedisType,
+    ) -> Result<Option<&mut T>, RedisError> {
         self.verify_type(redis_type)?;
 
         redis_log(self.ctx, "Going to get value");
 
-        let value = unsafe {
-            raw::RedisModule_ModuleTypeGetValue.unwrap()(self.key_inner) as *mut T
-        };
+        let value =
+            unsafe { raw::RedisModule_ModuleTypeGetValue.unwrap()(self.key_inner) as *mut T };
 
         if value.is_null() {
-            return Ok(None)
+            return Ok(None);
         }
 
         let value = unsafe { &mut *value };
@@ -196,7 +192,10 @@ impl RedisKeyWritable {
     pub fn set_value<T: Debug>(&self, redis_type: &RedisType, value: T) -> Result<(), RedisError> {
         self.verify_type(redis_type)?;
 
-        redis_log(self.ctx, format!("1. Going to set value to {:?}", &value).as_str());
+        redis_log(
+            self.ctx,
+            format!("1. Going to set value to {:?}", &value).as_str(),
+        );
 
         let value = Box::into_raw(Box::new(value)) as *mut c_void;
 
@@ -208,7 +207,8 @@ impl RedisKeyWritable {
                 *redis_type.raw_type.borrow(),
                 value,
             )
-        }.into();
+        }
+        .into();
 
         redis_log(self.ctx, "3. Finished setting value");
 
@@ -225,7 +225,6 @@ impl From<raw::Status> for Result<(), RedisError> {
     }
 }
 
-
 impl Drop for RedisKeyWritable {
     // Frees resources appropriately as a RedisKey goes out of scope.
     fn drop(&mut self) {

src/lib.rs

@@ -1,7 +1,7 @@
 //#![allow(dead_code)]
 
-use std::string;
 use std::os::raw::c_char;
+use std::string;
 
 #[macro_use]
 extern crate bitflags;
@@ -11,12 +11,12 @@ extern crate num_traits;
 
 use libc::size_t;
 
-pub mod redismodule;
 pub mod alloc;
-pub mod redisraw;
 pub mod error;
-pub mod raw;
 pub mod native_types;
+pub mod raw;
+pub mod redismodule;
+pub mod redisraw;
 
 #[macro_use]
 mod macros;
@@ -29,7 +29,6 @@ pub use redismodule::*;
 #[global_allocator]
 static ALLOC: crate::alloc::RedisAlloc = crate::alloc::RedisAlloc;
 
-
 /// `LogLevel` is a level of logging to be specified with a Redis log directive.
 #[derive(Clone, Copy, Debug)]
 pub enum LogLevel {
@@ -51,7 +50,6 @@ pub enum Reply {
     Unknown,
 }
 
-
 fn from_byte_string(
     byte_str: *const c_char,
     length: size_t,
@@ -64,4 +62,3 @@ fn from_byte_string(
 
     String::from_utf8(vec_str)
 }
-