Upgrade Rust edition, fix formatting and clippy issues

Author: LuceusXylian

Cargo.toml

@@ -5,7 +5,7 @@ readme = "README.md"
 description = "Rust WebDAV server library. A fork of the webdav-handler crate."
 repository = "https://github.com/messense/dav-server-rs"
 authors = ["Miquel van Smoorenburg <mike@langeraar.net>", "messense <messense@icloud.com>"]
-edition = "2018"
+edition = "2024"
 license = "Apache-2.0"
 keywords = ["webdav"]
 categories = ["web-programming"]

examples/actix.rs

@@ -1,8 +1,8 @@
 use std::io;
 
-use actix_web::{web, App, HttpServer};
+use actix_web::{App, HttpServer, web};
 use dav_server::actix::*;
-use dav_server::{fakels::FakeLs, localfs::LocalFs, DavConfig, DavHandler};
+use dav_server::{DavConfig, DavHandler, fakels::FakeLs, localfs::LocalFs};
 
 pub async fn dav_handler(req: DavRequest, davhandler: web::Data<DavHandler>) -> DavResponse {
     if let Some(prefix) = req.prefix() {

examples/auth.rs

@@ -1,12 +1,13 @@
 use std::{convert::Infallible, fmt::Display, net::SocketAddr, path::Path};
 
-use futures_util::{stream, StreamExt};
+use futures_util::{StreamExt, stream};
 use http::{Request, Response, StatusCode};
 use hyper::{body::Incoming, server::conn::http1, service::service_fn};
 use hyper_util::rt::TokioIo;
 use tokio::{net::TcpListener, task::spawn};
 
 use dav_server::{
+    DavHandler,
     body::Body,
     davpath::DavPath,
     fakels::FakeLs,
@@ -15,7 +16,6 @@ use dav_server::{
         OpenOptions, ReadDirMeta,
     },
     localfs::LocalFs,
-    DavHandler,
 };
 
 /// The server example demonstrates a limited scope policy for access to the file system.
@@ -129,7 +129,7 @@ enum Filter {
 
 impl Filter {
     fn from_request(request: &Request<Incoming>) -> Result<Self, Box<dyn Display>> {
-        use headers::{authorization::Basic, Authorization, HeaderMapExt};
+        use headers::{Authorization, HeaderMapExt, authorization::Basic};
 
         let auth = request
             .headers()

examples/hyper.rs

@@ -4,7 +4,7 @@ use hyper::{server::conn::http1, service::service_fn};
 use hyper_util::rt::TokioIo;
 use tokio::net::TcpListener;
 
-use dav_server::{fakels::FakeLs, localfs::LocalFs, DavHandler};
+use dav_server::{DavHandler, fakels::FakeLs, localfs::LocalFs};
 
 #[tokio::main]
 async fn main() {

examples/sample-litmus-server.rs

@@ -8,12 +8,12 @@
 use std::{convert::Infallible, error::Error, net::SocketAddr};
 
 use clap::Parser;
-use headers::{authorization::Basic, Authorization, HeaderMapExt};
+use headers::{Authorization, HeaderMapExt, authorization::Basic};
 use hyper::{server::conn::http1, service::service_fn};
 use hyper_util::rt::TokioIo;
 use tokio::net::TcpListener;
 
-use dav_server::{body::Body, fakels, localfs, memfs, memls, DavConfig, DavHandler};
+use dav_server::{DavConfig, DavHandler, body::Body, fakels, localfs, memfs, memls};
 
 #[derive(Clone)]
 struct Server {

src/actix.rs

@@ -21,9 +21,9 @@ use std::{
 
 use actix_web::body::BoxBody;
 use actix_web::error::PayloadError;
-use actix_web::{dev, Error, FromRequest, HttpRequest, HttpResponse};
+use actix_web::{Error, FromRequest, HttpRequest, HttpResponse, dev};
 use bytes::Bytes;
-use futures_util::{future, Stream};
+use futures_util::{Stream, future};
 use pin_project::pin_project;
 
 /// http::Request compatibility.

src/conditional.rs

@@ -83,15 +83,13 @@ pub(crate) fn http_if_match(req: &Request, meta: Option<&dyn DavMetaData>) -> Op
                 return Some(StatusCode::PRECONDITION_FAILED);
             }
         }
-    } else if let Some(r) = req.headers().typed_get::<headers::IfModifiedSince>() {
-        if req.method() == Method::GET || req.method() == Method::HEAD {
-            if let Some(file_modified) = file_modified {
-                if round_time(file_modified) <= round_time(r) {
-                    trace!("not-modified If-Modified-Since {r:?}");
-                    return Some(StatusCode::NOT_MODIFIED);
-                }
-            }
-        }
+    } else if let Some(r) = req.headers().typed_get::<headers::IfModifiedSince>()
+        && (req.method() == Method::GET || req.method() == Method::HEAD)
+        && let Some(file_modified) = file_modified
+        && round_time(file_modified) <= round_time(r)
+    {
+        trace!("not-modified If-Modified-Since {r:?}");
+        return Some(StatusCode::NOT_MODIFIED);
     }
     None
 }

src/davhandler.rs

@@ -17,13 +17,13 @@ use http_body_util::BodyExt;
 use crate::body::{Body, StreamBody};
 use crate::davheaders;
 use crate::davpath::DavPath;
-use crate::util::{dav_method, DavMethod, DavMethodSet};
+use crate::util::{DavMethod, DavMethodSet, dav_method};
 
+use crate::DavResult;
 use crate::errors::DavError;
 use crate::fs::*;
 use crate::ls::*;
-use crate::voidfs::{is_voidfs, VoidFs};
-use crate::DavResult;
+use crate::voidfs::{VoidFs, is_voidfs};
 
 /// WebDAV request handler.
 ///
@@ -459,10 +459,10 @@ where
         };
 
         // debug when running the webdav litmus tests.
-        if log_enabled!(log::Level::Debug) {
-            if let Some(t) = req.headers().typed_get::<davheaders::XLitmus>() {
-                debug!("X-Litmus: {t:?}");
-            }
+        if log_enabled!(log::Level::Debug)
+            && let Some(t) = req.headers().typed_get::<davheaders::XLitmus>()
+        {
+            debug!("X-Litmus: {t:?}");
         }
 
         // translate HTTP method to Webdav method.
@@ -497,15 +497,15 @@ where
         }
 
         // see if method is allowed.
-        if let Some(ref a) = self.allow {
-            if !a.contains(method) {
-                debug!(
-                    "method {} not allowed on request {}",
-                    req.method(),
-                    req.uri()
-                );
-                return Err(DavError::StatusClose(StatusCode::METHOD_NOT_ALLOWED));
-            }
+        if let Some(ref a) = self.allow
+            && !a.contains(method)
+        {
+            debug!(
+                "method {} not allowed on request {}",
+                req.method(),
+                req.uri()
+            );
+            return Err(DavError::StatusClose(StatusCode::METHOD_NOT_ALLOWED));
         }
 
         // make sure the request path is valid.

src/davheaders.rs

@@ -48,7 +48,7 @@ fn map_invalid(_e: impl std::error::Error) -> headers::Error {
 }
 
 macro_rules! header {
-    ($tname:ident, $hname:ident, $sname:expr) => {
+    ($tname:ident, $hname:ident, $sname:expr_2021) => {
         lazy_static! {
             pub static ref $hname: HeaderName = HeaderName::from_static($sname);
         }
@@ -250,10 +250,10 @@ impl Header for Destination {
         if s.starts_with('/') {
             return Ok(Destination(s.to_string()));
         }
-        if let Some(caps) = RE_URL.captures(s) {
-            if let Some(path) = caps.get(1) {
-                return Ok(Destination(path.as_str().to_string()));
-            }
+        if let Some(caps) = RE_URL.captures(s)
+            && let Some(path) = caps.get(1)
+        {
+            return Ok(Destination(path.as_str().to_string()));
         }
         Err(invalid())
     }

src/davpath.rs

@@ -422,12 +422,11 @@ impl DavPathRef {
     pub(crate) fn get_mime_type_str(&self) -> &'static str {
         let name = self.file_name_bytes();
         let d = name.rsplitn(2, |&c| c == b'.').collect::<Vec<&[u8]>>();
-        if d.len() > 1 {
-            if let Ok(ext) = std::str::from_utf8(d[0]) {
-                if let Some(t) = mime_guess::from_ext(ext).first_raw() {
-                    return t;
-                }
-            }
+        if d.len() > 1
+            && let Ok(ext) = std::str::from_utf8(d[0])
+            && let Some(t) = mime_guess::from_ext(ext).first_raw()
+        {
+            return t;
         }
         "application/octet-stream"
     }