rdf-tabular 0.4.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e84b41fe3c25549c84acc75984afc3c2fdd320b2
-  data.tar.gz: fe3b1a0987bb7cc28e3ef9f8f7ed11617a2e6d8e
+  metadata.gz: 5fd3ba26034d83ae78387e86545e7020a2299141
+  data.tar.gz: 79494794a8a96f1799c0ecf7e28891f230a97f70
 SHA512:
-  metadata.gz: 1c867b3e2abc2b5800b0f53367a1aadb6406471911f275878f9b79ecd00a8d3f7f19a47cdc58c8a7614575be8d993aebc8a3ac893bf04220b907d66833c33106
-  data.tar.gz: 7e47390a977454aad3f15765501e56acf587f2aa829deec58bcc6b3857c3bec59e0ac9c136fee57994b6fe9a2ab2fa4d5251527cc18dcd05509600979756ca30
+  metadata.gz: def477f7bc65c716906f2e5bf75afde8e79a8abb5304cffc4cb5624f9dc412ae936a5ef4308e3555c865e1b0562d7b398b4706927df632ef47f1b706ea8fc66b
+  data.tar.gz: c61c6772c207e44062e6a92726e64e07a28ab18149f18b564403fd15e6f85badb96f0eb5e39fe253547f9c6837c4538b9a5db52881011d521f51217a2682bcf6

data/README.md

@@ -248,7 +248,7 @@ Full documentation available on [RubyDoc](http://rubydoc.info/gems/rdf-tabular/f
   * {RDF::Tabular::Reader}
 
 ## Dependencies
-* [Ruby](http://ruby-lang.org/) (>= 2.0)
+* [Ruby](http://ruby-lang.org/) (>= 2.2.2)
 * [RDF.rb](http://rubygems.org/gems/rdf) (>= 2.0)
 * [JSON](https://rubygems.org/gems/json) (>= 1.5)
 

data/VERSION

@@ -1 +1 @@
-0.4.0
+1.0.0

data/lib/rdf/tabular/format.rb

@@ -24,10 +24,10 @@ module RDF::Tabular
   #
   # @see http://www.w3.org/TR/rdf-testcases/#ntriples
   class Format < RDF::Format
-    content_type     'text/csv',
+    content_type     'text/csv;q=0.4',
                      extensions: [:csv, :tsv],
                      alias: %w{
-                       text/tab-separated-values
+                       text/tab-separated-values;q=0.4
                        application/csvm+json
                      }
     content_encoding 'utf-8'

data/lib/rdf/tabular/metadata.rb

@@ -2171,33 +2171,13 @@ module RDF::Tabular
         decimalChar = format["decimalChar"] || '.'
         pattern = format["pattern"]
 
-        if !datatype.parse_uax35_number(pattern, value, groupChar || ",", decimalChar)
+        begin
+          value = datatype.parse_uax35_number(pattern, value, groupChar || ",", decimalChar)
+        rescue UAX35::ParseError
           value_errors << "#{value} does not match numeric pattern #{pattern ? pattern.inspect : 'default'}"
         end
 
-        # pattern facet failed
-        value_errors << "#{value} has repeating #{groupChar.inspect}" if groupChar && value.include?(groupChar*2)
-        value = value.gsub(groupChar || ',', '')
-        value = value.sub(decimalChar, '.')
-
-        # Extract percent or per-mille sign
-        percent = permille = false
-        case value
-        when /%/
-          value = value.sub('%', '')
-          percent = true
-        when /‰/
-          value = value.sub('‰', '')
-          permille = true
-        end
-
         lit = RDF::Literal(value, datatype: expanded_dt)
-        if percent || permille
-          o = lit.object
-          o = o / 100 if percent
-          o = o / 1000 if permille
-          lit = RDF::Literal(o, datatype: expanded_dt)
-        end
 
         if !lit.plain? && datatype.minimum && lit < datatype.minimum
           value_errors << "#{value} < minimum #{datatype.minimum}"
@@ -2238,10 +2218,11 @@ module RDF::Tabular
           end
         end
       when :date, :time, :dateTime, :dateTimeStamp, :datetime
-        if value = datatype.parse_uax35_date(format, value)
+        begin
+          value = datatype.parse_uax35_date(format, value)
           lit = RDF::Literal(value, datatype: expanded_dt)
-        else
-          value_errors << "#{original_value} does not match format #{format}"
+        rescue UAX35::ParseError
+          value_errors << "#{value} does not match format #{format}"
         end
       when :duration, :dayTimeDuration, :yearMonthDuration
         # SPEC CONFUSION: surely format also includes that for other duration types?

data/lib/rdf/tabular/uax35.rb

@@ -7,50 +7,99 @@ module RDF::Tabular
   module UAX35
 
     ##
-    # Parse the date format (if provided), and match against the value (if provided)
-    # Otherwise, validate format and raise an error
+    # Parse the date pattern (if provided), and match against the value (if provided)
+    # Otherwise, validate pattern and raise an error.
     #
-    # @param [String] format
+    # Supported patterns are:
+    #
+    # * yyyy-MM-dd
+    # * yyyyMMdd
+    # * dd-MM-yyyy
+    # * d-M-yyyy
+    # * d-M-yy
+    # * d-M-y
+    # * MM-dd-yyyy
+    # * M-d-yyyy
+    # * M-d-yy
+    # * M-d-y
+    # * dd/MM/yyyy
+    # * d/M/yyyy
+    # * d/M/yy
+    # * d/M/y
+    # * MM/dd/yyyy
+    # * M/d/yyyy
+    # * M/d/yy
+    # * M/d/y
+    # * dd.MM.yyyy
+    # * d.M.yyyy
+    # * d.M.yy
+    # * d.M.y
+    # * MM.dd.yyyy
+    # * M.d.yyyy
+    # * M.d.yy
+    # * M.d.y
+    # * yyyy-MM-ddTHH:mm
+    # * yyyy-MM-ddTHH:mm:ss
+    # * yyyy-MM-ddTHH:mm:ss.S+
+    #
+    # Year comonents less than four digits are normalized to 1900 or 2000 based on if the value is <= 99 or >= 70, it is considered to be in the 1900 range, otherwise, based on 2000.
+    #
+    # @param [String] pattern
     # @param [String] value
     # @return [String] XMLSchema version of value
-    # @raise [ArgumentError] if format is not valid, or nil, if value does not match
-    def parse_uax35_date(format, value)
-      date_format, time_format = nil, nil
-      return value unless format
-      value ||= ""
+    # @raise [ArgumentError] if pattern is not valid, or nil
+    # @raise [ParseError] if value does not match
+    def parse_uax35_date(pattern, value)
+      date_pattern, time_pattern = nil, nil
+      return value unless pattern
+      orig_value = value ||= ""
+      orig_pattern = pattern
 
       # Extract tz info
-      if md = format.match(/^(.*[dyms])+(\s*[xX]+)$/)
-        format, tz_format = md[1], md[2]
+      if md = pattern.match(/^(.*[dyms])+(\s*[xX]+)$/)
+        pattern, tz_pattern = md[1], md[2]
       end
 
-      date_format, time_format = format.split(' ')
-      date_format, time_format = nil, date_format if self.base.to_sym == :time
+      date_pattern, time_pattern = pattern.split(' ')
+      # Snuff out if this is a Time pattern
+      date_pattern, time_pattern = nil, date_pattern if time_pattern.nil? && !date_pattern.match(/[TyMd]/)
 
       # Extract date, of specified
-      date_part = case date_format
+      date_part = case date_pattern
       when 'yyyy-MM-dd' then value.match(/^(?<yr>\d{4})-(?<mo>\d{2})-(?<da>\d{2})/)
       when 'yyyyMMdd'   then value.match(/^(?<yr>\d{4})(?<mo>\d{2})(?<da>\d{2})/)
       when 'dd-MM-yyyy' then value.match(/^(?<da>\d{2})-(?<mo>\d{2})-(?<yr>\d{4})/)
       when 'd-M-yyyy'   then value.match(/^(?<da>\d{1,2})-(?<mo>\d{1,2})-(?<yr>\d{4})/)
+      when 'd-M-yy'     then value.match(/^(?<da>\d{1,2})-(?<mo>\d{1,2})-(?<yr>\d{2})/)
+      when 'd-M-y'      then value.match(/^(?<da>\d{1,2})-(?<mo>\d{1,2})-(?<yr>\d{1,4})/)
       when 'MM-dd-yyyy' then value.match(/^(?<mo>\d{2})-(?<da>\d{2})-(?<yr>\d{4})/)
       when 'M-d-yyyy'   then value.match(/^(?<mo>\d{1,2})-(?<da>\d{1,2})-(?<yr>\d{4})/)
-      when 'dd/MM/yyyy' then value.match(/^(?<da>\d{2})\/(?<mo>\d{2})\/(?<yr>\d{4})/)
+      when 'M-d-yy'     then value.match(/^(?<mo>\d{1,2})-(?<da>\d{1,2})-(?<yr>\d{2})/)
+      when 'M-d-y'      then value.match(/^(?<mo>\d{1,2})-(?<da>\d{1,2})-(?<yr>\d{1,4})/)
+      when 'dd/MM/yyyy' then value.match(/^(?<da>\d{2})\/(?<mo>\d{2})\/(?<yr>\d{1,4})/)
       when 'd/M/yyyy'   then value.match(/^(?<da>\d{1,2})\/(?<mo>\d{1,2})\/(?<yr>\d{4})/)
-      when 'MM/dd/yyyy' then value.match(/^(?<mo>\d{2})\/(?<da>\d{2})\/(?<yr>\d{4})/)
+      when 'd/M/yy'     then value.match(/^(?<da>\d{1,2})\/(?<mo>\d{1,2})\/(?<yr>\d{2})/)
+      when 'd/M/y'      then value.match(/^(?<da>\d{1,2})\/(?<mo>\d{1,2})\/(?<yr>\d{1,4})/)
+      when 'MM/dd/yyyy' then value.match(/^(?<mo>\d{2})\/(?<da>\d{2})\/(?<yr>\d{1,4})/)
       when 'M/d/yyyy'   then value.match(/^(?<mo>\d{1,2})\/(?<da>\d{1,2})\/(?<yr>\d{4})/)
+      when 'M/d/yy'     then value.match(/^(?<mo>\d{1,2})\/(?<da>\d{1,2})\/(?<yr>\d{2})/)
+      when 'M/d/y'      then value.match(/^(?<mo>\d{1,2})\/(?<da>\d{1,2})\/(?<yr>\d{1,4})/)
       when 'dd.MM.yyyy' then value.match(/^(?<da>\d{2})\.(?<mo>\d{2})\.(?<yr>\d{4})/)
       when 'd.M.yyyy'   then value.match(/^(?<da>\d{1,2})\.(?<mo>\d{1,2})\.(?<yr>\d{4})/)
+      when 'd.M.yy'     then value.match(/^(?<da>\d{1,2})\.(?<mo>\d{1,2})\.(?<yr>\d{2})/)
+      when 'd.M.y'      then value.match(/^(?<da>\d{1,2})\.(?<mo>\d{1,2})\.(?<yr>\d{1,4})/)
       when 'MM.dd.yyyy' then value.match(/^(?<mo>\d{2})\.(?<da>\d{2})\.(?<yr>\d{4})/)
       when 'M.d.yyyy'   then value.match(/^(?<mo>\d{1,2})\.(?<da>\d{1,2})\.(?<yr>\d{4})/)
+      when 'M.d.yy'     then value.match(/^(?<mo>\d{1,2})\.(?<da>\d{1,2})\.(?<yr>\d{2})/)
+      when 'M.d.y'      then value.match(/^(?<mo>\d{1,2})\.(?<da>\d{1,2})\.(?<yr>\d{1,4})/)
       when 'yyyy-MM-ddTHH:mm' then value.match(/^(?<yr>\d{4})-(?<mo>\d{2})-(?<da>\d{2})T(?<hr>\d{2}):(?<mi>\d{2})(?<se>(?<ms>))/)
       when 'yyyy-MM-ddTHH:mm:ss' then value.match(/^(?<yr>\d{4})-(?<mo>\d{2})-(?<da>\d{2})T(?<hr>\d{2}):(?<mi>\d{2}):(?<se>\d{2})(?<ms>)/)
       when /yyyy-MM-ddTHH:mm:ss\.S+/
         md = value.match(/^(?<yr>\d{4})-(?<mo>\d{2})-(?<da>\d{2})T(?<hr>\d{2}):(?<mi>\d{2}):(?<se>\d{2})\.(?<ms>\d+)/)
-        num_ms = date_format.match(/S+/).to_s.length
+        num_ms = date_pattern.match(/S+/).to_s.length
         md if md && md[:ms].length <= num_ms
       else
-        raise ArgumentError, "unrecognized date/time format #{date_format}" if date_format
+        raise ArgumentError, "unrecognized date/time pattern #{date_pattern}" if date_pattern
         nil
       end
 
@@ -61,25 +110,25 @@ module RDF::Tabular
       end
 
       # Extract time, of specified
-      time_part = case time_format
+      time_part = case time_pattern
       when 'HH:mm:ss' then value.match(/^(?<hr>\d{2}):(?<mi>\d{2}):(?<se>\d{2})(?<ms>)/)
       when 'HHmmss'   then value.match(/^(?<hr>\d{2})(?<mi>\d{2})(?<se>\d{2})(?<ms>)/)
       when 'HH:mm'    then value.match(/^(?<hr>\d{2}):(?<mi>\d{2})(?<se>)(?<ms>)/)
       when 'HHmm'     then value.match(/^(?<hr>\d{2})(?<mi>\d{2})(?<se>)(?<ms>)/)
       when /HH:mm:ss\.S+/
         md = value.match(/^(?<hr>\d{2}):(?<mi>\d{2}):(?<se>\d{2})\.(?<ms>\d+)/)
-        num_ms = time_format.match(/S+/).to_s.length
+        num_ms = time_pattern.match(/S+/).to_s.length
         md if md && md[:ms].length <= num_ms
       else
-        raise ArgumentError, "unrecognized date/time format #{time_format}" if time_format
+        raise ArgumentError, "unrecognized date/time pattern #{pattern}" if time_pattern
         nil
       end
 
-      # If there's a date_format but no date_part, match fails
-      return nil if date_format && date_part.nil?
+      # If there's a date_pattern but no date_part, match fails
+      raise ParseError, "#{orig_value} does not match pattern #{orig_pattern}" if !orig_value.empty? && date_pattern && date_part.nil?
 
-      # If there's a time_format but no time_part, match fails
-      return nil if time_format && time_part.nil?
+      # If there's a time_pattern but no time_part, match fails
+      raise ParseError, "#{orig_value} does not match pattern #{orig_pattern}" if !orig_value.empty? && time_pattern && time_part.nil?
 
       # Forward past time part
       value = value[time_part.to_s.length..-1] if time_part
@@ -88,8 +137,8 @@ module RDF::Tabular
       time_part = date_part if date_part && date_part.names.include?("hr")
 
       # If there's a timezone, it may optionally start with whitespace
-      value = value.lstrip if tz_format.to_s.start_with?(' ')
-      tz_part = case tz_format.to_s.lstrip
+      value = value.lstrip if tz_pattern.to_s.start_with?(' ')
+      tz_part = case tz_pattern.to_s.lstrip
       when 'x'    then value.match(/^(?:(?<hr>[+-]\d{2})(?<mi>\d{2})?)$/)
       when 'X'    then value.match(/^(?:(?:(?<hr>[+-]\d{2})(?<mi>\d{2})?)|(?<z>Z))$/)
       when 'xx'   then value.match(/^(?:(?<hr>[+-]\d{2})(?<mi>\d{2}))|$/)
@@ -97,15 +146,30 @@ module RDF::Tabular
       when 'xxx'  then value.match(/^(?:(?<hr>[+-]\d{2}):(?<mi>\d{2}))$/)
       when 'XXX'  then value.match(/^(?:(?:(?<hr>[+-]\d{2}):(?<mi>\d{2}))|(?<z>Z))$/)
       else
-        raise ArgumentError, "unrecognized timezone format #{tz_format.to_s.lstrip}" if tz_format
+        raise ArgumentError, "unrecognized timezone pattern #{tz_pattern.to_s.lstrip}" if tz_pattern
         nil
       end
 
-      # If there's a tz_format but no time_part, match fails
-      return nil if tz_format && tz_part.nil?
+      # If there's a tz_pattern but no time_part, match fails
+      raise ParseError, "#{orig_value} does not match pattern #{orig_pattern}" if !orig_value.empty? && tz_pattern && tz_part.nil?
 
       # Compose normalized value
-      vd = ("%04d-%02d-%02d" % [date_part[:yr].to_i, date_part[:mo].to_i, date_part[:da].to_i]) if date_part
+      vd = if date_part
+        yr, mo, da = [date_part[:yr], date_part[:mo], date_part[:da]].map(&:to_i)
+
+        if date_part[:yr].length < 4
+          # Make sure that yr makes sense, if given
+          yr = case yr
+          when 0..69    then yr + 2000
+          when 100..999 then yr + 2000
+          when 70..99   then yr + 1900
+          else               yr
+          end
+        end
+
+        ("%04d-%02d-%02d" % [yr, mo, da])
+      end
+
       vt = ("%02d:%02d:%02d" % [time_part[:hr].to_i, time_part[:mi].to_i, time_part[:se].to_i]) if time_part
 
       # Add milliseconds, if matched
@@ -117,37 +181,74 @@ module RDF::Tabular
     end
 
     ##
-    # Parse the date format (if provided), and match against the value (if provided)
-    # Otherwise, validate format and raise an error
+    # Parse the date pattern (if provided), and match against the value (if provided)
+    # Otherwise, validate pattern and raise an error
     #
     # @param [String] pattern
     # @param [String] value
     # @param [String] groupChar
     # @param [String] decimalChar
     # @return [String] XMLSchema version of value or nil, if value does not match
-    # @raise [ArgumentError] if format is not valid
+    # @raise [ArgumentError] if pattern is not valid
     def parse_uax35_number(pattern, value, groupChar=",", decimalChar=".")
       value ||= ""
 
       re = build_number_re(pattern, groupChar, decimalChar)
 
+      raise ParseError, "#{value} has repeating #{groupChar.inspect}" if groupChar.length == 1 && value.include?(groupChar*2)
+
       # Upcase value and remove internal spaces
       value = value.upcase
 
       if value =~ re
-
         # Upcase value and remove internal spaces
         value = value.
-          upcase.
           gsub(/\s+/, '').
           gsub(groupChar, '').
           gsub(decimalChar, '.')
 
         # result re-assembles parts removed from value
         value
-      else
+      elsif !value.empty?
         # no match
-        nil
+        raise ParseError, "#{value.inspect} does not match #{pattern.inspect}"
+      end
+
+      # Extract percent or per-mille sign
+      case value
+      when /%/
+        value = value.sub('%', '')
+        lhs, rhs = value.split('.')
+
+        # Shift decimal
+        value = case lhs.length
+        when 0 then "0.00#{rhs}".sub('E', 'e')
+        when 1 then "0.0#{lhs}#{rhs}".sub('E', 'e')
+        when 2 then "0.#{lhs}#{rhs}".sub('E', 'e')
+        else
+          ll, lr = lhs[0..lhs.length-3], lhs[-2..-1]
+          ll = ll + "0" unless ll =~ /\d+/
+          "#{ll}.#{lr}#{rhs}".sub('E', 'e')
+        end
+      when /‰/
+        value = value.sub('‰', '')
+        lhs, rhs = value.split('.')
+
+        # Shift decimal
+        value = case lhs.length
+        when 0 then "0.000#{rhs}".sub('E', 'e')
+        when 1 then "0.00#{lhs}#{rhs}".sub('E', 'e')
+        when 2 then "0.0#{lhs}#{rhs}".sub('E', 'e')
+        when 3 then "0.#{lhs}#{rhs}".sub('E', 'e')
+        else
+          ll, lr = lhs[0..lhs.length-4], lhs[-3..-1]
+          ll = ll + "0" unless ll =~ /\d+/
+          "#{ll}.#{lr}#{rhs}".sub('E', 'e')
+        end
+      when /NAN/ then value.sub('NAN', 'NaN')
+      when /E/ then value.sub('E', 'e')
+      else
+        value
       end
     end
 
@@ -157,9 +258,10 @@ module RDF::Tabular
     # @param [String] groupChar
     # @param [String] decimalChar
     # @return [Regexp] Regular expression matching value
-    # @raise [ArgumentError] if format is not valid
+    # @raise [ArgumentError] if pattern is not valid
     def build_number_re(pattern, groupChar, decimalChar)
       # pattern must be composed of only 0, #, decimalChar, groupChar, E, %, and ‰
+
       ge = Regexp.escape groupChar
       de = Regexp.escape decimalChar
 
@@ -320,5 +422,8 @@ module RDF::Tabular
 
       Regexp.new("^(?<prefix>#{prefix})(?<numeric_part>#{integer_str}#{fractional_str}#{exponent_str})(?<suffix>#{suffix})$")
     end
+
+    # ParseError is raised when a value does not match the pattern
+    class ParseError < RuntimeError; end
   end
 end

data/spec/format_spec.rb

@@ -54,13 +54,14 @@ describe RDF::Tabular::Format do
           end
         })
     end
-    after(:each) {|example| puts logger.to_s if example.exception}
 
     require 'rdf/cli'
-    let(:input) {File.expand_path("../data/countries.json", __FILE__)}
+    let(:input) {"http://example.org/data/countries.json"}
     describe "#tabular-json" do
       it "serializes to JSON" do
-        expect {RDF::CLI.exec(["tabular-json", input], format: :tabular)}.to write.to(:output)
+        expect {
+          RDF::CLI.exec(["tabular-json", input], format: :tabular)
+      }.to write.to(:output)
       end
     end
   end

data/spec/metadata_spec.rb

@@ -1136,7 +1136,7 @@ describe RDF::Tabular::Metadata do
           format: {"groupChar" => ";"},
           value: "123;;456.789",
           result: "123;;456.789",
-          errors: [/has repeating/]
+          errors: [/does not match numeric pattern/]
         },
         "decimal with explicit decimalChar" => {
           base: "decimal",
@@ -1184,19 +1184,19 @@ describe RDF::Tabular::Metadata do
         "invalid nonPositiveInteger" => {base: "nonPositiveInteger", value: "1", errors: ["1 is not a valid nonPositiveInteger"]},
         "valid nonNegativeInteger" => {base: "nonNegativeInteger", value: "0"},
         "invalid nonNegativeInteger" => {base: "nonNegativeInteger", value: "-1", errors: ["-1 is not a valid nonNegativeInteger"]},
-        "valid double" => {base: "double", value: "1234.456E789"},
+        "valid double" => {base: "double", value: "1234.456e789"},
         "invalid double" => {base: "double", value: "1z", errors: ["1z is not a valid double"]},
-        "NaN double" => {base: "double", value: "NaN"},
+        "NaN double" => {base: "double", value: "NaN", result: "NaN"},
         "INF double" => {base: "double", value: "INF"},
         "-INF double" => {base: "double", value: "-INF"},
-        "valid number" => {base: "number", value: "1234.456E789"},
+        "valid number" => {base: "number", value: "1234.456e789"},
         "invalid number" => {base: "number", value: "1z", errors: ["1z is not a valid number"]},
-        "NaN number" => {base: "number", value: "NaN"},
+        "NaN number" => {base: "number", value: "NaN", result: "NaN"},
         "INF number" => {base: "number", value: "INF"},
         "-INF number" => {base: "number", value: "-INF"},
-        "valid float" => {base: "float", value: "1234.456E7"},
+        "valid float" => {base: "float", value: "1234.456e7"},
         "invalid float" => {base: "float", value: "1z", errors: ["1z is not a valid float"]},
-        "NaN float" => {base: "float", value: "NaN"},
+        "NaN float" => {base: "float", value: "NaN", result: "NaN"},
         "INF float" => {base: "float", value: "INF"},
         "-INF float" => {base: "float", value: "-INF"},
 
@@ -1327,7 +1327,7 @@ describe RDF::Tabular::Metadata do
         "valid NMTOKEN" => {base: "NMTOKEN", value: "someThing", result: RDF::Literal("someThing", datatype: RDF::XSD.NMTOKEN)},
 
         # Aliases
-        "number is alias for double" => {base: "number", value: "1234.456E789", result: RDF::Literal("1234.456E789", datatype: RDF::XSD.double)},
+        "number is alias for double" => {base: "number", value: "1234.456e789", result: RDF::Literal("1234.456e789", datatype: RDF::XSD.double)},
         "binary is alias for base64Binary" => {base: "binary", value: "Tm93IGlzIHRoZSB0aW1lIGZvciBhbGwgZ29vZCBjb2RlcnMKdG8gbGVhcm4g", result: RDF::Literal("Tm93IGlzIHRoZSB0aW1lIGZvciBhbGwgZ29vZCBjb2RlcnMKdG8gbGVhcm4g", datatype: RDF::XSD.base64Binary)},
         "datetime is alias for dateTime" => {base: "dateTime", value: "15-3-2015 1502",  format: "d-M-yyyy HHmm", result: RDF::Literal("2015-03-15T15:02:00", datatype: RDF::XSD.dateTime)},
         "any is alias for anyAtomicType" => {base: "any", value: "some thing", result: RDF::Literal("some thing", datatype: RDF::XSD.anyAtomicType)},

data/spec/suite_spec.rb

@@ -18,7 +18,7 @@ describe RDF::Tabular::Reader do
           m.entries.each do |t|
             next if t.approval =~ /Rejected/
             specify "#{t.id.split("/").last}: #{t.name} - #{t.comment}" do
-              pending "rdf#test158 should be isomorphic" if t.id.include?("rdf#test158")
+              pending "rdf#test283 literal normalization" if t.id.include?("rdf#test283")
               t.logger = RDF::Spec.logger
               t.logger.formatter = lambda {|severity, datetime, progname, msg| "#{severity}: #{msg}\n"}
               t.logger.info t.inspect

data/spec/uax35_spec.rb

@@ -0,0 +1,239 @@
+# encoding: UTF-8
+$:.unshift "."
+require 'spec_helper'
+
+describe RDF::Tabular::UAX35 do
+  subject {"".extend(RDF::Tabular::UAX35)}
+
+  describe "parse_uax35_date" do
+    {
+      # Dates
+      "valid date yyyy-MM-dd" => {value: "2015-03-22", pattern: "yyyy-MM-dd", result: "2015-03-22"},
+      "valid date yyyyMMdd"   => {value: "20150322", pattern: "yyyyMMdd", result: "2015-03-22"},
+      "valid date dd-MM-yyyy" => {value: "22-03-2015", pattern: "dd-MM-yyyy", result: "2015-03-22"},
+      "valid date d-M-yyyy"   => {value: "22-3-2015", pattern: "d-M-yyyy", result: "2015-03-22"},
+      "valid date d-M-yy"     => {value: "22-3-15", pattern: "d-M-yy", result: "2015-03-22"},
+      "valid date d-M-y"      => {value: "22-3-15", pattern: "d-M-y", result: "2015-03-22"},
+      "valid date MM-dd-yyyy" => {value: "03-22-2015", pattern: "MM-dd-yyyy", result: "2015-03-22"},
+      "valid date M-d-yyyy"   => {value: "3-22-2015", pattern: "M-d-yyyy", result: "2015-03-22"},
+      "valid date M-d-yy"     => {value: "3-22-70", pattern: "M-d-yy", result: "1970-03-22"},
+      "valid date M-d-y"      => {value: "3-22-70", pattern: "M-d-y", result: "1970-03-22"},
+      "valid date dd/MM/yyyy" => {value: "22/03/2015", pattern: "dd/MM/yyyy", result: "2015-03-22"},
+      "valid date d/M/yyyy"   => {value: "22/3/2015", pattern: "d/M/yyyy", result: "2015-03-22"},
+      "valid date d/M/yy"     => {value: "22/3/15", pattern: "d/M/yy", result: "2015-03-22"},
+      "valid date d/M/y"      => {value: "22/3/15", pattern: "d/M/y", result: "2015-03-22"},
+      "valid date MM/dd/yyyy" => {value: "03/22/2015", pattern: "MM/dd/yyyy", result: "2015-03-22"},
+      "valid date M/d/yyyy"   => {value: "3/22/2015", pattern: "M/d/yyyy", result: "2015-03-22"},
+      "valid date M/d/yy"     => {value: "3/22/15", pattern: "M/d/yy", result: "2015-03-22"},
+      "valid date M/d/y"      => {value: "3/22/15", pattern: "M/d/y", result: "2015-03-22"},
+      "valid date dd.MM.yyyy" => {value: "22.03.2015", pattern: "dd.MM.yyyy", result: "2015-03-22"},
+      "valid date d.M.yyyy"   => {value: "22.3.2015", pattern: "d.M.yyyy", result: "2015-03-22"},
+      "valid date d.M.yy"     => {value: "22.3.15", pattern: "d.M.yy", result: "2015-03-22"},
+      "valid date d.M.y"      => {value: "22.3.15", pattern: "d.M.y", result: "2015-03-22"},
+      "valid date MM.dd.yyyy" => {value: "03.22.2015", pattern: "MM.dd.yyyy", result: "2015-03-22"},
+      "valid date M.d.yyyy"   => {value: "3.22.2015", pattern: "M.d.yyyy", result: "2015-03-22"},
+      "valid date M.d.yy"     => {value: "3.22.15", pattern: "M.d.yy", result: "2015-03-22"},
+      "valid date M.d.y"      => {value: "3.22.15", pattern: "M.d.y", result: "2015-03-22"},
+
+      # Times
+      "valid time HH:mm:ss.S" => {value: "15:02:37.1", pattern: "HH:mm:ss.S", result: "15:02:37.1"},
+      "valid time HH:mm:ss"   => {value: "15:02:37", pattern: "HH:mm:ss", result: "15:02:37"},
+      "valid time HHmmss"     => {value: "150237", pattern: "HHmmss", result: "15:02:37"},
+      "valid time HH:mm"      => {value: "15:02", pattern: "HH:mm", result: "15:02:00"},
+      "valid time HHmm"       => {value: "1502", pattern: "HHmm", result: "15:02:00"},
+
+      # DateTimes
+      "valid dateTime yyyy-MM-ddTHH:mm:ss"  => {value: "2015-03-15T15:02:37", pattern: "yyyy-MM-ddTHH:mm:ss", result: "2015-03-15T15:02:37"},
+      "valid dateTime yyyy-MM-ddTHH:mm:ss.S"=> {value: "2015-03-15T15:02:37.1", pattern: "yyyy-MM-ddTHH:mm:ss.S", result: "2015-03-15T15:02:37.1"},
+      "valid dateTime yyyy-MM-dd HH:mm:ss"  => {value: "2015-03-15 15:02:37", pattern: "yyyy-MM-dd HH:mm:ss", result: "2015-03-15T15:02:37"},
+      "valid dateTime yyyyMMdd HHmmss"      => {value: "20150315 150237",   pattern: "yyyyMMdd HHmmss",   result: "2015-03-15T15:02:37"},
+      "valid dateTime dd-MM-yyyy HH:mm"     => {value: "15-03-2015 15:02", pattern: "dd-MM-yyyy HH:mm", result: "2015-03-15T15:02:00"},
+      "valid dateTime d-M-yyyy HHmm"        => {value: "15-3-2015 1502",  pattern: "d-M-yyyy HHmm",   result: "2015-03-15T15:02:00"},
+      "valid dateTime yyyy-MM-ddTHH:mm"     => {value: "2015-03-15T15:02",  pattern: "yyyy-MM-ddTHH:mm",   result: "2015-03-15T15:02:00"},
+      "valid dateTimeStamp d-M-yyyy HHmm X" => {value: "15-3-2015 1502 Z",  pattern: "d-M-yyyy HHmm X",   result: "2015-03-15T15:02:00Z"},
+      "valid datetime yyyy-MM-ddTHH:mm:ss"  => {value: "2015-03-15T15:02:37", pattern: "yyyy-MM-ddTHH:mm:ss", result: "2015-03-15T15:02:37"},
+      "valid datetime yyyy-MM-dd HH:mm:ss"  => {value: "2015-03-15 15:02:37", pattern: "yyyy-MM-dd HH:mm:ss", result: "2015-03-15T15:02:37"},
+      "valid datetime yyyyMMdd HHmmss"      => {value: "20150315 150237",   pattern: "yyyyMMdd HHmmss",   result: "2015-03-15T15:02:37"},
+      "valid datetime dd-MM-yyyy HH:mm"     => {value: "15-03-2015 15:02", pattern: "dd-MM-yyyy HH:mm", result: "2015-03-15T15:02:00"},
+      "valid datetime d-M-yyyy HHmm"        => {value: "15-3-2015 1502",  pattern: "d-M-yyyy HHmm",   result: "2015-03-15T15:02:00"},
+      "valid datetime yyyy-MM-ddTHH:mm"     => {value: "2015-03-15T15:02",  pattern: "yyyy-MM-ddTHH:mm",   result: "2015-03-15T15:02:00"},
+
+      # Timezones
+      "valid w/TZ yyyy-MM-ddX"              => {value: "2015-03-22Z", pattern: "yyyy-MM-ddX", result: "2015-03-22Z"},
+      "valid w/TZ HH:mm:ssX"                => {value: "15:02:37-05", pattern: "HH:mm:ssX", result: "15:02:37-05:00"},
+      "valid w/TZ yyyy-MM-dd HH:mm:ss X"    => {value: "2015-03-15 15:02:37 +0800", pattern: "yyyy-MM-dd HH:mm:ss X", result: "2015-03-15T15:02:37+08:00"},
+      "valid w/TZ HHmm XX"                  => {value: "1502 +0800", pattern: "HHmm XX", result: "15:02:00+08:00"},
+      "valid w/TZ yyyy-MM-dd HH:mm:ss XX"   => {value: "2015-03-15 15:02:37 -0800", pattern: "yyyy-MM-dd HH:mm:ss XX", result: "2015-03-15T15:02:37-08:00"},
+      "valid w/TZ HHmm XXX"                 => {value: "1502 +08:00", pattern: "HHmm XXX", result: "15:02:00+08:00"},
+      "valid w/TZ yyyy-MM-ddTHH:mm:ssXXX"   => {value: "2015-03-15T15:02:37-05:00", pattern: "yyyy-MM-ddTHH:mm:ssXXX", result: "2015-03-15T15:02:37-05:00"},
+      "invalid w/TZ HH:mm:ssX"              => {value: "15:02:37-05:00", pattern: "HH:mm:ssX", error: "15:02:37-05:00 does not match pattern HH:mm:ssX"},
+      "invalid w/TZ HH:mm:ssXX"             => {value: "15:02:37-05", pattern: "HH:mm:ssXX", error: "15:02:37-05 does not match pattern HH:mm:ssXX"},
+    }.each do |name, props|
+      context name do
+        let(:base) {props[:base]}
+        let(:pattern) {props[:pattern]}
+        let(:value) {props[:value]}
+        let(:result) {props.fetch(:result, value)}
+        if props[:error]
+          it "finds error" do
+            expect {subject.parse_uax35_date(pattern, value)}.to raise_error(RDF::Tabular::UAX35::ParseError, props[:error])
+          end
+        else
+          it "generates #{props[:result] || props[:value]}" do
+            expect(subject.parse_uax35_date(pattern, value)).to eql result
+          end
+        end
+      end
+    end
+  end
+
+  describe "parse_uax35_number" do
+    {
+      # Numbers
+      "default no constraints" => {valid: %w(4)},
+      "default matching pattern" => {pattern: "000", valid: %w(123)},
+      "default explicit groupChar" => {groupChar: ";", valid: {"123;456.789" => "123456.789"}},
+      "default repeated groupChar" => {groupChar: ";", invalid: %w(123;;456.789)},
+      "default explicit decimalChar" => {decimalChar: ";", valid: {"123456;789" => "123456.789"}},
+      "default percent" => {groupChar: ",", valid: {"123456.789%" => "1234.56789"}},
+      "default per-mille" => {groupChar: ",", valid: {"123456.789‰" => "123.456789"}},
+
+      "0"          => {pattern: "0", valid: %w(1 -1 12), invalid: %w(1.2)},
+      "00"         => {pattern: "00", valid: %w(12 123), invalid: %w(1 1,2)},
+      "#"          => {pattern: "#", valid: %w(1 12 123), invalid: %w(1.2)},
+      "##"         => {pattern: "##", valid: %w(1 12 123), invalid: %w(1.2)},
+      "#0"         => {pattern: "#0", valid: %w(1 12 123), invalid: %w(1.2)},
+      '0.0'        => {pattern: "0.0", valid: %w(1.1 -1.1 12.1), invalid: %w(1.12)},
+      '0.00'       => {pattern: '0.00', valid: %w(1.12 +1.12 12.12), invalid: %w(1.1 1.123)},
+      '0.#'        => {pattern: '0.#', valid: %w(1 1.1 12.1), invalid: %w(1.12)},
+      '-0'         => {pattern: '-0', valid: %w(-1 -10), invalid: %w(1 +1)},
+      '%000'       => {pattern: '%000', valid: {"%123" => "1.23", "%+123" => "+1.23", "%1234" => "12.34"}, invalid: %w(%12 123%)},
+      '‰000'       => {pattern: '‰000', valid: {"‰123" => "0.123", "‰+123" => "+0.123", "‰1234" => "1.234"}, invalid: %w(‰12 123‰)},
+      '000%'       => {pattern: '000%', valid: {"123%" => "1.23", "+123%" => "+1.23", "1234%" => "12.34"}, invalid: %w(12% %123)},
+      '000‰'       => {pattern: '000‰', valid: {"123‰" => "0.123", "+123‰" => "+0.123", "1234‰" => "1.234"}, invalid: %w(12‰ ‰123)},
+      '000.0%'     => {pattern: '000.0%', valid: {"123.4%" => "1.234", "+123.4%" => "+1.234"}, invalid: %w(123.4‰ 123.4 1.234% 12.34% 123.45%)},
+      
+      '###0.#####' => {pattern: '###0.#####', valid: %w(1 1.1 12345.12345), invalid: %w(1,234.1 1.123456)},
+      '###0.0000#' => {pattern: '###0.0000#', valid: %w(1.1234 1.12345 12345.12345), invalid: %w(1,234.1234 1.12)},
+      '00000.0000' => {pattern: '00000.0000', valid: %w(12345.1234), invalid: %w(1.2 1,234.123,4)},
+      
+      '#0.0#E#0'   => {pattern: '#0.0#E#0', valid: %w(1.2e3 12.34e56)},
+      '#0.0#E+#0'  => {pattern: '#0.0#E+#0', valid: %w(1.2e+3 12.34e+56), invalid: %w(1.2e3 12.34e56)},
+      '#0.0#E#0%'  => {pattern: '#0.0#E#0%', valid: {"1.2e3%" => "0.012e3", "12.34e56%" => "0.1234e56"}, invalid: %w(1.2e+3 12.34e+56 1.2e3 12.34e56)},
+      
+      # Grouping
+      '#,##,##0'   => {pattern: '#,##,##0', valid: {"1" => "1", "12" => "12", "123" => "123", "1,234" => "1234", "12,345" => "12345", "1,23,456" => "123456"}, invalid: %w(1,2 12,34)},
+      '#,##,#00'   => {pattern: '#,##,#00', valid: {"12" => "12", "123" => "123", "1,234" => "1234", "12,345" => "12345"}, invalid: %w(1)},
+      '#,##,000'   => {pattern: '#,##,000', valid: {"123" => "123", "1,234" => "1234", "12,345" => "12345"}, invalid: %w(1 12)},
+      '#,#0,000'   => {pattern: '#,#0,000', valid: {"1,234" => "1234", "12,345" => "12345"}, invalid: %w(1 12 123)},
+      '#,00,000'   => {pattern: '#,00,000', valid: {"12,345" => "12345"}, invalid: %w(1 12 123 1,234)},
+      '0,00,000'   => {pattern: '0,00,000'},
+      
+      '0.0##,###'  => {pattern: '0.0##,###'},
+      '0.00#,###'  => {pattern: '0.00#,###'},
+      '0.000,###'  => {pattern: '0.000,###'},
+      '0.000,0##'  => {pattern: '0.000,0##'},
+      '0.000,00#'  => {pattern: '0.000,00#'},
+      '0.000,000'  => {pattern: '0.000,000'},
+      
+      # Jeni's
+      '##0'        => {pattern: '##0', valid: %w(1 12 123 1234), invalid: %w(1,234 123.4)},
+      '#,#00'      => {pattern: '#,#00', valid: {"12" => "12", "123" => "123", "1,234" => "1234", "1,234,567" => "1234567"}, invalid: %w(1 1234 12,34 12,34,567)},
+      '#0.#'       => {pattern: '#0.#', valid: %w(1 1.2 1234.5), invalid: %w(12.34 1,234.5)},
+      '#0.0#,#'    => {pattern: '#0.0#,#', valid: {"12.3" => "12.3", "12.34" => "12.34", "12.34,5" => "12.345"}, invalid: %w(1 12.345 12.34,56,7 12.34,567)},
+    }.each do |name, props|
+      context name do
+        let(:pattern) {props[:pattern]}
+        let(:groupChar) {props.fetch(:groupChar, ',')}
+        let(:decimalChar) {props.fetch(:decimalChar, '.')}
+
+        describe "valid" do
+          case props[:valid]
+          when Hash
+            props[:valid].each do |value, result|
+              it "with #{props[:pattern].inspect} #{value.inspect} => #{result.inspect}" do
+                expect(subject.parse_uax35_number(pattern, value, groupChar, decimalChar)).to eql result
+              end
+            end
+          when Array
+            props[:valid].each do |value|
+              it "with #{props[:pattern].inspect} #{value.inspect} => #{value.inspect}" do
+                expect(subject.parse_uax35_number(pattern, value, groupChar, decimalChar)).to eql value
+              end
+            end
+          end
+        end
+        describe "invalid" do
+          Array(props[:invalid]).each do |value|
+            it "with #{props[:pattern].inspect} #{value.inspect} invalid" do
+              expect {subject.parse_uax35_number(pattern, value, groupChar, decimalChar)}.to raise_error RDF::Tabular::UAX35::ParseError
+            end
+          end
+        end
+
+        it "recognizes bad pattern #{pattern.inspect}" do
+          expect{subject.parse_uax35_number(pattern, "", groupChar, decimalChar)}.to raise_error(ArgumentError)
+        end if props[:exception]
+      end
+    end
+  end
+
+  describe "#build_number_re" do
+    {
+      '0'          => {valid: %w(1 -1 +1 12), invalid: %w(1.2), base: "integer", re: /^(?<prefix>[+-]?)(?<numeric_part>\d{1,})(?<suffix>)$/},
+      '00'         => {valid: %w(12 123), invalid: %w(1 1,2), base: "integer", re: /^(?<prefix>[+-]?)(?<numeric_part>\d{2,})(?<suffix>)$/},
+      '#'          => {valid: %w(1 12 123), invalid: %w(1.2), base: "integer", re: /^(?<prefix>[+-]?)(?<numeric_part>\d{0,})(?<suffix>)$/},
+      '##'         => {re: /^(?<prefix>[+-]?)(?<numeric_part>\d{0,})(?<suffix>)$/},
+      '#0'         => {re: /^(?<prefix>[+-]?)(?<numeric_part>\d{1,})(?<suffix>)$/},
+
+      '0.0'         => {valid: %w(1.1 -1.1 12.1), invalid: %w(1.12), base: "decimal", re: /^(?<prefix>[+-]?)(?<numeric_part>\d{1,}\.\d{1})(?<suffix>)$/},
+      '0.00'        => {valid: %w(1.12 +1.12 12.12), invalid: %w(1.1 1.123), base: "decimal", re: /^(?<prefix>[+-]?)(?<numeric_part>\d{1,}\.\d{2})(?<suffix>)$/},
+      '0.#'         => {valid: %w(1 1.1 12.1), invalid: %w(1.12), base: "decimal", re: /^(?<prefix>[+-]?)(?<numeric_part>\d{1,}(?:\.\d{0,1})?)(?<suffix>)$/},
+      '-0'         => {valid: %w(-1 -10), invalid: %w(1 +1), base: "decimal", re: /^(?<prefix>\-)(?<numeric_part>\d{1,})(?<suffix>)$/},
+      '%000'       => {valid: %w(%123 %+123 %-123 %1234), invalid: %w(%12 123%), base: "decimal", re: /^(?<prefix>%[+-]?)(?<numeric_part>\d{3,})(?<suffix>)$/},
+      '‰000'       => {valid: %w(‰123 ‰+123 ‰-123 ‰1234), invalid: %w(‰12 123‰), base: "decimal", re: /^(?<prefix>‰[+-]?)(?<numeric_part>\d{3,})(?<suffix>)$/},
+      '000%'       => {valid: %w(123% +123% -123% 1234%), invalid: %w(12% %123), base: "decimal", re: /^(?<prefix>[+-]?)(?<numeric_part>\d{3,})(?<suffix>%)$/},
+      '000‰'       => {valid: %w(123‰ +123‰ -123‰ 1234‰), invalid: %w(12‰ ‰123), base: "decimal", re: /^(?<prefix>[+-]?)(?<numeric_part>\d{3,})(?<suffix>‰)$/},
+      '000.0%'     => {base: "decimal", re: /^(?<prefix>[+-]?)(?<numeric_part>\d{3,}\.\d{1})(?<suffix>%)$/},
+
+      '###0.#####' => {valid: %w(1 1.1 12345.12345), invalid: %w(1,234.1 1.123456), base: "decimal", re: /^(?<prefix>[+-]?)(?<numeric_part>\d{1,}(?:\.\d{0,5})?)(?<suffix>)$/},
+      '###0.0000#' => {valid: %w(1.1234 1.12345 12345.12345), invalid: %w(1,234.1234 1.12), base: "decimal", re: /^(?<prefix>[+-]?)(?<numeric_part>\d{1,}\.\d{4,5})(?<suffix>)$/},
+      '00000.0000' => {valid: %w(12345.1234), invalid: %w(1.2 1,234.123,4), base: "decimal", re: /^(?<prefix>[+-]?)(?<numeric_part>\d{5,}\.\d{4})(?<suffix>)$/},
+
+      '#0.0#E#0'   => {base: "double", re: /^(?<prefix>[+-]?)(?<numeric_part>\d{1,}\.\d{1,2}E[+-]?\d{1,2})(?<suffix>)$/},
+      '#0.0#E+#0'   => {base: "double", re: /^(?<prefix>[+-]?)(?<numeric_part>\d{1,}\.\d{1,2}E\+\d{1,2})(?<suffix>)$/},
+      '#0.0#E#0%'  => {base: "double", re: /^(?<prefix>[+-]?)(?<numeric_part>\d{1,}\.\d{1,2}E[+-]?\d{1,2})(?<suffix>%)$/},
+
+      # Grouping
+      '#,##,##0'   => {base: "integer", re: /^(?<prefix>[+-]?)(?<numeric_part>(?:(?:(?:\d{1,2},)?(?:\d{2},)*\d)?\d)?\d{1})(?<suffix>)$/},
+      '#,##,#00'   => {base: "integer", re: /^(?<prefix>[+-]?)(?<numeric_part>(?:(?:\d{1,2},)?(?:\d{2},)*\d)?\d{2})(?<suffix>)$/},
+      '#,##,000'   => {base: "integer", re: /^(?<prefix>[+-]?)(?<numeric_part>(?:\d{1,2},)?(?:\d{2},)*\d{3})(?<suffix>)$/},
+      '#,#0,000'   => {base: "integer", re: /^(?<prefix>[+-]?)(?<numeric_part>(?:(?:\d{1,2},)?(?:\d{2},)*\d)?\d{1},\d{3})(?<suffix>)$/},
+      '#,00,000'   => {base: "integer", re: /^(?<prefix>[+-]?)(?<numeric_part>(?:\d{1,2},)?(?:\d{2},)*\d{2},\d{3})(?<suffix>)$/},
+      '0,00,000'   => {base: "integer", re: /^(?<prefix>[+-]?)(?<numeric_part>(?:(?:\d{1,2},)?(?:\d{2},)*\d)?\d{1},\d{2},\d{3})(?<suffix>)$/},
+
+      '0.0##,###'  => {base: "decimal", re: /^(?<prefix>[+-]?)(?<numeric_part>\d{1,}\.\d{1}(?:\d(?:\d(?:,\d(?:\d(?:\d)?)?)?)?)?)(?<suffix>)$/},
+      '0.00#,###'  => {base: "decimal", re: /^(?<prefix>[+-]?)(?<numeric_part>\d{1,}\.\d{2}(?:\d(?:,\d(?:\d(?:\d)?)?)?)?)(?<suffix>)$/},
+      '0.000,###'  => {base: "decimal", re: /^(?<prefix>[+-]?)(?<numeric_part>\d{1,}\.\d{3}(?:,\d(?:\d(?:\d)?)?)?)(?<suffix>)$/},
+      '0.000,0##'  => {base: "decimal", re:/^(?<prefix>[+-]?)(?<numeric_part>\d{1,}\.\d{3},\d{1}(?:\d(?:\d)?)?)(?<suffix>)$/},
+      '0.000,00#'  => {base: "decimal", re: /^(?<prefix>[+-]?)(?<numeric_part>\d{1,}\.\d{3},\d{2}(?:\d)?)(?<suffix>)$/},
+      '0.000,000'  => {base: "decimal", re: /^(?<prefix>[+-]?)(?<numeric_part>\d{1,}\.\d{3},\d{3})(?<suffix>)$/},
+
+      # Jeni's
+      '##0'        => {valid: %w(1 12 123 1234), invalid: %w(1,234 123.4), base: "integer", re: /^(?<prefix>[+-]?)(?<numeric_part>\d{1,})(?<suffix>)$/},
+      '#,#00'      => {valid: %w(12 123 1,234 1,234,567), invalid: %w(1 1234 12,34 12,34,567), base: "integer", re: /^(?<prefix>[+-]?)(?<numeric_part>(?:(?:\d{1,3},)?(?:\d{3},)*\d)?\d{2})(?<suffix>)$/},
+      '#0.#'       => {valid: %w(1 1.2 1234.5), invalid: %w(12.34 1,234.5), base: "decimal", re: /^(?<prefix>[+-]?)(?<numeric_part>\d{1,}(?:\.\d{0,1})?)(?<suffix>)$/},
+      '#0.0#,#'    => {valid: %w(12.3 12.34 12.34,5), invalid: %w(1 12.345 12.34,56,7 12.34,567), base: "decimal", re: /^(?<prefix>[+-]?)(?<numeric_part>\d{1,}\.\d{1}(?:\d(?:,\d)?)?)(?<suffix>)$/},
+    }.each do |pattern, props|
+      context pattern do
+        it "generates #{props[:re]} for #{pattern}" do
+          expect(subject.build_number_re(pattern, ",", ".")).to eql props[:re]
+        end if props[:re].is_a?(Regexp)
+
+        it "recognizes bad pattern #{pattern}" do
+          expect{subject.build_number_re(pattern, ",", ".")}.to raise_error(ArgumentError)
+        end if props[:re] == ArgumentError
+      end
+    end
+  end
+end

data/spec/w3c-csvw

@@ -0,0 +1 @@
+spec/../../w3c-csvw

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rdf-tabular
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 1.0.0
 platform: ruby
 authors:
 - Gregg Kellogg
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-04-10 00:00:00.000000000 Z
+date: 2016-12-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bcp47
@@ -36,14 +36,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '2.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '2.1'
 - !ruby/object:Gem::Dependency
   name: rdf-vocab
   requirement: !ruby/object:Gem::Requirement
@@ -204,14 +204,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.17'
+        version: '2.3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.17'
+        version: '2.3'
 - !ruby/object:Gem::Dependency
   name: yard
   requirement: !ruby/object:Gem::Requirement
@@ -263,6 +263,8 @@ files:
 - spec/spec_helper.rb
 - spec/suite_helper.rb
 - spec/suite_spec.rb
+- spec/uax35_spec.rb
+- spec/w3c-csvw
 homepage: http://github.com/ruby-rdf/rdf-tabular
 licenses:
 - Unlicense
@@ -275,7 +277,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.0'
+      version: 2.2.2
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -283,7 +285,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.8
+rubygems_version: 2.6.8
 signing_key: 
 specification_version: 4
 summary: Tabular Data RDF Reader and JSON serializer.
@@ -295,4 +297,5 @@ test_files:
 - spec/spec_helper.rb
 - spec/suite_helper.rb
 - spec/suite_spec.rb
-has_rdoc: false
+- spec/uax35_spec.rb
+- spec/w3c-csvw