async-caldav 1.0.0

data/lib/async/caldav/handlers/proppatch.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "scampi"
+require "async/caldav"
+
+module Async
+  module Caldav
+    module Handlers
+      module Proppatch
+        module_function
+
+        def call(path:, body:, storage:, **)
+          col_path = path.ensure_trailing_slash
+          col = storage.get_collection(col_path.to_s)
+
+          return [404, { 'content-type' => 'text/plain' }, ['Not Found']] unless col
+
+          updates = {}
+
+          # Check for removals
+          is_remove = body&.match?(/<[^>]*remove[^>]*>/m)
+
+          dn = Protocol::Caldav::Xml.extract_value(body, 'displayname')
+          desc = Protocol::Caldav::Xml.extract_value(body, 'calendar-description')
+          color = Protocol::Caldav::Xml.extract_value(body, 'calendar-color')
+
+          if is_remove
+            updates[:displayname] = nil if body.match?(/displayname/i) && !dn
+            updates[:description] = nil if body.match?(/calendar-description/i) && !desc
+            updates[:color] = nil if body.match?(/calendar-color/i) && !color
+          end
+
+          updates[:displayname] = dn if dn
+          updates[:description] = desc if desc
+          updates[:color] = color if color
+
+          storage.update_collection(col_path.to_s, updates)
+
+          response_xml = <<~XML
+            <d:response>
+              <d:href>#{Protocol::Caldav::Xml.escape(col_path.to_s)}</d:href>
+              <d:propstat>
+                <d:prop/>
+                <d:status>HTTP/1.1 200 OK</d:status>
+              </d:propstat>
+            </d:response>
+          XML
+
+          xml = Protocol::Caldav::Multistatus.new([response_xml]).to_xml
+          [207, Protocol::Caldav::Constants::DAV_HEADERS, [xml]]
+        end
+      end
+    end
+  end
+end
+
+test do
+  describe "Async::Caldav::Handlers::Proppatch" do
+    def call(**opts)
+      Async::Caldav::Handlers::Proppatch.call(**opts)
+    end
+
+    def path(p, s)
+      Protocol::Caldav::Path.new(p, storage_class: s)
+    end
+
+    it "updates displayname and returns 207" do
+      s = Async::Caldav::Storage::Mock.new
+      s.create_collection('/cal/', displayname: 'Old')
+      status, = call(
+        path: path('/cal/', s), storage: s,
+        body: '<d:set><d:prop><d:displayname>New</d:displayname></d:prop></d:set>'
+      )
+      status.should.equal 207
+      s.get_collection('/cal/')[:displayname].should.equal 'New'
+    end
+
+    it "returns 404 for non-existent collection" do
+      s = Async::Caldav::Storage::Mock.new
+      status, = call(path: path('/nope/', s), storage: s, body: '')
+      status.should.equal 404
+    end
+
+    it "updates multiple properties at once" do
+      s = Async::Caldav::Storage::Mock.new
+      s.create_collection('/cal/', displayname: 'Old', description: 'OldDesc')
+      status, = call(
+        path: path('/cal/', s), storage: s,
+        body: '<d:set><d:prop><d:displayname>New</d:displayname><c:calendar-description>NewDesc</c:calendar-description></d:prop></d:set>'
+      )
+      status.should.equal 207
+      col = s.get_collection('/cal/')
+      col[:displayname].should.equal 'New'
+      col[:description].should.equal 'NewDesc'
+    end
+
+    it "handles mixed set and remove in one request" do
+      s = Async::Caldav::Storage::Mock.new
+      s.create_collection('/cal/', displayname: 'Keep', description: 'Remove', color: '#ff0000')
+      call(
+        path: path('/cal/', s), storage: s,
+        body: '<d:set><d:prop><d:displayname>Updated</d:displayname></d:prop></d:set><d:remove><d:prop><c:calendar-description/></d:prop></d:remove>'
+      )
+      col = s.get_collection('/cal/')
+      col[:displayname].should.equal 'Updated'
+      col[:description].should.be.nil
+      col[:color].should.equal '#ff0000'
+    end
+
+    it "removes a property" do
+      s = Async::Caldav::Storage::Mock.new
+      s.create_collection('/cal/', displayname: 'Work')
+      call(
+        path: path('/cal/', s), storage: s,
+        body: '<d:remove><d:prop><d:displayname/></d:prop></d:remove>'
+      )
+      s.get_collection('/cal/')[:displayname].should.be.nil
+    end
+  end
+end

data/lib/async/caldav/handlers/put.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "scampi"
+require "async/caldav"
+
+module Async
+  module Caldav
+    module Handlers
+      module Put
+        module_function
+
+        def call(path:, body:, storage:, headers: {}, resource_type: nil, **)
+          return [400, { 'content-type' => 'text/plain' }, ['Empty body']] if body.nil? || body.strip.empty?
+
+          # Validate body format
+          if resource_type == :calendar
+            return [400, { 'content-type' => 'text/plain' }, ['Invalid calendar data']] unless body.start_with?('BEGIN:VCALENDAR')
+            content_type = headers['content-type'] || 'text/calendar'
+          elsif resource_type == :addressbook
+            return [400, { 'content-type' => 'text/plain' }, ['Invalid vCard data']] unless body.start_with?('BEGIN:VCARD')
+            content_type = headers['content-type'] || 'text/vcard'
+          else
+            content_type = headers['content-type'] || 'application/octet-stream'
+          end
+
+          existing = storage.get_item(path.to_s)
+
+          # Precondition checks
+          if_match = headers['if-match']
+          if_none_match = headers['if-none-match']
+
+          if if_match && (!existing || existing[:etag] != if_match)
+            return [412, { 'content-type' => 'text/plain' }, ['Precondition Failed']]
+          end
+
+          if if_none_match == '*' && existing
+            return [412, { 'content-type' => 'text/plain' }, ['Precondition Failed']]
+          end
+
+          # UID conflict check for new items
+          if !existing
+            uid = extract_uid(body)
+            if uid
+              collection_path = path.parent.to_s
+              items = storage.list_items(collection_path)
+              items.each do |item_path, item_data|
+                next if item_path == path.to_s
+                if extract_uid(item_data[:body]) == uid
+                  return [409, { 'content-type' => 'text/plain' }, ['UID conflict']]
+                end
+              end
+            end
+          end
+
+          item, is_new = storage.put_item(path.to_s, body, content_type)
+
+          if is_new
+            [201, { 'etag' => item[:etag], 'content-type' => 'text/plain' }, ['']]
+          else
+            [204, { 'etag' => item[:etag] }, ['']]
+          end
+        end
+
+        def extract_uid(body)
+          return nil unless body
+          match = body.match(/^UID:(.+)/i)
+          match ? match[1].strip : nil
+        end
+
+        private_class_method :extract_uid
+      end
+    end
+  end
+end
+
+test do
+  describe "Async::Caldav::Handlers::Put" do
+    def call(**opts)
+      Async::Caldav::Handlers::Put.call(**opts)
+    end
+
+    def path(p, s)
+      Protocol::Caldav::Path.new(p, storage_class: s)
+    end
+
+    it "creates a new calendar item and returns 201" do
+      s = Async::Caldav::Storage::Mock.new
+      s.create_collection('/calendars/admin/cal/')
+      status, headers, = call(
+        path: path('/calendars/admin/cal/ev.ics', s), storage: s,
+        body: "BEGIN:VCALENDAR\r\nUID:123\r\nEND:VCALENDAR",
+        resource_type: :calendar
+      )
+      status.should.equal 201
+      headers['etag'].should.not.be.nil
+    end
+
+    it "updates an existing item and returns 204" do
+      s = Async::Caldav::Storage::Mock.new
+      s.create_collection('/calendars/admin/cal/')
+      s.put_item('/calendars/admin/cal/ev.ics', "BEGIN:VCALENDAR\r\nUID:123\r\nEND:VCALENDAR", 'text/calendar')
+      status, = call(
+        path: path('/calendars/admin/cal/ev.ics', s), storage: s,
+        body: "BEGIN:VCALENDAR\r\nUID:123\r\nSUMMARY:Updated\r\nEND:VCALENDAR",
+        resource_type: :calendar
+      )
+      status.should.equal 204
+    end
+
+    it "returns 400 for empty body" do
+      s = Async::Caldav::Storage::Mock.new
+      status, = call(path: path('/cal/ev.ics', s), storage: s, body: "")
+      status.should.equal 400
+    end
+
+    it "returns 400 for invalid calendar data" do
+      s = Async::Caldav::Storage::Mock.new
+      status, = call(path: path('/cal/ev.ics', s), storage: s, body: "NOT ICAL", resource_type: :calendar)
+      status.should.equal 400
+    end
+
+    it "returns 400 for invalid vCard data" do
+      s = Async::Caldav::Storage::Mock.new
+      status, = call(path: path('/addr/c.vcf', s), storage: s, body: "NOT VCARD", resource_type: :addressbook)
+      status.should.equal 400
+    end
+
+    it "returns 412 on If-Match mismatch" do
+      s = Async::Caldav::Storage::Mock.new
+      s.put_item('/cal/ev.ics', 'BEGIN:VCALENDAR', 'text/calendar')
+      status, = call(
+        path: path('/cal/ev.ics', s), storage: s,
+        body: "BEGIN:VCALENDAR\r\nNEW", resource_type: :calendar,
+        headers: { 'if-match' => '"wrong"' }
+      )
+      status.should.equal 412
+    end
+
+    it "returns 412 on If-None-Match=* when item exists" do
+      s = Async::Caldav::Storage::Mock.new
+      s.put_item('/cal/ev.ics', 'BEGIN:VCALENDAR', 'text/calendar')
+      status, = call(
+        path: path('/cal/ev.ics', s), storage: s,
+        body: "BEGIN:VCALENDAR\r\nNEW", resource_type: :calendar,
+        headers: { 'if-none-match' => '*' }
+      )
+      status.should.equal 412
+    end
+
+    it "returns 409 on UID conflict" do
+      s = Async::Caldav::Storage::Mock.new
+      s.create_collection('/cal/')
+      s.put_item('/cal/a.ics', "BEGIN:VCALENDAR\r\nUID:same\r\nEND:VCALENDAR", 'text/calendar')
+      status, = call(
+        path: path('/cal/b.ics', s), storage: s,
+        body: "BEGIN:VCALENDAR\r\nUID:same\r\nEND:VCALENDAR",
+        resource_type: :calendar
+      )
+      status.should.equal 409
+    end
+  end
+end

data/lib/async/caldav/handlers/report.rb

@@ -0,0 +1,257 @@
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "scampi"
+require "async/caldav"
+
+module Async
+  module Caldav
+    module Handlers
+      module Report
+        module_function
+
+        def call(path:, body:, storage:, resource_type: nil, **)
+          # Detect sync-collection report
+          if body&.include?('sync-collection')
+            return handle_sync_collection(path: path, body: body, storage: storage)
+          end
+          col_path = path.ensure_trailing_slash
+          items = storage.list_items(col_path.to_s)
+
+          data_tag = resource_type == :addressbook ? 'cr:address-data' : 'c:calendar-data'
+
+          # Parse expand-property if present
+          expand_range = parse_expand(body)
+
+          # Parse filter if present (multiget requests have no filter — ignore parse errors)
+          filter = begin
+            if resource_type == :addressbook
+              Protocol::Caldav::Filter::Parser.parse_addressbook(body)
+            else
+              Protocol::Caldav::Filter::Parser.parse_calendar(body)
+            end
+          rescue Protocol::Caldav::ParseError
+            nil
+          end
+
+          # Check for multiget (href list)
+          hrefs = extract_hrefs(body)
+
+          if hrefs && !hrefs.empty?
+            # Calendar-multiget / addressbook-multiget
+            multi = storage.get_multi(hrefs)
+            items = multi.select { |_, data| data }
+          end
+
+          responses = items.filter_map do |item_path, data|
+            next unless data
+
+            # Apply filter
+            if filter
+              if resource_type == :addressbook
+                card = Protocol::Caldav::Vcard::Parser.parse(data[:body])
+                next unless card && Protocol::Caldav::Filter::Match.addressbook?(filter, card)
+              else
+                component = Protocol::Caldav::Ical::Parser.parse(data[:body])
+                next unless component && Protocol::Caldav::Filter::Match.calendar?(filter, component)
+              end
+            end
+
+            item_body = data[:body]
+
+            # Apply expand if requested (calendar items only)
+            if expand_range && resource_type != :addressbook
+              component = Protocol::Caldav::Ical::Parser.parse(item_body)
+              if component
+                item_body = Protocol::Caldav::Ical::Expand.expand(
+                  component,
+                  range_start: expand_range[:start],
+                  range_end: expand_range[:end]
+                )
+              end
+            end
+
+            item_p = Protocol::Caldav::Path.new(item_path, storage_class: storage)
+            item = Protocol::Caldav::Item.new(
+              path: item_p,
+              body: item_body,
+              content_type: data[:content_type],
+              etag: data[:etag]
+            )
+            item.to_report_xml(data_tag: data_tag)
+          end
+
+          xml = Protocol::Caldav::Multistatus.new(responses).to_xml
+          [207, Protocol::Caldav::Constants::DAV_HEADERS, [xml]]
+        end
+
+        def handle_sync_collection(path:, body:, storage:)
+          col_path = path.ensure_trailing_slash.to_s
+
+          # Extract sync-token from request
+          token_match = body.match(/<[^>]*sync-token[^>]*>(?:<!\[CDATA\[)?([^<\]]*?)(?:\]\]>)?</)
+          old_token = token_match ? token_match[1].strip : nil
+          old_token = nil if old_token&.empty?
+
+          if old_token
+            # Incremental sync
+            result = storage.sync_changes(col_path, old_token)
+            unless result
+              # Invalid token
+              error_xml = <<~XML
+                <?xml version="1.0" encoding="UTF-8"?>
+                <d:error xmlns:d="DAV:">
+                  <d:valid-sync-token/>
+                </d:error>
+              XML
+              return [403, { 'content-type' => 'application/xml' }, [error_xml]]
+            end
+
+            new_token, changes = result
+            responses = changes.map do |item_path, status|
+              if status == :deleted
+                <<~XML
+                  <d:response>
+                    <d:href>#{Protocol::Caldav::Xml.escape(item_path)}</d:href>
+                    <d:status>HTTP/1.1 404 Not Found</d:status>
+                  </d:response>
+                XML
+              else
+                etag = storage.etag(item_path)
+                <<~XML
+                  <d:response>
+                    <d:href>#{Protocol::Caldav::Xml.escape(item_path)}</d:href>
+                    <d:propstat>
+                      <d:prop>
+                        <d:getetag>#{Protocol::Caldav::Xml.escape(etag)}</d:getetag>
+                      </d:prop>
+                      <d:status>HTTP/1.1 200 OK</d:status>
+                    </d:propstat>
+                  </d:response>
+                XML
+              end
+            end
+          else
+            # Initial sync — return all items
+            new_token = storage.snapshot_sync(col_path)
+            items = storage.list_items(col_path)
+            responses = items.map do |item_path, data|
+              <<~XML
+                <d:response>
+                  <d:href>#{Protocol::Caldav::Xml.escape(item_path)}</d:href>
+                  <d:propstat>
+                    <d:prop>
+                      <d:getetag>#{Protocol::Caldav::Xml.escape(data[:etag])}</d:getetag>
+                    </d:prop>
+                    <d:status>HTTP/1.1 200 OK</d:status>
+                  </d:propstat>
+                </d:response>
+              XML
+            end
+          end
+
+          xml = <<~XML
+            <?xml version="1.0" encoding="UTF-8"?>
+            <d:multistatus xmlns:d="DAV:" xmlns:c="urn:ietf:params:xml:ns:caldav" xmlns:cr="urn:ietf:params:xml:ns:carddav" xmlns:cs="http://calendarserver.org/ns/" xmlns:x="http://apple.com/ns/ical/">
+            #{responses.join}
+            <d:sync-token>#{Protocol::Caldav::Xml.escape(new_token)}</d:sync-token>
+            </d:multistatus>
+          XML
+
+          [207, Protocol::Caldav::Constants::DAV_HEADERS, [xml]]
+        end
+
+        def parse_expand(body)
+          return nil unless body
+          match = body.match(/<[^>]*expand[^>]*start\s*=\s*["']([^"']+)["'][^>]*end\s*=\s*["']([^"']+)["']/)
+          return nil unless match
+          start_time = Protocol::Caldav::Filter::Match.send(:parse_datetime_string, match[1])
+          end_time = Protocol::Caldav::Filter::Match.send(:parse_datetime_string, match[2])
+          return nil unless start_time && end_time
+          { start: start_time, end: end_time }
+        end
+
+        def extract_hrefs(body)
+          return nil unless body
+          body.scan(/<[^>]*href[^>]*>([^<]+)</).map { |m| m[0].strip }
+        end
+
+        private_class_method :extract_hrefs, :handle_sync_collection, :parse_expand
+      end
+    end
+  end
+end
+
+test do
+  def normalize(xml)
+    xml.gsub(/>\s+</, '><').strip
+  end
+
+  describe "Async::Caldav::Handlers::Report" do
+    def call(**opts)
+      Async::Caldav::Handlers::Report.call(**opts)
+    end
+
+    def path(p, s)
+      Protocol::Caldav::Path.new(p, storage_class: s)
+    end
+
+    it "returns 207 with all items when no filter" do
+      s = Async::Caldav::Storage::Mock.new
+      s.create_collection('/cal/')
+      s.put_item('/cal/a.ics', "BEGIN:VCALENDAR\r\nBEGIN:VEVENT\r\nSUMMARY:A\r\nEND:VEVENT\r\nEND:VCALENDAR", 'text/calendar')
+      s.put_item('/cal/b.ics', "BEGIN:VCALENDAR\r\nBEGIN:VEVENT\r\nSUMMARY:B\r\nEND:VEVENT\r\nEND:VCALENDAR", 'text/calendar')
+      status, _, body = call(path: path('/cal/', s), storage: s, body: '', resource_type: :calendar)
+      status.should.equal 207
+      body[0].should.include 'a.ics'
+      body[0].should.include 'b.ics'
+    end
+
+    it "filters items by comp-filter" do
+      s = Async::Caldav::Storage::Mock.new
+      s.create_collection('/cal/')
+      s.put_item('/cal/ev.ics', "BEGIN:VCALENDAR\r\nBEGIN:VEVENT\r\nSUMMARY:Meeting\r\nEND:VEVENT\r\nEND:VCALENDAR", 'text/calendar')
+      s.put_item('/cal/td.ics', "BEGIN:VCALENDAR\r\nBEGIN:VTODO\r\nSUMMARY:Task\r\nEND:VTODO\r\nEND:VCALENDAR", 'text/calendar')
+
+      filter_xml = <<~XML
+        <c:filter xmlns:c="urn:ietf:params:xml:ns:caldav">
+          <c:comp-filter name="VCALENDAR">
+            <c:comp-filter name="VEVENT"/>
+          </c:comp-filter>
+        </c:filter>
+      XML
+
+      _, _, body = call(path: path('/cal/', s), storage: s, body: filter_xml, resource_type: :calendar)
+      body[0].should.include 'ev.ics'
+      body[0].should.not.include 'td.ics'
+    end
+
+    it "uses c:calendar-data tag for calendars" do
+      s = Async::Caldav::Storage::Mock.new
+      s.create_collection('/cal/')
+      s.put_item('/cal/ev.ics', "BEGIN:VCALENDAR\r\nEND:VCALENDAR", 'text/calendar')
+      _, _, body = call(path: path('/cal/', s), storage: s, body: '', resource_type: :calendar)
+      body[0].should.include 'c:calendar-data'
+    end
+
+    it "uses cr:address-data tag for addressbooks" do
+      s = Async::Caldav::Storage::Mock.new
+      s.create_collection('/addr/')
+      s.put_item('/addr/c.vcf', "BEGIN:VCARD\r\nFN:John\r\nEND:VCARD", 'text/vcard')
+      _, _, body = call(path: path('/addr/', s), storage: s, body: '', resource_type: :addressbook)
+      body[0].should.include 'cr:address-data'
+    end
+
+    it "handles calendar-multiget with hrefs" do
+      s = Async::Caldav::Storage::Mock.new
+      s.create_collection('/cal/')
+      s.put_item('/cal/a.ics', "BEGIN:VCALENDAR\r\nEND:VCALENDAR", 'text/calendar')
+      s.put_item('/cal/b.ics', "BEGIN:VCALENDAR\r\nEND:VCALENDAR", 'text/calendar')
+
+      multiget_body = '<d:href>/cal/a.ics</d:href>'
+      _, _, body = call(path: path('/cal/', s), storage: s, body: multiget_body, resource_type: :calendar)
+      body[0].should.include 'a.ics'
+      body[0].should.not.include 'b.ics'
+    end
+  end
+end