agcaldav 0.1

data/.gitignore

@@ -0,0 +1 @@
+caldaver-test.sh

data/README.rdoc

@@ -0,0 +1,3 @@
+CalDAV library
+
+based on 4fthawaiian/ruby-caldav and collectiveidea/caldav and martinpovolny/ruby-caldav

data/bin/caldav

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+require 'caldav'
+
+prg = CalDAV::CalDAVer.new
+prg.run_args( ARGV )
+

data/caldavtest.rb

@@ -0,0 +1,100 @@
+require './lib/caldav.rb'
+
+class CalDAVTester
+
+    def initialize
+        $caldav = {
+            :host     => 'localhost',
+            :port     => 5232,
+            :url      => '/user/calendar/',
+            :user     => 'user',
+            :password => 'yourpassword'
+        }
+        begin
+            require '~/.caldav_cred.rb'
+        rescue LoadError
+        end
+        
+        @cal = CalDAV::Client.new $caldav[:host], $caldav[:port], $caldav[:url], $caldav[:user], $caldav[:password]
+    end
+
+    attr :cal
+
+    def test_create_event
+        myevent = Event.new
+        myevent.dtstart = DateTime.parse( '2012/08/11 09:45')
+        myevent.dtend = DateTime.parse( '2012/08/11 10:45')
+        myevent.summary = "Jo?"
+        
+        uuid, response = cal.create myevent
+        
+        puts "CREATE Response #{response.code} #{response.message}: #{response.body}"
+        puts "UUID: #{uuid}"
+
+        return uuid
+    end
+
+    def test_delete_event( uuid )
+        response = cal.delete uuid
+        puts "DETELE Response #{response.code} #{response.message}: #{response.body}"
+    end
+
+    def test_get_event( uuid )
+        #ev, response = cal.get uuid
+        ev = cal.get( uuid )
+        #puts "GET Response #{response.code} #{response.message}: #{response.body}"
+        puts ev
+    end
+
+    def test_read_todo
+        puts '*' * 20 + ' TODO ' + '*' * 20
+        res = cal.todo
+        
+        res.each{ |todo| 
+            p todo
+        }
+    end
+    
+    def test_report
+        puts '*' * 20 + ' EVENTS ' + '*' * 20
+        p cal.report "20111201T000000", "20131231T000000"
+    end
+
+    def test_query0
+        puts CalDAV::Query.event.to_xml
+
+        time1 = DateTime.parse('2011/08/08 09:45')
+        time2 = DateTime.parse('2012/08/08 10:45')
+        puts CalDAV::Query.event(time1..time2).to_xml
+        puts CalDAV::Query.event.uid( UUID.generate ).to_xml
+        #puts CalDAV::Query.todo.alarm(time1..time2).to_xml
+        #puts CalDAV::Query.event.attendee(email).partstat('NEEDS-ACTION').to_xml
+        #puts CalDAV::Query.todo.completed(false).status(:cancelled => false).to_xml
+    end
+
+    def test_query
+        p cal.query( CalDAV::Query.event ) #=> All events
+        p cal.query( CalDAV::Query.event(time1..time2) )
+        p cal.query( CalDAV::Query.event.uid("UID") )
+        p cal.query( CalDAV::Query.todo.alarm(time1..time2) )
+        p cal.query( CalDAV::Query.event.attendee(email).partstat('NEEDS-ACTION') )
+        p cal.query( CalDAV::Query.todo.completed(false).status(:cancelled => false) )
+    end
+end
+
+#r = CalDAV::Request::Report.new( "20111201T000000", "20131231T000000" )
+#puts r.to_xml
+#exit
+
+t = CalDAVTester.new
+
+t.test_query0
+
+uuid = t.test_create_event
+t.test_get_event( uuid )
+t.test_delete_event( uuid )
+
+t.test_report
+t.test_read_todo
+#t.test_query
+

data/lib/caldav.rb

@@ -0,0 +1,19 @@
+require 'net/https'
+require 'uuid'
+require 'rexml/document'
+require 'rexml/xpath'
+require 'date'
+require 'icalendar'
+require 'time'
+
+['client.rb', 'request.rb', 'net.rb', 'query.rb', 'filter.rb', 'caldaver.rb', 'format.rb'].each do |f|
+    require File.join( File.dirname(__FILE__), 'caldav', f )
+end
+
+class Event
+    attr_accessor :uid, :created, :dtstart, :dtend, :lastmodified, :summary, :description, :name, :action
+end
+
+class Todo
+    attr_accessor :uid, :created, :summary, :dtstart, :status, :completed
+end

data/lib/caldav/caldaver.rb

@@ -0,0 +1,103 @@
+require 'optparse'
+
+# caldav --user USER --password PASSWORD --uri URI --command COMMAND
+# caldav --user martin@solnet.cz --password test --uri https://mail.solnet.cz/caldav.php/martin.povolny@solnet.cz/test --command create_event 
+
+# caldav report --begin 2012-01-01 --end 2012-07-01 --format raw --user USER --password PASSWORD --uri https://in.solnet.cz/caldav.php/martin.povolny@solnet.cz/public
+# caldav get --user USER --password PASSWD --uri https://mail.solnet.cz/caldav.php/martin.povolny%40solnet.cz/public/ --uuid 64d0b933-e916-4755-9e56-2f4d0d9068cb
+
+module CalDAV
+
+class CalDAVer
+
+    def create_object( options )
+        if options[:raw]
+            # STDIN
+            return STDIN.read(nil)
+        else
+            # options[:subject]
+            # options[:login]
+            # options[:summary]
+            # options[:begin]
+            # options[:end]
+            # options[:due]
+            case options[:what].intern
+            when :task
+                # FIXME
+            when :event
+                # FIXME
+            when :contact
+                # FIXME
+            else
+                print_help_and_exit if options[:command].to_s.empty? or options[:uri].to_s.empty?
+            end
+        end
+    end
+
+    def print_help_and_exit
+        puts @o.help
+        exit 1
+    end
+
+    def run_args( args )
+        options = {}
+        @o = OptionParser.new do |o|
+            o.banner = "Usage: caldaver [command] [options]"
+            o.on('-p', '--password [STRING]', String, 'Password')     { |p|   options[:password] = p }
+            o.on('-u', '--user [STRING}',     String, 'User (login)') { |l|   options[:login]    = l }
+            o.on('--uri [STRING]',        String, 'Calendar URI') { |uri| options[:uri] = uri }
+            o.on('--format [STRING]',     String, 'Format of output: raw,pretty,[debug]') { 
+                                                                    |fmt| options[:fmt] = fmt }
+            ##o.on('--command [STRING]',    String, 'Command')      { |c|   options[:command] = c }
+            o.on('--uuid [STRING]',       String, 'UUID')         { |u|   options[:uuid] = u }
+            # what to create
+            o.on('--what [STRING]',       String, 'Event/task/contact') { |c| options[:command]  = command }
+            o.on('--raw',                         'Read raw data (event/task/contact) from STDIN') { |raw|   options[:raw] = true }
+            # report and event options
+            o.on('--begin [DATETIME]',    String, 'Start time')   { |dt|  options[:begin] = dt }
+            o.on('--end [DATETIME]',      String, 'End time')     { |dt|  options[:end]   = dt }
+            o.on('--due [DATETIME]',      String, 'Due time')     { |dt|  options[:due]   = dt }
+            #o.on('--begin [DATETIME]',    DateTime, 'Start time') { |dt|  options[:begin]    = dt }
+            #o.on('--end [DATETIME]',      DateTime, 'End time')   { |dt|  options[:end]      = dt }
+            # event options
+            o.on('--summary  [string]',   String, 'summary of event/task')  { |s|  options[:summary]  = s }
+            o.on('--location [string]',   String, 'location of event/task') { |s|  options[:location] = s }
+            o.on('--subject  [string]',   String, 'subject of event/task')  { |s|  options[:subject]  = s }
+            o.on('-h') { print_help_and_exit }
+        end
+
+        options[:command] =  @o.parse( args )[0]
+
+        print_help_and_exit if options[:command].to_s.empty? or options[:uri].to_s.empty?
+        cal = CalDAV::Client.new( options[:uri], options[:login], options[:password] )
+
+        if options[:format]
+            cal.format = case options[:format].intern
+                when :raw
+                    CalDAV::Format::Raw.new
+                when :pretty
+                    CalDAV::Format::Pretty.new
+                when :debug
+                    CalDAV::Format::Debug.new
+                else
+                    nil
+            end
+        end
+
+        case options[:command].intern
+        when :create
+            obj = create_object( options )
+        when :delete
+        when :modify
+            obj = create_object( options )
+        when :get
+            puts cal.get( options[:uuid] )
+        when :report
+            puts cal.report( options[:begin], options[:end] )
+        else
+            print_help_and_exit
+        end
+    end
+end
+
+end

data/lib/caldav/client.rb

@@ -0,0 +1,220 @@
+module CalDAV
+    class Client
+        include Icalendar
+        attr_accessor :host, :port, :url, :user, :password, :ssl
+
+        def format=( fmt )
+            @format = fmt
+        end
+
+        def format
+            @format ||= Format::Debug.new
+        end
+
+        def initialize( *args )
+            case args.length
+            when 3
+                __init_from_uri( *args )
+            when 5
+                __init_from_host_port( *args )
+            else
+                raise "#{self.class.to_s}: invalid number of arguments: #{args.length}"
+            end
+        end
+
+        def __init_from_uri( suri, user, password )
+            uri = URI( suri )
+            @host     = uri.host
+            @port     = uri.port
+            @url      = [ uri.scheme, '://', uri.host, uri.path ].join('') # FIXME: port?
+            @user     = user
+            @password = password 
+            @ssl      = uri.scheme == 'https'
+        end
+
+        def __init_from_host_port( host, port, url, user, password )
+           @host     = host
+           @port     = port
+           @url      = url
+           @user     = user
+           @password = password 
+           @ssl      = port == 443
+        end
+    
+        def __create_http
+            http = Net::HTTP.new(@host, @port)
+            http.use_ssl = @ssl
+            http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+            #http.set_debug_output $stderr
+            http
+        end
+    
+        def report start, stop
+            res = nil
+            __create_http.start {|http|
+                req = Net::HTTP::Report.new(@url, initheader = {'Content-Type'=>'application/xml'} )
+                req.basic_auth @user, @password
+                req.body = CalDAV::Request::ReportVEVENT.new( start, stop ).to_xml
+                res = http.request( req )
+            }
+            format.parse_calendar( res.body )
+        end
+        
+        def get uuid
+            res = nil
+            __create_http.start {|http|
+                req = Net::HTTP::Get.new("#{@url}/#{uuid}.ics")
+                req.basic_auth @user, @password
+                res = http.request( req )
+            }
+
+            # FIXME: process HTTP code
+            format.parse_single( res.body )
+        end
+    
+        def delete uuid
+            __create_http.start {|http|
+                req = Net::HTTP::Delete.new("#{@url}/#{uuid}.ics")
+                req.basic_auth @user, @password
+                res = http.request( req )
+            }
+        end
+    
+        def create event
+            nowstr = DateTime.now.strftime "%Y%m%dT%H%M%SZ"
+            uuid   = UUID.generate
+            dings  = """BEGIN:VCALENDAR
+PRODID:Caldav.rb
+VERSION:2.0
+BEGIN:VEVENT
+CREATED:#{nowstr}
+UID:#{uuid}
+SUMMARY:#{event.summary}
+DTSTART:#{event.dtstart.strftime("%Y%m%dT%H%M%S")}
+DTEND:#{event.dtend.strftime("%Y%m%dT%H%M%S")}
+END:VEVENT
+END:VCALENDAR"""
+
+            res = nil
+            http = Net::HTTP.new(@host, @port) 
+            __create_http.start { |http|
+                req = Net::HTTP::Put.new("#{@url}/#{uuid}.ics")
+                req['Content-Type'] = 'text/calendar'
+                req.basic_auth @user, @password
+                req.body = dings
+                res = http.request( req )
+            }
+            return uuid, res
+        end
+    
+        def add_alarm tevent, altCal="Calendar"
+        #[#<Icalendar::Alarm:0x10b9d1b90 @name=\"VALARM\", @components={}, @properties={\"trigger\"=>\"-PT5M\", \"action\"=>\"DISPLAY\", \"description\"=>\"\"}>]    
+            dtstart_string = ( Time.parse(tevent.dtstart.to_s) + Time.now.utc_offset.to_i.abs ).strftime "%Y%m%dT%H%M%S"
+            dtend_string = ( Time.parse(tevent.dtend.to_s) + Time.now.utc_offset.to_i.abs ).strftime "%Y%m%dT%H%M%S"
+            alarmText = <<EOL
+BEGIN:VCALENDAR
+VERSION:2.0
+PRODID:Ruby iCalendar
+BEGIN:VEVENT
+UID:#{tevent.uid}
+SUMMARY:#{tevent.summary}
+DESCRIPTION:#{tevent.description}
+DTSTART:#{dtstart_string}
+DTEND:#{dtend_string}
+BEGIN:VALARM
+ACTION:DISPLAY
+TRIGGER;RELATED=START:-PT5M
+DESCRIPTION:Reminder
+END:VALARM
+BEGIN:VALARM
+TRIGGER:-PT5M
+ACTION:EMAIL
+ATTENDEE:#{tevent.organizer}
+SUMMARY:#{tevent.summary}
+DESCRIPTION:#{tevent.description}
+TRIGGER:-PT5M
+END:VALARM
+END:VEVENT
+END:VCALENDAR
+EOL
+            p alarmText
+            res = nil
+            puts "#{@url}/#{tevent.uid}.ics"
+            thttp = __create_http.start
+            #thttp.set_debug_output $stderr
+            req = Net::HTTP::Put.new("#{@url}/#{tevent.uid}.ics", initheader = {'Content-Type'=>'text/calendar'} )
+            req.basic_auth @user, @password
+            req.body = alarmText
+            res = thttp.request( req )
+            p res.inspect
+    
+            return tevent.uid
+        end
+        
+        def update event
+            dings = """BEGIN:VCALENDAR
+PRODID:Caldav.rb
+VERSION:2.0
+
+BEGIN:VTIMEZONE
+TZID:/Europe/Vienna
+X-LIC-LOCATION:Europe/Vienna
+BEGIN:DAYLIGHT
+TZOFFSETFROM:+0100
+TZOFFSETTO:+0200
+TZNAME:CEST
+DTSTART:19700329T020000
+RRULE:FREQ=YEARLY;INTERVAL=1;BYDAY=-1SU;BYMONTH=3
+END:DAYLIGHT
+BEGIN:STANDARD
+TZOFFSETFROM:+0200
+TZOFFSETTO:+0100
+TZNAME:CET
+DTSTART:19701025T030000
+RRULE:FREQ=YEARLY;INTERVAL=1;BYDAY=-1SU;BYMONTH=10
+END:STANDARD
+END:VTIMEZONE
+
+BEGIN:VEVENT
+CREATED:#{event.created}
+UID:#{event.uid}
+SUMMARY:#{event.summary}
+DTSTART;TZID=Europe/Vienna:#{event.dtstart}
+DTEND;TZID=Europe/Vienna:#{event.dtend.rfc3339}
+END:VEVENT
+END:VCALENDAR"""
+    
+            res = nil
+            __create_http.start {|http|
+                req = Net::HTTP::Put.new("#{@url}/#{event.uid}.ics", initheader = {'Content-Type'=>'text/calendar'} )
+                req.basic_auth @user, @password
+                req.body = dings
+                res = http.request( req )
+            }
+            return event.uid
+        end
+    
+        def todo 
+            res = nil
+            __create_http.start {|http|
+                req = Net::HTTP::Report.new(@url, initheader = {'Content-Type'=>'application/xml'} )
+                req.basic_auth @user, @password
+                req.body = CalDAV::Request::ReportVTODO.new.to_xml
+                res = http.request( req )
+            }
+            # FIXME: process HTTP code
+            format.parse_todo( res.body )
+        end
+        
+        def filterTimezone( vcal )
+            data = ""
+            inTZ = false
+            vcal.split("\n").each{ |l| 
+                inTZ = true if l.index("BEGIN:VTIMEZONE") 
+                data << l+"\n" unless inTZ 
+                inTZ = false if l.index("END:VTIMEZONE") 
+            }
+            return data
+        end
+    end
+end

data/lib/caldav/filter.rb

@@ -0,0 +1,78 @@
+module CalDAV
+  module Filter
+    class Base
+      attr_accessor :parent, :child
+      
+      def to_xml(xml = Builder::XmlMarkup.new(:indent => 2))
+        if parent
+          parent.to_xml
+        else
+          build_xml(xml)
+        end
+      end
+      
+      def build_xml(xml)
+        #do nothing
+      end
+      
+      def child=(child)
+        @child = child
+        child.parent = self
+      end
+    end
+
+    class Component < Base
+      attr_accessor :name
+      
+      def initialize(name, parent = nil)
+        self.name = name
+        self.parent = parent
+      end
+      
+      def time_range(range)
+        self.child = TimeRange.new(range, self)
+      end
+      
+      def uid(uid)
+        self.child = Property.new("UID", uid, self)
+      end
+      
+      def build_xml(xml)
+        xml.tag! "cal:comp-filter", :name => name do
+          child.build_xml(xml) unless child.nil? 
+        end
+      end
+    end
+
+    class TimeRange < Base
+      attr_accessor :range
+      
+      def initialize(range, parent = nil)
+        self.range = range
+        self.parent = parent
+      end
+      
+      def build_xml(xml)
+        xml.tag! "cal:time-range",
+          :start => range.begin.to_ical,
+          :end   => range.end.to_ical
+      end
+    end
+
+    class Property < Base
+      attr_accessor :name, :text
+      
+      def initialize(name, text, parent = nil)
+        self.name = name
+        self.text = text
+        self.parent = parent
+      end
+      
+      def build_xml(xml)
+        xml.tag! "cal:prop-filter", :name => self.name do
+          xml.tag! "cal:text-match", self.text, :collation => "i;octet"
+        end
+      end
+    end
+  end
+end

data/lib/caldav/format.rb

@@ -0,0 +1,64 @@
+module CalDAV
+    module Format
+        class Raw
+            def method_missing(m, *args, &block)
+                return *args
+            end
+        end
+
+        class Debug < Raw
+        end
+
+        class Pretty < Raw
+            def parse_calendar( body )
+                result = []
+                xml = REXML::Document.new( res.body )
+                REXML::XPath.each( xml, '//c:calendar-data/', { "c"=>"urn:ietf:params:xml:ns:caldav"} ){ |c|
+                    result += parse_events( c.text )
+                }
+                return result
+            end
+
+            def parse_todo( body )
+                result = []
+                xml = REXML::Document.new( body )
+                REXML::XPath.each( xml, '//c:calendar-data/', { "c"=>"urn:ietf:params:xml:ns:caldav"} ){ |c|
+                    p c.text
+                    p parse_tasks( c.text )
+                    result += parse_tasks( c.text )
+                }
+                return result
+            end
+
+            def parse_tasks( vcal )
+                return_tasks = Array.new
+                cals = Icalendar.parse(vcal)
+                cals.each { |tcal|
+                    tcal.todos.each { |ttask|  # FIXME
+                        return_tasks << ttask
+                    }
+                }
+                return return_tasks
+            end
+
+            def parse_events( vcal )
+                return_events = Array.new
+                cals = Icalendar.parse(vcal)
+                cals.each { |tcal|
+                    tcal.events.each { |tevent|
+                        if tevent.recurrence_id.to_s.empty? # skip recurring events
+                            return_events << tevent
+                        end
+                    }
+                }
+                return return_events
+            end
+
+            def parse_single( body )
+                # FIXME: parse event/todo/vcard
+                parse_events( body )
+            end
+        end
+    end
+end
+

data/lib/caldav/net.rb

@@ -0,0 +1,16 @@
+module Net
+    class HTTP
+        class Report < HTTPRequest
+            METHOD = 'REPORT'
+            REQUEST_HAS_BODY = true
+            RESPONSE_HAS_BODY = true
+        end
+
+        class Mkcalendar < HTTPRequest
+            METHOD = 'MKCALENDAR'
+            REQUEST_HAS_BODY = true
+            RESPONSE_HAS_BODY = true
+        end
+    end
+end
+

data/lib/caldav/query.rb

@@ -0,0 +1,51 @@
+module CalDAV
+  class Query
+    attr_accessor :child
+    
+    #TODO: raise error if to_xml is called before child is assigned
+    def to_xml(xml = Builder::XmlMarkup.new(:indent => 2))
+      xml.instruct!
+      xml.tag! "cal:calendar-query", CalDAV::NAMESPACES do
+        xml.tag! "dav:prop" do
+          xml.tag! "dav:getetag"
+          xml.tag! "cal:calendar-data"
+        end
+        xml.tag! "cal:filter" do
+          cal = Filter::Component.new("VCALENDAR", self)
+          cal.child = self.child
+          cal.build_xml(xml)
+        end
+      end
+    end
+    
+    def event(param = nil)
+      self.child = Filter::Component.new("VEVENT")
+      if param.is_a? Range
+        self.child.time_range(param) 
+      elsif param.is_a? String
+        self.child.uid(param)
+      else
+        self.child
+      end
+    end
+
+    def todo(param = nil)
+      self.child = Filter::Component.new("VTODO")
+      self.child
+    end
+    
+    def child=(child)
+      child.parent = self
+      @child = child
+    end
+
+    def self.event( param=nil )
+        self.new.event( param )
+    end
+
+
+    def self.todo( param=nil )
+        self.new.todo
+    end
+  end
+end

data/lib/caldav/request.rb

@@ -0,0 +1,76 @@
+require 'builder'
+
+module CalDAV
+    NAMESPACES = { "xmlns:d" => 'DAV:', "xmlns:c" => "urn:ietf:params:xml:ns:caldav" }
+    module Request
+        class Base
+            def initialize
+                @xml = Builder::XmlMarkup.new(:indent => 2)
+                @xml.instruct!
+            end
+            attr :xml
+        end
+
+        class Mkcalendar < Base
+            attr_accessor :displayname, :description
+
+            def initialize(displayname = nil, description = nil)
+                @displayname = displayname
+                @description = description
+            end
+            
+            def to_xml
+                xml.c :mkcalendar, NAMESPACES do
+                    xml.d :set do
+                        xml.d :prop do
+                            xml.d :displayname, displayname unless displayname.to_s.empty?
+                            xml.tag! "c:calendar-description", description, "xml:lang" => "en" unless description.to_s.empty?
+                        end
+                    end
+                end
+            end
+        end    
+
+        class ReportVEVENT < Base
+            attr_accessor :tstart, :tend
+
+            def initialize( tstart=nil, tend=nil )
+                @tstart = tstart
+                @tend   = tend
+                super()
+            end
+
+            def to_xml
+                xml.c 'calendar-query'.intern, NAMESPACES do
+                    xml.d :prop do
+                        xml.d :getetag
+                        xml.c 'calendar-data'.intern
+                    end
+                    xml.c :filter do
+                        xml.c 'comp-filter'.intern, :name=> 'VCALENDAR' do
+                            xml.c 'comp-filter'.intern, :name=> 'VEVENT' do
+                                xml.c 'time-range'.intern, :start=> "#{tstart}Z", :end=> "#{tend}Z"
+                            end
+                        end
+                    end
+                end
+            end
+        end    
+
+        class ReportVTODO < Base
+            def to_xml
+                xml.c 'calendar-query'.intern, NAMESPACES do
+                    xml.d :prop do
+                        xml.d :getetag
+                        xml.c 'calendar-data'.intern
+                    end
+                    xml.c :filter do
+                        xml.c 'comp-filter'.intern, :name=> 'VCALENDAR' do
+                            xml.c 'comp-filter'.intern, :name=> 'VTODO'
+                        end
+                    end
+                end
+            end
+        end    
+    end
+end

data/lib/caldav/version.rb

@@ -0,0 +1,3 @@
+module CalDAV
+    VERSION=0.1
+end

data/ruby-caldav.gemspec

@@ -0,0 +1,20 @@
+require File.expand_path('../lib/caldav/version', __FILE__)
+
+Gem::Specification.new do |s|
+  s.name        = "agcaldav"
+  s.version     = CalDAV::VERSION
+  s.summary     = "Ruby CalDAV client"
+  s.description = "Ruby client for CalDAV calendar and tasks."
+  s.homepage    = "https://github.com/agilastic/ruby-caldav"
+  s.authors     = ["Alex Ebeling-Hoppe"]
+  s.email       = ["ebeling-hoppe@agilastic.de"]
+  
+  s.add_runtime_dependency 'nokogiri'
+  s.add_runtime_dependency 'icalendar'
+  s.add_runtime_dependency 'uuid'
+  s.add_runtime_dependency 'builder'
+
+  s.files         = `git ls-files`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{|f| File.basename(f)}
+  s.require_paths = ["lib"]
+end

metadata

@@ -0,0 +1,124 @@
+--- !ruby/object:Gem::Specification
+name: agcaldav
+version: !ruby/object:Gem::Version
+  version: '0.1'
+  prerelease: 
+platform: ruby
+authors:
+- Alex Ebeling-Hoppe
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-12-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: icalendar
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: uuid
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: builder
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Ruby client for CalDAV calendar and tasks.
+email:
+- ebeling-hoppe@agilastic.de
+executables:
+- caldav
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- README.rdoc
+- bin/caldav
+- caldavtest.rb
+- lib/caldav.rb
+- lib/caldav/caldaver.rb
+- lib/caldav/client.rb
+- lib/caldav/filter.rb
+- lib/caldav/format.rb
+- lib/caldav/net.rb
+- lib/caldav/query.rb
+- lib/caldav/request.rb
+- lib/caldav/version.rb
+- ruby-caldav.gemspec
+homepage: https://github.com/agilastic/ruby-caldav
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Ruby CalDAV client
+test_files: []