Move properties into separate files

crates/carddav/src/address_object/methods.rs

@@ -1,8 +1,6 @@
-use std::str::FromStr;
-
-use super::resource::AddressObjectPathComponents;
+use super::AddressObjectPathComponents;
+use super::AddressObjectResourceService;
 use crate::Error;
-use crate::address_object::resource::AddressObjectResourceService;
 use crate::addressbook::resource::AddressbookResource;
 use axum::body::Body;
 use axum::extract::{Path, State};
@@ -15,6 +13,7 @@ use rustical_dav::resource::Resource;
 use rustical_ical::AddressObject;
 use rustical_store::AddressbookStore;
 use rustical_store::auth::User;
+use std::str::FromStr;
 use tracing::instrument;
 
 #[instrument(skip(addr_store))]

crates/carddav/src/address_object/mod.rs

@@ -1,2 +1,6 @@
 pub mod methods;
 pub mod resource;
+mod service;
+pub use service::*;
+mod prop;
+pub use prop::*;

crates/carddav/src/address_object/prop.rs

@@ -0,0 +1,23 @@
+use rustical_dav::extensions::CommonPropertiesProp;
+use rustical_xml::{EnumVariants, PropName, XmlDeserialize, XmlSerialize};
+
+#[derive(XmlDeserialize, XmlSerialize, PartialEq, Clone, EnumVariants, PropName)]
+#[xml(unit_variants_ident = "AddressObjectPropName")]
+pub enum AddressObjectProp {
+    // WebDAV (RFC 2518)
+    #[xml(ns = "rustical_dav::namespace::NS_DAV")]
+    Getetag(String),
+    #[xml(ns = "rustical_dav::namespace::NS_DAV", skip_deserializing)]
+    Getcontenttype(&'static str),
+
+    // CalDAV (RFC 4791)
+    #[xml(ns = "rustical_dav::namespace::NS_CARDDAV")]
+    AddressData(String),
+}
+
+#[derive(XmlDeserialize, XmlSerialize, PartialEq, Clone, EnumVariants, PropName)]
+#[xml(unit_variants_ident = "AddressObjectPropWrapperName", untagged)]
+pub enum AddressObjectPropWrapper {
+    AddressObject(AddressObjectProp),
+    Common(CommonPropertiesProp),
+}

crates/carddav/src/address_object/resource.rs

@@ -1,56 +1,19 @@
-use crate::{CardDavPrincipalUri, Error};
-use async_trait::async_trait;
-use axum::{extract::Request, handler::Handler, response::Response};
-use derive_more::derive::{Constructor, From, Into};
-use futures_util::future::BoxFuture;
+use crate::{
+    Error,
+    address_object::{
+        AddressObjectProp, AddressObjectPropName, AddressObjectPropWrapper,
+        AddressObjectPropWrapperName,
+    },
+};
+use derive_more::derive::{From, Into};
 use rustical_dav::{
-    extensions::{CommonPropertiesExtension, CommonPropertiesProp},
+    extensions::CommonPropertiesExtension,
     privileges::UserPrivilegeSet,
-    resource::{AxumMethods, PrincipalUri, Resource, ResourceName, ResourceService},
+    resource::{PrincipalUri, Resource, ResourceName},
     xml::Resourcetype,
 };
 use rustical_ical::AddressObject;
-use rustical_store::{AddressbookStore, auth::User};
-use rustical_xml::{EnumVariants, PropName, XmlDeserialize, XmlSerialize};
-use serde::{Deserialize, Deserializer};
-use std::{convert::Infallible, sync::Arc};
-use tower::Service;
-
-use super::methods::{get_object, put_object};
-
-#[derive(Constructor)]
-pub struct AddressObjectResourceService<AS: AddressbookStore> {
-    pub(crate) addr_store: Arc<AS>,
-}
-
-impl<AS: AddressbookStore> Clone for AddressObjectResourceService<AS> {
-    fn clone(&self) -> Self {
-        Self {
-            addr_store: self.addr_store.clone(),
-        }
-    }
-}
-
-#[derive(XmlDeserialize, XmlSerialize, PartialEq, Clone, EnumVariants, PropName)]
-#[xml(unit_variants_ident = "AddressObjectPropName")]
-pub enum AddressObjectProp {
-    // WebDAV (RFC 2518)
-    #[xml(ns = "rustical_dav::namespace::NS_DAV")]
-    Getetag(String),
-    #[xml(ns = "rustical_dav::namespace::NS_DAV", skip_deserializing)]
-    Getcontenttype(&'static str),
-
-    // CalDAV (RFC 4791)
-    #[xml(ns = "rustical_dav::namespace::NS_CARDDAV")]
-    AddressData(String),
-}
-
-#[derive(XmlDeserialize, XmlSerialize, PartialEq, Clone, EnumVariants, PropName)]
-#[xml(unit_variants_ident = "AddressObjectPropWrapperName", untagged)]
-pub enum AddressObjectPropWrapper {
-    AddressObject(AddressObjectProp),
-    Common(CommonPropertiesProp),
-}
+use rustical_store::auth::User;
 
 #[derive(Clone, From, Into)]
 pub struct AddressObjectResource {
@@ -113,84 +76,3 @@ impl Resource for AddressObjectResource {
         ))
     }
 }
-
-fn deserialize_vcf_name<'de, D>(deserializer: D) -> Result<String, D::Error>
-where
-    D: Deserializer<'de>,
-{
-    let name: String = Deserialize::deserialize(deserializer)?;
-    if let Some(object_id) = name.strip_suffix(".vcf") {
-        Ok(object_id.to_owned())
-    } else {
-        Err(serde::de::Error::custom("Missing .vcf extension"))
-    }
-}
-
-#[derive(Debug, Clone, Deserialize)]
-pub struct AddressObjectPathComponents {
-    pub principal: String,
-    pub addressbook_id: String,
-    #[serde(deserialize_with = "deserialize_vcf_name")]
-    pub object_id: String,
-}
-
-#[async_trait]
-impl<AS: AddressbookStore> ResourceService for AddressObjectResourceService<AS> {
-    type PathComponents = AddressObjectPathComponents;
-    type Resource = AddressObjectResource;
-    type MemberType = AddressObjectResource;
-    type Error = Error;
-    type Principal = User;
-    type PrincipalUri = CardDavPrincipalUri;
-
-    const DAV_HEADER: &str = "1, 3, access-control, addressbook";
-
-    async fn get_resource(
-        &self,
-        AddressObjectPathComponents {
-            principal,
-            addressbook_id,
-            object_id,
-        }: &Self::PathComponents,
-    ) -> Result<Self::Resource, Self::Error> {
-        let object = self
-            .addr_store
-            .get_object(principal, addressbook_id, object_id, false)
-            .await?;
-        Ok(AddressObjectResource {
-            object,
-            principal: principal.to_owned(),
-        })
-    }
-
-    async fn delete_resource(
-        &self,
-        AddressObjectPathComponents {
-            principal,
-            addressbook_id,
-            object_id,
-        }: &Self::PathComponents,
-        use_trashbin: bool,
-    ) -> Result<(), Self::Error> {
-        self.addr_store
-            .delete_object(principal, addressbook_id, object_id, use_trashbin)
-            .await?;
-        Ok(())
-    }
-}
-
-impl<AS: AddressbookStore> AxumMethods for AddressObjectResourceService<AS> {
-    fn get() -> Option<fn(Self, Request) -> BoxFuture<'static, Result<Response, Infallible>>> {
-        Some(|state, req| {
-            let mut service = Handler::with_state(get_object::<AS>, state);
-            Box::pin(Service::call(&mut service, req))
-        })
-    }
-
-    fn put() -> Option<fn(Self, Request) -> BoxFuture<'static, Result<Response, Infallible>>> {
-        Some(|state, req| {
-            let mut service = Handler::with_state(put_object::<AS>, state);
-            Box::pin(Service::call(&mut service, req))
-        })
-    }
-}

crates/carddav/src/address_object/service.rs

@@ -0,0 +1,105 @@
+use super::methods::{get_object, put_object};
+use crate::{CardDavPrincipalUri, Error, address_object::resource::AddressObjectResource};
+use async_trait::async_trait;
+use axum::{extract::Request, handler::Handler, response::Response};
+use derive_more::derive::Constructor;
+use futures_util::future::BoxFuture;
+use rustical_dav::resource::{AxumMethods, ResourceService};
+use rustical_store::{AddressbookStore, auth::User};
+use serde::{Deserialize, Deserializer};
+use std::{convert::Infallible, sync::Arc};
+use tower::Service;
+
+#[derive(Constructor)]
+pub struct AddressObjectResourceService<AS: AddressbookStore> {
+    pub(crate) addr_store: Arc<AS>,
+}
+
+impl<AS: AddressbookStore> Clone for AddressObjectResourceService<AS> {
+    fn clone(&self) -> Self {
+        Self {
+            addr_store: self.addr_store.clone(),
+        }
+    }
+}
+
+#[derive(Debug, Clone, Deserialize)]
+pub struct AddressObjectPathComponents {
+    pub principal: String,
+    pub addressbook_id: String,
+    #[serde(deserialize_with = "deserialize_vcf_name")]
+    pub object_id: String,
+}
+
+#[async_trait]
+impl<AS: AddressbookStore> ResourceService for AddressObjectResourceService<AS> {
+    type PathComponents = AddressObjectPathComponents;
+    type Resource = AddressObjectResource;
+    type MemberType = AddressObjectResource;
+    type Error = Error;
+    type Principal = User;
+    type PrincipalUri = CardDavPrincipalUri;
+
+    const DAV_HEADER: &str = "1, 3, access-control, addressbook";
+
+    async fn get_resource(
+        &self,
+        AddressObjectPathComponents {
+            principal,
+            addressbook_id,
+            object_id,
+        }: &Self::PathComponents,
+    ) -> Result<Self::Resource, Self::Error> {
+        let object = self
+            .addr_store
+            .get_object(principal, addressbook_id, object_id, false)
+            .await?;
+        Ok(AddressObjectResource {
+            object,
+            principal: principal.to_owned(),
+        })
+    }
+
+    async fn delete_resource(
+        &self,
+        AddressObjectPathComponents {
+            principal,
+            addressbook_id,
+            object_id,
+        }: &Self::PathComponents,
+        use_trashbin: bool,
+    ) -> Result<(), Self::Error> {
+        self.addr_store
+            .delete_object(principal, addressbook_id, object_id, use_trashbin)
+            .await?;
+        Ok(())
+    }
+}
+
+impl<AS: AddressbookStore> AxumMethods for AddressObjectResourceService<AS> {
+    fn get() -> Option<fn(Self, Request) -> BoxFuture<'static, Result<Response, Infallible>>> {
+        Some(|state, req| {
+            let mut service = Handler::with_state(get_object::<AS>, state);
+            Box::pin(Service::call(&mut service, req))
+        })
+    }
+
+    fn put() -> Option<fn(Self, Request) -> BoxFuture<'static, Result<Response, Infallible>>> {
+        Some(|state, req| {
+            let mut service = Handler::with_state(put_object::<AS>, state);
+            Box::pin(Service::call(&mut service, req))
+        })
+    }
+}
+
+fn deserialize_vcf_name<'de, D>(deserializer: D) -> Result<String, D::Error>
+where
+    D: Deserializer<'de>,
+{
+    let name: String = Deserialize::deserialize(deserializer)?;
+    if let Some(object_id) = name.strip_suffix(".vcf") {
+        Ok(object_id.to_owned())
+    } else {
+        Err(serde::de::Error::custom("Missing .vcf extension"))
+    }
+}