owncloud_caldav 0.0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 1e634897f4ec9b1057261ce2994fe9f30395e5ab61f8f8410c2a48b9d1237852
+  data.tar.gz: b8c3d5ac7813004cc2c80d454e025e1412d8ba7bd48cea965ba0497b07f9c39c
+SHA512:
+  metadata.gz: 6aecfab72e20e2c8b184a86846a85737583a1c5ee50e9d7d3742b88334d0b5fcd6237817582e69321e7bacf6ea78cd40387ba8cbfc3c2e06c15c53d9cf8461a9
+  data.tar.gz: a07cca43ee9c154c2ce3efb5c0fb5e119fd75f0bb5bd4ab12a88044565b3f0493152b7ba2b4a6fbf3551232974676afb9515d7be2581512a27ddaec4b337c08d

data/.gitignore

@@ -0,0 +1,56 @@
+*.gem
+*.rbc
+/.config
+/coverage/
+/InstalledFiles
+/pkg/
+/spec/reports/
+/spec/examples.txt
+/test/tmp/
+/test/version_tmp/
+/tmp/
+
+# Used by dotenv library to load environment variables.
+# .env
+
+# Ignore Byebug command history file.
+.byebug_history
+
+## Specific to RubyMotion:
+.dat*
+.repl_history
+build/
+*.bridgesupport
+build-iPhoneOS/
+build-iPhoneSimulator/
+
+## Specific to RubyMotion (use of CocoaPods):
+#
+# We recommend against adding the Pods directory to your .gitignore. However
+# you should judge for yourself, the pros and cons are mentioned at:
+# https://guides.cocoapods.org/using/using-cocoapods.html#should-i-check-the-pods-directory-into-source-control
+#
+# vendor/Pods/
+
+## Documentation cache and generated files:
+/.yardoc/
+/_yardoc/
+/doc/
+/rdoc/
+
+## Environment normalization:
+/.bundle/
+/vendor/bundle
+/lib/bundler/man/
+
+# for a library or gem, you might want to ignore these files since the code is
+# intended to run in multiple environments; otherwise, check them in:
+# Gemfile.lock
+# .ruby-version
+# .ruby-gemset
+
+# unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
+.rvmrc
+
+# Used by RuboCop. Remote config files pulled in from inherit_from directive.
+# .rubocop-https?--*

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Krzysztof Tomczyk
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,54 @@
+# owncloud_caldav Ruby CalDAV library
+
+** owncloud_caldav is a CalDAV library based on agilastic/agcaldav **
+
+##Usage Events
+
+First, you've to install the gem
+
+    gem install owncloud_caldav
+
+and require it
+
+    require "owncloud_caldav"
+
+Next you have to obtain the URI, username and password to a CalDAV-Server.
+
+
+Now you can e.g. create a new connection:
+    	
+	cal = OwncloudCalDAV::Client.new(:uri => "http://localhost:5232/user/calendar", :user => "user" , :password => "")
+
+Alternatively, the proxy parameters can be specified:
+
+	cal = OwncloudCalDAV::Client.new(:uri => "http://localhost:5232/user/calendar",:user => "user" , :password => "password", :proxy_uri => "http://my-proxy.com:8080")
+
+
+####Create an Event
+
+    result = cal.create_event(:start => "2012-12-29 10:00", :end => "2012-12-30 12:00", :title => "12345", :description => "12345 12345")
+
+
+####Find Events within time interval
+
+    result = cal.find_events(:start => "2012-10-01 08:00", :end => "2013-01-01")
+
+ 
+##Licence
+
+MIT
+
+
+
+##Contributors
+
+
+1. Fork it.
+2. Create a branch (`git checkout -b my_feature_branch`)
+3. Commit your changes (`git commit -am "bugfixed abc..."`)
+4. Push to the branch (`git push origin my_feature_branch`)
+5. Open a [Pull Request][1]
+6. Enjoy a refreshing Club Mate and wait
+
+[1]: https://github.com/czytom/owncloud_caldav/pulls/
+

data/lib/owncloud_caldav/client.rb

@@ -0,0 +1,225 @@
+module OwncloudCalDAV
+  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( data )
+      unless data[:proxy_uri].nil?
+        proxy_uri   = URI(data[:proxy_uri])
+        @proxy_host = proxy_uri.host
+        @proxy_port = proxy_uri.port.to_i
+      end
+      uri = URI(data[:uri])
+      @host     = uri.host
+      @port     = uri.port.to_i
+      @url      = uri.path
+      @user     = data[:user]
+      @password = data[:password]
+      @ssl      = uri.scheme == 'https'
+    end
+
+    def __create_http
+      if @proxy_uri.nil?
+        http = Net::HTTP.new(@host, @port)
+      else
+        http = Net::HTTP.new(@host, @port, @proxy_host, @proxy_port)
+      end
+      if @ssl
+        http.use_ssl = @ssl
+        http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+      end
+      http
+    end
+
+    def find_events data
+      result = ""
+      events = []
+      res = nil
+      __create_http.start do |http|
+        req = Net::HTTP::Report.new(@url, initheader = {'Content-Type'=>'application/xml', 'depth' => '1'} )
+        req.basic_auth @user, @password
+        req.body = OwncloudCalDAV::Request::ReportVEVENT.new(DateTime.parse(data[:start]).strftime("%Y%m%dT%H%M%S"), DateTime.parse(data[:end]).strftime("%Y%m%dT%H%M%S")).to_xml
+        res = http.request(req)
+      end
+        errorhandling res
+        result = ""
+        xml = REXML::Document.new(res.body)
+        REXML::XPath.each( xml, '//d:response/') do |c| 
+          event = Icalendar.parse(c.elements['//cal:calendar-data'].text).first.events.first
+          uid = c.elements['d:href'].text.split('/').last.split('.').first
+          event.uid = uid
+          events << event
+        end
+      return events
+    end
+
+    def find_event uuid
+      res = nil
+      __create_http.start {|http|
+        req = Net::HTTP::Get.new("#{@url}/#{uuid}.ics")
+        req.basic_auth @user, @password
+        res = http.request( req )
+      }  
+      errorhandling res
+      r = Icalendar.parse(res.body)
+      unless r.empty?
+        r.first.events.first 
+      else
+        return false
+      end
+
+      
+    end
+
+    def delete_event uuid
+      res = nil
+      __create_http.start {|http|
+        req = Net::HTTP::Delete.new("#{@url}/#{uuid}.ics")
+        req.basic_auth @user, @password
+        res = http.request( req )
+      }
+      errorhandling res
+      if res.code.to_i == 200
+        return true
+      else
+        return false
+      end
+    end
+
+    def create_event event
+      c = Calendar.new
+      uuid = UUID.new.generate
+      raise DuplicateError if entry_with_uuid_exists?(uuid)
+      c.event do |e|
+        e.uid = uuid
+        e.dtstart = DateTime.parse(event[:start])
+        e.dtend = DateTime.parse(event[:end])
+        e.categories = event[:categories]# Array
+        e.duration = event[:duration]
+        e.summary = event[:title]
+        e.description = event[:description]
+        e.status = event[:status]
+      end
+      cstring = c.to_ical
+      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 = cstring
+        res = http.request( req )
+      }
+      errorhandling res
+      find_event uuid
+    end
+
+    def update_event event
+      #TODO... fix me
+      if delete_event event[:uid]
+        create_event event
+      else
+        return false
+      end
+    end
+
+    def add_alarm tevent, altCal="Calendar"
+    
+    end
+
+    def find_todo uuid
+      res = nil
+      __create_http.start {|http|
+        req = Net::HTTP::Get.new("#{@url}/#{uuid}.ics")
+        req.basic_auth @user, @password
+        res = http.request( req )
+      }  
+      errorhandling res
+      r = Icalendar.parse(res.body)
+      r.first.todos.first
+    end
+
+    def create_todo todo
+      c = Calendar.new
+      uuid = UUID.new.generate
+      raise DuplicateError if entry_with_uuid_exists?(uuid)
+      c.todo do
+        uid           uuid 
+        start         DateTime.parse(todo[:start])
+        duration      todo[:duration]
+        summary       todo[:title]
+        description   todo[:description]
+        klass         todo[:accessibility] #PUBLIC, PRIVATE, CONFIDENTIAL
+        location      todo[:location]
+        percent       todo[:percent]
+        priority      todo[:priority]
+        url           todo[:url]
+        geo           todo[:geo_location]
+        status        todo[:status]
+      end
+      c.todo.uid = uuid
+      cstring = c.to_ical
+      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 = cstring
+        res = http.request( req )
+      }
+      errorhandling res
+      find_todo uuid
+    end
+
+    def create_todo
+      res = nil
+      raise DuplicateError if entry_with_uuid_exists?(uuid)
+
+      __create_http.start {|http|
+        req = Net::HTTP::Report.new(@url, initheader = {'Content-Type'=>'application/xml'} )
+        req.basic_auth @user, @password
+        req.body = OwncloudCalDAV::Request::ReportVTODO.new.to_xml
+        res = http.request( req )
+      }
+      errorhandling res 
+      format.parse_todo( res.body )
+    end
+
+    private
+    def entry_with_uuid_exists? uuid
+      res = nil
+      __create_http.start {|http|
+        req = Net::HTTP::Get.new("#{@url}/#{uuid}.ics")
+        req.basic_auth @user, @password
+        res = http.request( req )
+      }      
+      if res.code.to_i == 404
+        return false
+      else
+        return true
+      end
+    end
+
+    def  errorhandling response   
+      raise AuthenticationError if response.code.to_i == 401
+      raise NotExistError if response.code.to_i == 410 
+      raise APIError if response.code.to_i >= 500
+    end
+  end
+
+  class OwncloudCalDAVError < StandardError
+  end
+  class AuthenticationError < OwncloudCalDAVError; end
+  class DuplicateError      < OwncloudCalDAVError; end
+  class APIError            < OwncloudCalDAVError; end
+  class NotExistError       < OwncloudCalDAVError; end
+end

data/lib/owncloud_caldav/filter.rb

@@ -0,0 +1,78 @@
+module OwncloudCalDAV
+  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/owncloud_caldav/format.rb

@@ -0,0 +1,54 @@
+module OwncloudCalDAV
+  module Format
+    class Raw
+      def method_missing(m, *args, &block)
+        return *args
+      end
+    end
+
+    class Debug < Raw
+    end
+
+    class Pretty < Raw
+      def parse_calendar(s)
+        result = ""
+        xml = REXML::Document.new(s)
+
+        REXML::XPath.each( xml, '//c:calendar-data/', {"c"=>"urn:ietf:params:xml:ns:caldav"} ){|c| result << c.text}
+        r = Icalendar.parse(result)
+        r
+      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 )
+        Icalendar.parse(vcal)        
+      end
+
+      def parse_single( body )
+        # FIXME: parse event/todo/vcard
+        parse_events( body )
+      end
+    end
+  end
+end

data/lib/owncloud_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/owncloud_caldav/query.rb

@@ -0,0 +1,51 @@
+module OwncloudCalDAV
+  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", OwncloudCalDAV::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/owncloud_caldav/request.rb

@@ -0,0 +1,76 @@
+require 'builder'
+
+module OwncloudCalDAV
+    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/owncloud_caldav/version.rb

@@ -0,0 +1,3 @@
+module OwncloudCalDAV
+    VERSION="0.0.0.1"
+end

data/lib/owncloud_caldav.rb

@@ -0,0 +1,13 @@
+require 'net/https'
+require 'uuid'
+require 'rexml/document'
+require 'rexml/xpath'
+require 'time'
+require 'date'
+require 'active_support'
+require 'icalendar'
+
+#['client.rb', 'request.rb', 'net.rb', 'query.rb', 'filter.rb', 'event.rb', 'todo.rb', 'format.rb'].each do |f|
+['client.rb', 'request.rb', 'net.rb', 'query.rb', 'filter.rb',   'format.rb'].each do |f|
+    require File.join( File.dirname(__FILE__), 'owncloud_caldav', f )
+end

data/owncloud_caldav.gemspec

@@ -0,0 +1,35 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require File.expand_path('../lib/owncloud_caldav/version', __FILE__)
+
+Gem::Specification.new do |s|
+  s.name        = "owncloud_caldav"
+  s.version     = OwncloudCalDAV::VERSION
+  s.summary     = "Ruby Owncloud CalDAV client"
+  s.description = "yet another great Ruby client for CalDAV calendar and tasks."
+
+  s.required_ruby_version     = '>= 1.9.2'
+
+  s.license     = 'MIT'
+
+  s.homepage    = %q{https://github.com/agilastic/agcaldav}
+  s.authors     = [%q{Krzysztof Tomczyk}]
+  s.email       = [%q{czytom@gmail.com}]
+  s.add_runtime_dependency 'icalendar'
+  s.add_runtime_dependency 'uuid'
+  s.add_runtime_dependency 'builder'
+  s.add_runtime_dependency 'net-http-digest_auth'
+  s.add_development_dependency "rspec"  
+  s.add_development_dependency "fakeweb"
+  s.description = <<-DESC
+  owncloud_caldav is Ruby client for CalDAV calendar.  It is based on the agcaldav gem.
+DESC
+  s.post_install_message = <<-POSTINSTALL
+  Changelog: https://github.com/czytom/owncloud_caldav/blob/master/CHANGELOG.rdoc
+  Examples:  https://github.com/czytom/owncloud_caldav
+POSTINSTALL
+
+
+  s.files         = `git ls-files`.split("\n")
+  s.require_paths = ["lib"]
+end

metadata

@@ -0,0 +1,142 @@
+--- !ruby/object:Gem::Specification
+name: owncloud_caldav
+version: !ruby/object:Gem::Version
+  version: 0.0.0.1
+platform: ruby
+authors:
+- Krzysztof Tomczyk
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2024-01-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: icalendar
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: uuid
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: builder
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: net-http-digest_auth
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: fakeweb
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: "  owncloud_caldav is Ruby client for CalDAV calendar.  It is based on
+  the agcaldav gem.\n"
+email:
+- czytom@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- LICENSE
+- README.md
+- lib/owncloud_caldav.rb
+- lib/owncloud_caldav/client.rb
+- lib/owncloud_caldav/filter.rb
+- lib/owncloud_caldav/format.rb
+- lib/owncloud_caldav/net.rb
+- lib/owncloud_caldav/query.rb
+- lib/owncloud_caldav/request.rb
+- lib/owncloud_caldav/version.rb
+- owncloud_caldav.gemspec
+homepage: https://github.com/agilastic/agcaldav
+licenses:
+- MIT
+metadata: {}
+post_install_message: |2
+    Changelog: https://github.com/czytom/owncloud_caldav/blob/master/CHANGELOG.rdoc
+    Examples:  https://github.com/czytom/owncloud_caldav
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 1.9.2
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3.1
+signing_key: 
+specification_version: 4
+summary: Ruby Owncloud CalDAV client
+test_files: []