calendav 0.0.1 → 0.1.0

data/lib/calendav/clients/events_client.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require_relative "../errors"
 require_relative "../event"
 require_relative "../requests/list_events"
 
@@ -13,23 +14,45 @@ module Calendav
       end
 
       def create(calendar_url, event_identifier, ics)
-        url = merged_url(calendar_url, event_identifier)
-        result = endpoint.put(ics, url: url, content_type: :ics)
+        event_url = merged_url(calendar_url, event_identifier)
+        result = endpoint.put(ics, url: event_url, content_type: :ics)
 
-        result.headers["Location"]
+        result.headers["Location"] || event_url
       end
 
-      def delete(event_url)
-        endpoint.delete(url: event_url)
+      def delete(event_url, etag: nil)
+        endpoint.delete(url: event_url, etag: etag)
+      rescue PreconditionError
+        false
       end
 
-      def list(calendar_url, from:, to:)
+      def find(event_url)
+        response = endpoint.get(url: event_url)
+
+        Event.new(
+          event_url,
+          calendar_data: response.body.to_s,
+          etag: response.headers["ETag"]
+        )
+      end
+
+      def list(calendar_url, from: nil, to: nil)
         request = Requests::ListEvents.call(from: from, to: to)
 
         endpoint
           .report(request.to_xml, url: calendar_url, depth: 1)
-          .xpath(".//dav:response")
-          .collect { |node| Event.from_xml(node) }
+          .reject { |node| node.xpath(".//caldav:calendar-data").text.empty? }
+          .collect { |node| Event.from_xml(calendar_url, node) }
+      end
+
+      def update(event_url, ics, etag: nil)
+        endpoint.put(
+          ics, url: event_url, content_type: :ics, etag: etag
+        )
+
+        true
+      rescue PreconditionError
+        false
       end
 
       private
@@ -37,11 +60,7 @@ module Calendav
       attr_reader :client, :endpoint, :credentials
 
       def merged_url(calendar_url, event_identifier)
-        if calendar_url.end_with?("/")
-          "#{calendar_url}#{event_identifier}"
-        else
-          "#{calendar_url}/#{event_identifier}"
-        end
+        "#{calendar_url.delete_suffix('/')}/#{event_identifier}"
       end
     end
   end

data/lib/calendav/contextual_url.rb

@@ -1,12 +1,15 @@
 # frozen_string_literal: true
 
+require "uri"
+
 module Calendav
   class ContextualURL
-    def self.call(credentials, url_or_path)
-      return credentials.host.to_s if url_or_path.nil? || url_or_path.empty?
+    def self.call(host, url_or_path)
+      host = URI(host)
+      return host.to_s if url_or_path.nil? || url_or_path.empty?
 
       if url_or_path.start_with?("/")
-        credentials.host.dup.tap { |new_url| new_url.path = url_or_path }.to_s
+        host.dup.tap { |new_url| new_url.path = url_or_path }.to_s
       else
         URI(url_or_path).to_s
       end

data/lib/calendav/endpoint.rb

@@ -1,7 +1,8 @@
 # frozen_string_literal: true
 
 require_relative "./contextual_url"
-require_relative "./xml_processor"
+require_relative "./errors"
+require_relative "./parsers/response_xml"
 
 module Calendav
   class Endpoint
@@ -10,14 +11,18 @@ module Calendav
       xml: "application/xml; charset=utf-8"
     }.freeze
 
-    RequestFailedError = Class.new(StandardError)
-
     def initialize(credentials)
       @credentials = credentials
     end
 
-    def delete(url:)
-      request(:delete, url: url).status.success?
+    def delete(url:, etag: nil)
+      request(:delete, url: url, http: with_headers(etag: etag))
+        .status
+        .success?
+    end
+
+    def get(url:)
+      request(:get, url: url)
     end
 
     def mkcalendar(body, url:)
@@ -29,6 +34,10 @@ module Calendav
       )
     end
 
+    def options(url:)
+      request(:options, url: url)
+    end
+
     def propfind(body, url: nil, depth: 0)
       request(
         :propfind,
@@ -38,12 +47,21 @@ module Calendav
       )
     end
 
-    def put(body, url:, content_type: nil)
+    def proppatch(body, url: nil)
+      request(
+        :proppatch,
+        body,
+        url: url,
+        http: with_headers(content_type: :xml)
+      )
+    end
+
+    def put(body, url:, content_type: nil, etag: nil)
       request(
         :put,
         body,
         url: url,
-        http: with_headers(content_type: content_type)
+        http: with_headers(content_type: content_type, etag: etag)
       )
     end
 
@@ -72,10 +90,11 @@ module Calendav
       end
     end
 
-    def with_headers(content_type: nil, depth: nil)
+    def with_headers(content_type: nil, depth: nil, etag: nil)
       http = authenticated
 
       http = http.headers(depth: depth) if depth
+      http = http.headers("If-Match" => etag) if etag
       if content_type
         http = http.headers("Content-Type" => CONTENT_TYPES[content_type])
       end
@@ -85,15 +104,26 @@ module Calendav
 
     def request(verb, body = nil, url:, http: with_headers)
       response = http.request(
-        verb, ContextualURL.call(credentials, url), body: body
+        verb, ContextualURL.call(credentials.host, url), body: body
       )
-      unless response.status.success?
-        raise RequestFailedError, response.status.to_s
+
+      if response.status.success?
+        parse(response)
+      elsif response.status.code == 412
+        raise PreconditionError, response
+      else
+        raise RequestError, response
       end
+    end
 
-      return response if response.content_length&.zero?
+    def parse(response)
+      return response if response.content_length&.zero? || response.body.empty?
 
-      XMLProcessor.call(response.body)
+      if response.content_type.mime_type == "text/calendar"
+        response
+      else
+        Parsers::ResponseXML.call(response.body)
+      end
     end
   end
 end

data/lib/calendav/errors.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Calendav
+  Error = Class.new(StandardError)
+
+  class ParsingXMLError < Error
+    attr_reader :xml, :original
+
+    def initialize(xml, original)
+      super original.message
+
+      @xml = xml
+      @original = original
+    end
+  end
+
+  class RequestError < Error
+    attr_reader :response
+
+    def initialize(response)
+      super response.status.to_s
+
+      @response = response
+    end
+  end
+
+  PreconditionError = Class.new(RequestError)
+end

data/lib/calendav/event.rb

@@ -1,56 +1,34 @@
 # frozen_string_literal: true
 
-require_relative "./xml_processor"
+require_relative "./contextual_url"
+require_relative "./parsers/event_xml"
 
 module Calendav
   class Event
-    attr_reader :path
+    attr_reader :url, :calendar_data, :etag
 
-    def self.from_xml(node)
+    def self.from_xml(host, node)
       new(
-        node.xpath("./dav:href").text,
-        node.xpath(".//dav:prop/*").to_xml,
-        node.namespaces
+        ContextualURL.call(host, node.xpath("./dav:href").text),
+        Parsers::EventXML.call(node)
       )
     end
 
-    def initialize(path, attribute_nodes, namespaces = {})
-      @path = path
-      @attribute_nodes = attribute_nodes
-      @namespaces = namespaces
-    end
-
-    def calendar_data
-      attribute_value fragment.xpath("//caldav:calendar-data")
-    end
-
-    def etag
-      attribute_value fragment.xpath("//dav:getetag")
+    def initialize(url, attributes = {})
+      @url = url
+      @calendar_data = attributes[:calendar_data]
+      @etag = attributes[:etag]
     end
 
     def summary
       inner_event.summary
     end
 
-    private
-
-    attr_reader :attribute_nodes, :namespaces
-
-    def fragment
-      @fragment ||= XMLProcessor.call(
-        "<nodes>#{attribute_nodes}</nodes>", namespaces
-      )
+    def unloaded?
+      calendar_data.nil?
     end
 
-    def attribute_value(node)
-      return nil if node.children.empty?
-
-      if node.children.any?(&:element?)
-        node.children.select(&:element?).collect(&:to_xml).join
-      else
-        node.children.text
-      end
-    end
+    private
 
     def inner_calendar
       Icalendar::Calendar.parse(calendar_data).first

data/lib/calendav/multi_response.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Calendav
+  class MultiResponse
+    include Enumerable
+
+    def initialize(document)
+      @document = document
+    end
+
+    def each(...)
+      responses.each(...)
+    end
+
+    def xpath(...)
+      document.xpath(...)
+    end
+
+    private
+
+    attr_reader :document
+
+    def responses
+      document.xpath("/dav:multistatus/dav:response")
+    end
+  end
+end

data/lib/calendav/namespaces.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Calendav
+  NAMESPACES = {
+    "xmlns:dav" => "DAV:",
+    "xmlns:caldav" => "urn:ietf:params:xml:ns:caldav",
+    "xmlns:cs" => "http://calendarserver.org/ns/",
+    "xmlns:apple" => "http://apple.com/ns/ical/"
+  }.freeze
+end

data/lib/calendav/parsers/calendar_xml.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Calendav
+  module Parsers
+    class CalendarXML
+      XPATHS = {
+        display_name: ".//dav:displayname",
+        description: ".//caldav:calendar-description",
+        ctag: ".//cs:getctag",
+        etag: ".//dav:getetag",
+        time_zone: ".//caldav:calendar-timezone",
+        color: ".//apple:calendar-color",
+        sync_token: ".//dav:sync-token"
+      }.freeze
+
+      def self.call(...)
+        new(...).call
+      end
+
+      def initialize(element)
+        @element = element
+      end
+
+      def call
+        XPATHS
+          .transform_values { |xpath| value(xpath) }
+          .merge(components: components, reports: reports)
+      end
+
+      private
+
+      attr_reader :element
+
+      def components
+        element
+          .xpath(".//caldav:supported-calendar-component-set/caldav:comp")
+          .collect { |node| node["name"] }
+      end
+
+      def reports
+        element
+          .xpath("//dav:supported-report-set/dav:supported-report/dav:report/*")
+          .collect(&:name)
+      end
+
+      def value(xpath)
+        node = element.xpath(xpath)
+        return nil if node.children.empty?
+
+        if node.children.any?(&:element?)
+          node.children.select(&:element?).collect(&:to_xml).join
+        else
+          node.children.text
+        end
+      end
+    end
+  end
+end

data/lib/calendav/parsers/event_xml.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Calendav
+  module Parsers
+    class EventXML
+      def self.call(...)
+        new(...).call
+      end
+
+      def initialize(element)
+        @element = element
+      end
+
+      def call
+        {
+          calendar_data: value(".//caldav:calendar-data"),
+          etag: value(".//dav:getetag")
+        }
+      end
+
+      private
+
+      attr_reader :element
+
+      def value(xpath)
+        node = element.xpath(xpath)
+        return nil if node.children.empty?
+
+        if node.children.any?(&:element?)
+          node.children.select(&:element?).collect(&:to_xml).join
+        else
+          node.children.text
+        end
+      end
+    end
+  end
+end

data/lib/calendav/parsers/response_xml.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require_relative "../errors"
+require_relative "../multi_response"
+require_relative "../namespaces"
+
+module Calendav
+  module Parsers
+    class ResponseXML
+      def self.call(...)
+        new(...).call
+      end
+
+      def initialize(raw, namespaces = NAMESPACES)
+        @raw = raw
+        @namespaces = namespaces
+      end
+
+      def call
+        return document if document.xpath("/dav:multistatus").empty?
+
+        MultiResponse.new(document)
+      end
+
+      private
+
+      attr_reader :raw, :namespaces
+
+      def document
+        @document ||= begin
+          initial = parse(raw)
+
+          namespaces.each do |key, value|
+            initial.root[key] = value unless initial.namespaces[key]
+          end
+
+          parse(initial.to_xml)
+        end
+      end
+
+      def parse(string)
+        Nokogiri::XML(string) { |config| config.strict.noblanks }
+      rescue Nokogiri::XML::SyntaxError => error
+        raise ParsingXMLError.new(string, error)
+      end
+    end
+  end
+end