refactor: refactor condition

src/http/response.rs

@@ -75,11 +75,12 @@ impl CandyHandler<'_> {
         let server = format!("{}/{}", NAME, VERSION);
         headers.insert("Server", server.parse()?);
         // config headers overrite
-        if let Some(c_headers) = &self.host.headers {
+        let Some(c_headers) = &self.host.headers else {
+            return Ok(());
+        };
         for (k, v) in c_headers {
             headers.insert(k.as_str(), v.parse()?);
         }
-        }
         Ok(())
     }
 
@@ -174,14 +175,15 @@ impl CandyHandler<'_> {
         // find resource local file path
         let mut path = None;
         for index in router.index.iter() {
-            if let Some(root) = &router.root {
+            let Some(root) = &router.root else {
+                continue;
+            };
             let p = parse_assets_path(assets_path, root, index);
             if Path::new(&p).exists() {
                 path = Some(p);
                 break;
             }
         }
-        }
         let path = match path {
             Some(p) => p,
             None => {
@@ -195,12 +197,11 @@ impl CandyHandler<'_> {
             Method::POST => handle_get(req, res, &path).await?,
             // Return the 404 Not Found for other routes.
             _ => {
-                if let Some(err_page) = &router.error_page {
+                let Some(err_page) = &router.error_page else {
+                    return Ok(not_found());
+                };
                 let res = res.status(err_page.status);
                 handle_get(req, res, &err_page.page).await?
-                } else {
-                    not_found()
-                }
             }
         };
         Ok(res)
@@ -364,16 +365,14 @@ pub async fn handle_not_found(
     router: &SettingRoute,
     assets_path: &str,
 ) -> Result<Response<CandyBody<Bytes>>> {
-    let res = if let Some(err_page) = &router.error_page {
-        let res = res.status(err_page.status);
-        if let Some(root) = &router.root {
-            let path = parse_assets_path(assets_path, root, &err_page.page);
-            handle_get(req, res, &path).await?
-        } else {
-            not_found()
-        }
-    } else {
-        not_found()
+    let Some(err_page) = &router.error_page else {
+        return Ok(not_found());
     };
+    let Some(root) = &router.root else {
+        return Ok(not_found());
+    };
+    let res = res.status(err_page.status);
+    let path = parse_assets_path(assets_path, root, &err_page.page);
+    let res = handle_get(req, res, &path).await?;
     Ok(res)
 }

src/service.rs

@@ -191,9 +191,7 @@ async fn handle_connection(
     };
 
     if host.certificate.is_some() && host.certificate_key.is_some() {
-        let tls_acceptor = if let Some(tls_acceptor) = tls_acceptor {
-            tls_acceptor
-        } else {
+        let Some(tls_acceptor) = tls_acceptor else {
             warn!("tls_acceptor is None");
             return;
         };

src/utils/service.rs

@@ -64,11 +64,12 @@ pub fn find_route<'a>(
         let index = i + 1;
         let path = &all_chars[..index];
         let path_str = path.iter().collect::<String>();
-        if let Some(router) = route_map.get(&path_str) {
+        let Some(router) = route_map.get(&path_str) else {
+            continue;
+        };
         last_router = Some((router, &req_path[index..]));
         break;
     }
-    }
 
     let (router, assets_path) = last_router.ok_or(Error::NotFound(not_found_err.into()))?;
     debug!("router {:?}", &router);