async-caldav 1.2.3 → 1.3.0

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

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 
-require "bundler/setup"
-require "scampi"
-require "async/caldav"
 require 'uri'
 
 module Async
@@ -13,114 +10,126 @@ module Async
 
         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']]
+          if destination
+            to_path = URI.parse(destination).path
+            overwrite = headers['overwrite'] != 'F'
+            source = storage.get_item(path.to_s)
+            if source
+              existing = storage.get_item(to_path)
+              if existing && !overwrite
+                [412, { 'content-type' => 'text/plain' }, ['Precondition Failed']]
+              elsif !existing && uid_conflict?(
+                path,
+                to_path,
+                source[:body],
+                storage,
+              )
+                [409, { 'content-type' => 'text/plain' }, ['UID conflict']]
+              else
+                storage.move_item(path.to_s, to_path)
+                if existing
+                  [204, {}, ['']]
+                else
+                  [201, {}, ['']]
                 end
               end
+            else
+              [404, { 'content-type' => 'text/plain' }, ['Not Found']]
             end
+          else
+            [400, { 'content-type' => 'text/plain' }, ['Missing Destination header']]
           end
+        end
 
-          storage.move_item(path.to_s, to_path)
-
-          if existing
-            [204, {}, ['']]
+        # A UID may appear once per collection. The source item itself is
+        # skipped, so moving an item back over its own path is not a clash.
+        def uid_conflict?(path, to_path, body, storage)
+          uid = extract_uid(body)
+          if uid
+            dest_col = Protocol::Caldav::Path.new(to_path).parent.to_s
+            storage.list_items(dest_col).any? do |item_path, item_data|
+              item_path != path.to_s && extract_uid(item_data[:body]) == uid
+            end
           else
-            [201, {}, ['']]
+            false
           end
         end
 
         def extract_uid(body)
-          return nil unless body
-          match = body.match(/^UID:(.+)/i)
-          match ? match[1].strip : nil
+          if body
+            match = body.match(/^UID:(.+)/i)
+            match ? match[1].strip : nil
+          else
+            nil
+          end
         end
 
-        private_class_method :extract_uid
+        private_class_method :extract_uid, :uid_conflict?
       end
     end
   end
 end
 
-test do
-  describe "Async::Caldav::Handlers::Move" do
-    def call(**opts)
-      Async::Caldav::Handlers::Move.call(**opts)
-    end
+__END__
 
-    def path(p, s)
-      Protocol::Caldav::Path.new(p, storage_class: s)
-    end
+require_relative "../../caldav"
 
-    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
+describe "Async::Caldav::Handlers::Move" do
+  def call(**opts)
+    Async::Caldav::Handlers::Move.call(**opts)
+  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
+  def path(p, s)
+    Protocol::Caldav::Path.new(p, storage_class: s)
+  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 "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 "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 "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 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
+  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
-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

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

@@ -1,9 +1,5 @@
 # frozen_string_literal: true
 
-require "bundler/setup"
-require "scampi"
-require "async/caldav"
-
 module Async
   module Caldav
     module Handlers
@@ -18,17 +14,19 @@ module Async
   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__
+
+require_relative "../../caldav"
+
+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

@@ -1,9 +1,5 @@
 # frozen_string_literal: true
 
-require "bundler/setup"
-require "scampi"
-require "async/caldav"
-
 module Async
   module Caldav
     module Handlers
@@ -13,7 +9,11 @@ module Async
         def call(path:, storage:, user:, headers: {}, body: nil, **)
           depth = headers['depth'] || '1'
           propname = body&.include?('propname')
-          build = propname ? :build_propname : :build_propfind
+          if propname
+            build = :build_propname
+          else
+            build = :build_propfind
+          end
 
           col_path = path.ensure_trailing_slash
           collection = storage.get_collection(col_path.to_s)
@@ -21,75 +21,74 @@ module Async
 
           # Non-existent deep path
           if !collection && !item_data && path.depth > 2
-            return [404, { 'content-type' => 'text/plain' }, ['Not Found']]
-          end
-
-          xml = Protocol::Caldav::Multistatus.new.to_xml do |x|
-            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]
-              )
-              col.send(build, x)
-
-              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]
-                  )
-                  child_col.send(build, x)
+            [404, { 'content-type' => 'text/plain' }, ['Not Found']]
+          else
+            xml = Protocol::Caldav::Multistatus.new.to_xml do |x|
+              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],
+                )
+                col.send(build, x)
+
+                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],
+                    )
+                    child_col.send(build, x)
+                  end
+
+                  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],
+                    )
+                    item.send(build, x)
+                  end
                 end
-
-                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]
-                  )
-                  item.send(build, x)
-                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]
-              )
-              item.send(build, x)
-            else
-              build_discovery(x, path, user)
-
-              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]
-                  )
-                  child_col.send(build, x)
+              elsif item_data
+                item = Protocol::Caldav::Item.new(
+                  path:         path,
+                  body:         item_data[:body],
+                  content_type: item_data[:content_type],
+                  etag:         item_data[:etag],
+                )
+                item.send(build, x)
+              else
+                build_discovery(x, path, user)
+
+                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],
+                    )
+                    child_col.send(build, x)
+                  end
                 end
               end
             end
+            [207, Protocol::Caldav::Constants::DAV_HEADERS, [xml]]
           end
-
-          [207, Protocol::Caldav::Constants::DAV_HEADERS, [xml]]
         end
 
         def build_discovery(xml, path, user)
@@ -109,83 +108,85 @@ module Async
   end
 end
 
-test do
-  def normalize(xml)
-    xml.gsub(/>\s+</, '><').strip
-  end
+__END__
 
-  describe "Async::Caldav::Handlers::Propfind" do
-    def call(**opts)
-      Async::Caldav::Handlers::Propfind.call(**opts)
-    end
+require_relative "../../caldav"
 
-    def path(p, s)
-      Protocol::Caldav::Path.new(p, storage_class: s)
-    end
+def normalize(xml)
+  xml.gsub(/>\s+</, '><').strip
+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
+describe "Async::Caldav::Handlers::Propfind" do
+  def call(**opts)
+    Async::Caldav::Handlers::Propfind.call(**opts)
+  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
+  def path(p, s)
+    Protocol::Caldav::Path.new(p, storage_class: s)
+  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 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 "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 "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 "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 "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 "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 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 "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
+  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
-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