fud | lilith | research/dhtd/ | geode | tests : Refactor to return match statements

bin/fud/fud/src/main.rs

@@ -110,14 +110,14 @@ pub struct Fud {
 #[async_trait]
 impl RequestHandler for Fud {
     async fn handle_request(&self, req: JsonRequest) -> JsonResult {
-        match req.method.as_str() {
-            "ping" => return self.pong(req.id, req.params).await,
+        return match req.method.as_str() {
+            "ping" => self.pong(req.id, req.params).await,
 
-            "put" => return self.put(req.id, req.params).await,
-            "get" => return self.get(req.id, req.params).await,
+            "put" => self.put(req.id, req.params).await,
+            "get" => self.get(req.id, req.params).await,
 
-            "dnet_switch" => return self.dnet_switch(req.id, req.params).await,
-            _ => return JsonError::new(ErrorCode::MethodNotFound, None, req.id).into(),
+            "dnet_switch" => self.dnet_switch(req.id, req.params).await,
+            _ => JsonError::new(ErrorCode::MethodNotFound, None, req.id).into(),
         }
     }
 

bin/lilith/src/main.rs

@@ -222,10 +222,10 @@ impl Lilith {
 #[async_trait]
 impl RequestHandler for Lilith {
     async fn handle_request(&self, req: JsonRequest) -> JsonResult {
-        match req.method.as_str() {
-            "ping" => return self.pong(req.id, req.params).await,
-            "spawns" => return self.spawns(req.id, req.params).await,
-            _ => return JsonError::new(ErrorCode::MethodNotFound, None, req.id).into(),
+        return match req.method.as_str() {
+            "ping" => self.pong(req.id, req.params).await,
+            "spawns" => self.spawns(req.id, req.params).await,
+            _ => JsonError::new(ErrorCode::MethodNotFound, None, req.id).into(),
         }
     }
 

script/research/dhtd/src/main.rs

@@ -126,14 +126,14 @@ impl Dhtd {
         // Check if key is local or shoud query network
         let local = exists.unwrap();
         if local {
-            match self.dht.read().await.get(key_hash.clone()) {
+            return match self.dht.read().await.get(key_hash.clone()) {
                 Some(value) => {
                     let string = std::str::from_utf8(&value).unwrap().to_string();
-                    return JsonResponse::new(json!((key, string)), id).into()
+                    JsonResponse::new(json!((key, string)), id).into()
                 }
                 None => {
                     info!("Did not find key: {}", key);
-                    return server_error(RpcError::UnknownKey, id).into()
+                    server_error(RpcError::UnknownKey, id).into()
                 }
             }
         }
@@ -256,13 +256,13 @@ impl RequestHandler for Dhtd {
 
         let params = req.params.as_array().unwrap();
 
-        match req.method.as_str() {
-            Some("get") => return self.get(req.id, params).await,
-            Some("insert") => return self.insert(req.id, params).await,
-            Some("remove") => return self.remove(req.id, params).await,
-            Some("map") => return self.map(req.id, params).await,
-            Some("lookup") => return self.lookup(req.id, params).await,
-            Some(_) | None => return JsonError::new(MethodNotFound, None, req.id).into(),
+        return match req.method.as_str() {
+            Some("get") => self.get(req.id, params).await,
+            Some("insert") => self.insert(req.id, params).await,
+            Some("remove") => self.remove(req.id, params).await,
+            Some("map") => self.map(req.id, params).await,
+            Some("lookup") => self.lookup(req.id, params).await,
+            Some(_) | None => JsonError::new(MethodNotFound, None, req.id).into(),
         }
     }
 }

src/geode/mod.rs

@@ -378,12 +378,14 @@ impl Geode {
         // that garbage collection needs to run.
         let chunk_hashes = match Self::read_metadata(&file_path).await {
             Ok(v) => v,
-            Err(e) => match e {
-                // If the file is not found, return according error.
-                Error::Io(std::io::ErrorKind::NotFound) => return Err(Error::GeodeFileNotFound),
-                // Anything else should tell the client to do garbage collection
-                _ => return Err(Error::GeodeNeedsGc),
-            },
+            Err(e) => {
+                return match e {
+                    // If the file is not found, return according error.
+                    Error::Io(std::io::ErrorKind::NotFound) => Err(Error::GeodeFileNotFound),
+                    // Anything else should tell the client to do garbage collection
+                    _ => Err(Error::GeodeNeedsGc),
+                }
+            }
         };
 
         let mut chunked_file = ChunkedFile::new(&chunk_hashes);

tests/jsonrpc.rs

@@ -59,10 +59,10 @@ impl RequestHandler for RpcSrv {
     async fn handle_request(&self, req: JsonRequest) -> JsonResult {
         assert!(req.params.is_array());
 
-        match req.method.as_str() {
-            "ping" => return self.pong(req.id, req.params).await,
-            "kill" => return self.kill(req.id, req.params).await,
-            _ => return JsonError::new(ErrorCode::MethodNotFound, None, req.id).into(),
+        return match req.method.as_str() {
+            "ping" => self.pong(req.id, req.params).await,
+            "kill" => self.kill(req.id, req.params).await,
+            _ => JsonError::new(ErrorCode::MethodNotFound, None, req.id).into(),
         }
     }