vcard 0.2.1 → 0.2.2

data/lib/vcard.rb

@@ -54,7 +54,7 @@ module Vcard
 
   # Convert a RFC 2425 date into an array of [year, month, day].
   def self.decode_date(v) # :nodoc:
-    unless v =~ %r{^\s*#{Bnf::DATE}\s*$}
+    if !(v =~ Bnf::DATE)
       raise ::Vcard::InvalidEncodingError, "date not valid (#{v})"
     end
     [$1.to_i, $2.to_i, $3.to_i]
@@ -85,7 +85,7 @@ module Vcard
 
   # Convert a RFC 2425 time into an array of [hour,min,sec,secfrac,timezone]
   def self.decode_time(v) # :nodoc:
-    unless match = %r{^\s*#{Bnf::TIME}\s*$}.match(v)
+    if !(match = Bnf::TIME.match(v))
       raise ::Vcard::InvalidEncodingError, "time '#{v}' not valid"
     end
     hour, min, sec, secfrac, tz = match.to_a[1..5]
@@ -94,13 +94,11 @@ module Vcard
   end
 
   def self.array_datetime_to_time(dtarray) #:nodoc:
-    # We get [ year, month, day, hour, min, sec, usec, tz ]
-    begin
-      tz = (dtarray.pop == "Z") ? :gm : :local
-      Time.send(tz, *dtarray)
-    rescue ArgumentError => e
-      raise ::Vcard::InvalidEncodingError, "#{tz} #{e} (#{dtarray.join(', ')})"
-    end
+  # We get [ year, month, day, hour, min, sec, usec, tz ]
+    tz = (dtarray.pop == "Z") ? :gm : :local
+    Time.send(tz, *dtarray)
+  rescue ArgumentError => e
+    raise ::Vcard::InvalidEncodingError, "#{tz} #{e} (#{dtarray.join(', ')})"
   end
 
   # Convert a RFC 2425 time into an array of Time objects.
@@ -110,7 +108,7 @@ module Vcard
 
   # Convert a RFC 2425 date-time into an array of [year,mon,day,hour,min,sec,secfrac,timezone]
   def self.decode_date_time(v) # :nodoc:
-    unless match = %r{^\s*#{Bnf::DATE}T#{Bnf::TIME}\s*$}.match(v)
+    if !(match = Bnf::DATE_TIME.match(v))
       raise ::Vcard::InvalidEncodingError, "date-time '#{v}' not valid"
     end
     year, month, day, hour, min, sec, secfrac, tz = match.to_a[1..8]
@@ -137,7 +135,7 @@ module Vcard
 
   # Convert an RFC2425 INTEGER value into an Integer
   def self.decode_integer(v) # :nodoc:
-    unless %r{\s*#{Bnf::INTEGER}\s*}.match(v)
+    if !(v =~ Bnf::INTEGER)
       raise ::Vcard::InvalidEncodingError, "integer not valid (#{v})"
     end
     v.to_i
@@ -227,8 +225,7 @@ module Vcard
   # paramtext  = *SAFE-CHAR
   # quoted-string      = DQUOTE *QSAFE-CHAR DQUOTE
   def self.encode_paramtext(value)
-    case value
-    when %r{\A#{Bnf::SAFECHAR}*\z}
+    if value =~ Bnf::ALL_SAFECHARS
       value
     else
       raise ::Vcard::Unencodable, "paramtext #{value.inspect}"
@@ -236,17 +233,15 @@ module Vcard
   end
 
   def self.encode_paramvalue(value)
-    case value
-    when %r{\A#{Bnf::SAFECHAR}*\z}
+    if value =~ Bnf::ALL_SAFECHARS
       value
-    when %r{\A#{Bnf::QSAFECHAR}*\z}
+    elsif value =~ Bnf::ALL_QSAFECHARS
       '"' + value + '"'
     else
       raise ::Vcard::Unencodable, "param-value #{value.inspect}"
     end
   end
 
-
   # Unfold the lines in +card+, then return an array of one Field object per
   # line.
   def self.decode(card) #:nodoc:

data/lib/vcard/bnf.rb

@@ -5,43 +5,41 @@
 # VPIM-LICENSE.txt for details.
 
 module Vcard
-  # Contains regular expression strings for the EBNF of RFC 2425.
+  # Contains regular expressions for the EBNF of RFC 2425.
   module Bnf #:nodoc:
 
     # 1*(ALPHA / DIGIT / "-")
-    # Note: I think I can add A-Z here, and get rid of the "i" matches elsewhere.
-    # Note: added "_" to allowed because its produced by Notes  (X-LOTUS-CHILD_UID:)
-    # Note: added "/" to allowed because its produced by KAddressBook (X-messaging/xmpp-All:)
-    # Note: added " " to allowed because its produced by highrisehq.com (X-GOOGLE TALK:)
-    NAME    = "[-a-z0-9_/][-a-z0-9_/ ]*"
+    # Note: "_" allowed because produced by Notes  (X-LOTUS-CHILD_UID:)
+    # Note: "/" allowed because produced by KAddressBook (X-messaging/xmpp-All:)
+    # Note: " " allowed because produced by highrisehq.com (X-GOOGLE TALK:)
+    NAME    = /[\w\/-][ \w\/-]*/
 
     # <"> <Any character except CTLs, DQUOTE> <">
-    QSTR    = '"([^"]*)"'
+    QSTR    = /"([^"]*)"/
 
     # *<Any character except CTLs, DQUOTE, ";", ":", ",">
-    PTEXT   = '([^";:,]+)'
+    PTEXT   = /([^";:,]+)/
 
     # param-value = ptext / quoted-string
-    PVALUE  = "(?:#{QSTR}|#{PTEXT})"
+    PVALUE  = /(?:#{QSTR}|#{PTEXT})/
 
     # param = name "=" param-value *("," param-value)
     # Note: v2.1 allows a type or encoding param-value to appear without the type=
     # or the encoding=. This is hideous, but we try and support it, if there
     # is no "=", then $2 will be "", and we will treat it as a v2.1 param.
-    PARAM = ";(#{NAME})(=?)((?:#{PVALUE})?(?:,#{PVALUE})*)"
+    PARAM = /;(#{NAME})(=?)((?:#{PVALUE})?(?:,#{PVALUE})*)/
 
     # V3.0: contentline  =   [group "."]  name *(";" param) ":" value
     # V2.1: contentline  = *( group "." ) name *(";" param) ":" value
-    #
     # We accept the V2.1 syntax for backwards compatibility.
-    #LINE = "((?:#{NAME}\\.)*)?(#{NAME})([^:]*)\:(.*)"
-    LINE = "^((?:#{NAME}\\.)*)?(#{NAME})((?:#{PARAM})*):(.*)$"
+    LINE = /\A((?:#{NAME}\.)*)?(#{NAME})((?:#{PARAM})*):(.*)\z/
 
     # date = date-fullyear ["-"] date-month ["-"] date-mday
     # date-fullyear = 4 DIGIT
     # date-month = 2 DIGIT
     # date-mday = 2 DIGIT
-    DATE = "(\d\d\d\d)-?(\d\d)-?(\d\d)"
+    DATE_PARTIAL = /(\d\d\d\d)-?(\d\d)-?(\d\d)/
+    DATE = /\A\s*#{DATE_PARTIAL}\s*\z/
 
     # time = time-hour [":"] time-minute [":"] time-second [time-secfrac] [time-zone]
     # time-hour = 2 DIGIT
@@ -50,17 +48,23 @@ module Vcard
     # time-secfrac = "," 1*DIGIT
     # time-zone = "Z" / time-numzone
     # time-numzone = sign time-hour [":"] time-minute
-    TIME = "(\d\d):?(\d\d):?(\d\d)(\.\d+)?(Z|[-+]\d\d:?\d\d)?"
+    TIME_PARTIAL = /(\d\d):?(\d\d):?(\d\d)(\.\d+)?(Z|[-+]\d\d:?\d\d)?/
+    TIME = /\A\s*#{TIME_PARTIAL}\s*\z/
+
+    # date-time = date "T" time
+    DATE_TIME = /\A\s*#{DATE_PARTIAL}T#{TIME_PARTIAL}\s*\z/
 
     # integer = (["+"] / "-") 1*DIGIT
-    INTEGER = "[-+]?\d+"
+    INTEGER = /\A\s*[-+]?\d+\s*\z/
 
     # QSAFE-CHAR = WSP / %x21 / %x23-7E / NON-US-ASCII
     #  ; Any character except CTLs and DQUOTE
-    QSAFECHAR = "[ \t\x21\x23-\x7e\x80-\xff]"
+    QSAFECHAR = /[ \t\x21\x23-\x7e\x80-\xff]/
+    ALL_QSAFECHARS = /\A#{QSAFECHAR}*\z/
 
     # SAFE-CHAR  = WSP / %x21 / %x23-2B / %x2D-39 / %x3C-7E / NON-US-ASCII
     #   ; Any character except CTLs, DQUOTE, ";", ":", ","
-    SAFECHAR = "[ \t\x21\x23-\x2b\x2d-\x39\x3c-\x7e\x80-\xff]"
+    SAFECHAR = /[ \t\x21\x23-\x2b\x2d-\x39\x3c-\x7e\x80-\xff]/
+    ALL_SAFECHARS = /\A#{SAFECHAR}*\z/
   end
 end

data/lib/vcard/field.rb

@@ -100,7 +100,7 @@ module Vcard
 
       # Decode a field.
       def Field.decode0(atline) # :nodoc:
-        unless atline =~ %r{#{Bnf::LINE}}i
+        if !(atline =~ Bnf::LINE)
           raise ::Vcard::InvalidEncodingError, atline
         end
 
@@ -126,7 +126,7 @@ module Vcard
         if paramslist.size > 1
 
           # v3.0 and v2.1 params
-          paramslist.scan( %r{#{Bnf::PARAM}}i ) do
+          paramslist.scan( Bnf::PARAM ) do
 
             # param names are case-insensitive, and multi-valued
             name = $1.upcase
@@ -156,7 +156,7 @@ module Vcard
               atparams[name] = []
             end
 
-            params.scan( %r{#{Bnf::PVALUE}} ) do
+            params.scan( Bnf::PVALUE ) do
               atparams[name] << ($1 || $2)
             end
           end
@@ -407,7 +407,7 @@ module Vcard
         v = param("VALUE")
         if v
           if v.size > 1
-            raise InvalidEncodingError, "multi-valued param 'VALUE' (#{values})"
+            raise ::Vcard::InvalidEncodingError, "multi-valued param 'VALUE' (#{values})"
           end
           v = v.first.downcase
         end
@@ -427,27 +427,25 @@ module Vcard
       # saying what the year is that breaks, so they at least know that
       # its ridiculous! I think I need my own DateTime variant.
       def to_time
-        begin
-          ::Vcard.decode_date_time_list(value).collect do |d|
-            # We get [ year, month, day, hour, min, sec, usec, tz ]
-            begin
-              if(d.pop == "Z")
-                Time.gm(*d)
-              else
-                Time.local(*d)
-              end
-            rescue ArgumentError => e
-              raise ::Vcard::InvalidEncodingError, "Time.gm(#{d.join(', ')}) failed with #{e.message}"
-            end
-          end
-        rescue ::Vcard::InvalidEncodingError
-          ::Vcard.decode_date_list(value).collect do |d|
-            # We get [ year, month, day ]
-            begin
+        ::Vcard.decode_date_time_list(value).collect do |d|
+          # We get [ year, month, day, hour, min, sec, usec, tz ]
+          begin
+            if(d.pop == "Z")
               Time.gm(*d)
-            rescue ArgumentError => e
-              raise ::Vcard::InvalidEncodingError, "Time.gm(#{d.join(', ')}) failed with #{e.message}"
+            else
+              Time.local(*d)
             end
+          rescue ArgumentError => e
+            raise ::Vcard::InvalidEncodingError, "Time.gm(#{d.join(', ')}) failed with #{e.message}"
+          end
+        end
+      rescue ::Vcard::InvalidEncodingError
+        ::Vcard.decode_date_list(value).collect do |d|
+          # We get [ year, month, day ]
+          begin
+            Time.gm(*d)
+          rescue ArgumentError => e
+            raise ::Vcard::InvalidEncodingError, "Time.gm(#{d.join(', ')}) failed with #{e.message}"
           end
         end
       end
@@ -460,16 +458,14 @@ module Vcard
       # decoding is tried first as a DATE-TIME, then as a DATE, if neither
       # works an InvalidEncodingError will be raised.
       def to_date
-        begin
-          ::Vcard.decode_date_time_list(value).collect do |d|
-            # We get [ year, month, day, hour, min, sec, usec, tz ]
-            Date.new(d[0], d[1], d[2])
-          end
-        rescue ::Vcard::InvalidEncodingError
-          ::Vcard.decode_date_list(value).collect do |d|
-            # We get [ year, month, day ]
-            Date.new(*d)
-          end
+        ::Vcard.decode_date_time_list(value).collect do |d|
+          # We get [ year, month, day, hour, min, sec, usec, tz ]
+          Date.new(d[0], d[1], d[2])
+        end
+      rescue ::Vcard::InvalidEncodingError
+        ::Vcard.decode_date_list(value).collect do |d|
+          # We get [ year, month, day ]
+          Date.new(*d)
         end
       end
 
@@ -591,14 +587,11 @@ module Vcard
       # new fields, not old fields.
       def mutate(g, n, p, v) #:nodoc:
         line = Field.encode0(g, n, p, v)
-
-        begin
-          @group, @name, @params, @value = Field.decode0(line)
-          @line = line
-        rescue ::Vcard::InvalidEncodingError => e
-          raise ArgumentError, e.to_s
-        end
+        @group, @name, @params, @value = Field.decode0(line)
+        @line = line
         self
+      rescue ::Vcard::InvalidEncodingError => e
+        raise ArgumentError, e.to_s
       end
 
       private :mutate

data/lib/vcard/vcard.rb

@@ -440,23 +440,18 @@ module Vcard
     end
 
     def decode_bday(field) #:nodoc:
-      begin
-        return decode_date_or_datetime(field)
-
-      rescue ::Vcard::InvalidEncodingError
-        # Hack around BDAY dates hat are correct in the month and day, but have
-        # some kind of garbage in the year.
-        if field.value =~ /^\s*(\d+)-(\d+)-(\d+)\s*$/
-          y = $1.to_i
-          m = $2.to_i
-          d = $3.to_i
-          if(y < 1900)
-            y = Time.now.year
-          end
-          Line.new( field.group, field.name, Date.new(y, m, d) )
-        else
-          raise
-        end
+      decode_date_or_datetime(field)
+    rescue ::Vcard::InvalidEncodingError
+      # Hack around BDAY dates hat are correct in the month and day, but have
+      # some kind of garbage in the year.
+      if field.value =~ /^\s*(\d+)-(\d+)-(\d+)\s*$/
+        y = $1.to_i
+        y = Time.now.year if y < 1900
+        m = $2.to_i
+        d = $3.to_i
+        Line.new( field.group, field.name, Date.new(y, m, d) )
+      else
+        raise
       end
     end
 
@@ -570,11 +565,9 @@ module Vcard
 
     # Return line for a field
     def f2l(field) #:nodoc:
-      begin
-        Line.decode(@@decode, self, field)
-      rescue ::Vcard::InvalidEncodingError
-        # Skip invalidly encoded fields.
-      end
+      Line.decode(@@decode, self, field)
+    rescue ::Vcard::InvalidEncodingError
+      # Skip invalidly encoded fields.
     end
 
     # With no block, returns an Array of Line. If +name+ is specified, the
@@ -1034,7 +1027,7 @@ module Vcard
       def make # :nodoc:
         yield self
         unless @card["N"]
-          raise Unencodeable, "N field is mandatory"
+          raise ::Vcard::Unencodeable, "N field is mandatory"
         end
         fn = @card.field("FN")
         if fn && fn.value.strip.length == 0
@@ -1377,14 +1370,12 @@ module Vcard
 
       # Delete +line+ if block yields true.
       def delete_if #:yield: line
-        begin
-          @card.delete_if do |line|
-            yield line
-          end
-        rescue NoMethodError
-          # FIXME - this is a hideous hack, allowing a DirectoryInfo to
-          # be passed instead of a Vcard, and for it to almost work. Yuck.
+        @card.delete_if do |line|
+          yield line
         end
+      rescue NoMethodError
+        # FIXME - this is a hideous hack, allowing a DirectoryInfo to
+        # be passed instead of a Vcard, and for it to almost work. Yuck.
       end
 
     end

data/lib/vcard/version.rb

@@ -1,3 +1,3 @@
 module Vcard
-  VERSION = "0.2.1"
+  VERSION = "0.2.2"
 end

data/test/field_test.rb

@@ -75,16 +75,17 @@ class FieldTest < Test::Unit::TestCase
     assert_equal("name;encoding=B:dmFsdWU=", line = Field.encode0(nil, "name", { "encoding"=>:b64 }, "value"))
     assert_equal([ nil, "NAME", { "ENCODING"=>["B"]}, ["value"].pack("m").chomp ], Field.decode0(line))
 
-    assert_equal("group.name:value", line = Field.encode0("group", "name", {}, "value"))
-    assert_equal([ "GROUP", "NAME", {}, "value"], Field.decode0(line))
+    line = Field.encode0("group", "name", {}, "value")
+    assert_equal "group.name:value", line
+    assert_equal [ "GROUP", "NAME", {}, "value"], Field.decode0(line)
   end
 
-  def tEst_invalid_fields
+  def test_invalid_fields
     [
       "g.:",
       ":v",
     ].each do |line|
-      assert_raises(Vcard::InvalidEncodingError) { Field.decode0(line) }
+      assert_raises(::Vcard::InvalidEncodingError) { Field.decode0(line) }
     end
   end
 

data/test/vcard_test.rb

@@ -24,7 +24,7 @@ class VcardTest < Test::Unit::TestCase
     card = nil
     assert_nothing_thrown { card = Vcard::Vcard.decode(vcard(:ex2)).first }
     assert_equal(vcard(:ex2), card.encode(0))
-    assert_raises(InvalidEncodingError) { card.version }
+    assert_raises(::Vcard::InvalidEncodingError) { card.version }
 
     assert_equal("Bj=F8rn Jensen", card.name.fullname)
     assert_equal("Jensen",  card.name.family)
@@ -169,40 +169,41 @@ EOF
 
   def test_bad
     # FIXME: this should THROW, it's badly encoded!
-    assert_raises(InvalidEncodingError) do
+    assert_raises(::Vcard::InvalidEncodingError) do
       Vcard::Vcard.decode("BEGIN:VCARD\nVERSION:3.0\nKEYencoding=b:this could be \nmy certificate\n\nEND:VCARD\n")
     end
   end
 
   def test_create
     card = Vcard::Vcard.create
-
     key = Vcard::DirectoryInfo.decode("key;type=x509;encoding=B:dGhpcyBjb3VsZCBiZSAKbXkgY2VydGlmaWNhdGUK\n")['key']
-
     card << Vcard::DirectoryInfo::Field.create('key', key, 'encoding' => :b64)
-
     assert_equal(key, card['key'])
   end
 
-  def test_values
-    # date
-    assert_equal [2002, 4, 22],       Vcard.decode_date(" 20020422  ")
-    assert_equal [2002, 4, 22],       Vcard.decode_date(" 2002-04-22  ")
-    assert_equal [2002, 4, 22],       Vcard.decode_date(" 2002-04-22 \n")
+  def test_decode_date
+    assert_equal [2002, 4, 22], Vcard.decode_date(" 20020422  ")
+    assert_equal [2002, 4, 22], Vcard.decode_date(" 2002-04-22  ")
+    assert_equal [2002, 4, 22], Vcard.decode_date(" 2002-04-22 \n")
+  end
+
+  def test_decode_date_list
     assert_equal [[2002, 4, 22]], Vcard.decode_date_list(" 2002-04-22 ")
     assert_equal [[2002, 4, 22],[2002, 4, 22]], Vcard.decode_date_list(" 2002-04-22, 2002-04-22,")
     assert_equal [[2002, 4, 22],[2002, 4, 22]], Vcard.decode_date_list(" 2002-04-22,,, ,   ,2002-04-22, , \n")
     assert_equal [], Vcard.decode_date_list("  ,           , ")
+  end
 
-    # time
+  def test_decode_time
     assert_equal [4, 53, 22, 0, nil], Vcard.decode_time(" 04:53:22 \n")
     assert_equal [4, 53, 22, 0.10, nil], Vcard.decode_time(" 04:53:22.10 \n")
     assert_equal [4, 53, 22, 0.10, "Z"], Vcard.decode_time(" 04:53:22.10Z \n")
     assert_equal [4, 53, 22, 0, "Z"], Vcard.decode_time(" 045322Z \n")
     assert_equal [4, 53, 22, 0, "+0530"], Vcard.decode_time(" 04:5322+0530 \n")
     assert_equal [4, 53, 22, 0.10, "Z"], Vcard.decode_time(" 045322.10Z \n")
+  end
 
-    # date-time
+  def test_decode_date_time
     assert_equal [2002, 4, 22, 4, 53, 22, 0, nil], Vcard.decode_date_time("20020422T04:53:22 \n")
     assert_equal [2002, 4, 22, 4, 53, 22, 0.10, nil], Vcard.decode_date_time(" 2002-04-22T04:53:22.10 \n")
     assert_equal [2002, 4, 22, 4, 53, 22, 0.10, "Z"], Vcard.decode_date_time(" 20020422T04:53:22.10Z \n")
@@ -210,9 +211,13 @@ EOF
     assert_equal [2002, 4, 22, 4, 53, 22, 0, "+0530"], Vcard.decode_date_time(" 20020422T04:5322+0530 \n")
     assert_equal [2002, 4, 22, 4, 53, 22, 0.10, "Z"], Vcard.decode_date_time(" 20020422T045322.10Z \n")
     assert_equal [2003, 3, 25, 3, 20, 35, 0, "Z"], Vcard.decode_date_time("20030325T032035Z")
+  end
 
-    # text
+  def test_decode_text
     assert_equal "aa,\n\n,\\,\\a;;b", Vcard.decode_text('aa,\\n\\n,\\\\\,\\\\a\;\;b')
+  end
+
+  def test_decode_text_list
     assert_equal ['', "1\n2,3", "bbb", '', "zz", ''], Vcard.decode_text_list(',1\\n2\\,3,bbb,,zz,')
   end
 
@@ -301,11 +306,11 @@ EOF
   def test_modify_name
     card = Vcard.decode("begin:vcard\nend:vcard\n").first
 
-    assert_raises(InvalidEncodingError) do
+    assert_raises(::Vcard::InvalidEncodingError) do
       card.name
     end
 
-    assert_raises(Unencodeable) do
+    assert_raises(::Vcard::Unencodeable) do
       Vcard::Maker.make2(card) {}
     end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: vcard
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.2.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-12-16 00:00:00.000000000 Z
+date: 2012-12-17 00:00:00.000000000 Z
 dependencies: []
 description: Vcard extracted from Vpim
 email:
@@ -78,7 +78,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -144601945951725492
+      hash: 376442794917458825
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -87,7 +87,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -144601945951725492
+      hash: 376442794917458825
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.24