vobject 0.1.0 → 1.0.2

data/lib/vobject/vcard/v3_0/component.rb

@@ -0,0 +1,40 @@
+require "vobject/component"
+require "vobject/vcard/v3_0/property"
+require "vobject/vcard/v3_0/grammar"
+require "pp"
+
+module Vcard::V3_0
+  class Component < Vobject::Component
+    class << self
+      def parse(vcf, strict)
+        hash = Vcard::V3_0::Grammar.new(strict).parse(vcf)
+        comp_name = hash.keys.first
+        new comp_name, hash[comp_name], hash[:errors]
+      end
+
+      private
+
+      def raise_invalid_parsing
+        raise "vCard parse failed"
+      end
+    end
+
+    private
+
+    def property_base_class
+      version_class.const_get(:Property)
+    end
+
+    def component_base_class
+      version_class.const_get(:Component)
+    end
+
+    def parameter_base_class
+      version_class.const_get(:Parameter)
+    end
+
+    def version_class
+      Vcard::V3_0
+    end
+  end
+end

data/lib/vobject/vcard/v3_0/grammar.rb

@@ -0,0 +1,175 @@
+require "rsec"
+require "set"
+require "uri"
+require "date"
+include Rsec::Helpers
+require "vobject"
+require "vobject/component"
+require "vobject/vcard/v3_0/paramcheck"
+require "vobject/vcard/v3_0/typegrammars"
+require_relative "../../../c"
+require_relative "../../../error"
+
+module Vcard::V3_0
+  class Grammar
+    attr_accessor :strict, :errors
+    class << self
+      def unfold(str)
+        str.gsub(/[\n\r]+[ \t]/, "")
+      end
+    end
+
+    def vobject_grammar
+      # properties with value cardinality 1
+      @cardinality1 = {}
+      @cardinality1[:PARAM] = Set.new [:VALUE]
+      @cardinality1[:PROP] = Set.new [:KIND, :N, :BDAY, :ANNIVERSARY, :GENDER, :PRODID, :REV, :UID]
+
+      group = C::IANATOKEN
+      linegroup = group <<  "."
+      beginend = /BEGIN/i.r | /END/i.r
+
+      # parameters && parameter types
+      paramname = /ENCODING/i.r | /LANGUAGE/i.r | /CONTEXT/i.r | /TYPE/i.r | /VALUE/i.r | /PREF/i.r
+      otherparamname = C::NAME_VCARD ^ paramname
+      paramvalue = C::QUOTEDSTRING_VCARD.map { |s| s } | C::PTEXT_VCARD.map(&:upcase)
+
+      # prefvalue = /[0-9]{1,2}/i.r | "100".r
+      valuetype = /URI/i.r | /DATE/i.r | /DATE-TIME/i.r | /BINARY/i.r | /PTEXT/i.r
+      # mediaattr = /[!\"#$%&'*+.^A-Z0-9a-z_`i{}|~-]+/.r
+      # mediavalue1 =	mediaattr | C::QUOTEDSTRING_VCARD
+      # mediatail = seq(";".r >> mediaattr, "=".r << mediavalue1).map do |a, v|
+      #  ";#{a}=#{v}"
+      # end
+      # rfc4288regname = /[A-Za-z0-9!#$&.+^+-]{1,127}/.r
+      # rfc4288typename = rfc4288regname
+      # rfc4288subtypename = rfc4288regname
+      # mediavalue = seq(rfc4288typename << "/".r, rfc4288subtypename, # mediatail.star).map do |t, s, tail|
+      #  ret = "#{t}/#{s}"
+      #  ret = ret . tail[0] unless tail.empty?
+      #  ret
+      # end
+      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
+      typevaluelist = seq(C::IANATOKEN, ",".r >> lazy { typevaluelist }).map do |t, l|
+        [t.upcase, l].flatten
+      end | C::IANATOKEN.map { |t| [t.upcase] }
+      quoted_string_list = (seq(C::QUOTEDSTRING_VCARD << ",".r, lazy { quoted_string_list }) & /[;:]/.r).map do |e, list|
+        [e.sub(Regexp.new("^\"(.+)\"$"), '\1').gsub(/\\n/, "\n"), list].flatten
+      end | (C::QUOTEDSTRING_VCARD & /[;:]/.r).map do |e|
+        [e.sub(Regexp.new("^\"(.+)\"$"), '\1').gsub(/\\n/, "\n")]
+      end
+
+      # fmttypevalue = seq(rfc4288typename, "/", rfc4288subtypename).map(&:join)
+      rfc1766primarytag = /[A-Za-z]{1,8}/.r
+      rfc1766subtag = seq("-", /[A-Za-z]{1,8}/.r) { |a, b| a + b }
+      rfc1766language = seq(rfc1766primarytag, rfc1766subtag.star) do |a, b|
+        a += b[0] unless b.empty?
+        a
+      end
+
+      param = seq(/ENCODING/i.r, "=", /b/.r) do |name, _, val|
+        { name.upcase.tr("-", "_").to_sym => val }
+      end | seq(/LANGUAGE/i.r, "=", rfc1766language) do |name, _, val|
+        { name.upcase.tr("-", "_").to_sym => val.upcase }
+      end | seq(/CONTEXT/i.r, "=", /word/.r) do |name, _, val|
+        { name.upcase.tr("-", "_").to_sym => val.upcase }
+      end | seq(/TYPE/i.r, "=", typevaluelist) do |name, _, val|
+        { name.upcase.tr("-", "_").to_sym => val }
+      end | seq(/VALUE/i.r, "=", valuetype) do |name, _, val|
+        { name.upcase.tr("-", "_").to_sym => val }
+      end | /PREF/i.r.map do |_name|
+        # this is likely erroneous use of VCARD 2.1 convention in RFC2739; converting to canonical TYPE=PREF
+        { TYPE: ["PREF"] }
+      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_VCARD, params._? << ":".r,
+                        C::VALUE, /(\r|\n|\r\n)/) do |g, name, p, value, _|
+        key =  name.upcase.tr("-", "_").to_sym
+        hash = { key => {} }
+        hash[key][:value], errors1 = Typegrammars.typematch(strict, key, p[0], :GENERIC, value, @ctx)
+        errors << errors1
+        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 = seq(contentline, lazy { props }) do |c, rest|
+        c.merge(rest) do |key, old, new|
+          if @cardinality1[:PROP].include?(key.upcase)
+            parse_err("Violated cardinality of property #{key}")
+          end
+          [old, new].flatten
+          # deal with duplicate properties
+        end
+      end | ("".r & beginend).map { {} }
+
+      calpropname = /VERSION/i.r
+      calprop = seq(linegroup._?, calpropname << ":".r, C::VALUE, /[\r\n]/) do |g, key, value, _|
+        key = key.upcase.tr("-", "_").to_sym
+        hash = { key => {} }
+        hash[key][:value], errors1 = Typegrammars.typematch(strict, key, nil, :VCARD, value, @ctx)
+        errors << errors1
+        hash[key][:group] = g[0] unless g.empty?
+        hash
+      end
+      vobject = seq(linegroup._?, /BEGIN:VCARD[\r\n]/i.r >> calprop, props, linegroup._? << /END:VCARD[\r\n]/i.r) do |(_g, v, rest, _g1)|
+        # TODO what do we do with the groups here?
+        parse_err("Missing VERSION attribute") unless v.has_key?(:VERSION)
+        parse_err("Missing FN attribute") unless rest.has_key?(:FN)
+        parse_err("Missing N attribute") unless rest.has_key?(:N)
+        rest.delete(:END)
+        { VCARD: v.merge(rest), errors: errors.flatten }
+      end
+      vobject.eof
+    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]
+        if strict
+          raise @ctx.generate_error "source"
+        else
+          errors << @ctx.generate_error("source")
+          ret = { VCARD: nil, errors: errors.flatten }
+        end
+      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

data/lib/vobject/vcard/v3_0/paramcheck.rb

@@ -0,0 +1,110 @@
+require "rsec"
+require "set"
+require "uri"
+require "date"
+include Rsec::Helpers
+require "vobject"
+
+module Vcard::V3_0
+  class Paramcheck
+    class << self
+      def paramcheck(strict, prop, params, ctx)
+        errors = []
+        if params && params[:TYPE]
+          parse_err(strict, errors, "multiple values for :TYPE parameter of #{prop}", ctx) if params[:TYPE].is_a?(Array) && params[:TYPE].length > 1 && prop != :EMAIL && prop != :ADR && prop != :TEL && prop != :LABEL && prop != :IMPP
+        end
+        case prop
+        when :NAME, :PROFILE, :GEO, :PRODID, :URL, :VERSION, :CLASS
+          parse_err(strict, errors, "illegal parameters #{params} given for #{prop}", ctx) unless params.empty?
+        when :CALURI, :CAPURI, :CALADRURI, :FBURL
+          params.each do |key, val|
+            parse_err(strict, errors, "illegal parameter #{key} given for #{prop}", ctx) unless key == :TYPE
+            if params[:TYPE].is_a?(Array)
+              val.each do |v|
+                parse_err(strict, errors, "illegal parameter value #{v} given for parameter #{key} of #{prop}", ctx) unless v == "PREF"
+              end
+            else
+              parse_err(strict, errors, "illegal parameter value #{val} given for parameter #{key} of #{prop}", ctx) unless val == "PREF"
+            end
+          end
+        when :SOURCE
+          params.each do |key, val|
+            parse_err(strict, errors, "illegal parameter #{key} given for #{prop}", ctx) unless key == :VALUE || key == :CONTEXT || key =~ /^x/i
+            parse_err(strict, errors, "illegal value #{val} given for parameter #{key} of #{prop}", ctx) if key == :VALUE && val != "uri"
+            parse_err(strict, errors, "illegal value #{val} given for parameter #{key} of #{prop}", ctx) if key == :CONTEXT && val != "word"
+          end
+        when :FN, :N, :NICKNAME, :MAILER, :TITLE, :ROLE, :ORG, :CATEGORIES, :NOTE, :SORT_STRING
+          params.each do |key, val|
+            parse_err(strict, errors, "illegal parameter #{key} given for #{prop}", ctx) unless key == :VALUE || key == :LANGUAGE || key =~ /^x/i
+            parse_err(strict, errors, "illegal value #{val} given for parameter #{key} of #{prop}", ctx) if key == :VALUE && val != "ptext"
+          end
+        when :TEL, :IMPP, :UID
+          # UID included here per errata
+          params.each_key do |key|
+            parse_err(strict, errors, "illegal parameter #{key} given for #{prop}", ctx) unless key == :TYPE
+          end
+          # we do not check the values of the :TEL :TYPE parameter, because they include ianaToken
+        when :EMAIL
+          params.each_key do |key|
+            parse_err(strict, errors, "illegal parameter #{key} given for #{prop}", ctx) unless key == :TYPE
+          end
+          # we do not check the values of the first :EMAIL :TYPE parameter, because they include ianaToken
+        when :ADR, :LABEL
+          params.each do |key, val|
+            parse_err(strict, errors, "illegal parameter #{key} given for #{prop}", ctx) unless [:VALUE, :LANGUAGE, :TYPE].include? key || key =~ /^x/i
+            parse_err(strict, errors, "illegal value #{val} given for parameter #{key} of #{prop}", ctx) if key == :VALUE && val != "ptext"
+          end
+          # we do not check the values of the :ADR :TYPE parameter, because they include ianaToken
+        when :KEY
+          params.each do |key, val|
+            # VALUE included here per errata
+            parse_err(strict, errors, "illegal parameter #{key} given for #{prop}", ctx) unless [:TYPE, :ENCODING, :VALUE].include? key
+            parse_err(strict, errors, "illegal value #{val} given for parameter #{key} of #{prop}", ctx) if key == :VALUE && val != "binary"
+          end
+          # we do not check the values of the :KEY :TYPE parameter, because they include ianaToken
+        when :PHOTO, :LOGO, :SOUND
+          params.each_key do |key|
+            parse_err(strict, errors, "illegal parameter #{key} given for #{prop}", ctx) unless [:VALUE, :TYPE, :ENCODING].include? key
+          end
+          parse_err(strict, errors, "illegal value #{params[:VALUE]} of :VALUE given for #{prop}", ctx) if params[:VALUE] && params[:VALUE] != "binary" && params[:VALUE] != "uri"
+          parse_err(strict, errors, "illegal value #{params[:ENCODING]} of :ENCODING given for #{prop}", ctx) if params[:ENCODING] && (params[:ENCODING] != "b" || params[:VALUE] == "uri")
+          parse_err(strict, errors, "mandatory parameter of :ENCODING missing for #{prop}", ctx) if !params.has_key?(:ENCODING) && (!params.key?(:VALUE) || params[:VALUE] == "binary")
+          # TODO restriction of :TYPE to image types registered with IANA
+          # TODO restriction of :TYPE to sound types registered with IANA
+        when :BDAY, :REV
+          params.each_key do |key|
+            parse_err(strict, errors, "illegal parameter #{key} given for #{prop}", ctx) unless key == :VALUE
+          end
+          parse_err(strict, errors, "illegal value #{params[:VALUE]} of :VALUE given for #{prop}", ctx) if params[:VALUE] && params[:VALUE] != "date" && params[:VALUE] != "date-time"
+        when :AGENT
+          params.each_key do |key|
+            parse_err(strict, errors, "illegal parameter #{key} given for #{prop}", ctx) unless key == :VALUE
+          end
+          parse_err(strict, errors, "illegal value #{params[:VALUE]} of :VALUE given for #{prop}", ctx) if params[:VALUE] && params[:VALUE] != "uri"
+        when :TZ
+          # example in definition contradicts spec! Spec says :TZ takes no params at all
+          params.each_key do |key|
+            parse_err(strict, errors, "illegal parameter #{key} given for #{prop}", ctx) unless key == :VALUE
+          end
+          parse_err(strict, errors, "illegal value #{params[:VALUE]} of :VALUE given for #{prop}", ctx) if params[:VALUE] && params[:VALUE] != "text"
+        else
+          params.each_key do |key|
+            parse_err(strict, errors, "illegal parameter #{key} given for #{prop}", ctx) unless key == :VALUE || key == :LANGUAGE || key =~ /^x/i
+            parse_err(strict, errors, "illegal value #{val} given for parameter #{key} of #{prop}") if key == :VALUE && val != "ptext"
+          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/vcard/v3_0/parameter.rb

@@ -0,0 +1,17 @@
+require "vobject/parameter"
+
+module Vcard::V3_0
+  class Parameter < Vobject::Parameter
+    def parameter_base_class
+      version_class.const_get(:Parameter)
+    end
+
+    def property_base_class
+      version_class.const_get(:Property)
+    end
+
+    def version_class
+      Vcard::V3_0
+    end
+  end
+end

data/lib/vobject/vcard/v3_0/property.rb

@@ -0,0 +1,18 @@
+require "vobject/property"
+
+module Vcard::V3_0
+  class Property < Vobject::Property
+  end
+
+  def parameter_base_class
+    version_class.const_get(:Parameter)
+  end
+
+  def property_base_class
+    version_class.const_get(:Property)
+  end
+
+  def version_class
+    Vcard::V3_0
+  end
+end

data/lib/vobject/vcard/v3_0/propertyvalue.rb

@@ -0,0 +1,401 @@
+require "vobject"
+require "vobject/propertyvalue"
+
+module Vcard::V3_0
+  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
+
+        def listencode(x)
+          ret = if x.is_a?(Array)
+                  x.map { |m| Text.escape m }.join(",")
+                elsif x.nil? || x.empty?
+                  ""
+                else
+                  Text.escape x
+                end
+          ret
+        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 Profilevalue < Text
+      def initialize(val)
+        self.value = val
+        self.type = "profilevalue"
+      end
+
+      def to_hash
+        value
+      end
+    end
+
+    class Kindvalue < Text
+      def initialize(val)
+        self.value = val
+        self.type = "kindvalue"
+      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 Phonenumber < Text
+      def initialize(val)
+        self.value = val
+        self.type = "phonenumber"
+      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
+
+      def to_s
+        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
+      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 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].to_i, value[:month].to_i, value[:day].to_i)
+      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"
+        val[:sec] += (val[:secfrac].to_f / (10**val[:secfrac].length)) if !val[:secfrac].nil? && !val[:secfrac].empty?
+        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]
+        if val[:zone] && val[:zone] != "Z"
+          offset = val[:zone][:hour].to_i * 3600 + val[:zone][:min].to_i * 60
+          offset += val[:zone][:sec].to_i if val[:zone][:sec]
+          offset = -offset if val[:sign] == "-"
+          value[:time] += offset.to_i
+        end
+      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])
+        ret = ret + ",#{value[:secfrac]}" if value[:secfrac]
+        zone = "Z" if value[:zone] && value[:zone] == "Z"
+        zone = "#{value[:zone][:sign]}#{value[:zone][:hour]}:#{value[:zone][:min]}" if value[:zone] && value[:zone].is_a?(Hash)
+        ret = ret + zone
+        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 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 + ".#{value[:secfrac]}" if value[:secfrac]
+        zone = ""
+        zone = "Z" if value[:zone] && value[:zone] == "Z"
+        zone = "#{value[:zone][:sign]}#{value[:zone][:hour]}:#{value[:zone][:min]}" if value[:zone] && value[:zone].is_a?(Hash)
+        ret = ret + zone
+        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[:hour]}:#{value[:min]}"
+        # ret += self.value[:sec] if self.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
+      end
+
+      def to_hash
+        value
+      end
+    end
+
+    class Org < Vobject::PropertyValue
+      def initialize(val)
+        self.value = val
+        self.type = "org"
+      end
+
+      def to_s
+        value.map { |m| Text.escape m }.join(";")
+      end
+
+      def to_hash
+        value
+      end
+    end
+
+    class Fivepartname < Vobject::PropertyValue
+      def initialize(val)
+        self.value = val
+        self.type = "fivepartname"
+      end
+
+      def to_s
+        ret = Text.listencode value[:surname]
+        ret += ";#{Text.listencode value[:givenname]}" if !value[:givenname].empty? || !value[:middlename].empty? || !value[:honprefix].empty? || !value[:honsuffix].empty?
+        ret += ";#{Text.listencode value[:middlename]}" if !value[:middlename].empty? || !value[:honprefix].empty?
+        ret += ";#{Text.listencode value[:honprefix]}" if !value[:honprefix].empty? || !value[:honsuffix].empty?
+        ret += ";#{Text.listencode value[:honsuffix]}" if !value[:honsuffix].empty?
+        ret
+      end
+
+      def to_hash
+        value
+      end
+    end
+
+    class Address < Vobject::PropertyValue
+      def initialize(val)
+        self.value = val
+        self.type = "address"
+      end
+
+      def to_s
+        ret = Text.listencode value[:pobox]
+        ret += ";#{Text.listencode value[:ext]}" if !value[:ext].empty? || !value[:street].empty? || !value[:locality].empty? || !value[:region].empty? || !value[:code].empty? || !value[:country].empty?
+        ret += ";#{Text.listencode value[:street]}" if !value[:street].empty? || !value[:locality].empty? || !value[:region].empty? || !value[:code].empty? || !value[:country].empty?
+        ret += ";#{Text.listencode value[:locality]}" if !value[:locality].empty? || !value[:region].empty? || !value[:code].empty? || !value[:country].empty?
+        ret += ";#{Text.listencode value[:region]}" if !value[:region].empty? || !value[:code].empty? || !value[:country].empty?
+        ret += ";#{Text.listencode value[:code]}" if !value[:code].empty? || !value[:country].empty?
+        ret += ";#{Text.listencode value[:country]}" if !value[:country].empty?
+        ret
+      end
+
+      def to_hash
+        value
+      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 Agent < Vobject::PropertyValue
+      def initialize(val)
+        val[:VCARD].delete(:VERSION)
+        self.value = val
+        self.type = "agent"
+      end
+
+      def to_hash
+        ret = {}
+        value.each do |k, v|
+          ret[k] = {}
+          v.each do |k1, v1|
+            if v1.is_a?(Hash)
+              ret[k][k1] = {}
+              v1.each { |k2, v2| ret[k][k1][k2] = v2.to_hash }
+            else
+              ret[k][k1] = v1
+            end
+          end
+        end
+        ret
+      end
+
+      def to_s
+        ret = Vobject::Component.new(:VCARD, value[:VCARD], []).to_s
+        # spec says that colons must be expected, but none of the examples do
+        ret.gsub(/\n/, "\\n").gsub(/,/, "\\,").gsub(/;/, "\\;")
+        # ret.gsub(/\n/,"\\n").gsub(/:/,"\\:")
+      end
+    end
+  end
+end