rustical_dav: Make actix-web a completely optional dependency

crates/dav/src/resource/methods/delete.rs

@@ -69,7 +69,7 @@ pub async fn route_delete<R: ResourceService>(
     if_match: Option<IfMatch>,
     if_none_match: Option<IfNoneMatch>,
 ) -> Result<(), R::Error> {
-    let resource = resource_service.get_resource(&path_components).await?;
+    let resource = resource_service.get_resource(path_components).await?;
 
     let privileges = resource.get_user_privileges(&principal)?;
     if !privileges.has(&UserPrivilege::Write) {

crates/dav/src/resource/methods/mod.rs

@@ -11,3 +11,6 @@ pub(crate) use delete::actix_route_delete;
 
 #[cfg(feature = "actix")]
 pub(crate) use propfind::actix_route_propfind;
+
+#[cfg(feature = "actix")]
+pub(crate) use proppatch::actix_route_proppatch;

crates/dav/src/resource/methods/proppatch.rs

@@ -5,9 +5,7 @@ use crate::resource::ResourceService;
 use crate::xml::MultistatusElement;
 use crate::xml::TagList;
 use crate::xml::multistatus::{PropstatElement, PropstatWrapper, ResponseElement};
-use actix_web::http::StatusCode;
-use actix_web::web::Data;
-use actix_web::{HttpRequest, web::Path};
+use http::StatusCode;
 use quick_xml::name::Namespace;
 use rustical_xml::EnumUnitVariants;
 use rustical_xml::Unparsed;
@@ -63,23 +61,41 @@ enum Operation<T: XmlDeserialize> {
 #[xml(ns = "crate::namespace::NS_DAV")]
 struct PropertyupdateElement<T: XmlDeserialize>(#[xml(ty = "untagged", flatten)] Vec<Operation<T>>);
 
+#[cfg(feature = "actix")]
 #[instrument(parent = root_span.id(), skip(path, req, root_span, resource_service))]
-pub(crate) async fn route_proppatch<R: ResourceService>(
-    path: Path<R::PathComponents>,
+pub(crate) async fn actix_route_proppatch<R: ResourceService>(
+    path: actix_web::web::Path<R::PathComponents>,
     body: String,
-    req: HttpRequest,
+    req: actix_web::HttpRequest,
     principal: R::Principal,
     root_span: RootSpan,
-    resource_service: Data<R>,
+    resource_service: actix_web::web::Data<R>,
 ) -> Result<MultistatusElement<String, String>, R::Error> {
-    let href = req.path().to_owned();
+    route_proppatch(
+        &path.into_inner(),
+        req.path(),
+        body,
+        principal,
+        resource_service.as_ref(),
+    )
+    .await
+}
+
+pub(crate) async fn route_proppatch<R: ResourceService>(
+    path_components: &R::PathComponents,
+    path: &str,
+    body: String,
+    principal: R::Principal,
+    resource_service: &R,
+) -> Result<MultistatusElement<String, String>, R::Error> {
+    let href = path.to_owned();
 
     // Extract operations
     let PropertyupdateElement::<SetPropertyPropWrapperWrapper<<R::Resource as Resource>::Prop>>(
         operations,
     ) = XmlDocument::parse_str(&body).map_err(Error::XmlError)?;
 
-    let mut resource = resource_service.get_resource(&path).await?;
+    let mut resource = resource_service.get_resource(path_components).await?;
     let privileges = resource.get_user_privileges(&principal)?;
     if !privileges.has(&UserPrivilege::Write) {
         return Err(Error::Unauthorized.into());
@@ -151,7 +167,9 @@ pub(crate) async fn route_proppatch<R: ResourceService>(
 
     if props_not_found.is_empty() && props_conflict.is_empty() {
         // Only save if no errors occured
-        resource_service.save_resource(&path, resource).await?;
+        resource_service
+            .save_resource(path_components, resource)
+            .await?;
     }
 
     Ok(MultistatusElement {

crates/dav/src/resource/resource_service.rs

@@ -1,8 +1,9 @@
-use super::methods::{actix_route_delete, actix_route_propfind, route_proppatch};
+#[cfg(feature = "actix")]
+use super::methods::{actix_route_delete, actix_route_propfind, actix_route_proppatch};
 use super::{PrincipalUri, Resource};
 use crate::Principal;
-use actix_web::web::Data;
-use actix_web::{ResponseError, http::Method, web};
+#[cfg(feature = "actix")]
+use actix_web::{http::Method, web, web::Data};
 use async_trait::async_trait;
 use serde::Deserialize;
 use std::str::FromStr;
@@ -12,7 +13,7 @@ pub trait ResourceService: Sized + 'static {
     type MemberType: Resource<Error = Self::Error, Principal = Self::Principal>;
     type PathComponents: for<'de> Deserialize<'de> + Sized + Clone + 'static; // defines how the resource URI maps to parameters, i.e. /{principal}/{calendar} -> (String, String)
     type Resource: Resource<Error = Self::Error, Principal = Self::Principal>;
-    type Error: ResponseError + From<crate::Error>;
+    type Error: From<crate::Error>;
     type Principal: Principal;
     type PrincipalUri: PrincipalUri;
 
@@ -44,16 +45,28 @@ pub trait ResourceService: Sized + 'static {
         Err(crate::Error::Unauthorized.into())
     }
 
+    #[cfg(feature = "actix")]
     #[inline]
-    fn actix_resource(self) -> actix_web::Resource {
+    fn actix_resource(self) -> actix_web::Resource
+    where
+        Self::Error: actix_web::ResponseError,
+        Self::Principal: actix_web::FromRequest,
+    {
         web::resource("")
             .app_data(Data::new(self))
             .route(
                 web::method(Method::from_str("PROPFIND").unwrap()).to(actix_route_propfind::<Self>),
             )
-            .route(web::method(Method::from_str("PROPPATCH").unwrap()).to(route_proppatch::<Self>))
+            .route(
+                web::method(Method::from_str("PROPPATCH").unwrap())
+                    .to(actix_route_proppatch::<Self>),
+            )
             .delete(actix_route_delete::<Self>)
     }
 
-    fn actix_scope(self) -> actix_web::Scope;
+    #[cfg(feature = "actix")]
+    fn actix_scope(self) -> actix_web::Scope
+    where
+        Self::Error: actix_web::ResponseError,
+        Self::Principal: actix_web::FromRequest;
 }