vobject 0.1.0 → 1.0.2

data/lib/vobject/vcalendar/paramcheck.rb

@@ -0,0 +1,259 @@
+require "rsec"
+require "set"
+require "uri"
+require "date"
+require "tzinfo"
+include Rsec::Helpers
+require_relative "../../c"
+require_relative "../../error"
+
+module Vobject::Vcalendar
+  class Paramcheck
+    class << self
+      def paramcheck(strict, prop, params, ctx)
+        errors = []
+        if params && params[:ALTREP]
+          case prop
+          when :COMMENT, :DESCRIPTION, :LOCATION, :RESOURCES, :SUMMARY,
+            :CONTACT, :NAME, :IMAGE
+          else
+            parse_err(strict, errors, "(:ALTREP parameter given for #{prop}", ctx)
+          end
+        end
+        if params && params[:CN]
+          case prop
+          when :ATTENDEE, :ORGANIZER
+          else
+            parse_err(strict, errors, "(:CN parameter given for #{prop}", ctx)
+          end
+        end
+        if params && params[:CUTYPE]
+          case prop
+          when :ATTENDEE
+          else
+            parse_err(strict, errors, "(:CUTYPE parameter given for #{prop}", ctx)
+          end
+        end
+        if params && params[:DELEGATED_FROM]
+          case prop
+          when :ATTENDEE
+          else
+            parse_err(strict, errors, "(:DELEGATED_FROM parameter given for #{prop}", ctx)
+          end
+        end
+        if params && params[:DELEGATED_TO]
+          case prop
+          when :ATTENDEE
+          else
+            parse_err(strict, errors, "(:DELEGATED_TO parameter given for #{prop}", ctx)
+          end
+        end
+        if params && params[:DIR]
+          case prop
+          when :ATTENDEE, :ORGANIZER
+          else
+            parse_err(strict, errors, "(:DIR parameter given for #{prop}", ctx)
+          end
+        end
+        if params && params[:ENCODING]
+          case prop
+          when :ATTACH, :IMAGE 
+          else
+            parse_err(strict, errors, "(:ENCODING parameter given for #{prop}", ctx)
+          end
+        end
+        if params && params[:FMTTYPE]
+          case prop
+          when :ATTACH, :IMAGE
+          else
+            parse_err(strict, errors, "(:FMTTYPE parameter given for #{prop}", ctx)
+          end
+        end
+        if params && params[:FBTYPE]
+          case prop
+          when :FREEBUSY
+          else
+            parse_err(strict, errors, "(:FBTYPE parameter given for #{prop}", ctx)
+          end
+        end
+        if params && params[:LANGUAGE]
+          case prop
+          when :CATEGORIES, :COMMENT, :DESCRIPTION, :LOCATION, :RESOURCES,
+            :SUMMARY, :TZNAME, :ATTENDEE, :CONTACT, :ORGANIZER, :REQUEST_STATUS,
+            :NAME, :CONFERENCE
+          else
+            parse_err(strict, errors, "(:LANGUAGE parameter given for #{prop}", ctx)
+          end
+        end
+        if params && params[:MEMBER]
+          case prop
+          when :ATTENDEE
+          else
+            parse_err(strict, errors, "(:MEMBER parameter given for #{prop}", ctx)
+          end
+        end
+        if params && params[:PARTSTAT]
+          case prop
+          when :ATTENDEE
+          else
+            parse_err(strict, errors, "(:PARTSTAT parameter given for #{prop}", ctx)
+          end
+        end
+        if params && params[:RANGE]
+          case prop
+          when :RECURRENCE_ID
+          else
+            parse_err(strict, errors, "(:RANGE parameter given for #{prop}", ctx)
+          end
+        end
+        if params && params[:RELATED]
+          case prop
+          when :TRIGGER
+          else
+            parse_err(strict, errors, "(:RELATED parameter given for #{prop}", ctx)
+          end
+        end
+        if params && params[:RELTYPE]
+          case prop
+          when :RELATED_TO
+          else
+            parse_err(strict, errors, "(:RELTYPE parameter given for #{prop}", ctx)
+          end
+        end
+        if params && params[:ROLE]
+          case prop
+          when :ATTENDEE
+          else
+            parse_err(strict, errors, "(:ROLE parameter given for #{prop}", ctx)
+          end
+        end
+        if params && params[:RSVP]
+          case prop
+          when :ATTENDEE
+          else
+            parse_err(strict, errors, "(:RSVP parameter given for #{prop}", ctx)
+          end
+        end
+        if params && params[:SENT_BY]
+          case prop
+          when :ATTENDEE, :ORGANIZER
+          else
+            parse_err(strict, errors, "(:SENT_BY parameter given for #{prop}", ctx)
+          end
+        end
+        if params && params[:TZID]
+          case prop
+          when :DTEND, :DUE, :DTSTART, :RECURRENCE_ID, :EXDATE, :RDATE
+          else
+            parse_err(strict, errors, "(:TZID parameter given for #{prop}", ctx)
+          end
+        end
+        if params && params[:DISPLAY]
+          case prop
+          when :IMAGE
+          else
+            parse_err(strict, errors, "(:DISPLAY parameter given for #{prop}", ctx)
+          end
+        end
+        if params && params[:FEATURE]
+          case prop
+          when :CONFERENCE
+          else
+            parse_err(strict, errors, "(:FEATURE parameter given for #{prop}", ctx)
+          end
+        end
+        if params && params[:LABEL]
+          case prop
+          when :CONFERENCE
+          else
+            parse_err(strict, errors, "(:LABEL parameter given for #{prop}", ctx)
+          end
+        end
+        if params && params[:EMAIL]
+          case prop
+          when :ORGANIZER, :ATTENDEE
+          else
+            parse_err(strict, errors, "(:EMAIL parameter given for #{prop}", ctx)
+          end
+        end
+
+        case prop
+        when :TZURL, :URL, :CONFERENCE, :SOURCE
+          params.each do |key, val|
+            parse_err(strict, errors, "(illegal value #{val} given for parameter #{key} of #{prop}", ctx) if key == :VALUE && val.casecmp("uri") != 0
+          end
+        when :FREEBUSY
+          params.each do |key, val|
+            parse_err(strict, errors, "(illegal value #{val} given for parameter #{key} of #{prop}", ctx) if key == :VALUE && val.casecmp("period") != 0
+          end
+        when :COMPLETED
+          params.each do |key, val|
+            parse_err(strict, errors, "(illegal value #{val} given for parameter #{key} of #{prop}", ctx) if key == :VALUE && val.casecmp("date-time") != 0
+          end
+        when :PERCENT_COMPLETE, :PRIORITY, :REPEAT, :SEQUENCE
+          params.each do |key, val|
+            parse_err(strict, errors, "(illegal value #{val} given for parameter #{key} of #{prop}", ctx) if key == :VALUE && val.casecmp("integer") != 0
+          end
+        when :DURATION, :REFRESH_INTERVAL
+          params.each do |key, val|
+            parse_err(strict, errors, "(illegal value #{val} given for parameter #{key} of #{prop}", ctx) if key == :VALUE && val.casecmp("duration") != 0
+          end
+        when :GEO
+          params.each do |key, val|
+            parse_err(strict, errors, "(illegal value #{val} given for parameter #{key} of #{prop}", ctx) if key == :VALUE && val.casecmp("float") != 0
+          end
+        when :CREATED, :DTSTAMP, :LAST_MODIFIED
+          params.each do |key, val|
+            parse_err(strict, errors, "(illegal value #{val} given for parameter #{key} of #{prop}", ctx) if key == :VALUE && val.casecmp("date-time") != 0
+          end
+        when :CALSCALE, :METHOD, :PRODID, :VERSION, :CATEGORIES, :CLASS,
+          :COMMENT, :DESCRIPTION, :LOCATION, :RESOURCES, :STATUS, :SUMMARY,
+          :TRANSP, :TZID, :TZNAME, :CONTACT, :RELATED_TO, :UID, :ACTION,
+          :REQUEST_STATUS, :COLOR, :NAME
+          params.each do |key, val|
+            parse_err(strict, errors, "(illegal value #{val} given for parameter #{key} of #{prop}", ctx) if key == :VALUE && val.casecmp("text") != 0
+          end
+        when :DTEND, :DUE, :DTSTART, :RECURRENCE_ID, :EXDATE
+          params.each do |key, val|
+            parse_err(strict, errors, "(illegal value #{val} given for parameter #{key} of #{prop}", ctx) if key == :VALUE && val.casecmp("date-time") != 0 && val.casecmp("date") != 0
+          end
+        when :RDATE
+          params.each do |key, val|
+            parse_err(strict, errors, "(illegal value #{val} given for parameter #{key} of #{prop}", ctx) if key == :VALUE && val.casecmp("period") != 0 && val.casecmp("date") != 0 && val.casecmp("date-time") != 0
+          end
+        when :RRULE
+          params.each do |key, val|
+            parse_err(strict, errors, "(illegal value #{val} given for parameter #{key} of #{prop}", ctx) if key == :VALUE && val.casecmp("recur") != 0
+          end
+        when :TZOFFSETFROM, :TZOFFSETTO
+          params.each do |key, val|
+            parse_err(strict, errors, "(illegal value #{val} given for parameter #{key} of #{prop}", ctx) if key == :VALUE && val.casecmp("utc-offset") != 0
+          end
+        when :ATTENDEE, :ORGANIZER
+          params.each do |key, val|
+            parse_err(strict, errors, "(illegal value #{val} given for parameter #{key} of #{prop}", ctx) if key == :VALUE && val.casecmp("cal-address") != 0
+          end
+        when :TRIGGER
+          params.each do |key, val|
+            parse_err(strict, errors, "(illegal value #{val} given for parameter #{key} of #{prop}", ctx) if key == :VALUE && val.casecmp("duration") != 0 && val.casecmp("date-time") != 0
+          end
+        when :ATTACH, :IMAGE
+          params.each do |key, val|
+            parse_err(strict, errors, "(illegal value #{val} given for parameter #{key} of #{prop}", ctx) if key == :VALUE && val.casecmp("uri") != 0 && val.casecmp("binary") != 0
+          end
+        end
+        errors
+      end
+
+      private
+
+      def parse_err(strict, errors, msg, ctx)
+        if strict
+          raise ctx.report_error msg, "source"
+        else
+          errors << ctx.report_error(msg, "source")
+        end
+      end
+    end
+  end
+end

data/lib/vobject/vcalendar/propertyparent.rb

@@ -0,0 +1,98 @@
+require "rsec"
+require "set"
+require "uri"
+require "date"
+require "tzinfo"
+include Rsec::Helpers
+require_relative "../../c"
+require_relative "../../error"
+require "vobject"
+
+module Vobject::Vcalendar
+  class Typegrammars
+    class << self
+      # Ensure each property belongs to a legal component
+      def property_parent(strict, key, component, _value, ctx1)
+        errors = []
+        if key !~ /^x/i && registered_propname?(key.to_s)
+          case component
+          when :EVENT
+            case key
+            when :DTSTAMP, :UID, :DTSTART, :CLASS, :CREATED, :DESCRIPTION,
+              :GEO, :LAST_MOD, :LOCATION, :ORGANIZER, :PRIORITY, :SEQUENCE, :STATUS,
+              :SUMMARY, :TRANSP, :URL, :RECURRENCE_ID, :RRULE, :DTEND, :DURATION,
+              :ATTACH, :ATTENDEE, :CATEGORIES, :COMMENT, :CONTACT, :EXDATE,
+              :RSTATUS, :RELATED, :RESOURCES, :RDATE, :COLOR, :CONFERENCE, :IMAGE
+            else
+              parse_err(strict, errors, "Invalid property #{key} specified for #{component}", ctx1)
+            end
+          when :TODO
+            case key
+            when :DTSTAMP, :UID, :DTSTART, :CLASS, :CREATED, :DESCRIPTION,
+              :GEO, :LAST_MOD, :LOCATION, :ORGANIZER, :PRIORITY, :PERCENT_COMPLETED, :SEQUENCE, :STATUS,
+              :SUMMARY, :URL, :RECURRENCE_ID, :RRULE, :DUE, :DURATION,
+              :ATTACH, :ATTENDEE, :CATEGORIES, :COMMENT, :CONTACT, :EXDATE,
+              :RSTATUS, :RELATED, :RESOURCES, :RDATE, :COLOR, :CONFERENCE, :IMAGE
+            else
+              parse_err(strict, errors, "Invalid property #{key} specified for #{component}", ctx1)
+            end
+          when :JOURNAL
+            case key
+            when :DTSTAMP, :UID, :DTSTART, :CLASS, :CREATED, :DESCRIPTION,
+              :LAST_MOD, :ORGANIZER, :RECURRENCE_ID, :SEQUENCE, :STATUS,
+              :SUMMARY, :URL, :RRULE,
+              :ATTACH, :ATTENDEE, :CATEGORIES, :COMMENT, :CONTACT, :EXDATE,
+              :RSTATUS, :RELATED, :RDATE, :COLOR, :IMAGE
+            else
+              parse_err(strict, errors, "Invalid property #{key} specified for #{component}", ctx1)
+            end
+          when :FREEBUSY
+            case key
+            when :DTSTAMP, :UID, :CONTACT, :DTSTART, :DTEND, :ORGANIZER, :URL,
+              :ATTENDEE, :COMMENT, :FREEBUSY, :RSTATUS
+            else
+              parse_err(strict, errors, "Invalid property #{key} specified for #{component}", ctx1)
+            end
+          when :TIMEZONE
+            case key
+            when :TZID, :LAST_MODIFIED, :TZURL
+            else
+              parse_err(strict, errors, "Invalid property #{key} specified for #{component}", ctx1)
+            end
+          when :DAYLIGHT, :STANDARD
+            case key
+            when :DTSTART, :TZOFFSETTO, :TZOFFSETFROM, :RRULE,
+              :COMMENT, :RDATE, :TZNAME
+            else
+              parse_err(strict, errors, "Invalid property #{key} specified for #{component}", ctx1)
+            end
+          when :ALARM
+            case key
+            when :ACTION, :TRIGGER, :DURATION, :REPEAT, :ATTACH, :DESCRIPTION,
+              :SUMMARY, :ATTENDEE
+            else
+              parse_err(strict, errors, "Invalid property #{key} specified for #{component}", ctx1)
+            end
+          when :VAVAILABILITY
+            case key
+            when :DTSTAMP, :UID, :BUSYTYPE, :CLASS, :CREATED, :DESCRIPTION,
+              :DTSTART, :LAST_MODIFIED, :LOCATION, :ORGANIZER, :PRIORITY, :SEQUENCE,
+              :SUMMARY, :URL, :DTEND, :DURATION, :CATEGORIES, :COMMENT, :CONTACT
+            else
+              parse_err(strict, errors, "Invalid property #{key} specified for #{component}", ctx1)
+            end
+          when :AVAILABLE
+            case key
+            when :DTSTAMP, :DTSTART, :UID, :DTEND, :DURATION, :CREATED,
+              :DESCRIPTION, :LAST_MODIFIED, :LOCATION, :RECURRENCE_ID, :RRULE,
+              :SUMMARY, :CATEGORIES, :COMMENT, :CONTACT, :EXDATE, :RDATE
+            else
+              parse_err(strict, errors, "Invalid property #{key} specified for #{component}", ctx1)
+            end
+          end
+        end
+        errors
+      end
+    end
+  end
+end

data/lib/vobject/vcalendar/propertyvalue.rb

@@ -0,0 +1,606 @@
+require "vobject"
+require "vobject/propertyvalue"
+
+module Vobject
+  module Vcalendar
+    module PropertyValue
+      class Text < Vobject::PropertyValue
+        class << self
+          def escape(x)
+            # temporarily escape \\ as \u007f, which is banned from text
+            x.tr("\\", "\u007f").gsub(/\n/, "\\n").gsub(/,/, "\\,").
+              gsub(/;/, "\\;").gsub(/\u007f/, "\\\\\\\\")
+          end
+        end
+
+        def initialize(val)
+          self.value = val
+          self.type = "text"
+        end
+
+        def to_s
+          Text.escape value
+        end
+
+        def to_hash
+          value
+        end
+      end
+
+      class ClassValue < Text
+        def initialize(val)
+          self.value = val
+          self.type = "classvalue"
+        end
+
+        def to_hash
+          value
+        end
+      end
+
+      class TranspValue < Text
+        def initialize(val)
+          self.value = val
+          self.type = "transpvalue"
+        end
+
+        def to_hash
+          value
+        end
+      end
+
+      class ActionValue < Text
+        def initialize(val)
+          self.value = val
+          self.type = "actionvalue"
+        end
+
+        def to_hash
+          value
+        end
+      end
+
+      class MethodValue < Text
+        def initialize(val)
+          self.value = val
+          self.type = "methodvalue"
+        end
+
+        def to_hash
+          value
+        end
+      end
+
+      class Busytype < Text
+        def initialize(val)
+          self.value = val
+          self.type = "busytype"
+        end
+
+        def to_hash
+          value
+        end
+      end
+
+      class Color < Text
+        def initialize(val)
+          self.value = val
+          self.type = "color"
+        end
+
+        def to_hash
+          value
+        end
+      end
+
+      class EventStatus < Text
+        def initialize(val)
+          self.value = val
+          self.type = "eventstatus"
+        end
+
+        def to_hash
+          value
+        end
+      end
+
+      class Todostatus < Text
+        def initialize(val)
+          self.value = val
+          self.type = "todostatus"
+        end
+
+        def to_hash
+          value
+        end
+      end
+
+      class Journalstatus < Text
+        def initialize(val)
+          self.value = val
+          self.type = "journalstatus"
+        end
+
+        def to_hash
+          value
+        end
+      end
+
+      class Ianatoken < Text
+        def initialize(val)
+          self.value = val
+          self.type = "ianatoken"
+        end
+
+        def to_hash
+          value
+        end
+      end
+
+      class Binary < Text
+        def initialize(val)
+          self.value = val
+          self.type = "binary"
+        end
+
+        def to_hash
+          value
+        end
+      end
+
+      class Uri < Text
+        def initialize(val)
+          self.value = val
+          self.type = "uri"
+        end
+
+        def to_hash
+          value
+        end
+      end
+
+      class Calscale < Vobject::PropertyValue
+        def initialize(val)
+          self.value = val
+          self.type = "calscale"
+        end
+
+        def to_s
+          value
+        end
+
+        def to_hash
+          value
+        end
+      end
+
+      class Float < Vobject::PropertyValue
+        include Comparable
+        def <=>(another)
+          value <=> another.value
+        end
+
+        def initialize(val)
+          self.value = val
+          self.type = "float"
+        end
+
+        def to_s
+          value.to_s
+        end
+
+        def to_hash
+          value
+        end
+      end
+
+      class Integer < Vobject::PropertyValue
+        include Comparable
+        def <=>(another)
+          value <=> another.value
+        end
+
+        def initialize(val)
+          self.value = val
+          self.type = "integer"
+        end
+
+        def to_s
+          value.to_s
+        end
+
+        def to_hash
+          value
+        end
+      end
+
+      class PercentComplete < Integer
+        def initialize(val)
+          self.value = val
+          self.type = "percentcomplete"
+        end
+
+        def to_hash
+          value
+        end
+      end
+
+      class Priority < Integer
+        def initialize(val)
+          self.value = val
+          self.type = "priority"
+        end
+
+        def to_hash
+          value
+        end
+      end
+
+      class Date < Vobject::PropertyValue
+        include Comparable
+        def <=>(another)
+          value <=> another.value
+        end
+
+        def initialize(val)
+          self.value = val
+          self.type = "date"
+        end
+
+        def to_s
+          sprintf("%04d%02d%02d", value.year, value.month, value.day)
+        end
+
+        def to_hash
+          value
+        end
+      end
+
+      class DateTimeLocal < Vobject::PropertyValue
+        include Comparable
+        def <=>(another)
+          value[:time] <=> another.value[:time]
+        end
+
+        def initialize(val)
+          self.value = val.clone
+          # val consists of :time && :zone values. If :zone is empty, floating local time (i.e. system local time) is assumed
+          self.type = "datetimeLocal"
+          value[:time] = if val[:zone].nil? || val[:zone].empty?
+                           ::Time.local(val[:year], val[:month], val[:day], val[:hour], val[:min], val[:sec])
+                         else
+                           ::Time.utc(val[:year], val[:month], val[:day], val[:hour], val[:min], val[:sec])
+                         end
+          value[:origtime] = value[:time]
+        end
+
+        def to_s
+          # ret = sprintf("%04d%02d%02dT%02d%02d%02d", value[:year], value[:month], value[:day], value[:hour], value[:min], value[:sec])
+          ret = sprintf("%s%s%sT%s%s%s", value[:year], value[:month], value[:day], value[:hour], value[:min], value[:sec])
+          zone = "Z" if value[:zone] && value[:zone] == "Z"
+          ret = ret + zone if !zone.nil?
+          ret
+        end
+
+
+        def to_hash
+          ret = {
+            year: value[:year],
+            month: value[:month],
+            day: value[:day],
+            hour: value[:hour],
+            min: value[:min],
+            sec: value[:sec],
+          }
+          ret[:zone] = value[:zone] if value[:zone]
+          ret
+        end
+      end
+
+      class DateTimeUTC < Vobject::PropertyValue
+        include Comparable
+        def <=>(another)
+          value[:time] <=> another.value[:time]
+        end
+
+        def initialize(val)
+          self.value = val.clone
+          value[:time] =  ::Time.utc(val[:year], val[:month], val[:day], val[:hour], val[:min], val[:sec])
+          value[:origtime] = value[:time]
+        end
+
+        def to_s
+          localtime = value[:origtime]
+          ret = sprintf("%04d%02d%02dT%02d%02d%02dZ", localtime.year, localtime.month, localtime.day,
+                        localtime.hour, localtime.min, localtime.sec)
+          ret
+        end
+
+        def to_hash
+          ret = {
+            year: value[:year],
+            month: value[:month],
+            day: value[:day],
+            hour: value[:hour],
+            min: value[:min],
+            sec: value[:sec],
+          }
+          ret
+        end
+      end
+
+      class Boolean < Vobject::PropertyValue
+        def initialize(val)
+          self.value = val
+          self.type = "boolean"
+        end
+
+        def to_s
+          value.to_s
+        end
+
+        def to_hash
+          value
+        end
+
+        def to_norm
+          value.to_s.upcase
+        end
+      end
+
+      class Duration < Vobject::PropertyValue
+        def initialize(val)
+          self.value = val
+          self.type = "duration"
+        end
+
+        def to_s
+          ret = "P"
+          ret = value[:sign] + ret if value[:sign]
+          ret = ret + "#{value[:weeks]}W" if value[:weeks]
+          ret = ret + "#{value[:days]}D" if value[:days]
+          ret = ret + "T" if value[:hours] || value[:minutes] || value[:seconds]
+          ret = ret + "#{value[:hours]}H" if value[:hours]
+          ret = ret + "#{value[:minutes]}M" if value[:minutes]
+          ret = ret + "#{value[:seconds]}S" if value[:seconds]
+          ret
+        end
+
+        def to_hash
+          value
+        end
+      end
+
+      class Time < Vobject::PropertyValue
+        def initialize(val)
+          self.value = val
+          self.type = "time"
+        end
+
+        def to_s
+          ret = "#{value[:hour]}#{value[:min]}#{value[:sec]}"
+          ret = ret + "Z" if value[:utc]
+          ret
+        end
+
+        def to_hash
+          value
+        end
+      end
+
+      class Utcoffset < Vobject::PropertyValue
+        def initialize(val)
+          self.value = val
+          self.type = "utcoffset"
+        end
+
+        def to_s
+          ret = "#{value[:sign]}#{value[:hr]}#{value[:min]}"
+          ret += value[:sec] if value[:sec]
+          ret
+        end
+
+        def to_hash
+          value
+        end
+      end
+
+      class Geovalue < Vobject::PropertyValue
+        def initialize(val)
+          self.value = val
+          self.type = "geovalue"
+        end
+
+        def to_s
+          ret = "#{value[:lat]};#{value[:long]}"
+          ret
+        end
+
+        def to_hash
+          value
+        end
+      end
+
+      class Version < Vobject::PropertyValue
+        def initialize(val)
+          self.value = val
+          self.type = "version"
+        end
+
+        def to_s
+          value.join(";")
+        end
+
+        def to_hash
+          if value.length == 1
+            value[0]
+          else
+            value
+          end
+        end
+      end
+
+      class Textlist < Vobject::PropertyValue
+        def initialize(val)
+          self.value = val
+          self.type = "textlist"
+        end
+
+        def to_s
+          value.map { |m| Text.escape m }.join(",")
+        end
+
+        def to_hash
+          value
+        end
+      end
+
+      class Periodlist < Vobject::PropertyValue
+        def initialize(val)
+          self.value = val
+          self.type = "periodlist"
+        end
+
+        def to_s
+          value.map do |m|
+            ret = m[:start].to_s + "/"
+            ret += m[:end].to_s if m.has_key? :end
+            ret += m[:duration].to_s if m.has_key? :duration
+            ret
+          end.join(",")
+        end
+
+        def to_hash
+          value.map { |m| m.each { |k, v| m[k] = v.to_hash } }
+        end
+      end
+
+      class Datelist < Vobject::PropertyValue
+        def initialize(val)
+          self.value = val
+          self.type = "datelist"
+        end
+
+        def to_s
+          value.map(&:to_s).join(",")
+        end
+
+        def to_hash
+          value.map(&:to_hash)
+        end
+      end
+
+      class Datetimelist < Vobject::PropertyValue
+        def initialize(val)
+          self.value = val
+          self.type = "datetimelist"
+        end
+
+        def to_s
+          value.map(&:to_s).join(",")
+        end
+
+        def to_hash
+          value.map(&:to_hash)
+        end
+      end
+
+      class Datetimeutclist < Vobject::PropertyValue
+        def initialize(val)
+          self.value = val
+          self.type = "datetimeutclist"
+        end
+
+        def to_s
+          value.map(&:to_s).join(",")
+        end
+
+        def to_hash
+          value.map(&:to_hash)
+        end
+      end
+
+      class Requeststatusvalue < Vobject::PropertyValue
+        def initialize(val)
+          self.value = val
+          self.type = "requeststatusvalue"
+        end
+
+        def to_s
+          ret = "#{value[:statcode]};#{value[:statdesc]}"
+          ret += ";#{value[:extdata]}" if value[:extdata]
+          ret
+        end
+
+        def to_hash
+          value
+        end
+      end
+
+      class Recur < Vobject::PropertyValue
+        def initialize(val)
+          self.value = val
+          self.type = "recur"
+        end
+
+        def to_s
+          ret = []
+          value.each do |k, v|
+            ret << "#{k.to_s.upcase}=#{valencode(k, v)}"
+          end
+          ret.join(";")
+        end
+
+        def to_hash
+          ret = {}
+          value.each do |k, v|
+            ret[k] = if v.respond_to?(:to_hash)
+                       v.to_hash
+                     else
+                       v
+                     end
+          end
+          ret
+        end
+
+        private
+
+        def valencode(k, v)
+          case k
+          when :bysetpos, :byyearday
+            v.map do |x|
+              ret = x[:ordyrday]
+              ret = x[:sign] + ret if x[:sign]
+              ret
+            end.join(",")
+          when :byweekno
+            v.map do |x|
+              ret = x[:ordwk]
+              ret = x[:sign] + ret if x[:sign]
+              ret
+            end.join(",")
+          when :bymonthday
+            v.map do |x|
+              ret = x[:ordmoday]
+              ret = x[:sign] + ret if x[:sign]
+              ret
+            end.join(",")
+          when :byday
+            v.map do |x|
+              ret = x[:weekday]
+              ret = x[:ordwk] + ret if x[:ordwk]
+              ret = x[:sign] + ret if x[:sign]
+              ret
+            end.join(",")
+          when :bymonth, :byhour, :byminute, :bysecond
+            v.join(",")
+          when :enddate
+            v.to_s
+          else
+            v
+          end
+        end
+      end
+    end
+  end
+end