vobject 0.1.0 → 1.0.2

data/lib/vobject/parametervalue.rb

@@ -0,0 +1,26 @@
+module Vobject
+  class ParameterValue
+    def initialize(val)
+      self.value = val
+    end
+    # raise_invalid_initialization if key != name
+  end
+
+  def to_s
+    value
+  end
+
+  private
+
+  def name
+    prop_name
+  end
+
+  def default_value_type
+    "text"
+  end
+
+  def raise_invalid_initialization
+    raise "vObject property initialization failed"
+  end
+end

data/lib/vobject/property.rb

@@ -1,83 +1,162 @@
-module Vobject
-
-  class Property
-
-    MAX_LINE_WIDTH = 75
-
-    attr_accessor :group, :prop_name, :params, :value
+require "vobject"
+require "vobject/parameter"
+
+class Vobject::Property
+  attr_accessor :group, :prop_name, :params, :value, :multiple, :norm
+
+  def <=>(another)
+    if self.prop_name =~ /^VERSION$/i
+      -1
+    elsif another.prop_name =~ /^VERSION$/i
+      1
+    else
+      self.to_norm <=> another.to_norm
+    end
+  end
 
-    def initialize key, options
-      self.group = options[:group]
+  def initialize(key, options)
+    if options.class == Array
+      self.multiple = []
+      options.each do |v|
+        multiple << property_base_class.new(key, v)
+        self.prop_name = key
+      end
+    else
       self.prop_name = key
-      self.params = options[:params]
-      self.value = parse_value(options[:value])
+      if options.nil? || options.empty?
+        self.group = nil
+        self.params = []
+        self.value = nil
+      else
+        self.group = options[:group]
+        self.prop_name = key
+        unless options[:params].nil? || options[:params].empty?
+          self.params = []
+          options[:params].each do |k, v|
+            params << parameter_base_class.new(k, v)
+          end
+        end
+        # self.value = parse_value(options[:value])
+        self.value = options[:value]
+      end
+    end
+    self.norm = nil
+    raise_invalid_initialization if key != name
+  end
 
-      raise_invalid_initialization if key != name
+  def to_s
+    if multiple.nil? || multiple.empty?
+      ret = to_s_line
+    else
+      arr = []
+      multiple.each do |x|
+        arr << x.to_s_line
+      end
+      ret = arr.join("")
     end
+    ret
+  end
 
-    def to_s
-      line = group ? "#{group}." : ""
-      line << "#{name}"
+  def to_s_line
+    line = group ? "#{group}." : ""
+    line << name.to_s.tr("_", "-")
 
-      (params || {}).each do |pname, pvalue|
-        pvalue.to_s.gsub!(/\n/, '\n')
+    (params || {}).each do |p|
+      line << ";#{p}"
+    end
 
-        line << ";#{pname}=#{pvalue}"
-      end
+    line << ":#{value}"
 
-      line << ":#{value}"
+    line = Vobject::fold_line(line) << "\n"
 
-      line = fold_line(line) << "\n"
+    line
+  end
 
-      line
+  def to_norm
+    if @norm.nil?
+      if multiple.nil? || multiple.empty?
+        ret = to_norm_line
+      else
+        arr = []
+        multiple.sort.each do |x|
+          arr << x.to_norm_line
+        end
+        ret = arr.join("")
+      end
+      @norm = ret
     end
+    @norm
+  end
 
-    private
+  def to_norm_line
+    line = group ? "#{group}." : ""
+    line << name.to_s.tr("_", "-").upcase
 
-    def name
-      prop_name
+    (params || {}).sort.each do |p|
+      line << ";#{p.to_norm}"
     end
 
-    def parse_value value
-      parse_method = :"parse_#{value_type}_value"
-      parse_method = respond_to?(parse_method, true) ? parse_method : :parse_text_value
-      send(parse_method, value)
-    end
+    line << ":#{value.to_norm}"
 
-    def parse_text_value value
-      value
-    end
+    line = Vobject::fold_line(line) << "\n"
 
-    def value_type
-      (params || {})[:VALUE] || default_value_type
-    end
+    line
+  end
 
-    def default_value_type
-      "text"
-    end
 
-    def raise_invalid_initialization
-      raise "vObject property initialization failed"
+  def to_hash
+    ret = {}
+    if multiple
+      ret[prop_name] = []
+      multiple.each do |c|
+        ret[prop_name] = ret[prop_name] << c.to_hash[prop_name]
+      end
+    else
+      ret = {prop_name => { value: value.to_hash } }
+      ret[prop_name][:group] = group unless group.nil?
+      if params
+        ret[prop_name][:params] = {}
+        params.each do |p|
+          ret[prop_name][:params] = ret[prop_name][:params].merge p.to_hash
+        end
+      end
     end
+    ret
+  end
 
-    # This implements the line folding as specified in
-    # http://tools.ietf.org/html/rfc6350#section-3.2
-    #
-    # NOTE: the "line" here is not including the trailing \n
-    def fold_line(line)
-      folded_line    = line[0, MAX_LINE_WIDTH]
-      remainder_line = line[MAX_LINE_WIDTH, line.length - MAX_LINE_WIDTH] || ''
+  private
 
-      max_width = MAX_LINE_WIDTH - 1
+  def name
+    prop_name
+  end
 
-      for i in 0..((remainder_line.length - 1) / max_width)
-        folded_line << "\n "
-        folded_line << remainder_line[i * max_width, max_width]
-      end
+  def parse_value(value)
+    parse_method = :"parse_#{value_type}_value"
+    parse_method = respond_to?(parse_method, true) ? parse_method : :parse_text_value
+    send(parse_method, value)
+  end
 
-      folded_line
-    end
+  def parse_text_value(value)
+    value
+  end
 
+  def value_type
+    params ? params[0].value : default_value_type
   end
 
+  def default_value_type
+    "text"
+  end
+
+  def property_base_class
+    Vobject::Property
+  end
+
+  def parameter_base_class
+    Vobject::Parameter
+  end
+
+  def raise_invalid_initialization
+    raise "vObject property initialization failed"
+  end
 end

data/lib/vobject/propertyvalue.rb

@@ -0,0 +1,46 @@
+module Vobject
+  class PropertyValue
+    attr_accessor :value, :type, :errors, :norm
+
+    def <=>(another)
+      self.value <=> another.value
+    end
+
+    def initialize(val)
+      self.value = val
+      self.type = "text" # safe default
+      self.norm = nil
+    end
+
+    # raise_invalid_initialization if key != name
+
+    def to_s
+      value
+    end
+
+    def to_norm
+      if norm.nil?
+        norm = to_s
+      end
+      norm
+    end
+
+    def to_hash
+      value
+    end
+
+    def name
+      type
+    end
+
+    private
+
+    def default_value_type
+      "text"
+    end
+
+    def raise_invalid_initialization
+      raise "vObject property initialization failed"
+    end
+  end
+end

data/lib/vobject/vcalendar/component.rb

@@ -0,0 +1,106 @@
+require "vobject"
+require "vobject/property"
+require "vobject/vcalendar/grammar"
+require "json"
+
+class Vobject::Component::Vcalendar < Vobject::Component
+  attr_accessor :comp_name, :children
+
+  class << self
+    def parse(vcf, strict)
+      hash = Vobject::Vcalendar::Grammar.new(strict).parse(vcf)
+      comp_name = hash.keys.first
+
+      new comp_name, hash[comp_name], hash[:errors]
+    end
+
+    def initialize(key, cs)
+      # super key, cs
+      self.comp_name = key
+      raise_invalid_initialization if key != name
+
+      self.children = []
+      if cs.is_a?(Array)
+        cs.each do |component|
+          c = []
+          component.each_key do |k|
+            val = component[k]
+            # iteration of array || hash values is making the value a key!
+            next if k.class == Array
+            next if k.class == Hash
+            cc = child_class(k, val)
+            c << cc.new(k, val)
+          end
+          children << c
+        end
+      else
+        cs.each_key do |k|
+          val = cs[k]
+          # iteration of array || hash values is making the value a key!
+          next if k.class == Array
+          next if k.class == Hash
+          cc = child_class(k, val)
+          children << cc.new(k, val)
+        end
+      end
+    end
+
+    def child_class(key, val)
+      base_class = if key == :VTODO
+                     Vobject::Component::Vcalendar::ToDo
+                   elsif key == :VFREEBUSY
+                     Vobject::Component::Vcalendar::FreeBusy
+                   elsif key == :JOURNAL
+                     Vobject::Component::Vcalendar::Journal
+                   elsif key == :STANDARD
+                     Vobject::Component::Vcalendar::Timezone::Standard
+                   elsif key == :DAYLIGHT
+                     Vobject::Component::Vcalendar::Timezone::Daylight
+                   elsif key == :VTIMEZONE
+                     Vobject::Component::Vcalendar::Timezone
+                   elsif key == :VEVENT
+                     Vobject::Component::Vcalendar::Event
+                   elsif key == :VALARM
+                     Vobject::Component::Vcalendar::Alarm
+                   elsif key == :VAVAILABILITY
+                     Vobject::Component::Vcalendar::Vavailability
+                   elsif key == :AVAILABLE
+                     Vobject::Component::Vcalendar::Vavailability::Available
+                   elsif !(val.is_a?(Hash) && !val.has_key?(:value))
+                     property_base_class
+                   else
+                     Vobject::Component::Vcalendar
+                   end
+      return base_class if [:CLASS, :OBJECT, :METHOD].include? key
+      camelized_key = key.to_s.downcase.split("_").map(&:capitalize).join("")
+      base_class.const_get(camelized_key) rescue base_class
+    end
+
+    private
+
+    def raise_invalid_parsing
+      raise "Vobject component parse failed"
+    end
+  end
+end
+
+class Vobject::Component::Vcalendar::ToDo < Vobject::Component::Vcalendar
+end
+class Vobject::Component::Vcalendar::Freebusy < Vobject::Component::Vcalendar
+end
+class Vobject::Component::Vcalendar::Journal < Vobject::Component::Vcalendar
+end
+class Vobject::Component::Vcalendar::Timezone < Vobject::Component::Vcalendar
+end
+class Vobject::Component::Vcalendar::Timezone::Standard < Vobject::Component::Vcalendar::Timezone
+end
+class Vobject::Component::Vcalendar::Timezone::Daylight < Vobject::Component::Vcalendar::Timezone
+end
+class Vobject::Component::Vcalendar::Event < Vobject::Component::Vcalendar
+end
+class Vobject::Component::Vcalendar::Alarm < Vobject::Component::Vcalendar
+end
+class Vobject::Component::Vcalendar::Vavailability < Vobject::Component::Vcalendar
+end
+class Vobject::Component::Vcalendar::Vavailability::Available < Vobject::Component::Vcalendar
+end

data/lib/vobject/vcalendar/grammar.rb

@@ -0,0 +1,595 @@
+require "rsec"
+require "set"
+require "uri"
+require "date"
+require "tzinfo"
+include Rsec::Helpers
+require_relative "../../c"
+require_relative "../../error"
+require "vobject"
+require "vobject/vcalendar/typegrammars"
+require "vobject/vcalendar/paramcheck"
+
+module Vobject::Vcalendar
+  class Grammar
+    include C
+    attr_accessor :strict, :errors
+
+    class << self
+      # RFC 6868
+      def rfc6868decode(x)
+        x.gsub(/\^n/, "\n").gsub(/\^\^/, "^").gsub(/\^'/, '"')
+      end
+
+      def unfold(str)
+        str.gsub(/(\r|\n|\r\n)[ \t]/, "")
+      end
+    end
+
+    def vobject_grammar
+      # properties with value cardinality 1
+      @cardinality1 = {}
+      @cardinality1[:ICAL] = Set.new [:PRODID, :VERSION, :CALSCALE, :METHOD, :UID, :LAST_MOD, :URL,
+                                      :REFRESH_INTERVAL, :SOURCE, :COLOR]
+      @cardinality1[:EVENT] = Set.new [:UID, :DTSTAMP, :DTSTART, :CLASS, :CREATED, :DESCRIPTION, :GEO, :LAST_MOD,
+                                       :LOCATION, :ORGANIZER, :PRIORITY, :SEQ, :STATUS, :TRANSP, :URL, :RECURID, :COLOR]
+      @cardinality1[:TODO] = Set.new [:UID, :DTSTAMP, :CLASS, :COMPLETED, :CREATED, :DESCRIPTION, :DTSTART, :GEO, :LAST_MOD,
+                                      :LOCATION, :ORGANIZER, :PERCENT_COMPLETE, :PRIORITY, :SEQ, :STATUS, :SUMMARY, :URL, :RECURID, :COLOR]
+      @cardinality1[:JOURNAL] = Set.new [:UID, :DTSTAMP, :CLASS, :CREATED, :DTSTART, :LAST_MOD,
+                                         :ORGANIZER, :SEQ, :STATUS, :SUMMARY, :URL, :RECURID, :COLOR]
+      @cardinality1[:FREEBUSY] = Set.new [:UID, :DTSTAMP, :CONTACT, :DTSTART, :DTEND, :ORGANIZER, :URL]
+      @cardinality1[:TIMEZONE] = Set.new [:TZID, :LAST_MOD, :TZURL]
+      @cardinality1[:TZ] = Set.new [:DTSTART, :TZOFFSETTTO, :TZOFFSETFROM]
+      @cardinality1[:ALARM] = Set.new [:ACTION, :TRIGGER, :DURATION, :REPEAT, :DESCRIPTION, :SUMMARY]
+      @cardinality1[:VAVAILABILITY] = Set.new [:UID, :DTSTAMP, :DTSTART, :BUSYTYPE, :CLASS, :CREATED, :DESCRIPTION, :LAST_MOD,
+                                               :LOCATION, :ORGANIZER, :PRIORITY, :SEQ, :SUMMARY, :URL]
+      @cardinality1[:AVAILABLE] = Set.new [:DTSTAMP, :DTSTART, :UID, :CREATED, :DESCRIPTION, :LAST_MOD, :LOCATION,
+                                           :RECURID, :RRULE, :SUMMARY]
+      @cardinality1[:PARAM] = Set.new [:FMTTYPE, :LANGUAGE, :ALTREP, :FBTYPE, :TRANSP, :CUTYPE, :MEMBER, :ROLE, :PARTSTAT, :RSVP, :DELEGATED_TO,
+                                       :DELEGATED_FROM, :SENT_BY, :CN, :DIR, :RANGE, :RELTYPE, :RELATED, :DISPLAY, :FEATURE, :LABEL]
+
+      group = C::IANATOKEN
+      linegroup = group <<  "."
+      beginend = /BEGIN/i.r | /END/i.r
+
+      # parameters && parameter types
+      paramname = /ALTREP/i.r | /CN/i.r | /CUTYPE/i.r | /DELEGATED-FROM/i.r | /DELEGATED-TO/i.r |
+        /DIR/i.r | /ENCODING/i.r | /FMTTYPE/i.r | /FBTYPE/i.r | /LANGUAGE/i.r |
+        /MEMBER/i.r | /PARTSTAT/i.r | /RANGE/i.r | /RELATED/i.r | /RELTYPE/i.r |
+        /ROLE/i.r | /RSVP/i.r | /SENT-BY/i.r | /TZID/i.r | /RSCALE/i.r | /DISPLAY/i.r |
+        /FEATURE/i.r | /LABEL/i.r | /EMAIL/i.r
+      otherparamname = C::XNAME_VCAL | seq("".r ^ paramname, C::IANATOKEN)[1]
+      paramvalue = C::QUOTEDSTRING_VCAL.map { |s| self.class.rfc6868decode s } |
+        C::PTEXT_VCAL.map { |s| self.class.rfc6868decode(s) }
+      quotedparamvalue = C::QUOTEDSTRING_VCAL.map { |s| self.class.rfc6868decode s }
+      cutypevalue = /INDIVIDUAL/i.r | /GROUP/i.r | /RESOURCE/i.r | /ROOM/i.r | /UNKNOWN/i.r |
+        C::XNAME_VCAL | C::IANATOKEN.map
+      encodingvalue = /8BIT/i.r | /BASE64/i.r
+      fbtypevalue = /FREE/i.r | /BUSY/i.r | /BUSY-UNAVAILABLE/i.r | /BUSY-TENTATIVE/i.r |
+        C::XNAME_VCAL | C::IANATOKEN
+      partstatevent = /NEEDS-ACTION/i.r | /ACCEPTED/i.r | /DECLINED/i.r | /TENTATIVE/i.r |
+        /DELEGATED/i.r | C::XNAME_VCAL | C::IANATOKEN
+      partstattodo = /NEEDS-ACTION/i.r | /ACCEPTED/i.r | /DECLINED/i.r | /TENTATIVE/i.r |
+        /DELEGATED/i.r | /COMPLETED/i.r | /IN-PROCESS/i.r | C::XNAME_VCAL | C::IANATOKEN
+      partstatjour = /NEEDS-ACTION/i.r | /ACCEPTED/i.r | /DECLINED/i.r | C::XNAME_VCAL | C::IANATOKEN
+      partstatvalue = partstatevent | partstattodo | partstatjour
+      rangevalue = /THISANDFUTURE/i.r
+      relatedvalue = /START/i.r | /END/i.r
+      reltypevalue = /PARENT/i.r | /CHILD/i.r | /SIBLING/i.r | C::XNAME_VCAL | C::IANATOKEN
+      tzidvalue = seq("/".r._?, C::PTEXT_VCAL).map { |_, val| val }
+      valuetype = /BINARY/i.r | /BOOLEAN/i.r | /CAL-ADDRESS/i.r | /DATE-TIME/i.r | /DATE/i.r |
+        /DURATION/i.r | /FLOAT/i.r | /INTEGER/i.r | /PERIOD/i.r | /RECUR/i.r | /TEXT/i.r |
+        /TIME/i.r | /URI/i.r | /UTC-OFFSET/i.r | C::XNAME_VCAL | C::IANATOKEN
+      rolevalue = /CHAIR/i.r | /REQ-PARTICIPANT/i.r | /OPT-PARTICIPANT/i.r | /NON-PARTICIPANT/i.r |
+        C::XNAME_VCAL | C::IANATOKEN
+      pvalue_list = (seq(paramvalue << ",".r, lazy { pvalue_list }) & /[;:]/.r).map do |e, list|
+        [e.sub(Regexp.new("^\"(.+)\"$"), '\1').gsub(/\\n/, "\n"), list].flatten
+      end | (paramvalue & /[;:]/.r).map do |e|
+        [e.sub(Regexp.new("^\"(.+)\"$"), '\1').gsub(/\\n/, "\n")]
+      end
+      quoted_string_list = (seq(C::QUOTEDSTRING_VCAL << ",".r, lazy { quoted_string_list }) & /[;:]/.r).map do |e, list|
+        [self.class.rfc6868decode(e.sub(Regexp.new("^\"(.+)\"$"), "\1").gsub(/\\n/, "\n")), list].flatten
+      end | (C::QUOTEDSTRING_VCAL & /[;:]/.r).map do |e|
+        [self.class.rfc6868decode(e.sub(Regexp.new("^\"(.+)\"$"), "\1").gsub(/\\n/, "\n"))]
+      end
+
+      rfc4288regname = /[A-Za-z0-9!#$&.+^+-]{1,127}/.r
+      rfc4288typename = rfc4288regname
+      rfc4288subtypename = rfc4288regname
+      fmttypevalue = seq(rfc4288typename, "/", rfc4288subtypename).map(&:join)
+
+      # RFC 7986
+      displayval = /BADGE/i.r | /GRAPHIC/i.r | /FULLSIZE/i.r | /THUMBNAIL/i.r | C::XNAME_VCAL | C::IANATOKEN
+      displayvallist = seq(displayval << ",".r, lazy { displayvallist }) do |d, l|
+        [d, l].flatten
+      end | displayval.map { |d| [d] }
+      featureval = /AUDIO/i.r | /CHAT/i.r | /FEED/i.r | /MODERATOR/i.r | /PHONE/i.r | /SCREEN/i.r |
+        /VIDEO/i.r | C::XNAME_VCAL | C::IANATOKEN
+      featurevallist = seq(featureval << ",".r, lazy { featurevallist }) do |d, l|
+        [d, l].flatten
+      end | featureval.map { |d| [d] }
+
+      param = seq(/ALTREP/i.r, "=", quotedparamvalue) do |name, _, val|
+        { name.upcase.tr("-", "_").to_sym => val }
+      end | seq(/CN/i.r, "=", paramvalue) do |name, _, val|
+        { name.upcase.tr("-", "_").to_sym => val }
+      end | seq(/CUTYPE/i.r, "=", cutypevalue) do |name, _, val|
+        { name.upcase.tr("-", "_").to_sym => val.upcase }
+      end | seq(/DELEGATED-FROM/i.r, "=", quoted_string_list) do |name, _, val|
+        val = val[0] if val.length == 1
+        { name.upcase.tr("-", "_").to_sym => val }
+      end | seq(/DELEGATED-TO/i.r, "=", quoted_string_list) do |name, _, val|
+        val = val[0] if val.length == 1
+        { name.upcase.tr("-", "_").to_sym => val }
+      end | seq(/DIR/i.r, "=", quotedparamvalue) do |name, _, val|
+        { name.upcase.tr("-", "_").to_sym => val }
+      end | seq(/ENCODING/i.r, "=", encodingvalue) do |name, _, val|
+        { name.upcase.tr("-", "_").to_sym => val.upcase }
+      end | seq(/FMTTYPE/i.r, "=", fmttypevalue) do |name, _, val|
+        { name.upcase.tr("-", "_").to_sym => val.downcase }
+      end | seq(/FBTYPE/i.r, "=", fbtypevalue) do |name, _, val|
+        { name.upcase.tr("-", "_").to_sym => val.upcase }
+      end | seq(/LANGUAGE/i.r, "=", C::RFC5646LANGVALUE) do |name, _, val|
+        { name.upcase.tr("-", "_").to_sym => val.upcase }
+      end | seq(/MEMBER/i.r, "=", quoted_string_list) do |name, _, val|
+        val = val[0] if val.length == 1
+        { name.upcase.tr("-", "_").to_sym => val }
+      end | seq(/PARTSTAT/i.r, "=", partstatvalue) do |name, _, val|
+        { name.upcase.tr("-", "_").to_sym => val.upcase }
+      end | seq(/RANGE/i.r, "=", rangevalue) do |name, _, val|
+        { name.upcase.tr("-", "_").to_sym => val.upcase }
+      end | seq(/RELATED/i.r, "=", relatedvalue) do |name, _, val|
+        { name.upcase.tr("-", "_").to_sym => val.upcase }
+      end | seq(/RELTYPE/i.r, "=", reltypevalue) do |name, _, val|
+        { name.upcase.tr("-", "_").to_sym => val.upcase }
+      end | seq(/ROLE/i.r, "=", rolevalue) do |name, _, val|
+        { name.upcase.tr("-", "_").to_sym => val.upcase }
+      end | seq(/RSVP/i.r, "=", C::BOOLEAN) do |name, _, val|
+        { name.upcase.tr("-", "_").to_sym => val }
+      end | seq(/SENT-BY/i.r, "=", quotedparamvalue) do |name, _, val|
+        { name.upcase.tr("-", "_").to_sym => val }
+      end | seq(/TZID/i.r, "=", tzidvalue) do |name, _, val|
+        { name.upcase.tr("-", "_").to_sym => val }
+      end | seq(/VALUE/i.r, "=", valuetype) do |name, _, val|
+        { name.upcase.tr("-", "_").to_sym => val }
+        # RFC 7986
+      end | seq(/DISPLAY/i.r, "=", displayvallist) do |name, _, val|
+        { name.upcase.tr("-", "_").to_sym => val }
+      end | seq(/FEATURE/i.r, "=", featurevallist) do |name, _, val|
+        { name.upcase.tr("-", "_").to_sym => val }
+      end | seq(/EMAIL/i.r, "=", paramvalue) do |name, _, val|
+        { name.upcase.tr("-", "_").to_sym => val }
+      end | seq(/LABEL/i.r, "=", paramvalue) do |name, _, val|
+        { name.upcase.tr("-", "_").to_sym => val }
+      end | seq(otherparamname, "=", pvalue_list) do |name, _, val|
+        val = val[0] if val.length == 1
+        { name.upcase.tr("-", "_").to_sym => val }
+      end | seq(paramname, "=", pvalue_list) do |name, _, val|
+        parse_err("Violated format of parameter value #{name} = #{val}")
+      end
+
+      params = seq(";".r >> param & ";", lazy { params }) do |p, ps|
+        p.merge(ps) do |key, old, new|
+          if @cardinality1[:PARAM].include?(key)
+            parse_err("Violated cardinality of parameter #{key}")
+          end
+          [old, new].flatten
+          # deal with duplicate properties
+        end
+      end | seq(";".r >> param).map { |e| e[0] }
+
+      contentline = seq(linegroup._?, C::NAME_VCAL, params._? << ":".r,
+                        C::VALUE, /(\r|\n|\r\n)/) do |g, name, p, value, _|
+        key =  name.upcase.tr("-", "_").to_sym
+        hash = { key => { value: value } }
+        hash[key][:group] = g[0] unless g.empty?
+        errors << Paramcheck.paramcheck(strict, key, p.empty? ? {} : p[0], @ctx)
+        hash[key][:params] = p[0] unless p.empty?
+        hash
+      end
+
+      props = ("".r & beginend).map { {} } |
+        seq(contentline, lazy { props }) do |c, rest|
+        k = c.keys[0]
+        c[k][:value], errors1 = Typegrammars.typematch(strict, k, c[k][:params], :GENERIC, c[k][:value], @ctx)
+        errors << errors1
+        c.merge(rest) do |_, old, new|
+          [old, new].flatten
+          # deal with duplicate properties
+        end
+      end
+      alarmprops = ("".r & beginend).map { {} } |
+        seq(contentline, lazy { alarmprops }) do |c, rest|
+        k = c.keys[0]
+        c[k][:value], errors1 = Typegrammars.typematch(strict, k, c[k][:params], :ALARM, c[k][:value], @ctx)
+        errors << errors1
+        c.merge(rest) do |key, old, new|
+          if @cardinality1[:ALARM].include?(key.upcase)
+            parse_err("Violated cardinality of property #{key}")
+          end
+          [old, new].flatten
+        end
+      end
+      fbprops = ("".r & beginend).map { {} } |
+        seq(contentline, lazy { fbprops }) do |c, rest|
+        k = c.keys[0]
+        c[k][:value], errors1 = Typegrammars.typematch(strict, k, c[k][:params], :FREEBUSY, c[k][:value], @ctx)
+        errors << errors1
+        c.merge(rest) do |key, old, new|
+          if @cardinality1[:FREEBUSY].include?(key.upcase)
+            parse_err("Violated cardinality of property #{key}")
+          end
+          [old, new].flatten
+        end
+      end
+      journalprops = ("".r & beginend).map { {} } |
+        seq(contentline, lazy { journalprops }) do |c, rest|
+        k = c.keys[0]
+        c[k][:value], errors1 = Typegrammars.typematch(strict, k, c[k][:params], :JOURNAL, c[k][:value], @ctx)
+        errors << errors1
+        c.merge(rest) do |key, old, new|
+          if @cardinality1[:JOURNAL].include?(key.upcase)
+            parse_err("Violated cardinality of property #{key}")
+          end
+          [old, new].flatten
+        end
+      end
+      tzprops = ("".r & beginend).map { {} } |
+        seq(contentline, lazy { tzprops }) do |c, rest|
+        k = c.keys[0]
+        c[k][:value], errors1 = Typegrammars.typematch(strict, k, c[k][:params], :TZ, c[k][:value], @ctx)
+        errors << errors1
+        c.merge(rest) do |key, old, new|
+          if @cardinality1[:TZ].include?(key.upcase)
+            parse_err("Violated cardinality of property #{key}")
+          end
+          [old, new].flatten
+        end
+      end
+      standardc = seq(/BEGIN:STANDARD(\r|\n|\r\n)/i.r, tzprops, /END:STANDARD(\r|\n|\r\n)/i.r) do |_, e, _|
+        parse_err("Missing DTSTART property") unless e.has_key?(:DTSTART)
+        parse_err("Missing TZOFFSETTO property") unless e.has_key?(:TZOFFSETTO)
+        parse_err("Missing TZOFFSETFROM property") unless e.has_key?(:TZOFFSETFROM)
+        { STANDARD: { component: [e] } }
+      end
+      daylightc = seq(/BEGIN:DAYLIGHT(\r|\n|\r\n)/i.r, tzprops, /END:DAYLIGHT(\r|\n|\r\n)/i.r) do |_, e, _|
+        parse_err("Missing DTSTART property") unless e.has_key?(:DTSTART)
+        parse_err("Missing TZOFFSETTO property") unless e.has_key?(:TZOFFSETTO)
+        parse_err("Missing TZOFFSETFROM property") unless e.has_key?(:TZOFFSETFROM)
+        { DAYLIGHT: { component: [e] } }
+      end
+      timezoneprops =
+        seq(standardc, lazy { timezoneprops }) do |e, rest|
+        e.merge(rest) { |_, old, new| { component: [old[:component], new[:component]].flatten } }
+        end | seq(daylightc, lazy { timezoneprops }) do |e, rest|
+          e.merge(rest) { |_, old, new| { component: [old[:component], new[:component]].flatten } }
+        end | seq(contentline, lazy { timezoneprops }) do |e, rest|
+          k = e.keys[0]
+          e[k][:value], errors1 = Typegrammars.typematch(strict, k, e[k][:params], :TIMEZONE, e[k][:value], @ctx)
+          errors << errors1
+          e.merge(rest) do |key, old, new|
+            if @cardinality1[:TIMEZONE].include?(key.upcase)
+              parse_err("Violated cardinality of property #{key}")
+            end
+            [old, new].flatten
+          end
+        end |
+        ("".r & beginend).map { {} }
+        todoprops = ("".r & beginend).map { {} } |
+          seq(contentline, lazy { todoprops }) do |c, rest|
+          k = c.keys[0]
+          c[k][:value], errors1 = Typegrammars.typematch(strict, k, c[k][:params], :TODO, c[k][:value], @ctx)
+          errors << errors1
+          c.merge(rest) do |key, old, new|
+            if @cardinality1[:TODO].include?(key.upcase)
+              parse_err("Violated cardinality of property #{key}")
+            end
+            [old, new].flatten
+          end
+        end
+        eventprops = seq(contentline, lazy { eventprops }) do |c, rest|
+          k = c.keys[0]
+          c[k][:value], errors1 = Typegrammars.typematch(strict, k, c[k][:params], :EVENT, c[k][:value], @ctx)
+          errors << errors1
+          c.merge(rest) do |key, old, new|
+            if @cardinality1[:EVENT].include?(key.upcase)
+              parse_err("Violated cardinality of property #{key}")
+            end
+            [old, new].flatten
+          end
+        end |
+        ("".r & beginend).map { {} }
+        alarmc = seq(/BEGIN:VALARM(\r|\n|\r\n)/i.r, alarmprops, /END:VALARM(\r|\n|\r\n)/i.r) do |_, e, _|
+          parse_err("Missing ACTION property") unless e.has_key?(:ACTION)
+          parse_err("Missing TRIGGER property") unless e.has_key?(:TRIGGER)
+          if e.has_key?(:DURATION) && !e.has_key?(:REPEAT) || !e.has_key?(:DURATION) && e.has_key?(:REPEAT)
+            parse_err("Missing DURATION && REPEAT properties")
+          end
+          if e[:ACTION] == "AUDIO"
+            parse_err("Multiple ATTACH properties") if e.has_key?(:ATTACH) && e[:ATTACH].is_a?(Array)
+            parse_err("Invalid DESCRIPTION property") if e.has_key?(:DESCRIPTION)
+            parse_err("Invalid SUMMARY property") if e.has_key?(:SUMMARY)
+            parse_err("Invalid ATTENDEE property") if e.has_key?(:ATTENDEE)
+          elsif e[:ACTION] == "DISP"
+            parse_err("Missing DESCRIPTION property") unless e.has_key?(:DESCRIPTION)
+            parse_err("Invalid ATTACH property") if e.has_key?(:ATTACH)
+            parse_err("Invalid SUMMARY property") if e.has_key?(:SUMMARY)
+            parse_err("Invalid ATTENDEE property") if e.has_key?(:ATTENDEE)
+          elsif e[:ACTION] == "EMAIL"
+            parse_err("Missing DESCRIPTION property") unless e.has_key?(:DESCRIPTION)
+          end
+          { VALARM: { component: [e] } }
+        end
+        freebusyc = seq(/BEGIN:VFREEBUSY(\r|\n|\r\n)/i.r, fbprops, /END:VFREEBUSY(\r|\n|\r\n)/i.r) do |_, e, _|
+          parse_err("Missing DTSTAMP property") unless e.has_key?(:DTSTAMP)
+          parse_err("Missing UID property") unless e.has_key?(:UID)
+          parse_err("DTEND before DTSTART") if e.has_key?(:DTEND) && e.has_key?(:DTSTART) &&
+            e[:DTEND][:value] < e[:DTSTART][:value]
+          { VFREEBUSY: { component: [e] } }
+        end
+        journalc = seq(/BEGIN:VJOURNAL(\r|\n|\r\n)/i.r, journalprops, /END:VJOURNAL(\r|\n|\r\n)/i.r) do |_, e, _|
+          parse_err("Missing DTSTAMP property") unless e.has_key?(:DTSTAMP)
+          parse_err("Missing UID property") unless e.has_key?(:UID)
+          parse_err("Missing DTSTART property with RRULE property") if e.has_key?(:RRULE) && !e.has_key?(:DTSTART)
+          { VJOURNAL: { component: [e] } }
+        end
+        timezonec = seq(/BEGIN:VTIMEZONE(\r|\n|\r\n)/i.r, timezoneprops, /END:VTIMEZONE(\r|\n|\r\n)/i.r) do |_, e, _|
+          parse_err("Missing STANDARD || DAYLIGHT property") unless e.has_key?(:STANDARD) || e.has_key?(:DAYLIGHT)
+          { VTIMEZONE: { component: [e] } }
+        end
+        todoc = seq(/BEGIN:VTODO(\r|\n|\r\n)/i.r, todoprops, alarmc.star, /END:VTODO(\r|\n|\r\n)/i.r) do |_, e, a, _|
+          parse_err("Missing DTSTAMP property") unless e.has_key?(:DTSTAMP)
+          parse_err("Missing UID property") unless e.has_key?(:UID)
+          parse_err("Coocurring DUE && DURATION properties") if e.has_key?(:DUE) && e.has_key?(:DURATION)
+          parse_err("Missing DTSTART property with DURATION property") if e.has_key?(:DURATION) && !e.has_key?(:DTSTART)
+          parse_err("Missing DTSTART property with RRULE property") if e.has_key?(:RRULE) && !e.has_key?(:DTSTART)
+          parse_err("DUE before DTSTART") if e.has_key?(:DUE) &&
+            e.has_key?(:DTSTART) &&
+            e[:DUE][:value] < e[:DTSTART][:value]
+          # TODO not doing constraint that due && dtstart are both || neither local time
+          # TODO not doing constraint that recurrence-id && dtstart are both || neither local time
+          # TODO not doing constraint that recurrence-id && dtstart are both || neither date
+          a.each do |x|
+            e = e.merge(x) { |_, old, new| { component: [old[:component], new[:component]].flatten } }
+          end
+          { VTODO: { component: [e] } }
+        end
+        eventc = seq(/BEGIN:VEVENT(\r|\n|\r\n)/i.r, eventprops, alarmc.star, /END:VEVENT(\r|\n|\r\n)/i.r) do |_, e, a, _|
+          parse_err("Missing DTSTAMP property") unless e.has_key?(:DTSTAMP)
+          parse_err("Missing UID property") unless e.has_key?(:UID)
+          parse_err("Coocurring DTEND && DURATION properties") if e.has_key?(:DTEND) && e.has_key?(:DURATION)
+          parse_err("Missing DTSTART property with RRULE property") if e.has_key?(:RRULE) && !e.has_key?(:DTSTART)
+          parse_err("DTEND before DTSTART") if e.has_key?(:DTEND) &&
+            e.has_key?(:DTSTART) &&
+            e[:DTEND][:value] < e[:DTSTART][:value]
+          # TODO not doing constraint that dtend && dtstart are both || neither local time
+          a.each do |x|
+            e = e.merge(x) { |_, old, new| { component: [old[:component], new[:component]].flatten } }
+          end
+          { VEVENT: { component: [e] } }
+        end
+        xcomp	= seq(/BEGIN:/i.r, C::XNAME_VCAL, /(\r|\n|\r\n)/i.r, props, /END:/i.r, C::XNAME_VCAL, /(\r|\n|\r\n)/i.r) do |_, n, _, p, _, n1, _|
+          n = n.upcase
+          n1 = n1.upcase
+          parse_err("Mismatch BEGIN:#{n}, END:#{n1}") if n != n1
+          { n1.to_sym => { component: [p] } }
+        end
+        ianacomp = seq(/BEGIN:/i.r ^ C::ICALPROPNAMES, C::IANATOKEN, /(\r|\n|\r\n)/i.r, props, /END:/i.r ^ C::ICALPROPNAMES, C::IANATOKEN, /(\r|\n|\r\n)/i.r) do |_, n, _, p, _, n1, _|
+          n = n.upcase
+          n1 = n1.upcase
+          parse_err("Mismatch BEGIN:#{n}, END:#{n1}") if n != n1
+          { n1.to_sym => { component: [p] } }
+        end
+        # RFC 7953
+        availableprops = seq(contentline, lazy { availableprops }) do |c, rest|
+          k = c.keys[0]
+          c[k][:value], errors1 = Typegrammars.typematch(strict, k, c[k][:params], :AVAILABLE, c[k][:value], @ctx)
+          errors << errors1
+          c.merge(rest) do |key, old, new|
+            if @cardinality1[:AVAILABLE].include?(key.upcase)
+              parse_err("Violated cardinality of property #{key}")
+            end
+            [old, new].flatten
+          end
+        end | ("".r & beginend).map { {} }
+        availablec = seq(/BEGIN:AVAILABLE(\r|\n|\r\n)/i.r, availableprops, /END:AVAILABLE(\r|\n|\r\n)/i.r) do |_, e, _|
+          # parse_err("Missing DTSTAMP property") unless e.has_key?(:DTSTAMP) # required in spec, but not in examples
+          parse_err("Missing DTSTART property") unless e.has_key?(:DTSTART)
+          parse_err("Missing UID property") unless e.has_key?(:UID)
+          parse_err("Coocurring DTEND && DURATION properties") if e.has_key?(:DTEND) && e.has_key?(:DURATION)
+          { AVAILABLE: { component: [e] } }
+        end
+        availabilityprops = seq(contentline, lazy { availabilityprops }) do |c, rest|
+          k = c.keys[0]
+          c[k][:value], errors1 = Typegrammars.typematch(strict, k, c[k][:params], :VAVAILABILITY, c[k][:value], @ctx)
+          errors << errors1
+          c.merge(rest) do |key, old, new|
+            if @cardinality1[:VAVAILABILITY].include?(key.upcase)
+              parse_err("Violated cardinality of property #{key}")
+            end
+            [old, new].flatten
+          end
+        end | ("".r & beginend).map { {} }
+        vavailabilityc = seq(/BEGIN:VAVAILABILITY(\r|\n|\r\n)/i.r, availabilityprops, availablec.star, /END:VAVAILABILITY(\r|\n|\r\n)/i.r) do |_, e, a, _|
+          parse_err("Missing DTSTAMP property") unless e.has_key?(:DTSTAMP)
+          parse_err("Missing UID property") unless e.has_key?(:UID)
+          parse_err("Coocurring DTEND && DURATION properties") if e.has_key?(:DTEND) && e.has_key?(:DURATION)
+          parse_err("Missing DTSTART property with DURATION property") if e.has_key?(:DURATION) && !e.has_key?(:DTSTART)
+          parse_err("DTEND before DTSTART") if e.has_key?(:DTEND) && e.has_key?(:DTSTART) && e[:DTEND][:value] < e[:DTSTART][:value]
+          # TODO not doing constraint that dtend && dtstart are both || neither local time
+          # TODO not doing constraint that each TZID param must have matching VTIMEZONE component
+          a.each do |x|
+            e = e.merge(x) { |_key, old, new| { component: [old[:component], new[:component]].flatten } }
+          end
+          { VAVAILABILITY: { component: [e] } }
+        end
+
+        component = eventc | todoc | journalc | freebusyc | timezonec | ianacomp | xcomp | vavailabilityc
+        components = seq(component, lazy { components }) do |c, r|
+          c.merge(r) do |_key, old, new|
+            { component: [old[:component], new[:component]].flatten }
+          end
+        end | component
+
+        calpropname = /CALSCALE/i.r | /METHOD/i.r | /PRODID/i.r | /VERSION/i.r |
+          /UID/i.r | /LAST-MOD/i.r | /URL/i.r | /REFRESH/i.r | /SOURCE/i.r | /COLOR/i.r | # RFC 7986
+          /NAME/i.r | /DESCRIPTION/i.r | /CATEGORIES/i.r | /IMAGE/i.r | # RFC 7986
+          C::XNAME_VCAL | C::IANATOKEN
+        calprop = seq(calpropname, params._? << ":".r, C::VALUE, /(\r|\n|\r\n)/) do |key, p, value, _|
+          key = key.upcase.tr("-", "_").to_sym
+          val, errors1 = Typegrammars.typematch(strict, key, p[0], :CALENDAR, value, @ctx)
+          errors << errors1
+          hash = { key => { value: val } }
+          errors << Paramcheck.paramcheck(strict, key, p.empty? ? {} : p[0], @ctx)
+          hash[key][:params] = p[0] unless p.empty?
+          hash
+          # TODO not doing constraint that each description must be in a different language
+        end
+        calprops = ("".r & beginend).map { {} } |
+          seq(calprop, lazy { calprops }) do |c, rest|
+          c.merge(rest) do |key, old, new|
+            if @cardinality1[:ICAL].include?(key.upcase)
+              parse_err("Violated cardinality of property #{key}")
+            end
+            [old, new].flatten
+          end
+        end
+        vobject = seq(/BEGIN:VCALENDAR(\r|\n|\r\n)/i.r, calprops, components, /END:VCALENDAR(\r|\n|\r\n)/i.r) do |_b, v, rest, _e|
+          parse_err("Missing PRODID attribute") unless v.has_key?(:PRODID)
+          parse_err("Missing VERSION attribute") unless v.has_key?(:VERSION)
+          rest.delete(:END)
+          if !v.has_key?(:METHOD) && rest.has_key?(:VEVENT)
+            rest[:VEVENT][:component].each do |e1|
+              parse_err("Missing DTSTART property from VEVENT component") if !e1.has_key?(:DTSTART)
+            end
+          end
+          tidyup(VCALENDAR: v.merge(rest), errors: errors.flatten)
+        end
+        vobject.eof
+    end
+
+    # any residual tidying of object
+    def tidyup(v)
+      # adjust any VTIMEZONE.{STANDARD|DAYLIGHT}.{DTSTART|RDATE} times from floating local to the time within the timezone component
+      if !v[:VCALENDAR].has_key?(:VTIMEZONE) || v[:VCALENDAR][:VTIMEZONE][:component].nil? || v[:VCALENDAR][:VTIMEZONE][:component].empty?
+        return v
+      elsif v[:VCALENDAR][:VTIMEZONE][:component].is_a?(Array)
+        v[:VCALENDAR][:VTIMEZONE][:component].map do |x|
+          timezoneadjust x
+        end
+      else
+        v[:VCALENDAR][:VTIMEZONE][:component] = timezoneadjust v[:VCALENDAR][:VTIMEZONE][:component]
+      end
+      v
+    end
+
+    def timezoneadjust(x)
+      if x[:TZID].nil? || x[:TZID].empty?
+        return x
+      end
+      # TODO deal with unregistered timezones
+      begin
+        tz = TZInfo::Timezone.get(x[:TZID][:value].value)
+      rescue
+        return x
+      end
+      [:STANDARD, :DAYLIGHT].each do |k|
+        next unless x.has_key?(k)
+        if x[k][:component].is_a?(Array)
+          x[k][:component].each do |y|
+            # subtracting an hour and a  minute to avoid PeriodNotFound exceptions on the boundary between daylight saving && standard time
+            # if that doesn't work either, we'll rescue to floating localtime
+            # ... no, I will treat STANDARD times as standard, and DAYLIGHT times as daylight savings
+            # TODO lookup offsets applicable by parsing dates && offsets in the ical. I'd rather not.
+            begin
+              y[:DTSTART][:value].value[:time] = tz.local_to_utc(y[:DTSTART][:value].value[:time] - 3660, true) + 3660
+            rescue
+              # nop
+             else
+              y[:DTSTART][:value].value[:zone] = x[:TZID][:value].value 
+            end
+            next unless y.has_key?(:RDATE)
+            if y[:RDATE].is_a?(Array)
+              y[:RDATE].each do |z|
+                z[:value].value.each do |w|
+                  begin
+                    w.value[:time] = tz.local_to_utc(w.value[:time] - 3660, true) + 3660
+                  rescue
+                    # nop
+                    else
+                    w.value[:zone] = x[:TZID][:value].value 
+                  end
+                end
+              end
+            else
+              begin
+                y[:RDATE][:value].value[:time] = tz.local_to_utc(y[:RDATE].value[:time] - 3660, true) + 3660
+              rescue
+                # nop
+               else
+                y[:RDATE][:value].value[:zone] = x[:TZID][:value].value
+              end
+            end
+          end
+        else
+          begin
+            x[k][:component][:DTSTART][:value].value[:time] = tz.local_to_utc(x[k][:component][:DTSTART][:value].value[:time] - 3660, true) + 3660
+          rescue
+            # nop
+            else
+            x[k][:component][:DTSTART][:value].value[:zone] = x[:TZID][:value].value
+          end
+          next unless x[k][:component].has_key?(:RDATE)
+          if x[k][:component][:RDATE].is_a?(Array)
+            x[k][:component][:RDATE].each do |z|
+              z[:value].value.each do |w|
+                begin
+                  w.value[:time] = tz.local_to_utc(w.value[:time] - 3660, true) + 3660
+                rescue
+                  # nop
+                else
+                  w.value[:zone] = x[:TZID][:value].value
+                end
+              end
+            end
+          else
+            begin
+              x[k][:component][:RDATE][:value].value[:time] = tz.local_to_utc(x[k][:component][:RDATE][:value].value[:time] - 3660, true) + 3660
+            rescue
+              # nop
+            else
+              x[k][:component][:RDATE][:value].value[:zone] = x[:TZID][:value].value
+            end
+          end
+        end
+      end
+      x
+    end
+
+    def initialize(strict)
+      self.strict = strict
+      self.errors = []
+    end
+
+    def parse(vobject)
+      @ctx = Rsec::ParseContext.new self.class.unfold(vobject), "source"
+      ret = vobject_grammar._parse @ctx
+      if !ret || Rsec::INVALID[ret]
+        parse_err(@ctx.generate_error("source"))
+        ret = { VCALENDAR: nil, errors: errors.flatten }
+      end
+      Rsec::Fail.reset
+      ret
+    end
+
+    private
+
+    def parse_err(msg)
+      if strict
+        raise @ctx.report_error msg, "source"
+      else
+        errors << @ctx.report_error(msg, "source")
+      end
+    end
+  end
+end