RubyGems - async-caldav - Versions diffs - 1.0.0 - Mend

async-caldav 1.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (21) hide show

checksums.yaml +7 -0
data/lib/async/caldav/client/addressbook.rb +117 -0
data/lib/async/caldav/client/calendar.rb +152 -0
data/lib/async/caldav/client.rb +580 -0
data/lib/async/caldav/forward_auth.rb +94 -0
data/lib/async/caldav/handlers/delete.rb +60 -0
data/lib/async/caldav/handlers/get.rb +87 -0
data/lib/async/caldav/handlers/head.rb +36 -0
data/lib/async/caldav/handlers/mkcol.rb +95 -0
data/lib/async/caldav/handlers/move.rb +126 -0
data/lib/async/caldav/handlers/options.rb +34 -0
data/lib/async/caldav/handlers/propfind.rb +201 -0
data/lib/async/caldav/handlers/proppatch.rb +121 -0
data/lib/async/caldav/handlers/put.rb +163 -0
data/lib/async/caldav/handlers/report.rb +257 -0
data/lib/async/caldav/server.rb +1152 -0
data/lib/async/caldav/storage/filesystem.rb +375 -0
data/lib/async/caldav/storage/mock.rb +402 -0
data/lib/async/caldav/version.rb +7 -0
data/lib/async/caldav.rb +24 -0
metadata +90 -0

data/lib/async/caldav/handlers/delete.rb ADDED Viewed

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+require "bundler/setup"
+require "scampi"
+require "async/caldav"
+module Async
+  module Caldav
+    module Handlers
+      module Delete
+        module_function
+        def call(path:, storage:, **)
+          item = storage.get_item(path.to_s)
+          if item
+            storage.delete_item(path.to_s)
+            [204, {}, ['']]
+          elsif storage.collection_exists?(path.ensure_trailing_slash.to_s)
+            storage.delete_collection(path.ensure_trailing_slash.to_s)
+            [204, {}, ['']]
+          else
+            [404, { 'content-type' => 'text/plain' }, ['Not Found']]
+          end
+        end
+      end
+    end
+  end
+end
+test do
+  describe "Async::Caldav::Handlers::Delete" do
+    def call(**opts)
+      Async::Caldav::Handlers::Delete.call(**opts)
+    end
+    it "deletes an item and returns 204" do
+      s = Async::Caldav::Storage::Mock.new
+      s.create_collection('/calendars/admin/cal/', type: :calendar)
+      s.put_item('/calendars/admin/cal/event.ics', 'data', 'text/calendar')
+      status, = call(path: Protocol::Caldav::Path.new('/calendars/admin/cal/event.ics', storage_class: s), storage: s)
+      status.should.equal 204
+      s.get_item('/calendars/admin/cal/event.ics').should.be.nil
+    end
+    it "deletes a collection and returns 204" do
+      s = Async::Caldav::Storage::Mock.new
+      s.create_collection('/calendars/admin/cal/', type: :calendar)
+      status, = call(path: Protocol::Caldav::Path.new('/calendars/admin/cal/', storage_class: s), storage: s)
+      status.should.equal 204
+      s.collection_exists?('/calendars/admin/cal/').should.equal false
+    end
+    it "returns 404 for non-existent resource" do
+      s = Async::Caldav::Storage::Mock.new
+      status, = call(path: Protocol::Caldav::Path.new('/calendars/admin/nope/', storage_class: s), storage: s)
+      status.should.equal 404
+    end
+  end
+end

data/lib/async/caldav/handlers/get.rb ADDED Viewed

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+require "bundler/setup"
+require "scampi"
+require "async/caldav"
+module Async
+  module Caldav
+    module Handlers
+      module Get
+        module_function
+        def call(path:, storage:, headers: {}, **)
+          item = storage.get_item(path.to_s)
+          col_path = path.ensure_trailing_slash.to_s
+          if item
+            if headers['if-none-match'] == item[:etag]
+              [304, { 'etag' => item[:etag], 'cache-control' => 'private, no-cache' }, []]
+            else
+              [200, { 'content-type' => item[:content_type], 'etag' => item[:etag], 'cache-control' => 'private, no-cache' }, [item[:body]]]
+            end
+          elsif storage.collection_exists?(col_path)
+            items = storage.list_items(col_path)
+            body = items.map { |_, data| data[:body] }.join("\n")
+            [200, { 'content-type' => 'text/plain' }, [body]]
+          elsif path.depth <= 2
+            [200, { 'content-type' => 'text/html' }, ['<html><body>CalDAV</body></html>']]
+          else
+            [404, { 'content-type' => 'text/plain' }, ['Not Found']]
+          end
+        end
+      end
+    end
+  end
+end
+test do
+  describe "Async::Caldav::Handlers::Get" do
+    def call(**opts)
+      Async::Caldav::Handlers::Get.call(**opts)
+    end
+    def path(p, s)
+      Protocol::Caldav::Path.new(p, storage_class: s)
+    end
+    it "returns item body with 200" do
+      s = Async::Caldav::Storage::Mock.new
+      s.put_item('/cal/ev.ics', 'BEGIN:VCALENDAR', 'text/calendar')
+      status, headers, body = call(path: path('/cal/ev.ics', s), storage: s)
+      status.should.equal 200
+      headers['content-type'].should.equal 'text/calendar'
+      body[0].should.equal 'BEGIN:VCALENDAR'
+    end
+    it "returns 304 on If-None-Match hit" do
+      s = Async::Caldav::Storage::Mock.new
+      item, = s.put_item('/cal/ev.ics', 'data', 'text/calendar')
+      status, = call(path: path('/cal/ev.ics', s), storage: s, headers: { 'if-none-match' => item[:etag] })
+      status.should.equal 304
+    end
+    it "returns collection contents" do
+      s = Async::Caldav::Storage::Mock.new
+      s.create_collection('/cal/')
+      s.put_item('/cal/a.ics', 'A', 'text/calendar')
+      s.put_item('/cal/b.ics', 'B', 'text/calendar')
+      status, _, body = call(path: path('/cal/', s), storage: s)
+      status.should.equal 200
+      body[0].should.include 'A'
+      body[0].should.include 'B'
+    end
+    it "returns 404 for deep non-existent path" do
+      s = Async::Caldav::Storage::Mock.new
+      status, = call(path: path('/calendars/admin/nope/item.ics', s), storage: s)
+      status.should.equal 404
+    end
+    it "returns 200 for shallow path" do
+      s = Async::Caldav::Storage::Mock.new
+      status, = call(path: path('/calendars/admin/', s), storage: s)
+      status.should.equal 200
+    end
+  end
+end

data/lib/async/caldav/handlers/head.rb ADDED Viewed

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+require "bundler/setup"
+require "scampi"
+require "async/caldav"
+module Async
+  module Caldav
+    module Handlers
+      module Head
+        module_function
+        def call(**opts)
+          status, headers, _body = Get.call(**opts)
+          [status, headers, []]
+        end
+      end
+    end
+  end
+end
+test do
+  describe "Async::Caldav::Handlers::Head" do
+    it "returns same status and headers as GET but empty body" do
+      s = Async::Caldav::Storage::Mock.new
+      s.put_item('/cal/ev.ics', 'BEGIN:VCALENDAR', 'text/calendar')
+      status, headers, body = Async::Caldav::Handlers::Head.call(
+        path: Protocol::Caldav::Path.new('/cal/ev.ics', storage_class: s),
+        storage: s
+      )
+      status.should.equal 200
+      headers['content-type'].should.equal 'text/calendar'
+      body.should.equal []
+    end
+  end
+end

data/lib/async/caldav/handlers/mkcol.rb ADDED Viewed

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+require "bundler/setup"
+require "scampi"
+require "async/caldav"
+module Async
+  module Caldav
+    module Handlers
+      module Mkcol
+        module_function
+        # method: 'MKCALENDAR' or 'MKCOL'
+        def call(path:, body:, storage:, method: 'MKCOL', resource_type: nil, **)
+          col_path = path.ensure_trailing_slash
+          if storage.collection_exists?(col_path.to_s)
+            return [405, { 'content-type' => 'text/plain' }, ['Collection already exists']]
+          end
+          unless col_path.parent_exists?
+            return [409, { 'content-type' => 'text/plain' }, ['Parent collection does not exist']]
+          end
+          displayname = Protocol::Caldav::Xml.extract_value(body, 'displayname')
+          description = Protocol::Caldav::Xml.extract_value(body, 'calendar-description')
+          color = Protocol::Caldav::Xml.extract_value(body, 'calendar-color')
+          type = if method == 'MKCALENDAR'
+            :calendar
+          elsif body && body.include?('addressbook')
+            :addressbook
+          else
+            resource_type || :collection
+          end
+          storage.create_collection(col_path.to_s, type: type, displayname: displayname, description: description, color: color)
+          [201, {}, ['']]
+        end
+      end
+    end
+  end
+end
+test do
+  describe "Async::Caldav::Handlers::Mkcol" do
+    def call(**opts)
+      Async::Caldav::Handlers::Mkcol.call(**opts)
+    end
+    def path(p, s)
+      Protocol::Caldav::Path.new(p, storage_class: s)
+    end
+    it "creates a calendar and returns 201" do
+      s = Async::Caldav::Storage::Mock.new
+      s.create_collection('/calendars/admin/')
+      status, = call(
+        path: path('/calendars/admin/work', s), storage: s,
+        body: '<d:displayname>Work</d:displayname>', method: 'MKCALENDAR'
+      )
+      status.should.equal 201
+      col = s.get_collection('/calendars/admin/work/')
+      col[:type].should.equal :calendar
+      col[:displayname].should.equal 'Work'
+    end
+    it "creates an addressbook via MKCOL" do
+      s = Async::Caldav::Storage::Mock.new
+      s.create_collection('/addressbooks/admin/')
+      status, = call(
+        path: path('/addressbooks/admin/contacts', s), storage: s,
+        body: '<resourcetype><addressbook/></resourcetype>', method: 'MKCOL'
+      )
+      status.should.equal 201
+      s.get_collection('/addressbooks/admin/contacts/')[:type].should.equal :addressbook
+    end
+    it "returns 405 if collection exists" do
+      s = Async::Caldav::Storage::Mock.new
+      s.create_collection('/cal/')
+      status, = call(path: path('/cal/', s), storage: s, body: '', method: 'MKCALENDAR')
+      status.should.equal 405
+    end
+    it "returns 409 if parent does not exist" do
+      s = Async::Caldav::Storage::Mock.new
+      status, = call(
+        path: path('/calendars/admin/deep/nested/cal', s), storage: s,
+        body: '', method: 'MKCALENDAR'
+      )
+      status.should.equal 409
+    end
+  end
+end

data/lib/async/caldav/handlers/move.rb ADDED Viewed

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+require "bundler/setup"
+require "scampi"
+require "async/caldav"
+require 'uri'
+module Async
+  module Caldav
+    module Handlers
+      module Move
+        module_function
+        def call(path:, storage:, headers: {}, **)
+          destination = headers['destination']
+          return [400, { 'content-type' => 'text/plain' }, ['Missing Destination header']] unless destination
+          to_path = URI.parse(destination).path
+          overwrite = headers['overwrite'] != 'F'
+          source = storage.get_item(path.to_s)
+          return [404, { 'content-type' => 'text/plain' }, ['Not Found']] unless source
+          existing = storage.get_item(to_path)
+          if existing && !overwrite
+            return [412, { 'content-type' => 'text/plain' }, ['Precondition Failed']]
+          end
+          # UID conflict check when destination doesn't already exist
+          if !existing
+            uid = extract_uid(source[:body])
+            if uid
+              dest_col = Protocol::Caldav::Path.new(to_path).parent.to_s
+              items = storage.list_items(dest_col)
+              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
+          storage.move_item(path.to_s, to_path)
+          if existing
+            [204, {}, ['']]
+          else
+            [201, {}, ['']]
+          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::Move" do
+    def call(**opts)
+      Async::Caldav::Handlers::Move.call(**opts)
+    end
+    def path(p, s)
+      Protocol::Caldav::Path.new(p, storage_class: s)
+    end
+    it "moves an item and returns 201" do
+      s = Async::Caldav::Storage::Mock.new
+      s.create_collection('/cal/')
+      s.put_item('/cal/a.ics', 'BEGIN:VCALENDAR', 'text/calendar')
+      status, = call(
+        path: path('/cal/a.ics', s), storage: s,
+        headers: { 'destination' => 'http://localhost/cal/b.ics' }
+      )
+      status.should.equal 201
+      s.get_item('/cal/a.ics').should.be.nil
+      s.get_item('/cal/b.ics').should.not.be.nil
+    end
+    it "overwrites and returns 204" do
+      s = Async::Caldav::Storage::Mock.new
+      s.put_item('/cal/a.ics', 'A', 'text/calendar')
+      s.put_item('/cal/b.ics', 'B', 'text/calendar')
+      status, = call(
+        path: path('/cal/a.ics', s), storage: s,
+        headers: { 'destination' => 'http://localhost/cal/b.ics' }
+      )
+      status.should.equal 204
+    end
+    it "returns 400 without Destination header" do
+      s = Async::Caldav::Storage::Mock.new
+      status, = call(path: path('/cal/a.ics', s), storage: s, headers: {})
+      status.should.equal 400
+    end
+    it "returns 404 when source missing" do
+      s = Async::Caldav::Storage::Mock.new
+      status, = call(
+        path: path('/cal/nope.ics', s), storage: s,
+        headers: { 'destination' => 'http://localhost/cal/b.ics' }
+      )
+      status.should.equal 404
+    end
+    it "returns 412 when Overwrite=F and destination exists" do
+      s = Async::Caldav::Storage::Mock.new
+      s.put_item('/cal/a.ics', 'A', 'text/calendar')
+      s.put_item('/cal/b.ics', 'B', 'text/calendar')
+      status, = call(
+        path: path('/cal/a.ics', s), storage: s,
+        headers: { 'destination' => 'http://localhost/cal/b.ics', 'overwrite' => 'F' }
+      )
+      status.should.equal 412
+    end
+  end
+end

data/lib/async/caldav/handlers/options.rb ADDED Viewed

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+require "bundler/setup"
+require "scampi"
+require "async/caldav"
+module Async
+  module Caldav
+    module Handlers
+      module Options
+        module_function
+        def call(path:, storage:, **)
+          [200, Protocol::Caldav::Constants::DAV_HEADERS.merge('content-length' => '0'), []]
+        end
+      end
+    end
+  end
+end
+test do
+  describe "Async::Caldav::Handlers::Options" do
+    it "returns 200 with DAV headers" do
+      status, headers, = Async::Caldav::Handlers::Options.call(
+        path: Protocol::Caldav::Path.new("/calendars/admin/cal/"),
+        storage: Async::Caldav::Storage::Mock.new
+      )
+      status.should.equal 200
+      headers['dav'].should.include 'calendar-access'
+      headers['allow'].should.include 'PROPFIND'
+      headers['content-length'].should.equal '0'
+    end
+  end
+end

data/lib/async/caldav/handlers/propfind.rb ADDED Viewed

@@ -0,0 +1,201 @@
+# frozen_string_literal: true
+require "bundler/setup"
+require "scampi"
+require "async/caldav"
+module Async
+  module Caldav
+    module Handlers
+      module Propfind
+        module_function
+        def call(path:, storage:, user:, headers: {}, body: nil, **)
+          depth = headers['depth'] || '1'
+          propname = body&.include?('propname')
+          col_path = path.ensure_trailing_slash
+          collection = storage.get_collection(col_path.to_s)
+          item_data = storage.get_item(path.to_s)
+          # Non-existent deep path
+          if !collection && !item_data && path.depth > 2
+            return [404, { 'content-type' => 'text/plain' }, ['Not Found']]
+          end
+          responses = []
+          if collection
+            col = Protocol::Caldav::Collection.new(
+              path: col_path,
+              type: collection[:type],
+              displayname: collection[:displayname],
+              description: collection[:description],
+              color: collection[:color],
+              props: collection[:props]
+            )
+            responses << (propname ? col.to_propname_xml : col.to_propfind_xml)
+            if depth != '0'
+              # Child collections
+              storage.list_collections(col_path.to_s).each do |child_path, child_data|
+                child_p = Protocol::Caldav::Path.new(child_path, storage_class: storage)
+                child_col = Protocol::Caldav::Collection.new(
+                  path: child_p,
+                  type: child_data[:type],
+                  displayname: child_data[:displayname],
+                  description: child_data[:description],
+                  color: child_data[:color],
+                  props: child_data[:props]
+                )
+                responses << (propname ? child_col.to_propname_xml : child_col.to_propfind_xml)
+              end
+              # Child items
+              storage.list_items(col_path.to_s).each do |item_path, data|
+                item_p = Protocol::Caldav::Path.new(item_path, storage_class: storage)
+                item = Protocol::Caldav::Item.new(
+                  path: item_p,
+                  body: data[:body],
+                  content_type: data[:content_type],
+                  etag: data[:etag]
+                )
+                responses << (propname ? item.to_propname_xml : item.to_propfind_xml)
+              end
+            end
+          elsif item_data
+            item = Protocol::Caldav::Item.new(
+              path: path,
+              body: item_data[:body],
+              content_type: item_data[:content_type],
+              etag: item_data[:etag]
+            )
+            responses << (propname ? item.to_propname_xml : item.to_propfind_xml)
+          else
+            # Shallow path with no collection — return basic discovery info
+            responses << build_discovery_xml(path, user)
+            # Still list child collections/items for depth=1
+            if depth != '0'
+              storage.list_collections(col_path.to_s).each do |child_path, child_data|
+                child_p = Protocol::Caldav::Path.new(child_path, storage_class: storage)
+                child_col = Protocol::Caldav::Collection.new(
+                  path: child_p,
+                  type: child_data[:type],
+                  displayname: child_data[:displayname],
+                  description: child_data[:description],
+                  color: child_data[:color],
+                  props: child_data[:props]
+                )
+                responses << (propname ? child_col.to_propname_xml : child_col.to_propfind_xml)
+              end
+            end
+          end
+          xml = Protocol::Caldav::Multistatus.new(responses).to_xml
+          [207, Protocol::Caldav::Constants::DAV_HEADERS, [xml]]
+        end
+        def build_discovery_xml(path, user)
+          <<~XML
+            <d:response>
+              <d:href>#{Protocol::Caldav::Xml.escape(path.to_s)}</d:href>
+              <d:propstat>
+                <d:prop>
+                  <d:resourcetype><d:collection/></d:resourcetype>
+                  <d:current-user-principal><d:href>/#{user}/</d:href></d:current-user-principal>
+                  <c:calendar-home-set><d:href>/calendars/#{user}/</d:href></c:calendar-home-set>
+                  <cr:addressbook-home-set><d:href>/addressbooks/#{user}/</d:href></cr:addressbook-home-set>
+                </d:prop>
+                <d:status>HTTP/1.1 200 OK</d:status>
+              </d:propstat>
+            </d:response>
+          XML
+        end
+        private_class_method :build_discovery_xml
+      end
+    end
+  end
+end
+test do
+  def normalize(xml)
+    xml.gsub(/>\s+</, '><').strip
+  end
+  describe "Async::Caldav::Handlers::Propfind" do
+    def call(**opts)
+      Async::Caldav::Handlers::Propfind.call(**opts)
+    end
+    def path(p, s)
+      Protocol::Caldav::Path.new(p, storage_class: s)
+    end
+    it "returns 207 with collection properties" do
+      s = Async::Caldav::Storage::Mock.new
+      s.create_collection('/calendars/admin/work/', type: :calendar, displayname: 'Work')
+      status, _, body = call(path: path('/calendars/admin/work/', s), storage: s, user: 'admin', headers: { 'depth' => '0' })
+      status.should.equal 207
+      body[0].should.include 'Work'
+      body[0].should.include 'calendar'
+    end
+    it "depth=1 includes child items" do
+      s = Async::Caldav::Storage::Mock.new
+      s.create_collection('/calendars/admin/work/', type: :calendar, displayname: 'Work')
+      s.put_item('/calendars/admin/work/ev.ics', 'BEGIN:VCALENDAR', 'text/calendar')
+      _, _, body = call(path: path('/calendars/admin/work/', s), storage: s, user: 'admin', headers: { 'depth' => '1' })
+      body[0].should.include 'ev.ics'
+    end
+    it "returns 404 for deep non-existent path" do
+      s = Async::Caldav::Storage::Mock.new
+      status, = call(path: path('/calendars/admin/nope/deep/', s), storage: s, user: 'admin')
+      status.should.equal 404
+    end
+    it "returns discovery info for shallow path" do
+      s = Async::Caldav::Storage::Mock.new
+      status, _, body = call(path: path('/', s), storage: s, user: 'admin')
+      status.should.equal 207
+      body[0].should.include 'current-user-principal'
+      body[0].should.include '/admin/'
+      body[0].should.include 'calendar-home-set'
+    end
+    it "propname request returns property names without values" do
+      s = Async::Caldav::Storage::Mock.new
+      s.create_collection('/calendars/admin/work/', type: :calendar, displayname: 'Work')
+      s.put_item('/calendars/admin/work/ev.ics', 'BEGIN:VCALENDAR', 'text/calendar')
+      propname_body = '<d:propfind xmlns:d="DAV:"><d:propname/></d:propfind>'
+      status, _, body = call(path: path('/calendars/admin/work/', s), storage: s, user: 'admin',
+        headers: { 'depth' => '1' }, body: propname_body)
+      status.should.equal 207
+      body[0].should.include '<d:resourcetype/>'
+      body[0].should.include '<d:getetag/>'
+    end
+    it "allprop request returns all properties with values" do
+      s = Async::Caldav::Storage::Mock.new
+      s.create_collection('/calendars/admin/work/', type: :calendar, displayname: 'Work')
+      s.put_item('/calendars/admin/work/ev.ics', 'BEGIN:VCALENDAR', 'text/calendar')
+      allprop_body = '<d:propfind xmlns:d="DAV:"><d:allprop/></d:propfind>'
+      status, _, body = call(path: path('/calendars/admin/work/', s), storage: s, user: 'admin',
+        headers: { 'depth' => '1' }, body: allprop_body)
+      status.should.equal 207
+      body[0].should.include 'displayname'
+      body[0].should.include 'Work'
+      body[0].should.include 'getetag'
+    end
+    it "returns item propfind for a single item" do
+      s = Async::Caldav::Storage::Mock.new
+      s.put_item('/calendars/admin/work/ev.ics', 'BEGIN:VCALENDAR', 'text/calendar')
+      status, _, body = call(path: path('/calendars/admin/work/ev.ics', s), storage: s, user: 'admin')
+      status.should.equal 207
+      body[0].should.include 'getetag'
+    end
+  end
+end