address clippy warnings (#134)

actix-redis/src/redis.rs

@@ -37,8 +37,10 @@ impl RedisActor {
     pub fn start<S: Into<String>>(addr: S) -> Addr<RedisActor> {
         let addr = addr.into();
 
-        let mut backoff = ExponentialBackoff::default();
+        let backoff = ExponentialBackoff {
-        backoff.max_elapsed_time = None;
+            max_elapsed_time: None,
+            ..Default::default()
+        };
 
         Supervisor::start(|_| RedisActor {
             addr,

actix-redis/src/session.rs

@@ -221,27 +221,42 @@ impl Inner {
         &self,
         req: &ServiceRequest,
     ) -> Result<Option<(HashMap<String, String>, String)>, Error> {
-        if let Ok(cookies) = req.cookies() {
+        // wrapped in block to avoid holding `Ref` (from `req.cookies`) across await point
-            for cookie in cookies.iter() {
+        let (value, cache_key) = {
-                if cookie.name() == self.name {
+            let cookies = if let Ok(cookies) = req.cookies() {
+                cookies
+            } else {
+                return Ok(None);
+            };
+
+            if let Some(cookie) =
+                cookies.iter().find(|&cookie| cookie.name() == self.name)
+            {
                 let mut jar = CookieJar::new();
                 jar.add_original(cookie.clone());
+
                 if let Some(cookie) = jar.signed(&self.key).get(&self.name) {
                     let value = cookie.value().to_owned();
-                        let cachekey = (self.cache_keygen)(&cookie.value());
+                    let cache_key = (self.cache_keygen)(&cookie.value());
-                        return match self
+                    (value, cache_key)
+                } else {
+                    return Ok(None);
+                }
+            } else {
+                return Ok(None);
+            }
+        };
+
+        let res = self
             .addr
-                            .send(Command(resp_array!["GET", cachekey]))
+            .send(Command(resp_array!["GET", cache_key]))
-                            .await
+            .await?;
-                        {
+
-                            Err(e) => Err(Error::from(e)),
+        let val = res.map_err(error::ErrorInternalServerError)?;
-                            Ok(res) => match res {
+
-                                Ok(val) => {
         match val {
             RespValue::Error(err) => {
-                                            return Err(
+                return Err(error::ErrorInternalServerError(err));
-                                                error::ErrorInternalServerError(err),
-                                            );
             }
             RespValue::SimpleString(s) => {
                 if let Ok(val) = serde_json::from_str(&s) {
@@ -253,19 +268,9 @@ impl Inner {
                     return Ok(Some((val, value)));
                 }
             }
-                                        _ => (),
+            _ => {}
-                                    }
-                                    Ok(None)
-                                }
-                                Err(err) => Err(error::ErrorInternalServerError(err)),
-                            },
-                        };
-                    } else {
-                        return Ok(None);
-                    }
-                }
-            }
         }
+
         Ok(None)
     }
 
@@ -308,41 +313,37 @@ impl Inner {
             (value, Some(jar))
         };
 
-        let cachekey = (self.cache_keygen)(&value);
+        let cache_key = (self.cache_keygen)(&value);
 
         let state: HashMap<_, _> = state.collect();
-        match serde_json::to_string(&state) {
+
-            Err(e) => Err(e.into()),
+        let body = match serde_json::to_string(&state) {
-            Ok(body) => {
+            Err(e) => return Err(e.into()),
-                match self
+            Ok(body) => body,
-                    .addr
+        };
-                    .send(Command(resp_array!["SET", cachekey, body, "EX", &self.ttl]))
+
-                    .await
+        let cmd = Command(resp_array!["SET", cache_key, body, "EX", &self.ttl]);
-                {
+
-                    Err(e) => Err(Error::from(e)),
+        self.addr
-                    Ok(redis_result) => match redis_result {
+            .send(cmd)
-                        Ok(_) => {
+            .await?
+            .map_err(error::ErrorInternalServerError)?;
+
         if let Some(jar) = jar {
             for cookie in jar.delta() {
-                                    let val =
+                let val = HeaderValue::from_str(&cookie.to_string())?;
-                                        HeaderValue::from_str(&cookie.to_string())?;
                 res.headers_mut().append(header::SET_COOKIE, val);
             }
         }
+
         Ok(res)
     }
-                        Err(err) => Err(error::ErrorInternalServerError(err)),
-                    },
-                }
-            }
-        }
-    }
 
     /// removes cache entry
     async fn clear_cache(&self, key: String) -> Result<(), Error> {
-        let cachekey = (self.cache_keygen)(&key);
+        let cache_key = (self.cache_keygen)(&key);
 
-        match self.addr.send(Command(resp_array!["DEL", cachekey])).await {
+        match self.addr.send(Command(resp_array!["DEL", cache_key])).await {
             Err(e) => Err(Error::from(e)),
             Ok(res) => {
                 match res {
@@ -445,7 +446,7 @@ mod test {
     }
 
     #[actix_rt::test]
-    async fn test_workflow() {
+    async fn test_session_workflow() {
         // Step 1:  GET index
         //   - set-cookie actix-session will be in response (session cookie #1)
         //   - response should be: {"counter": 0, "user_id": None}