ruby-vobject 0.1.0 → 1.0.1

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

@@ -0,0 +1,426 @@
+require "rsec"
+require "set"
+require "uri"
+require "date"
+include Rsec::Helpers
+require "vobject/vcard/version"
+require "vobject"
+require_relative "./propertyvalue"
+
+module Vcard::V3_0
+  class Typegrammars
+    class << self
+      # property value types, each defining their own parser
+
+      def binary
+        binary = seq(/[a-zA-Z0-9+\/]*/.r, /={0,2}/.r) do |b, q|
+          if (b.length + q.length) % 4 == 0
+            PropertyValue::Binary.new(b + q)
+          else
+            { error: "Malformed binary coding" }
+          end
+        end
+        binary.eof
+      end
+
+      def phone_number
+        # This is on the lax side; there should be up to 15 digits
+        # Will allow letters
+        phone_number = /[0-9() +A-Z-]+/i.r.map { |p| PropertyValue::Phonenumber.new p }
+        phone_number.eof
+      end
+
+      def geovalue
+        float = prim(:double)
+        geovalue = seq(float << ";".r, float) do |a, b|
+          if a <= 180.0 && a >= -180.0 && b <= 180 && b > -180
+            PropertyValue::Geovalue.new(lat: a, long: b)
+          else
+            { error: "Latitude/Longitude outside of range -180..180" }
+          end
+        end
+        geovalue.eof
+      end
+
+      def classvalue
+        iana_token = /[a-zA-Z\d\-]+/.r
+        xname = seq(/[xX]-/, /[a-zA-Z0-9-]+/.r).map(&:join)
+        classvalue = (/PUBLIC/i.r | /PRIVATE/i.r | /CONFIDENTIAL/i.r | iana_token | xname).map do |m|
+          PropertyValue::ClassValue.new m
+        end
+        classvalue.eof
+      end
+
+      def integer
+        integer = prim(:int32).map { |i| PropertyValue::Integer.new i }
+        integer.eof
+      end
+
+      def float_t
+        float_t = prim(:double).map { |f| PropertyValue::Float.new f }
+        float_t.eof
+      end
+
+      def iana_token
+        iana_token = /[a-zA-Z\d\-]+/.r.map { |x| PropertyValue::Ianatoken.new x }
+        iana_token.eof
+      end
+
+      def versionvalue
+        versionvalue = "3.0".r.map { |v| PropertyValue::Version.new v }
+        versionvalue.eof
+      end
+
+      def profilevalue
+        profilevalue = /VCARD/i.r.map { |v| PropertyValue::Profilevalue.new v }
+        profilevalue.eof
+      end
+
+      def uri
+        uri    = /\S+/.r.map do |s|
+          if s =~ URI::DEFAULT_PARSER.make_regexp
+            PropertyValue::Uri.new(s)
+          else
+            { error: "Invalid URI" }
+          end
+        end
+        uri.eof
+      end
+
+      def text_t
+        text_t = C::TEXT3.map { |t| PropertyValue::Text.new(unescape(t)) }
+        text_t.eof
+      end
+
+      def textlist
+        text = C::TEXT3
+        textlist1 =
+          seq(text << ",".r, lazy { textlist1 }) { |a, b| [unescape(a), b].flatten } |
+          text.map { |t| [unescape(t)] }
+        textlist = textlist1.map { |m| PropertyValue::Textlist.new m }
+        textlist.eof
+      end
+
+      def org
+        text = C::TEXT3
+        org1 =
+          seq(text << ";".r, lazy { org1 }) { |a, b| [unescape(a), b].flatten } |
+          text.map { |t| [unescape(t)] }
+        org	 = org1.map { |o| PropertyValue::Org.new o }
+        org.eof
+      end
+
+      def date_t
+        date_t = seq(/[0-9]{4}/.r, /-/.r._? >> /[0-9]{2}/.r, /-/.r._? >> /[0-9]{2}/.r) do |yy, mm, dd|
+          PropertyValue::Date.new(year: yy, month: mm, day: dd)
+        end
+        date_t.eof
+      end
+
+      def time_t
+        utc_offset = seq(C::SIGN, /[0-9]{2}/.r << /:/.r._?, /[0-9]{2}/.r) do |s, h, m|
+          { sign: s, hour: h, min: m }
+        end
+        zone = utc_offset.map { |u| u } |
+          /Z/i.r.map { "Z" }
+        hour = /[0-9]{2}/.r
+        minute = /[0-9]{2}/.r
+        second = /[0-9]{2}/.r
+        secfrac = seq(",".r >> /[0-9]+/)
+        time_t = seq(hour << /:/._?, minute << /:/._?, second, secfrac._?, zone._?) do |h, m, s, f, z|
+          h = { hour: h, min: m, sec: s }
+          h[:zone] = z[0] unless z.empty?
+          h[:secfrac] = f[0] unless f.empty?
+          PropertyValue::Time.new(h)
+        end
+        time_t.eof
+      end
+
+      def date_time
+        utc_offset = seq(C::SIGN, /[0-9]{2}/.r << /:/.r._?, /[0-9]{2}/.r) do |s, h, m|
+          { sign: s, hour: h, min: m }
+        end
+        zone = utc_offset.map { |u| u } |
+          /Z/i.r.map { "Z" }
+        hour = /[0-9]{2}/.r
+        minute = /[0-9]{2}/.r
+        second = /[0-9]{2}/.r
+        secfrac = seq(",".r >> /[0-9]+/)
+        date = seq(/[0-9]{4}/.r, /-/.r._?, /[0-9]{2}/.r, /-/.r._?, /[0-9]{2}/.r) do |yy, _, mm, _, dd|
+          { year: yy, month: mm, day: dd }
+        end
+        time = seq(hour << /:/.r._?, minute << /:/.r._?, second, secfrac._?, zone._?) do |h, m, s, f, z|
+          h = { hour: h, min: m, sec: s }
+          h[:zone] = if z.empty?
+                       ""
+                     else
+                       z[0]
+                     end
+          h[:secfrac] = f[0] unless f.empty?
+          h
+        end
+        date_time = seq(date << "T".r, time) do |d, t|
+          PropertyValue::DateTimeLocal.new(d.merge(t))
+        end
+        date_time.eof
+      end
+
+      def date_or_date_time
+        utc_offset = seq(C::SIGN, /[0-9]{2}/.r << /:/.r._?, /[0-9]{2}/.r) do |s, h, m|
+          { sign: s, hour: h, min: m }
+        end
+        zone = utc_offset.map { |u| u } |
+          /Z/i.r.map { "Z" }
+        hour = /[0-9]{2}/.r
+        minute = /[0-9]{2}/.r
+        second = /[0-9]{2}/.r
+        secfrac = seq(",".r >> /[0-9]+/)
+        date = seq(/[0-9]{4}/.r << /-/.r._?, /[0-9]{2}/.r << /-/.r._?, /[0-9]{2}/.r) do |yy, mm, dd|
+          { year: yy, month: mm, day: dd }
+        end
+        time = seq(hour << /:/.r._?, minute << /:/.r._?, second, secfrac._?, zone._?) do |h, m, s, f, z|
+          h = { hour: h, min: m, sec: s }
+          h[:zone] = z[0] unless z.empty?
+          h[:secfrac] = f[0] unless f.empty?
+          h
+        end
+        date_or_date_time = seq(date << "T".r, time) do |d, t|
+          PropertyValue::DateTimeLocal.new(d.merge(t))
+        end | date.map { |d| PropertyValue::Date.new(d) }
+        date_or_date_time.eof
+      end
+
+      def utc_offset
+        utc_offset = seq(C::SIGN, /[0-9]{2}/.r, /:/.r._?, /[0-9]{2}/.r) do |s, h, _, m|
+          PropertyValue::Utcoffset.new(sign: s, hour: h, min: m)
+        end
+        utc_offset.eof
+      end
+
+      def kindvalue
+        iana_token = /[a-zA-Z\d\-]+/.r
+        xname = seq(/[xX]-/, /[a-zA-Z0-9-]+/.r).map(&:join)
+        kindvalue = (/individual/i.r | /group/i.r | /org/i.r | /location/i.r |
+                     iana_token | xname).map do |k|
+          PropertyValue::Kindvalue.new(k)
+        end
+        kindvalue.eof
+      end
+
+      def fivepartname
+        text = C::TEXT3
+        component = seq(text << ",".r, lazy { component }) do |a, b|
+          [unescape(a), b].flatten
+        end | text.map { |t| [unescape(t)] }
+        fivepartname1 = seq(component << ";".r, component << ";".r, component << ";".r,
+                            component << ";".r, component) do |a, b, c, d, e|
+          a = a[0] if a.length == 1
+          b = b[0] if b.length == 1
+          c = c[0] if c.length == 1
+          d = d[0] if d.length == 1
+          e = e[0] if e.length == 1
+          { surname: a, givenname: b, middlename: c, honprefix: d, honsuffix: e }
+        end | seq(component << ";".r, component << ";".r, component << ";".r, component) do |a, b, c, d|
+          a = a[0] if a.length == 1
+          b = b[0] if b.length == 1
+          c = c[0] if c.length == 1
+          d = d[0] if d.length == 1
+          { surname: a, givenname: b, middlename: c, honprefix: d, honsuffix: "" }
+        end | seq(component << ";".r, component << ";".r, component) do |a, b, c|
+          a = a[0] if a.length == 1
+          b = b[0] if b.length == 1
+          c = c[0] if c.length == 1
+          { surname: a, givenname: b, middlename: c, honprefix: "", honsuffix: "" }
+        end | seq(component << ";".r, component) do |a, b|
+          a = a[0] if a.length == 1
+          b = b[0] if b.length == 1
+          { surname: a, givenname: b, middlename: "", honprefix: "", honsuffix: "" }
+        end | component.map do |a|
+          a = a[0] if a.length == 1
+          { surname: a, givenname: "", middlename: "", honprefix: "", honsuffix: "" }
+        end
+        fivepartname = fivepartname1.map { |n| PropertyValue::Fivepartname.new(n) }
+        fivepartname.eof
+      end
+
+      def address
+        text = C::TEXT3
+        component = seq(text << ",".r, lazy { component }) do |a, b|
+          [unescape(a), b].flatten
+        end | text.map { |t| [unescape(t)] }
+        address1 = seq(component << ";".r, component << ";".r, component << ";".r, component << ";".r,
+                       component << ";".r, component << ";".r, component) do |a, b, c, d, e, f, g|
+          a = a[0] if a.length == 1
+          b = b[0] if b.length == 1
+          c = c[0] if c.length == 1
+          d = d[0] if d.length == 1
+          e = e[0] if e.length == 1
+          f = f[0] if f.length == 1
+          g = g[0] if g.length == 1
+          { pobox: a, ext: b, street: c,
+            locality: d, region: e, code: f, country: g }
+        end | seq(component << ";".r, component << ";".r, component << ";".r, component << ";".r,
+                  component << ";".r, component) do |a, b, c, d, e, f|
+          a = a[0] if a.length == 1
+          b = b[0] if b.length == 1
+          c = c[0] if c.length == 1
+          d = d[0] if d.length == 1
+          e = e[0] if e.length == 1
+          f = f[0] if f.length == 1
+          { pobox: a, ext: b, street: c,
+            locality: d, region: e, code: f, country: "" }
+        end | seq(component << ";".r, component << ";".r, component << ";".r,
+                  component << ";".r, component) do |a, b, c, d, e|
+          a = a[0] if a.length == 1
+          b = b[0] if b.length == 1
+          c = c[0] if c.length == 1
+          d = d[0] if d.length == 1
+          e = e[0] if e.length == 1
+          { pobox: a, ext: b, street: c,
+            locality: d, region: e, code: "", country: "" }
+        end | seq(component << ";".r, component << ";".r, component << ";".r, component) do |a, b, c, d|
+          a = a[0] if a.length == 1
+          b = b[0] if b.length == 1
+          c = c[0] if c.length == 1
+          d = d[0] if d.length == 1
+          { pobox: a, ext: b, street: c,
+            locality: d, region: "", code: "", country: "" }
+        end | seq(component << ";".r, component << ";".r, component) do |a, b, c|
+          a = a[0] if a.length == 1
+          b = b[0] if b.length == 1
+          c = c[0] if c.length == 1
+          { pobox: a, ext: b, street: c,
+            locality: "", region: "", code: "", country: "" }
+        end | seq(component << ";".r, component) do |a, b|
+          a = a[0] if a.length == 1
+          b = b[0] if b.length == 1
+          { pobox: a, ext: b, street: "",
+            locality: "", region: "", code: "", country: "" }
+        end | component.map do |a|
+          a = a[0] if a.length == 1
+          { pobox: a, ext: "", street: "",
+            locality: "", region: "", code: "", country: "" }
+        end
+        address = address1.map { |n| PropertyValue::Address.new(n) }
+        address.eof
+      end
+
+      def registered_propname
+        registered_propname = C::NAME_VCARD
+        registered_propname.eof
+      end
+
+      def registered_propname?(x)
+        p = registered_propname.parse(x)
+        not(Rsec::INVALID[p])
+      end
+
+      # text escapes: \\ \; \, \N \n
+      def unescape(x)
+        # temporarily escape \\ as \007f, which is disallowed in any text
+        x.gsub(/\\\\/, "\u007f").gsub(/\\;/, ";").gsub(/\\,/, ",").gsub(/\\[Nn]/, "\n").tr("\u007f", "\\")
+      end
+
+      # Enforce type restrictions on values of particular properties.
+      # If successful, return typed interpretation of string
+      def typematch(strict, key, params, _component, value, ctx)
+        errors = []
+        params[:VALUE] = params[:VALUE].downcase if params && params[:VALUE]
+        ctx1 = Rsec::ParseContext.new value, "source"
+        case key
+        when :VERSION
+          ret = versionvalue._parse ctx1
+        when :SOURCE, :URL, :IMPP, :FBURL, :CALURI, :CALADRURI, :CAPURI
+          ret = uri._parse ctx1
+          # not imposing filename restrictions on calendar URIs
+        when :NAME, :FN, :LABEL, :EMAIL, :MAILER, :TITLE, :ROLE, :NOTE, :PRODID, :SORT_STRING, :UID
+          ret = text_t._parse ctx1
+        when :CLASS
+          ret = classvalue._parse ctx1
+        when :CATEGORIES, :NICKNAME
+          ret = textlist._parse ctx1
+        when :ORG
+          ret = org._parse ctx1
+        when :PROFILE
+          ret = profilevalue._parse ctx1
+        when :N
+          ret = fivepartname._parse ctx1
+        when :PHOTO, :LOGO, :SOUND
+          ret = if params && params[:VALUE] == "uri"
+                  uri._parse ctx1
+                else
+                  binary._parse ctx1
+                end
+        when :KEY
+          ret = if params && params[:ENCODING] == "b"
+                  binary._parse ctx1
+                else
+                  text_t._parse ctx1
+                end
+        when :BDAY
+          ret = if params && params[:VALUE] == "date-time"
+                  date_time._parse ctx1
+                elsif params && params[:VALUE] == "date"
+                  date_t._parse ctx1
+                else
+                  # unlike VCARD 4, can have either date || date_time without explicit value switch
+                  date_or_date_time._parse ctx1
+                end
+        when :REV
+          ret = if params && params[:VALUE] == "date"
+                  date_t._parse ctx1
+                elsif params && params[:VALUE] == "date-time"
+                  date_time._parse ctx1
+                else
+                  # unlike VCARD 4, can have either date || date_time without explicit value switch
+                  ret = date_or_date_time._parse ctx1
+                end
+        when :ADR
+          ret = address._parse ctx1
+        when :TEL
+          ret = phone_number._parse ctx1
+        when :TZ
+          ret = if params && params[:VALUE] == "text"
+                  text_t._parse ctx1
+                else
+                  utc_offset._parse ctx1
+                end
+        when :GEO
+          ret = geovalue._parse ctx1
+        when :AGENT
+          if params && params[:VALUE] == "uri"
+            ret = uri._parse ctx1
+          else
+            # unescape
+            value = value.gsub(/\\n/, "\n").gsub(/\\;/, ";").gsub(/\\,/, ",").gsub(/\\:/, ":")
+            # spec says that colons need to be escaped, but none of the examples do so
+            value = value.gsub(/BEGIN:VCARD\n/, "BEGIN:VCARD\nVERSION:3.0\n") unless value =~ /\nVERSION:3\.0/
+            ctx1 = Rsec::ParseContext.new value, "source"
+            ret = PropertyValue::Agent.new(Grammar.new(strict).vobject_grammar._parse(ctx1))
+            # TODO same strictness as grammar
+          end
+        else
+          ret = text_t._parse ctx1
+        end
+        if ret.is_a?(Hash) && ret[:error]
+          parse_err(strict, errors, "#{ret[:error]} for property #{key}, value #{value}", ctx)
+        end
+        if Rsec::INVALID[ret]
+          parse_err(strict, errors, "Type mismatch for property #{key}, value #{value}", ctx)
+        end
+        Rsec::Fail.reset
+        [ret, 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/v4_0/component.rb

@@ -0,0 +1,40 @@
+require "vobject/component"
+require "vobject/vcard/v4_0/property"
+require "vobject/vcard/v4_0/grammar"
+require "pp"
+
+module Vcard::V4_0
+  class Component < Vobject::Component
+    class << self
+      def parse(vcf, strict)
+        hash = Vcard::V4_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::V4_0
+    end
+  end
+end