calendav 0.0.1 → 0.1.0

data/lib/calendav/parsers/sync_xml.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require "uri"
+
+require_relative "../sync_collection"
+
+module Calendav
+  module Parsers
+    class SyncXML
+      def self.call(...)
+        new(...).call
+      end
+
+      def initialize(calendar_url, multi_response)
+        @calendar_url = calendar_url
+        @multi_response = multi_response
+      end
+
+      def call
+        SyncCollection.new(events, deleted_urls, token)
+      end
+
+      private
+
+      attr_reader :calendar_url, :multi_response
+
+      def deleted_urls
+        individual_responses
+          .select { |node| node.xpath("./dav:status").text["404 Not Found"] }
+          .collect { |node| response_url(node) }
+      end
+
+      def events
+        individual_responses
+          .reject { |node| node.xpath("./dav:status").text["404 Not Found"] }
+          .collect { |node| Event.from_xml(calendar_url, node) }
+      end
+
+      def calendar_path
+        @calendar_path ||= URI(calendar_url).path
+      end
+
+      def individual_responses
+        multi_response
+          .reject { |node| node.xpath("./dav:href").text == calendar_path }
+      end
+
+      def token
+        multi_response.xpath("/dav:multistatus/dav:sync-token").text
+      end
+
+      def response_url(response)
+        ContextualURL.call(calendar_url, response.xpath("./dav:href").text)
+      end
+    end
+  end
+end

data/lib/calendav/requests/calendar_home_set.rb

@@ -2,7 +2,7 @@
 
 require "nokogiri"
 
-require_relative "../xml_processor"
+require_relative "../namespaces"
 
 module Calendav
   module Requests
@@ -13,7 +13,7 @@ module Calendav
 
       def call
         Nokogiri::XML::Builder.new do |xml|
-          xml["dav"].propfind(XMLProcessor::NAMESPACES) do
+          xml["dav"].propfind(NAMESPACES) do
             xml["dav"].prop do
               xml["caldav"].public_send(:"calendar-home-set")
             end

data/lib/calendav/requests/current_user_principal.rb

@@ -2,7 +2,7 @@
 
 require "nokogiri"
 
-require_relative "../xml_processor"
+require_relative "../namespaces"
 
 module Calendav
   module Requests
@@ -13,7 +13,7 @@ module Calendav
 
       def call
         Nokogiri::XML::Builder.new do |xml|
-          xml["dav"].propfind(XMLProcessor::NAMESPACES) do
+          xml["dav"].propfind(NAMESPACES) do
             xml["dav"].prop do
               xml["dav"].public_send(:"current-user-principal")
             end

data/lib/calendav/requests/list_calendars.rb

@@ -2,28 +2,53 @@
 
 require "nokogiri"
 
-require_relative "../xml_processor"
+require_relative "../namespaces"
 
 module Calendav
   module Requests
     class ListCalendars
+      PROPERTIES = [
+        { key: :display_name, namespace: "dav", name: "displayname" },
+        { key: :resource_type, namespace: "dav", name: "resourcetype" },
+        { key: :etag, namespace: "dav", name: "getetag" },
+        { key: :ctag, namespace: "cs", name: "getctag" },
+        { key: :color, namespace: "apple", name: "calendar-color" },
+        { key: :sync_token, namespace: "dav", name: "sync-token" },
+        { key: :reports, namespace: "dav", name: "supported-report-set" },
+        {
+          key: :components,
+          namespace: "caldav",
+          name: "supported-calendar-component-set"
+        }
+      ].freeze
+
       def self.call(...)
         new(...).call
       end
 
+      def initialize(attributes)
+        @attributes = attributes
+      end
+
       def call
         Nokogiri::XML::Builder.new do |xml|
-          xml["dav"].propfind(XMLProcessor::NAMESPACES) do
+          xml["dav"].propfind(NAMESPACES) do
             xml["dav"].prop do
-              xml["dav"].displayname
-              xml["dav"].resourcetype
-              xml["dav"].getetag
-              xml["cs"].getctag
-              xml["apple"].public_send(:"calendar-color")
+              properties.each do |hash|
+                xml[hash[:namespace]].public_send(hash[:name].to_sym)
+              end
             end
           end
         end
       end
+
+      private
+
+      attr_reader :attributes
+
+      def properties
+        PROPERTIES.select { |hash| attributes.include?(hash[:key]) }
+      end
     end
   end
 end

data/lib/calendav/requests/list_events.rb

@@ -2,7 +2,7 @@
 
 require "nokogiri"
 
-require_relative "../xml_processor"
+require_relative "../namespaces"
 
 module Calendav
   module Requests
@@ -18,9 +18,7 @@ module Calendav
 
       def call
         Nokogiri::XML::Builder.new do |xml|
-          xml["caldav"].public_send(
-            "calendar-query", XMLProcessor::NAMESPACES
-          ) do
+          xml["caldav"].public_send("calendar-query", NAMESPACES) do
             xml["dav"].prop do
               xml["dav"].getetag
               xml["caldav"].public_send(:"calendar-data")
@@ -28,11 +26,11 @@ module Calendav
             xml["caldav"].filter do
               xml["caldav"].public_send(:"comp-filter", name: "VCALENDAR") do
                 xml["caldav"].public_send(:"comp-filter", name: "VEVENT") do
-                  xml["caldav"].public_send(
-                    :"time-range",
-                    start: from.utc.iso8601.delete(":-"),
-                    end: to.utc.iso8601.delete(":-")
-                  )
+                  if range?
+                    xml["caldav"].public_send(
+                      :"time-range", start: from, end: to
+                    )
+                  end
                 end
               end
             end
@@ -42,7 +40,21 @@ module Calendav
 
       private
 
-      attr_reader :from, :to
+      def from
+        return nil if @from.nil?
+
+        @from.utc.iso8601.delete(":-")
+      end
+
+      def to
+        return nil if @to.nil?
+
+        @to.utc.iso8601.delete(":-")
+      end
+
+      def range?
+        to || from
+      end
     end
   end
 end

data/lib/calendav/requests/make_calendar.rb

@@ -2,7 +2,7 @@
 
 require "nokogiri"
 
-require_relative "../xml_processor"
+require_relative "../namespaces"
 
 module Calendav
   module Requests
@@ -17,7 +17,7 @@ module Calendav
 
       def call
         Nokogiri::XML::Builder.new do |xml|
-          xml["caldav"].propfind(XMLProcessor::NAMESPACES) do
+          xml["caldav"].mkcalendar(NAMESPACES) do
             xml["dav"].set do
               xml["dav"].prop do
                 xml["dav"].displayname display_name
@@ -32,6 +32,8 @@ module Calendav
                   xml["caldav"].public_send(:"calendar-timezone", time_zone)
                 end
 
+                xml["apple"].public_send(:"calendar-color", color) if color
+
                 xml["caldav"].public_send(
                   :"supported-calendar-component-set"
                 ) do
@@ -47,6 +49,10 @@ module Calendav
 
       attr_reader :attributes
 
+      def color
+        attributes[:color]
+      end
+
       def display_name
         attributes[:display_name]
       end

data/lib/calendav/requests/sync_collection.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "nokogiri"
+
+require_relative "../namespaces"
+
+module Calendav
+  module Requests
+    class SyncCollection
+      def self.call(...)
+        new(...).call
+      end
+
+      def initialize(token)
+        @token = token
+      end
+
+      def call
+        Nokogiri::XML::Builder.new do |xml|
+          xml["dav"].public_send(:"sync-collection", NAMESPACES) do
+            xml["dav"].public_send(:"sync-token", token)
+            xml["dav"].public_send(:"sync-level", 1)
+            xml["dav"].prop do
+              xml["dav"].getetag
+              xml["caldav"].public_send(:"calendar-data")
+            end
+          end
+        end
+      end
+
+      private
+
+      attr_reader :token
+    end
+  end
+end

data/lib/calendav/requests/update_calendar.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require "nokogiri"
+
+require_relative "../namespaces"
+
+module Calendav
+  module Requests
+    class UpdateCalendar
+      def self.call(...)
+        new(...).call
+      end
+
+      def initialize(attributes)
+        @attributes = attributes
+      end
+
+      def call
+        Nokogiri::XML::Builder.new do |xml|
+          xml["dav"].propertyupdate(NAMESPACES) do
+            xml["dav"].set do
+              xml["dav"].prop do
+                xml["dav"].displayname display_name if display_name
+
+                if description
+                  xml["caldav"].public_send(
+                    :"calendar-description", description
+                  )
+                end
+
+                if time_zone
+                  xml["caldav"].public_send(:"calendar-timezone", time_zone)
+                end
+
+                xml["apple"].public_send(:"calendar-color", color) if color
+              end
+            end
+          end
+        end
+      end
+
+      private
+
+      attr_reader :attributes
+
+      def color
+        attributes[:color]
+      end
+
+      def display_name
+        attributes[:display_name]
+      end
+
+      def description
+        attributes[:description]
+      end
+
+      def time_zone
+        attributes[:time_zone]
+      end
+    end
+  end
+end

data/lib/calendav/sync_collection.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Calendav
+  class SyncCollection
+    attr_reader :changes, :deletions, :sync_token
+
+    def initialize(changes, deletions, sync_token)
+      @changes = changes
+      @deletions = deletions
+      @sync_token = sync_token
+    end
+  end
+end

data/spec/acceptance/apple_spec.rb

@@ -0,0 +1,217 @@
+# frozen_string_literal: true
+
+require "icalendar"
+require "icalendar/tzinfo"
+require "securerandom"
+require "uri"
+
+RSpec.describe "Apple" do
+  let(:provider) { :apple }
+  let(:username) { ENV.fetch("APPLE_USERNAME") }
+  let(:password) { ENV.fetch("APPLE_PASSWORD") }
+  let(:credentials) { Calendav.credentials(provider, username, password) }
+
+  subject { Calendav.client(credentials) }
+
+  it "determines the user's principal URL" do
+    expect(subject.principal_url)
+      .to eq_encoded_url("https://caldav.icloud.com/20264203208/principal/")
+  end
+
+  it "determines the user's calendar URL" do
+    expect(subject.calendars.home_url)
+      .to eq_encoded_url("https://p49-caldav.icloud.com/20264203208/calendars/")
+  end
+
+  it "supports calendar creation" do
+    expect(subject.calendars.create?).to eq(true)
+  end
+
+  it "can create, find, update and delete calendars" do
+    identifier = SecureRandom.uuid
+    time_zone = TZInfo::Timezone.get "UTC"
+    ical_time_zone = time_zone.ical_timezone Time.now.utc
+
+    url = subject.calendars.create(
+      identifier,
+      display_name: "Calendav Test",
+      description: "For test purposes only",
+      color: "#00FF00",
+      time_zone: ical_time_zone.to_ical
+    )
+    expect(url).to include(URI.decode_www_form_component(identifier))
+    expect(url).to start_with("https://")
+
+    calendars = subject.calendars.list
+    expect(calendars.collect(&:display_name)).to include("Calendav Test")
+
+    expect(
+      subject.calendars.update(url, display_name: "Calendav Update")
+    ).to eq(true)
+
+    calendars = subject.calendars.list
+    expect(calendars.collect(&:display_name)).to include("Calendav Update")
+
+    subject.calendars.delete(url)
+  end
+
+  context "with a calendar" do
+    let(:calendar_url) do
+      subject.calendars.create(SecureRandom.uuid, display_name: "Calendav Test")
+    end
+    let(:calendar) { subject.calendars.find(calendar_url) }
+    let(:identifier) { "#{SecureRandom.uuid}.ics" }
+    let(:start) { Time.new 2021, 6, 1, 10, 30 }
+    let(:finish) { Time.new 2021, 6, 1, 12, 30 }
+
+    after :each do
+      subject.calendars.delete(calendar_url)
+    end
+
+    it "supports events" do
+      expect(calendar.components).to include("VEVENT")
+    end
+
+    it "supports WebDAV-Sync" do
+      expect(calendar.reports).to include("sync-collection")
+    end
+
+    it "can create, find, update and delete events" do
+      ics = Icalendar::Calendar.new
+      ics.event do |event|
+        event.dtstart = start.utc
+        event.dtend = finish.utc
+        event.summary = "Brunch"
+      end
+      ics.publish
+
+      # Create an event
+      event_url = subject.events.create(calendar.url, identifier, ics.to_ical)
+      expect(event_url).to include(URI.decode_www_form_component(calendar.url))
+
+      # Search for the event
+      events = subject.events.list(
+        calendar.url, from: Time.new(2021, 6, 1), to: Time.new(2021, 6, 2)
+      )
+      expect(events.length).to eq(1)
+      expect(events.first.summary).to eq("Brunch")
+      expect(events.first.url).to eq_encoded_url(event_url)
+
+      # Update the event
+      ics.events.first.dtstart = Time.new(2021, 7, 1, 10, 30).utc
+      ics.events.first.dtend = Time.new(2021, 7, 1, 12, 30).utc
+      subject.events.update(event_url, ics.to_ical)
+
+      # Search again
+      events = subject.events.list(
+        calendar.url, from: Time.new(2021, 7, 1), to: Time.new(2021, 7, 2)
+      )
+      expect(events.length).to eq(1)
+      expect(events.first.summary).to eq("Brunch")
+      expect(events.first.url).to eq_encoded_url(event_url)
+
+      # Create another event
+      ics = Icalendar::Calendar.new
+      ics.event do |event|
+        event.dtstart = start.utc
+        event.dtend = finish.utc
+        event.summary = "Brunch"
+      end
+      ics.publish
+
+      another_url = subject.events.create(
+        calendar.url, "#{SecureRandom.uuid}.ics", ics.to_ical
+      )
+
+      # Search for all events
+      events = subject.events.list(calendar.url)
+      expect(events.length).to eq(2)
+
+      # Delete the events
+      expect(subject.events.delete(event_url)).to eq(true)
+      expect(subject.events.delete(another_url)).to eq(true)
+    end
+
+    it "respects etag conditions with updates and deletions" do
+      ics = Icalendar::Calendar.new
+      ics.event do |event|
+        event.dtstart = start.utc
+        event.dtend = finish.utc
+        event.summary = "Brunch"
+      end
+      ics.publish
+
+      event_url = subject.events.create(calendar.url, identifier, ics.to_ical)
+      event = subject.events.find(event_url)
+
+      ics.events.first.summary = "Coffee"
+      expect(
+        subject.events.update(event_url, ics.to_ical, etag: event.etag)
+      ).to eq(true)
+
+      expect(subject.events.find(event_url).summary).to eq("Coffee")
+
+      # Updating with the old etag should fail
+      ics.events.first.summary = "Brunch"
+      expect(
+        subject.events.update(event_url, ics.to_ical, etag: event.etag)
+      ).to eq(false)
+
+      expect(subject.events.find(event_url).summary).to eq("Coffee")
+
+      expect(subject.events.delete(event_url, etag: event.etag)).to eq(false)
+      expect(subject.events.delete(event_url)).to eq(true)
+    end
+
+    it "handles synchronisation requests" do
+      first = Icalendar::Calendar.new
+      first.event do |event|
+        event.dtstart = start.utc
+        event.dtend = finish.utc
+        event.summary = "Brunch"
+      end
+      first.publish
+
+      first_url = subject.events.create(calendar.url, identifier, first.to_ical)
+      token = subject.calendars.find(calendar.url, sync: true).sync_token
+
+      events = subject.events.list(calendar.url)
+      expect(events.length).to eq(1)
+
+      second = Icalendar::Calendar.new
+      second.event do |event|
+        event.dtstart = start.utc
+        event.dtend = finish.utc
+        event.summary = "Brunch Again"
+      end
+      second.publish
+      second_url = subject.events.create(
+        calendar.url, "#{SecureRandom.uuid}.ics", second.to_ical
+      )
+
+      first.events.first.summary = "Coffee"
+      subject.events.update(first_url, first.to_ical)
+
+      collection = subject.calendars.sync(calendar.url, token)
+      expect(collection.changes.collect(&:url))
+        .to match_encoded_urls([first_url, second_url])
+
+      expect(collection.deletions).to be_empty
+
+      first.events.first.summary = "Brunch"
+      subject.events.update(first_url, first.to_ical)
+
+      subject.events.delete(second_url)
+
+      collection = subject.calendars.sync(calendar.url, collection.sync_token)
+      urls = collection.changes.collect(&:url)
+      expect(urls.length).to eq(1)
+      expect(urls[0]).to eq_encoded_url(first_url)
+
+      expect(collection.deletions.length).to eq(1)
+      expect(collection.deletions.first).to eq_encoded_url(second_url)
+
+      subject.events.delete(first_url)
+    end
+  end
+end