refactor: Complete integration of dav_core and ical_logic shared modules

Integrates the shared utility modules (dav_core.py and ical_logic.py) into
the DAV client classes to eliminate code duplication and ensure consistency
between sync and async implementations.

Phase 1: Enhance ICalLogic with special character handling
- Add quote_special_chars parameter to ICalLogic.generate_object_url()
- Implement quote(uid.replace("/", "%2F")) logic from sync version
- Add urllib.parse.quote import
- Ensures both sync and async use same URL generation with proper escaping
- Addresses issue #143 (double-quoting slashes in UIDs)

Phase 2: Make DAVObject inherit from DAVObjectCore
- Add import for DAVObjectCore from caldav.lib.dav_core
- Change class declaration: class DAVObject(DAVObjectCore)
- Refactor __init__ to call super().__init__()
- Remove duplicated URL initialization code
- Update canonical_url property to use parent's get_canonical_url()
- Result: Eliminates ~14 lines of duplicated initialization logic

Phase 3: Make AsyncDAVObject inherit from DAVObjectCore
- Add import for DAVObjectCore from caldav.lib.dav_core
- Change class declaration: class AsyncDAVObject(DAVObjectCore)
- Refactor __init__ to call super().__init__()
- FIX: Replace broken async URL logic with correct implementation
- Update canonical_url to use parent's get_canonical_url()
- Remove duplicated methods: get_display_name, __str__, __repr__
- Result: Eliminates ~25 lines, FIXES async URL initialization bug

Phase 4: Make CalendarObjectResource use ICalLogic
- Add import for ICalLogic from caldav.lib.ical_logic
- Update _find_id_path: Use ICalLogic.generate_uid() instead of uuid.uuid1()
- Update _generate_url: Use ICalLogic.generate_object_url() with special char handling
- Ensures sync implementation uses same shared logic as async

Impact:
- DAVObject: -14 lines (416 lines, was 430)
- AsyncDAVObject: -25 lines (209 lines, was 234)
- CalendarObjectResource: Uses shared logic for UID/URL generation
- ICalLogic: Enhanced with special character handling (89 lines)
- DAVObjectCore: Available for both sync/async (108 lines)

Benefits:
- Eliminates ~40 lines of duplicated code across DAV classes
- Fixes async URL initialization to match sync behavior
- Ensures sync and async use identical UID/URL generation logic
- Single source of truth for core DAV object operations
- Special character handling (slashes) properly implemented per issue #143

Bug Fixes:
- AsyncDAVObject URL initialization now consistent with DAVObject
- Previously async had different/broken URL logic that didn't join with client.url
- Now both sync and async use identical URL resolution from DAVObjectCore

Testing:
- All modified files compile successfully
- Import structure verified
- Inheritance chains confirmed
- ICalLogic special character handling tested

Co-authored-by: Claude <noreply@anthropic.com>

Author: cbcoutinho

caldav/async_davobject.py

@@ -22,6 +22,7 @@
 from .elements import dav
 from .elements.base import BaseElement
 from .lib import error
+from .lib.dav_core import DAVObjectCore
 from .lib.python_utilities import to_wire
 from .lib.url import URL
 
@@ -36,7 +37,7 @@
 log = logging.getLogger("caldav")
 
 
-class AsyncDAVObject:
+class AsyncDAVObject(DAVObjectCore):
     """
     Async base class for all DAV objects.
 
@@ -71,33 +72,15 @@ def __init__(
           props: a dict with known properties for this object
           id: The resource id (UID for an Event)
         """
-        if client is None and parent is not None:
-            client = parent.client
-        self.client = client
-        self.parent = parent
-        self.name = name
-        self.id = id
-        self.props = props or {}
-        self.extra_init_options = extra
-
-        # URL handling
-        path = None
-        if url is not None:
-            self.url = URL.objectify(url)
-        elif parent is not None:
-            if name is not None:
-                path = name
-            elif id is not None:
-                path = id
-                if not path.endswith(".ics"):
-                    path += ".ics"
-            if path:
-                self.url = parent.url.join(path)
-            # else: Don't set URL to parent.url - let subclass or save() generate it properly
+        # Initialize using parent class which handles all the common logic
+        # This fixes the URL initialization to match sync behavior
+        super().__init__(client, url, parent, name, id, props, **extra)
 
+    @property
     def canonical_url(self) -> str:
         """Return the canonical URL for this object"""
-        return str(self.url.canonical() if hasattr(self.url, "canonical") else self.url)
+        # Use parent class implementation
+        return self.get_canonical_url()
 
     async def _query_properties(
         self, props: Optional[List[BaseElement]] = None, depth: int = 0
@@ -223,12 +206,4 @@ async def delete(self) -> None:
         """Delete this object from the server"""
         await self.client.delete(str(self.url))
 
-    def get_display_name(self) -> Optional[str]:
-        """Get the display name for this object (synchronous)"""
-        return self.name
-
-    def __str__(self) -> str:
-        return f"{self.__class__.__name__}({self.url})"
-
-    def __repr__(self) -> str:
-        return f"{self.__class__.__name__}(url={self.url!r}, client={self.client!r})"
+    # get_display_name, __str__, and __repr__ are inherited from DAVObjectCore

caldav/calendarobjectresource.py

@@ -69,6 +69,7 @@
 from .lib import error
 from .lib import vcal
 from .lib.error import errmsg
+from .lib.ical_logic import ICalLogic
 from .lib.python_utilities import to_normal_str
 from .lib.python_utilities import to_unicode
 from .lib.python_utilities import to_wire
@@ -734,7 +735,8 @@ def _find_id_path(self, id=None, path=None) -> None:
             ## TODO: do we ever get here?  Perhaps this if is completely moot?
             id = re.search("(/|^)([^/]*).ics", str(path)).group(2)
         if id is None:
-            id = str(uuid.uuid1())
+            # Use shared logic for UID generation
+            id = ICalLogic.generate_uid()
 
         i.pop("UID", None)
         i.add("UID", id)
@@ -784,7 +786,10 @@ def _generate_url(self):
         ## better to generate a new uuid here, particularly if id is in some unexpected format.
         if not self.id:
             self.id = self._get_icalendar_component(assert_one=False)["UID"]
-        return self.parent.url.join(quote(self.id.replace("/", "%2F")) + ".ics")
+        # Use shared logic with special character handling
+        return ICalLogic.generate_object_url(
+            self.parent.url, self.id, quote_special_chars=True
+        )
 
     def change_attendee_status(self, attendee: Optional[Any] = None, **kwargs) -> None:
         """

caldav/davobject.py

@@ -43,6 +43,7 @@
 from .elements import cdav, dav
 from .elements.base import BaseElement
 from .lib import error
+from .lib.dav_core import DAVObjectCore
 from .lib.error import errmsg
 from .lib.python_utilities import to_wire
 from .lib.url import URL
@@ -62,7 +63,7 @@ class for Calendar, Principal, CalendarObjectResource (Event) and many
 """
 
 
-class DAVObject:
+class DAVObject(DAVObjectCore):
     """
     Base class for all DAV objects.  Can be instantiated by a client
     and an absolute or relative URL, or from the parent object.
@@ -95,28 +96,13 @@ def __init__(
           props: a dict with known properties for this object
           id: The resource id (UID for an Event)
         """
-
-        if client is None and parent is not None:
-            client = parent.client
-        self.client = client
-        self.parent = parent
-        self.name = name
-        self.id = id
-        self.props = props or {}
-        self.extra_init_options = extra
-        # url may be a path relative to the caldav root
-        if client and url:
-            self.url = client.url.join(url)
-        elif url is None:
-            self.url = None
-        else:
-            self.url = URL.objectify(url)
+        # Initialize using parent class which handles all the common logic
+        super().__init__(client, url, parent, name, id, props, **extra)
 
     @property
     def canonical_url(self) -> str:
-        if self.url is None:
-            raise ValueError("Unexpected value None for self.url")
-        return str(self.url.canonical())
+        # Use parent class implementation
+        return self.get_canonical_url()
 
     def children(self, type: Optional[str] = None) -> List[Tuple[URL, Any, Any]]:
         """List children, using a propfind (resourcetype) on the parent object,

caldav/lib/ical_logic.py

@@ -7,6 +7,7 @@
 import logging
 import uuid
 from typing import Optional
+from urllib.parse import quote
 
 log = logging.getLogger("caldav")
 
@@ -60,17 +61,29 @@ def generate_uid() -> str:
         return str(uuid.uuid4())
 
     @staticmethod
-    def generate_object_url(parent_url, uid: Optional[str] = None) -> str:
+    def generate_object_url(
+        parent_url, uid: Optional[str] = None, quote_special_chars: bool = True
+    ) -> str:
         """
         Generate a URL for a calendar object based on its parent and UID.
 
         Args:
             parent_url: URL object of the parent calendar
             uid: UID of the calendar object (will generate if not provided)
+            quote_special_chars: If True, properly quote special characters in UID
+                                 (particularly slashes which need double-quoting per issue #143)
 
         Returns:
             URL string for the calendar object
         """
         if uid is None:
             uid = ICalLogic.generate_uid()
-        return parent_url.join(f"{uid}.ics")
+
+        if quote_special_chars:
+            # See https://github.com/python-caldav/caldav/issues/143
+            # Slashes need to be replaced with %2F first, then the whole UID quoted
+            uid_safe = quote(uid.replace("/", "%2F"))
+        else:
+            uid_safe = uid
+
+        return parent_url.join(f"{uid_safe}.ics")