protocol-caldav 1.0.2 → 1.1.0

data/lib/protocol/caldav/item.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "bundler/setup"
-require "scampi"
 require "builder"
 require "protocol/caldav"
 
@@ -74,52 +72,52 @@ module Protocol
   end
 end
 
-test do
-  def normalize(xml)
-    xml.gsub(/>\s+</, '><').strip
-  end
+__END__
 
-  describe "Protocol::Caldav::Item" do
-    def make_item(**opts)
-      defaults = {
-        path: Protocol::Caldav::Path.new("/calendars/admin/work/event.ics"),
-        body: "BEGIN:VCALENDAR\r\nEND:VCALENDAR",
-        content_type: "text/calendar",
-        etag: '"abc123"'
-      }
-      Protocol::Caldav::Item.new(**defaults.merge(opts))
-    end
+def normalize(xml)
+  xml.gsub(/>\s+</, '><').strip
+end
 
-    it "exposes path, body, content_type, etag" do
-      item = make_item
-      item.path.to_s.should.equal "/calendars/admin/work/event.ics"
-      item.body.should.include "VCALENDAR"
-      item.content_type.should.equal "text/calendar"
-      item.etag.should.equal '"abc123"'
-    end
+describe "Protocol::Caldav::Item" do
+  def make_item(**opts)
+    defaults = {
+      path: Protocol::Caldav::Path.new("/calendars/admin/work/event.ics"),
+      body: "BEGIN:VCALENDAR\r\nEND:VCALENDAR",
+      content_type: "text/calendar",
+      etag: '"abc123"'
+    }
+    Protocol::Caldav::Item.new(**defaults.merge(opts))
+  end
 
-    it "new? returns new_record state" do
-      make_item(new_record: true).new?.should.equal true
-      make_item(new_record: false).new?.should.equal false
-    end
+  it "exposes path, body, content_type, etag" do
+    item = make_item
+    item.path.to_s.should.equal "/calendars/admin/work/event.ics"
+    item.body.should.include "VCALENDAR"
+    item.content_type.should.equal "text/calendar"
+    item.etag.should.equal '"abc123"'
+  end
 
-    it "to_propfind_xml includes etag and content-type" do
-      xml = make_item.to_propfind_xml
-      xml.should.include "getetag"
-      xml.should.include "getcontenttype"
-      xml.should.include "text/calendar"
-    end
+  it "new? returns new_record state" do
+    make_item(new_record: true).new?.should.equal true
+    make_item(new_record: false).new?.should.equal false
+  end
 
-    it "to_report_xml includes data tag with body" do
-      xml = make_item.to_report_xml(data_tag: "c:calendar-data")
-      xml.should.include "c:calendar-data"
-      xml.should.include "VCALENDAR"
-    end
+  it "to_propfind_xml includes etag and content-type" do
+    xml = make_item.to_propfind_xml
+    xml.should.include "getetag"
+    xml.should.include "getcontenttype"
+    xml.should.include "text/calendar"
+  end
 
-    it "to_propname_xml includes empty prop elements" do
-      xml = make_item.to_propname_xml
-      xml.should.include "<d:getetag/>"
-      xml.should.include "<d:getcontenttype/>"
-    end
+  it "to_report_xml includes data tag with body" do
+    xml = make_item.to_report_xml(data_tag: "c:calendar-data")
+    xml.should.include "c:calendar-data"
+    xml.should.include "VCALENDAR"
+  end
+
+  it "to_propname_xml includes empty prop elements" do
+    xml = make_item.to_propname_xml
+    xml.should.include "<d:getetag/>"
+    xml.should.include "<d:getcontenttype/>"
   end
 end

data/lib/protocol/caldav/multistatus.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "bundler/setup"
-require "scampi"
 require "builder"
 
 module Protocol
@@ -24,60 +22,59 @@ module Protocol
   end
 end
 
+__END__
 
-test do
-  def normalize(xml)
-    xml.gsub(/>\s+</, '><').strip
-  end
+def normalize(xml)
+  xml.gsub(/>\s+</, '><').strip
+end
 
-  # Minimal wrapper so tests can pass objects with build_xml
-  class FakeResponse
-    def initialize(href)
-      @href = href
-    end
+# Minimal wrapper so tests can pass objects with build_xml
+class FakeResponse
+  def initialize(href)
+    @href = href
+  end
 
-    def build_xml(xml)
-      xml.tag!("d:response") { xml.tag!("d:href", @href) }
-    end
+  def build_xml(xml)
+    xml.tag!("d:response") { xml.tag!("d:href", @href) }
   end
+end
 
-  describe "Protocol::Caldav::Multistatus" do
-    it "declares all four required namespaces" do
-      xml = Protocol::Caldav::Multistatus.new([]).to_xml
-      xml.should.include 'xmlns:d="DAV:"'
-      xml.should.include 'xmlns:c="urn:ietf:params:xml:ns:caldav"'
-      xml.should.include 'xmlns:cr="urn:ietf:params:xml:ns:carddav"'
-      xml.should.include 'xmlns:cs="http://calendarserver.org/ns/"'
-    end
+describe "Protocol::Caldav::Multistatus" do
+  it "declares all four required namespaces" do
+    xml = Protocol::Caldav::Multistatus.new([]).to_xml
+    xml.should.include 'xmlns:d="DAV:"'
+    xml.should.include 'xmlns:c="urn:ietf:params:xml:ns:caldav"'
+    xml.should.include 'xmlns:cr="urn:ietf:params:xml:ns:carddav"'
+    xml.should.include 'xmlns:cs="http://calendarserver.org/ns/"'
+  end
 
-    it "emits responses in the order given" do
-      responses = [FakeResponse.new("/a"), FakeResponse.new("/b")]
-      xml = Protocol::Caldav::Multistatus.new(responses).to_xml
-      xml.index("/a").should.be < xml.index("/b")
-    end
+  it "emits responses in the order given" do
+    responses = [FakeResponse.new("/a"), FakeResponse.new("/b")]
+    xml = Protocol::Caldav::Multistatus.new(responses).to_xml
+    xml.index("/a").should.be < xml.index("/b")
+  end
 
-    it "produces valid XML for empty response array" do
-      xml = Protocol::Caldav::Multistatus.new([]).to_xml
-      xml.should.include '<?xml version="1.0"'
-      xml.should.include '<d:multistatus'
-      xml.should.include '</d:multistatus>'
-    end
+  it "produces valid XML for empty response array" do
+    xml = Protocol::Caldav::Multistatus.new([]).to_xml
+    xml.should.include '<?xml version="1.0"'
+    xml.should.include '<d:multistatus'
+    xml.should.include '</d:multistatus>'
+  end
 
-    it "does not double-escape when using builder" do
-      xml = Protocol::Caldav::Multistatus.new.to_xml do |x|
-        x.tag!("d:response") { x.tag!("d:href", "/Work & Personal") }
-      end
-      xml.should.include '&amp;'
-      xml.should.not.include '&amp;amp;'
+  it "does not double-escape when using builder" do
+    xml = Protocol::Caldav::Multistatus.new.to_xml do |x|
+      x.tag!("d:response") { x.tag!("d:href", "/Work & Personal") }
     end
+    xml.should.include '&amp;'
+    xml.should.not.include '&amp;amp;'
+  end
 
-    it "supports block form for custom content" do
-      xml = Protocol::Caldav::Multistatus.new.to_xml do |x|
-        x.tag!("d:response") { x.tag!("d:href", "/test") }
-        x.tag!("d:sync-token", "token-123")
-      end
-      xml.should.include '/test'
-      xml.should.include 'token-123'
+  it "supports block form for custom content" do
+    xml = Protocol::Caldav::Multistatus.new.to_xml do |x|
+      x.tag!("d:response") { x.tag!("d:href", "/test") }
+      x.tag!("d:sync-token", "token-123")
     end
+    xml.should.include '/test'
+    xml.should.include 'token-123'
   end
 end

data/lib/protocol/caldav/path.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "bundler/setup"
-require "scampi"
 require "builder"
 require "protocol/caldav"
 
@@ -12,7 +10,9 @@ module Protocol
 
       def initialize(raw, storage_class: nil)
         p = raw.to_s.gsub(%r{/+}, '/')
-        p = "/#{p}" unless p.start_with?('/')
+        unless p.start_with?('/')
+          p = "/#{p}"
+        end
         @to_s = p
         @storage_class = storage_class
       end
@@ -32,7 +32,9 @@ module Protocol
 
       def child_of?(other)
         parent_str = other.to_s
-        parent_str = "#{parent_str}/" unless parent_str.end_with?('/')
+        unless parent_str.end_with?('/')
+          parent_str = "#{parent_str}/"
+        end
         if @to_s.start_with?(parent_str)
           remainder = @to_s[parent_str.length..]
           remainder.chomp('/').count('/').zero? && !remainder.chomp('/').empty?
@@ -42,7 +44,9 @@ module Protocol
       end
 
       def parent_exists?
-        raise ArgumentError, "storage_class required for parent_exists?" unless @storage_class
+        unless @storage_class
+          raise ArgumentError, "storage_class required for parent_exists?"
+        end
 
         if parent.depth <= 2
           true
@@ -88,103 +92,102 @@ module Protocol
   end
 end
 
+__END__
 
-test do
-  describe "Protocol::Caldav::Path" do
-    it "normalizes // to /" do
-      Protocol::Caldav::Path.new("//foo//bar").to_s.should.equal "/foo/bar"
-    end
+describe "Protocol::Caldav::Path" do
+  it "normalizes // to /" do
+    Protocol::Caldav::Path.new("//foo//bar").to_s.should.equal "/foo/bar"
+  end
 
-    it "normalizes leading ///foo to /foo" do
-      Protocol::Caldav::Path.new("///foo").to_s.should.equal "/foo"
-    end
+  it "normalizes leading ///foo to /foo" do
+    Protocol::Caldav::Path.new("///foo").to_s.should.equal "/foo"
+  end
 
-    it "adds leading / if missing" do
-      Protocol::Caldav::Path.new("foo/bar").to_s.should.equal "/foo/bar"
-    end
+  it "adds leading / if missing" do
+    Protocol::Caldav::Path.new("foo/bar").to_s.should.equal "/foo/bar"
+  end
 
-    describe "#parent" do
-      it "parent of /a/b/c/ is /a/b/" do
-        Protocol::Caldav::Path.new("/a/b/c/").parent.to_s.should.equal "/a/b/"
-      end
+  describe "#parent" do
+    it "parent of /a/b/c/ is /a/b/" do
+      Protocol::Caldav::Path.new("/a/b/c/").parent.to_s.should.equal "/a/b/"
+    end
 
-      it "parent of /a/ is /" do
-        Protocol::Caldav::Path.new("/a/").parent.to_s.should.equal "/"
-      end
+    it "parent of /a/ is /" do
+      Protocol::Caldav::Path.new("/a/").parent.to_s.should.equal "/"
+    end
 
-      it "parent of / is / (idempotent)" do
-        Protocol::Caldav::Path.new("/").parent.to_s.should.equal "/"
-      end
+    it "parent of / is / (idempotent)" do
+      Protocol::Caldav::Path.new("/").parent.to_s.should.equal "/"
     end
+  end
 
-    describe "#depth" do
-      it "depth of / is 0" do
-        Protocol::Caldav::Path.new("/").depth.should.equal 0
-      end
+  describe "#depth" do
+    it "depth of / is 0" do
+      Protocol::Caldav::Path.new("/").depth.should.equal 0
+    end
 
-      it "depth of /a/ is 1" do
-        Protocol::Caldav::Path.new("/a/").depth.should.equal 1
-      end
+    it "depth of /a/ is 1" do
+      Protocol::Caldav::Path.new("/a/").depth.should.equal 1
+    end
 
-      it "depth of /a/b is 2 (trailing-slash-insensitive)" do
-        Protocol::Caldav::Path.new("/a/b").depth.should.equal 2
-      end
+    it "depth of /a/b is 2 (trailing-slash-insensitive)" do
+      Protocol::Caldav::Path.new("/a/b").depth.should.equal 2
     end
+  end
 
-    describe "#child_of?" do
-      it "returns true for direct child" do
-        child = Protocol::Caldav::Path.new("/a/b/")
-        parent = Protocol::Caldav::Path.new("/a/")
-        child.child_of?(parent).should.equal true
-      end
+  describe "#child_of?" do
+    it "returns true for direct child" do
+      child = Protocol::Caldav::Path.new("/a/b/")
+      parent = Protocol::Caldav::Path.new("/a/")
+      child.child_of?(parent).should.equal true
+    end
 
-      it "returns false for grandchild" do
-        grandchild = Protocol::Caldav::Path.new("/a/b/c/")
-        grandparent = Protocol::Caldav::Path.new("/a/")
-        grandchild.child_of?(grandparent).should.equal false
-      end
+    it "returns false for grandchild" do
+      grandchild = Protocol::Caldav::Path.new("/a/b/c/")
+      grandparent = Protocol::Caldav::Path.new("/a/")
+      grandchild.child_of?(grandparent).should.equal false
+    end
 
-      it "returns false for sibling" do
-        a = Protocol::Caldav::Path.new("/a/b/")
-        b = Protocol::Caldav::Path.new("/a/c/")
-        a.child_of?(b).should.equal false
-      end
+    it "returns false for sibling" do
+      a = Protocol::Caldav::Path.new("/a/b/")
+      b = Protocol::Caldav::Path.new("/a/c/")
+      a.child_of?(b).should.equal false
+    end
 
-      it "returns false for self" do
-        a = Protocol::Caldav::Path.new("/a/")
-        a.child_of?(a).should.equal false
-      end
+    it "returns false for self" do
+      a = Protocol::Caldav::Path.new("/a/")
+      a.child_of?(a).should.equal false
     end
+  end
 
-    describe "#ensure_trailing_slash" do
-      it "is idempotent on a slashed path" do
-        Protocol::Caldav::Path.new("/a/").ensure_trailing_slash.to_s.should.equal "/a/"
-      end
+  describe "#ensure_trailing_slash" do
+    it "is idempotent on a slashed path" do
+      Protocol::Caldav::Path.new("/a/").ensure_trailing_slash.to_s.should.equal "/a/"
+    end
 
-      it "adds slash to unslashed" do
-        Protocol::Caldav::Path.new("/a").ensure_trailing_slash.to_s.should.equal "/a/"
-      end
+    it "adds slash to unslashed" do
+      Protocol::Caldav::Path.new("/a").ensure_trailing_slash.to_s.should.equal "/a/"
     end
+  end
 
-    describe "#start_with?" do
-      it "delegates to string semantics" do
-        Protocol::Caldav::Path.new("/calendars/admin/").start_with?("/calendars/").should.equal true
-        Protocol::Caldav::Path.new("/addressbooks/admin/").start_with?("/calendars/").should.equal false
-      end
+  describe "#start_with?" do
+    it "delegates to string semantics" do
+      Protocol::Caldav::Path.new("/calendars/admin/").start_with?("/calendars/").should.equal true
+      Protocol::Caldav::Path.new("/addressbooks/admin/").start_with?("/calendars/").should.equal false
     end
+  end
 
-    describe "#==" do
-      it "paths with same string are equal" do
-        a = Protocol::Caldav::Path.new("/a/")
-        b = Protocol::Caldav::Path.new("/a/")
-        (a == b).should.equal true
-      end
+  describe "#==" do
+    it "paths with same string are equal" do
+      a = Protocol::Caldav::Path.new("/a/")
+      b = Protocol::Caldav::Path.new("/a/")
+      (a == b).should.equal true
+    end
 
-      it "paths from different storage_class but same string compare equal" do
-        a = Protocol::Caldav::Path.new("/a/", storage_class: Object.new)
-        b = Protocol::Caldav::Path.new("/a/", storage_class: Object.new)
-        (a == b).should.equal true
-      end
+    it "paths from different storage_class but same string compare equal" do
+      a = Protocol::Caldav::Path.new("/a/", storage_class: Object.new)
+      b = Protocol::Caldav::Path.new("/a/", storage_class: Object.new)
+      (a == b).should.equal true
     end
   end
 end

data/lib/protocol/caldav/storage.rb

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 
-require "bundler/setup"
-require "scampi"
-
 module Protocol
   module Caldav
     class Storage
@@ -86,35 +83,34 @@ module Protocol
   end
 end
 
-
-test do
-  describe "Protocol::Caldav::Storage" do
-    it "every method raises NotImplementedError" do
-      s = Protocol::Caldav::Storage.new
-      methods = %i[create_collection get_collection delete_collection list_collections
-                   update_collection collection_exists? get_item put_item delete_item
-                   list_items move_item get_multi exists? etag snapshot_sync sync_changes]
-      three_arg = %i[put_item]
-      two_arg = %i[update_collection move_item sync_changes]
-      methods.each do |m|
-        if three_arg.include?(m)
-          lambda { s.send(m, "/x", "body", "ct") }.should.raise NotImplementedError
-        elsif two_arg.include?(m)
-          lambda { s.send(m, "/x", {}) }.should.raise NotImplementedError
-        else
-          lambda { s.send(m, "/x") }.should.raise NotImplementedError
-        end
+__END__
+
+describe "Protocol::Caldav::Storage" do
+  it "every method raises NotImplementedError" do
+    s = Protocol::Caldav::Storage.new
+    methods = %i[create_collection get_collection delete_collection list_collections
+                 update_collection collection_exists? get_item put_item delete_item
+                 list_items move_item get_multi exists? etag snapshot_sync sync_changes]
+    three_arg = %i[put_item]
+    two_arg = %i[update_collection move_item sync_changes]
+    methods.each do |m|
+      if three_arg.include?(m)
+        lambda { s.send(m, "/x", "body", "ct") }.should.raise NotImplementedError
+      elsif two_arg.include?(m)
+        lambda { s.send(m, "/x", {}) }.should.raise NotImplementedError
+      else
+        lambda { s.send(m, "/x") }.should.raise NotImplementedError
       end
     end
+  end
 
-    it "can be subclassed with partial implementation" do
-      klass = Class.new(Protocol::Caldav::Storage) do
-        def exists?(path)
-          true
-        end
+  it "can be subclassed with partial implementation" do
+    klass = Class.new(Protocol::Caldav::Storage) do
+      def exists?(path)
+        true
       end
-      klass.new.exists?("/x").should.equal true
-      lambda { klass.new.get_item("/x") }.should.raise NotImplementedError
     end
+    klass.new.exists?("/x").should.equal true
+    lambda { klass.new.get_item("/x") }.should.raise NotImplementedError
   end
 end

data/lib/protocol/caldav/vcard/card.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "bundler/setup"
-require "scampi"
 require "protocol/caldav"
 
 module Protocol
@@ -24,35 +22,35 @@ module Protocol
   end
 end
 
-test do
-  describe "Protocol::Caldav::Vcard::Card" do
-    def prop(name, value)
-      Protocol::Caldav::Ical::Property.new(name: name, params: {}, value: value)
-    end
+__END__
 
-    it "find_property returns the first matching property" do
-      card = Protocol::Caldav::Vcard::Card.new(properties: [prop("FN", "John"), prop("FN", "Jane")])
-      card.find_property("FN").value.should.equal "John"
-    end
+describe "Protocol::Caldav::Vcard::Card" do
+  def prop(name, value)
+    Protocol::Caldav::Ical::Property.new(name: name, params: {}, value: value)
+  end
 
-    it "find_property is case-insensitive" do
-      card = Protocol::Caldav::Vcard::Card.new(properties: [prop("FN", "John")])
-      card.find_property("fn").value.should.equal "John"
-    end
+  it "find_property returns the first matching property" do
+    card = Protocol::Caldav::Vcard::Card.new(properties: [prop("FN", "John"), prop("FN", "Jane")])
+    card.find_property("FN").value.should.equal "John"
+  end
 
-    it "find_property returns nil when absent" do
-      card = Protocol::Caldav::Vcard::Card.new(properties: [])
-      card.find_property("FN").should.be.nil
-    end
+  it "find_property is case-insensitive" do
+    card = Protocol::Caldav::Vcard::Card.new(properties: [prop("FN", "John")])
+    card.find_property("fn").value.should.equal "John"
+  end
 
-    it "has no sub-component finder (vCards don't nest)" do
-      card = Protocol::Caldav::Vcard::Card.new
-      card.should.not.respond_to(:find_components)
-    end
+  it "find_property returns nil when absent" do
+    card = Protocol::Caldav::Vcard::Card.new(properties: [])
+    card.find_property("FN").should.be.nil
+  end
 
-    it "find_all_properties returns all matching" do
-      card = Protocol::Caldav::Vcard::Card.new(properties: [prop("TEL", "123"), prop("EMAIL", "x"), prop("TEL", "456")])
-      card.find_all_properties("TEL").length.should.equal 2
-    end
+  it "has no sub-component finder (vCards don't nest)" do
+    card = Protocol::Caldav::Vcard::Card.new
+    card.should.not.respond_to(:find_components)
+  end
+
+  it "find_all_properties returns all matching" do
+    card = Protocol::Caldav::Vcard::Card.new(properties: [prop("TEL", "123"), prop("EMAIL", "x"), prop("TEL", "456")])
+    card.find_all_properties("TEL").length.should.equal 2
   end
 end