csvlint 0.1.4 → 0.2.0

data/lib/csvlint/validate.rb

@@ -4,7 +4,7 @@ module Csvlint
 
     include Csvlint::ErrorCollector
 
-    attr_reader :encoding, :content_type, :extension, :headers, :line_breaks, :dialect, :csv_header, :schema, :data
+    attr_reader :encoding, :content_type, :extension, :headers, :link_headers, :line_breaks, :dialect, :csv_header, :schema, :data
 
     ERROR_MATCHERS = {
       "Missing or stray quote" => :stray_quote,
@@ -14,36 +14,33 @@ module Csvlint
     }
 
     def initialize(source, dialect = nil, schema = nil, options = {})
-
+      reset
       @source = source
       @formats = []
       @schema = schema
 
       @supplied_dialect = dialect != nil
 
-      @dialect = {
-        "header" => true,
-        "delimiter" => ",",
-        "skipInitialSpace" => true,
-        "lineTerminator" => :auto,
-        "quoteChar" => '"'
-      }.merge(dialect || {})
-
-      @csv_header = @dialect["header"]
       @limit_lines = options[:limit_lines]
-      @csv_options = dialect_to_csv_options(@dialect)
       @extension = parse_extension(source) unless @source.nil?
-      reset
-      validate
+      @errors += @schema.errors unless @schema.nil?
+      @warnings += @schema.warnings unless @schema.nil?
+      validate(dialect)
 
     end
 
-    def validate
+    def validate(dialect = nil)
       single_col = false
       io = nil
       begin
+        if @extension =~ /.xls(x)?/
+          build_warnings(:excel, :context)
+          return
+        end
         io = @source.respond_to?(:gets) ? @source : open(@source, :allow_redirections=>:all)
         validate_metadata(io)
+        locate_schema unless @schema.instance_of?(Csvlint::Schema)
+        set_dialect(dialect)
         parse_csv(io)
         sum = @col_counts.inject(:+)
         unless sum.nil?
@@ -51,17 +48,20 @@ module Csvlint
         end
         build_warnings(:check_options, :structure) if @expected_columns == 1
         check_consistency
+        check_foreign_keys
       rescue OpenURI::HTTPError, Errno::ENOENT
-        build_errors(:not_found)
+        build_errors(:not_found, nil, nil, nil, @source)
       ensure
         io.close if io && io.respond_to?(:close)
       end
     end
 
     def validate_metadata(io)
+      @csv_header = true
       @encoding = io.charset rescue nil
       @content_type = io.content_type rescue nil
       @headers = io.meta rescue nil
+      @link_headers = @headers["link"].split(",") rescue nil
       assumed_header = undeclared_header = !@supplied_dialect
       if @headers
         if @headers["content-type"] =~ /text\/csv/
@@ -81,7 +81,6 @@ module Csvlint
           build_warnings(:encoding, :context) if @encoding != "utf-8"
         end
         build_warnings(:no_content_type, :context) if @content_type == nil
-        build_warnings(:excel, :context) if @content_type == nil && @extension =~ /.xls(x)?/
         build_errors(:wrong_content_type, :context) unless (@content_type && @content_type =~ /text\/csv/)
 
         if undeclared_header
@@ -93,6 +92,25 @@ module Csvlint
       build_info_messages(:assumed_header, :structure) if assumed_header
     end
 
+    def set_dialect(dialect)
+      begin
+        schema_dialect = @schema.tables[@source_url].dialect || {}
+      rescue
+        schema_dialect = {}
+      end
+      @dialect = {
+        "header" => true,
+        "delimiter" => ",",
+        "skipInitialSpace" => true,
+        "lineTerminator" => :auto,
+        "quoteChar" => '"',
+        "trim" => :true
+      }.merge(schema_dialect).merge(dialect || {})
+
+      @csv_header = @csv_header && @dialect["header"]
+      @csv_options = dialect_to_csv_options(@dialect)
+    end
+
     # analyses the provided csv and builds errors, warnings and info messages
     def parse_csv(io)
       @expected_columns = 0
@@ -134,7 +152,7 @@ module Csvlint
                build_errors(:blank_rows, :structure, current_line, nil, wrapper.line) if row.reject{ |c| c.nil? || c.empty? }.size == 0
                # Builds errors and warnings related to the provided schema file
                if @schema
-                 @schema.validate_row(row, current_line, all_errors)
+                 @schema.validate_row(row, current_line, all_errors, @source)
                  @errors += @schema.errors
                  all_errors += @schema.errors
                  @warnings += @schema.warnings
@@ -163,6 +181,7 @@ module Csvlint
 
     def validate_header(header)
       names = Set.new
+      header.map{|h| h.strip! } if @dialect["trim"] == :true
       header.each_with_index do |name,i|
         build_warnings(:empty_column_name, :schema, nil, i+1) if name == ""
         if names.include?(name)
@@ -172,7 +191,7 @@ module Csvlint
         end
       end
       if @schema
-        @schema.validate_header(header)
+        @schema.validate_header(header, @source)
         @errors += @schema.errors
         @warnings += @schema.warnings
       end
@@ -249,6 +268,96 @@ module Csvlint
       end
     end
 
+    def check_foreign_keys
+      if @schema.instance_of? Csvlint::Csvw::TableGroup
+        @schema.validate_foreign_keys
+        @errors += @schema.errors
+        @warnings += @schema.warnings
+      end
+    end
+
+    def locate_schema
+      @source_url = nil
+      warn_if_unsuccessful = false
+      case @source
+      when StringIO
+        return
+      when File
+        @source_url = "file:#{File.expand_path(@source)}"
+      else
+        @source_url = @source
+      end
+      unless @schema.nil?
+        if @schema.tables[@source_url]
+          return
+        else
+          @schema = nil
+        end
+      end
+      link_schema = nil
+      @link_headers.each do |link_header|
+        match = LINK_HEADER_REGEXP.match(link_header)
+        uri = match["uri"].gsub(/(^\<|\>$)/, "") rescue nil
+        rel = match["rel-relationship"].gsub(/(^\"|\"$)/, "") rescue nil
+        param = match["param"]
+        param_value = match["param-value"].gsub(/(^\"|\"$)/, "") rescue nil
+        if rel == "describedby" && param == "type" && ["application/csvm+json", "application/ld+json", "application/json"].include?(param_value)
+          begin
+            url = URI.join(@source_url, uri)
+            schema = Schema.load_from_json(url)
+            if schema.instance_of? Csvlint::Csvw::TableGroup
+              if schema.tables[@source_url]
+                link_schema = schema
+              else
+                warn_if_unsuccessful = true
+                build_warnings(:schema_mismatch, :context, nil, nil, @source_url, schema)
+              end
+            end
+          rescue OpenURI::HTTPError
+          end
+        end
+      end if @link_headers
+      @schema = link_schema if link_schema
+
+      paths = []
+      if @source_url =~ /^http(s)?/
+        begin
+          well_known_uri = URI.join(@source_url, "/.well-known/csvm")
+          well_known = open(well_known_uri).read
+          # TODO
+        rescue OpenURI::HTTPError
+        end
+      end
+      paths = ["{+url}-metadata.json", "csv-metadata.json"] if paths.empty?
+      paths.each do |template|
+        begin
+          template = URITemplate.new(template)
+          path = template.expand('url' => @source_url)
+          url = URI.join(@source_url, path)
+          url = File.new(url.to_s.sub(/^file:/, "")) if url.to_s =~ /^file:/
+          schema = Schema.load_from_json(url)
+          if schema.instance_of? Csvlint::Csvw::TableGroup
+            if schema.tables[@source_url]
+              @schema = schema
+            else
+              warn_if_unsuccessful = true
+              build_warnings(:schema_mismatch, :context, nil, nil, @source_url, schema)
+            end
+          end
+        rescue Errno::ENOENT
+        rescue OpenURI::HTTPError
+        rescue ArgumentError
+        rescue => e
+          STDERR.puts e.class
+          STDERR.puts e.message
+          STDERR.puts e.backtrace
+          raise e
+        end
+      end
+      build_warnings(:schema_mismatch, :context, nil, nil, @source_url, schema) if warn_if_unsuccessful
+      @schema = nil
+    end
+
     private
 
     def parse_extension(source)
@@ -302,5 +411,19 @@ module Csvlint
       :dateTime_short => /\A\d\d (?:#{Date::ABBR_MONTHNAMES.join('|')}) \d\d:\d\d\z/,   # "01 Jan 00:00"
       :dateTime_time => /\A\d\d:\d\d\z/,                                                # "00:00"
     }.freeze
+
+    URI_REGEXP = /(?<uri>.*?)/
+    TOKEN_REGEXP = /([^\(\)\<\>@,;:\\"\/\[\]\?=\{\} \t]+)/
+    QUOTED_STRING_REGEXP = /("[^"]*")/
+    SGML_NAME_REGEXP = /([A-Za-z][-A-Za-z0-9\.]*)/
+    RELATIONSHIP_REGEXP = Regexp.new("(?<relationship>#{SGML_NAME_REGEXP}|(\"#{SGML_NAME_REGEXP}(\\s+#{SGML_NAME_REGEXP})*\"))")
+    REL_REGEXP = Regexp.new("(?<rel>\\s*rel\\s*=\\s*(?<rel-relationship>#{RELATIONSHIP_REGEXP}))")
+    REV_REGEXP = Regexp.new("(?<rev>\\s*rev\\s*=\\s*#{RELATIONSHIP_REGEXP})")
+    TITLE_REGEXP = Regexp.new("(?<title>\\s*title\\s*=\\s*#{QUOTED_STRING_REGEXP})")
+    ANCHOR_REGEXP = Regexp.new("(?<anchor>\\s*anchor\\s*=\\s*\\<#{URI_REGEXP}\\>)")
+    LINK_EXTENSION_REGEXP = Regexp.new("(?<link-extension>(?<param>#{TOKEN_REGEXP})(\\s*=\\s*(?<param-value>#{TOKEN_REGEXP}|#{QUOTED_STRING_REGEXP}))?)")
+    LINK_PARAM_REGEXP = Regexp.new("(#{REL_REGEXP}|#{REV_REGEXP}|#{TITLE_REGEXP}|#{ANCHOR_REGEXP}|#{LINK_EXTENSION_REGEXP})")
+    LINK_HEADER_REGEXP = Regexp.new("\<#{URI_REGEXP}\>(\\s*;\\s*#{LINK_PARAM_REGEXP})*")
+
   end
 end

data/lib/csvlint/version.rb

@@ -1,3 +1,3 @@
 module Csvlint
-  VERSION = "0.1.4"
+  VERSION = "0.2.0"
 end

data/spec/csvw/column_spec.rb

@@ -0,0 +1,112 @@
+require 'spec_helper'
+
+describe Csvlint::Csvw::Column do
+
+  it "shouldn't generate errors for string values" do
+    column = Csvlint::Csvw::Column.new(1, "foo")
+    valid = column.validate("bar", 2)
+    expect(valid).to eq(true)
+  end
+
+  it "should generate errors for string values that aren't long enough" do
+    column = Csvlint::Csvw::Column.new(1, "foo", datatype: { "base" => "http://www.w3.org/2001/XMLSchema#string", "minLength" => 4 })
+    valid = column.validate("bar", 2)
+    expect(valid).to eq(false)
+    expect(column.errors.length).to eq(1)
+  end
+
+  it "shouldn't generate errors for string values that are long enough" do
+    column = Csvlint::Csvw::Column.new(1, "foo", datatype: { "base" => "http://www.w3.org/2001/XMLSchema#string", "minLength" => 4 })
+    valid = column.validate("barn", 2)
+    expect(valid).to eq(true)
+    expect(column.errors.length).to eq(0)
+  end
+
+  context "when parsing CSVW column descriptions" do
+    it "should provide appropriate default values" do
+      @desc=<<-EOL
+      {
+        "name": "countryCode"
+      }
+      EOL
+      json = JSON.parse( @desc )
+      column = Csvlint::Csvw::Column.from_json(1, json)
+
+      expect(column).to be_a(Csvlint::Csvw::Column)
+      expect(column.number).to eq(1)
+      expect(column.name).to eq("countryCode")
+      expect(column.about_url).to eq(nil)
+      expect(column.datatype).to eq({ "@id" => "http://www.w3.org/2001/XMLSchema#string" })
+      expect(column.default).to eq("")
+      expect(column.lang).to eq("und")
+      expect(column.null).to eq([""])
+      expect(column.ordered).to eq(false)
+      expect(column.property_url).to eq(nil)
+      expect(column.required).to eq(false)
+      expect(column.separator).to eq(nil)
+      expect(column.source_number).to eq(1)
+      expect(column.suppress_output).to eq(false)
+      expect(column.text_direction).to eq(:inherit)
+      expect(column.titles).to eq(nil)
+      expect(column.value_url).to eq(nil)
+      expect(column.virtual).to eq(false)
+      expect(column.annotations).to eql({})
+    end
+
+    it "should override default values" do
+      @desc=<<-EOL
+      {
+        "name": "countryCode",
+        "titles": "countryCode",
+        "propertyUrl": "http://www.geonames.org/ontology{#_name}"
+      }
+      EOL
+      json = JSON.parse( @desc )
+      column = Csvlint::Csvw::Column.from_json(2, json)
+
+      expect(column).to be_a(Csvlint::Csvw::Column)
+      expect(column.number).to eq(2)
+      expect(column.name).to eq("countryCode")
+      expect(column.about_url).to eq(nil)
+      expect(column.datatype).to eq({ "@id" => "http://www.w3.org/2001/XMLSchema#string" })
+      expect(column.default).to eq("")
+      expect(column.lang).to eq("und")
+      expect(column.null).to eq([""])
+      expect(column.ordered).to eq(false)
+      expect(column.property_url).to eq("http://www.geonames.org/ontology{#_name}")
+      expect(column.required).to eq(false)
+      expect(column.separator).to eq(nil)
+      expect(column.source_number).to eq(2)
+      expect(column.suppress_output).to eq(false)
+      expect(column.text_direction).to eq(:inherit)
+      expect(column.titles).to eql({ "und" => [ "countryCode" ]})
+      expect(column.value_url).to eq(nil)
+      expect(column.virtual).to eq(false)
+      expect(column.annotations).to eql({})
+    end
+
+    it "should include the datatype" do
+      @desc=<<-EOL
+      { "name": "Id", "required": true, "datatype": { "base": "string", "minLength": 3 } }
+      EOL
+      json = JSON.parse(@desc)
+      column = Csvlint::Csvw::Column.from_json(1, json)
+      expect(column.name).to eq("Id")
+      expect(column.required).to eq(true)
+      expect(column.datatype).to eql({ "base" => "http://www.w3.org/2001/XMLSchema#string", "minLength" => 3 })
+    end
+
+    it "should generate warnings for invalid null values" do
+      @desc=<<-EOL
+      {
+        "name": "countryCode",
+        "null": true
+      }
+      EOL
+      json = JSON.parse( @desc )
+      column = Csvlint::Csvw::Column.from_json(1, json)
+      expect(column.warnings.length).to eq(1)
+      expect(column.warnings[0].type).to eq(:invalid_value)
+    end
+  end
+end

data/spec/csvw/date_format_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+describe Csvlint::Csvw::NumberFormat do
+
+  it "should parse dates that match yyyy-MM-dd correctly" do
+    format = Csvlint::Csvw::DateFormat.new("yyyy-MM-dd")
+    expect(format.parse("2015-03-22")).to eql(Date.new(2015, 3, 22))
+    expect(format.parse("2015-02-30")).to eql(nil)
+    expect(format.parse("22/03/2015")).to eq(nil)
+  end
+
+  it "should parse times that match HH:mm:ss correctly" do
+    format = Csvlint::Csvw::DateFormat.new("HH:mm:ss")
+    expect(format.parse("12:34:56")).to eql({ "hour" => 12, "minute" => 34, "second" => 56.0 })
+    expect(format.parse("22/03/2015")).to eq(nil)
+  end
+
+  it "should parse times that match HH:mm:ss.SSS correctly" do
+    format = Csvlint::Csvw::DateFormat.new("HH:mm:ss.SSS")
+    expect(format.parse("12:34:56")).to eql({ "hour" => 12, "minute" => 34, "second" => 56.0 })
+    expect(format.parse("12:34:56.78")).to eql({ "hour" => 12, "minute" => 34, "second" => 56.78 })
+    expect(format.parse("12:34:56.789")).to eql({ "hour" => 12, "minute" => 34, "second" => 56.789 })
+    expect(format.parse("12:34:56.7890")).to eql(nil)
+    expect(format.parse("22/03/2015")).to eq(nil)
+  end
+
+  it "should parse dateTimes that match yyyy-MM-ddTHH:mm:ss correctly" do
+    format = Csvlint::Csvw::DateFormat.new("yyyy-MM-ddTHH:mm:ss")
+    expect(format.parse("2015-03-15T15:02:37")).to eql(DateTime.new(2015, 3, 15, 15, 2, 37))
+    expect(format.parse("12:34:56")).to eql(nil)
+    expect(format.parse("22/03/2015")).to eq(nil)
+  end
+
+  it "should parse dateTimes that match yyyy-MM-ddTHH:mm:ss.S correctly" do
+    format = Csvlint::Csvw::DateFormat.new("yyyy-MM-ddTHH:mm:ss.S")
+    expect(format.parse("2015-03-15T15:02:37")).to eql(DateTime.new(2015, 3, 15, 15, 2, 37.0))
+    expect(format.parse("2015-03-15T15:02:37.4")).to eql(DateTime.new(2015, 3, 15, 15, 2, 37.4))
+    expect(format.parse("2015-03-15T15:02:37.45")).to eql(nil)
+    expect(format.parse("12:34:56")).to eql(nil)
+    expect(format.parse("22/03/2015")).to eq(nil)
+  end
+
+  it "should parse dateTimes that match M/d/yyyy HH:mm correctly" do
+    format = Csvlint::Csvw::DateFormat.new("M/d/yyyy HH:mm")
+    expect(format.parse("2015-03-15T15:02:37")).to eql(nil)
+    expect(format.parse("3/15/2015 15:02")).to eql(DateTime.new(2015, 3, 15, 15, 2))
+  end
+
+end

data/spec/csvw/number_format_spec.rb

@@ -0,0 +1,403 @@
+require 'spec_helper'
+
+describe Csvlint::Csvw::NumberFormat do
+
+  it "should correctly parse #,##0.##" do
+    format = Csvlint::Csvw::NumberFormat.new("#,##0.##")
+    expect(format.pattern).to eq("#,##0.##")
+    expect(format.prefix).to eq("")
+    expect(format.numeric_part).to eq("#,##0.##")
+    expect(format.suffix).to eq("")
+    expect(format.grouping_separator).to eq(",")
+    expect(format.decimal_separator).to eq(".")
+    expect(format.primary_grouping_size).to eq(3)
+    expect(format.secondary_grouping_size).to eq(3)
+    expect(format.fractional_grouping_size).to eq(0)
+  end
+
+  it "should correctly parse ###0.#####" do
+    format = Csvlint::Csvw::NumberFormat.new("###0.#####")
+    expect(format.primary_grouping_size).to eq(0)
+    expect(format.secondary_grouping_size).to eq(0)
+    expect(format.fractional_grouping_size).to eq(0)
+  end
+
+  it "should correctly parse ###0.0000#" do
+    format = Csvlint::Csvw::NumberFormat.new("###0.0000#")
+    expect(format.primary_grouping_size).to eq(0)
+    expect(format.secondary_grouping_size).to eq(0)
+    expect(format.fractional_grouping_size).to eq(0)
+  end
+
+  it "should correctly parse #,##,###,####" do
+    format = Csvlint::Csvw::NumberFormat.new("#,##,###,####")
+    expect(format.primary_grouping_size).to eq(4)
+    expect(format.secondary_grouping_size).to eq(3)
+    expect(format.fractional_grouping_size).to eq(0)
+  end
+
+  it "should correctly parse #,##0.###,#" do
+    format = Csvlint::Csvw::NumberFormat.new("#,##0.###,#")
+    expect(format.primary_grouping_size).to eq(3)
+    expect(format.secondary_grouping_size).to eq(3)
+    expect(format.fractional_grouping_size).to eq(3)
+  end
+
+  it "should correctly parse #0.###E#0" do
+    format = Csvlint::Csvw::NumberFormat.new("#0.###E#0")
+    expect(format.prefix).to eq("")
+    expect(format.numeric_part).to eq("#0.###E#0")
+    expect(format.suffix).to eq("")
+  end
+
+  it "should match numbers that match ##0 correctly" do
+    format = Csvlint::Csvw::NumberFormat.new("##0")
+    expect(format.match("1")).to eq(true)
+    expect(format.match("12")).to eq(true)
+    expect(format.match("123")).to eq(true)
+    expect(format.match("1234")).to eq(true)
+    expect(format.match("1,234")).to eq(false)
+    expect(format.match("123.4")).to eq(false)
+  end
+
+  it "should match numbers that match #,#00 correctly" do
+    format = Csvlint::Csvw::NumberFormat.new("#,#00")
+    expect(format.match("1")).to eq(false)
+    expect(format.match("12")).to eq(true)
+    expect(format.match("123")).to eq(true)
+    expect(format.match("1234")).to eq(false)
+    expect(format.match("1,234")).to eq(true)
+    expect(format.match("1,234,568")).to eq(true)
+    expect(format.match("12,34,568")).to eq(false)
+    expect(format.match("12,34")).to eq(false)
+    expect(format.match("123.4")).to eq(false)
+  end
+
+  it "should match numbers that match #,000 correctly" do
+    format = Csvlint::Csvw::NumberFormat.new("#,000")
+    expect(format.match("1")).to eq(false)
+    expect(format.match("12")).to eq(false)
+    expect(format.match("123")).to eq(true)
+    expect(format.match("1234")).to eq(false)
+    expect(format.match("1,234")).to eq(true)
+    expect(format.match("1,234,568")).to eq(true)
+    expect(format.match("12,34,568")).to eq(false)
+    expect(format.match("12,34")).to eq(false)
+    expect(format.match("123.4")).to eq(false)
+  end
+
+  it "should match numbers that match #,##,#00 correctly" do
+    format = Csvlint::Csvw::NumberFormat.new("#,##,#00")
+    expect(format.match("1")).to eq(false)
+    expect(format.match("12")).to eq(true)
+    expect(format.match("123")).to eq(true)
+    expect(format.match("1234")).to eq(false)
+    expect(format.match("1,234")).to eq(true)
+    expect(format.match("1,234,568")).to eq(false)
+    expect(format.match("12,34,568")).to eq(true)
+    expect(format.match("12,34")).to eq(false)
+    expect(format.match("123.4")).to eq(false)
+  end
+
+  it "should match numbers that match #0.# correctly" do
+    format = Csvlint::Csvw::NumberFormat.new("#0.#")
+    expect(format.match("1")).to eq(true)
+    expect(format.match("12")).to eq(true)
+    expect(format.match("12.3")).to eq(true)
+    expect(format.match("12.34")).to eq(false)
+    expect(format.match("1234.5")).to eq(true)
+    expect(format.match("1,234.5")).to eq(false)
+  end
+
+  it "should match numbers that match #0.0 correctly" do
+    format = Csvlint::Csvw::NumberFormat.new("#0.0")
+    expect(format.match("1")).to eq(false)
+    expect(format.match("12")).to eq(false)
+    expect(format.match("12.3")).to eq(true)
+    expect(format.match("12.34")).to eq(false)
+    expect(format.match("1234.5")).to eq(true)
+    expect(format.match("1,234.5")).to eq(false)
+  end
+
+  it "should match numbers that match #0.0# correctly" do
+    format = Csvlint::Csvw::NumberFormat.new("#0.0#")
+    expect(format.match("1")).to eq(false)
+    expect(format.match("12")).to eq(false)
+    expect(format.match("12.3")).to eq(true)
+    expect(format.match("12.34")).to eq(true)
+    expect(format.match("12.345")).to eq(false)
+  end
+
+  it "should match numbers that match #0.0#,# correctly" do
+    format = Csvlint::Csvw::NumberFormat.new("#0.0#,#")
+    expect(format.match("1")).to eq(false)
+    expect(format.match("12.3")).to eq(true)
+    expect(format.match("12.34")).to eq(true)
+    expect(format.match("12.345")).to eq(false)
+    expect(format.match("12.34,5")).to eq(true)
+    expect(format.match("12.34,56")).to eq(false)
+    expect(format.match("12.34,567")).to eq(false)
+    expect(format.match("12.34,56,7")).to eq(false)
+  end
+
+  it "should match numbers that match #0.###E#0 correctly" do
+    format = Csvlint::Csvw::NumberFormat.new("#0.###E#0")
+    expect(format.match("1")).to eq(false)
+    expect(format.match("12.3")).to eq(false)
+    expect(format.match("12.34")).to eq(false)
+    expect(format.match("12.3E4")).to eq(true)
+    expect(format.match("12.3E45")).to eq(true)
+    expect(format.match("12.34E5")).to eq(true)
+  end
+
+  it "should parse numbers that match ##0 correctly" do
+    format = Csvlint::Csvw::NumberFormat.new("##0")
+    expect(format.parse("1")).to eql(1)
+    expect(format.parse("12")).to eql(12)
+    expect(format.parse("123")).to eql(123)
+    expect(format.parse("1234")).to eql(1234)
+    expect(format.parse("1,234")).to eq(nil)
+    expect(format.parse("123.4")).to eq(nil)
+  end
+
+  it "should parse numbers that match #,#00 correctly" do
+    format = Csvlint::Csvw::NumberFormat.new("#,#00")
+    expect(format.parse("1")).to eq(nil)
+    expect(format.parse("12")).to eql(12)
+    expect(format.parse("123")).to eql(123)
+    expect(format.parse("1234")).to eq(nil)
+    expect(format.parse("1,234")).to eql(1234)
+    expect(format.parse("1,234,568")).to eql(1234568)
+    expect(format.parse("12,34,568")).to eq(nil)
+    expect(format.parse("12,34")).to eq(nil)
+    expect(format.parse("123.4")).to eq(nil)
+  end
+
+  it "should parse numbers that match #,000 correctly" do
+    format = Csvlint::Csvw::NumberFormat.new("#,000")
+    expect(format.parse("1")).to eq(nil)
+    expect(format.parse("12")).to eq(nil)
+    expect(format.parse("123")).to eql(123)
+    expect(format.parse("1234")).to eq(nil)
+    expect(format.parse("1,234")).to eql(1234)
+    expect(format.parse("1,234,568")).to eql(1234568)
+    expect(format.parse("12,34,568")).to eq(nil)
+    expect(format.parse("12,34")).to eq(nil)
+    expect(format.parse("123.4")).to eq(nil)
+  end
+
+  it "should parse numbers that match #0,000 correctly" do
+    format = Csvlint::Csvw::NumberFormat.new("#0,000")
+    expect(format.parse("1")).to eq(nil)
+    expect(format.parse("12")).to eq(nil)
+    expect(format.parse("123")).to eql(nil)
+    expect(format.parse("1234")).to eq(nil)
+    expect(format.parse("1,234")).to eql(1234)
+    expect(format.parse("1,234,568")).to eql(1234568)
+    expect(format.parse("12,34,568")).to eq(nil)
+    expect(format.parse("12,34")).to eq(nil)
+    expect(format.parse("123.4")).to eq(nil)
+  end
+
+  it "should parse numbers that match #,##,#00 correctly" do
+    format = Csvlint::Csvw::NumberFormat.new("#,##,#00")
+    expect(format.parse("1")).to eq(nil)
+    expect(format.parse("12")).to eql(12)
+    expect(format.parse("123")).to eql(123)
+    expect(format.parse("1234")).to eq(nil)
+    expect(format.parse("1,234")).to eql(1234)
+    expect(format.parse("12,345")).to eql(12345)
+    expect(format.parse("1,234,568")).to eq(nil)
+    expect(format.parse("12,34,568")).to eql(1234568)
+    expect(format.parse("12,34")).to eq(nil)
+    expect(format.parse("123.4")).to eq(nil)
+  end
+
+  it "should parse numbers that match #,00,000 correctly" do
+    format = Csvlint::Csvw::NumberFormat.new("#,00,000")
+    expect(format.parse("1")).to eq(nil)
+    expect(format.parse("12")).to eql(nil)
+    expect(format.parse("123")).to eql(nil)
+    expect(format.parse("1234")).to eq(nil)
+    expect(format.parse("1,234")).to eql(nil)
+    expect(format.parse("12,345")).to eql(12345)
+    expect(format.parse("1,234,568")).to eq(nil)
+    expect(format.parse("1,34,568")).to eql(134568)
+    expect(format.parse("12,34,568")).to eql(1234568)
+    expect(format.parse("1,23,45,678")).to eql(12345678)
+    expect(format.parse("12,34")).to eq(nil)
+    expect(format.parse("123.4")).to eq(nil)
+  end
+
+  it "should parse numbers that match 0,00,000 correctly" do
+    format = Csvlint::Csvw::NumberFormat.new("0,00,000")
+    expect(format.parse("1")).to eq(nil)
+    expect(format.parse("12")).to eql(nil)
+    expect(format.parse("123")).to eql(nil)
+    expect(format.parse("1234")).to eq(nil)
+    expect(format.parse("1,234")).to eql(nil)
+    expect(format.parse("12,345")).to eql(nil)
+    expect(format.parse("1,234,568")).to eq(nil)
+    expect(format.parse("1,34,568")).to eql(134568)
+    expect(format.parse("12,34,568")).to eql(1234568)
+    expect(format.parse("1,23,45,678")).to eql(12345678)
+    expect(format.parse("12,34")).to eq(nil)
+    expect(format.parse("123.4")).to eq(nil)
+  end
+
+  it "should parse numbers that match #0.# correctly" do
+    format = Csvlint::Csvw::NumberFormat.new("#0.#")
+    expect(format.parse("1")).to eql(1.0)
+    expect(format.parse("12")).to eql(12.0)
+    expect(format.parse("12.3")).to eql(12.3)
+    expect(format.parse("12.34")).to eq(nil)
+    expect(format.parse("1234.5")).to eql(1234.5)
+    expect(format.parse("1,234.5")).to eq(nil)
+  end
+
+  it "should parse numbers that match #0.0 correctly" do
+    format = Csvlint::Csvw::NumberFormat.new("#0.0")
+    expect(format.parse("1")).to eq(nil)
+    expect(format.parse("12")).to eq(nil)
+    expect(format.parse("12.3")).to eql(12.3)
+    expect(format.parse("12.34")).to eq(nil)
+    expect(format.parse("1234.5")).to eql(1234.5)
+    expect(format.parse("1,234.5")).to eq(nil)
+  end
+
+  it "should parse numbers that match #0.0# correctly" do
+    format = Csvlint::Csvw::NumberFormat.new("#0.0#")
+    expect(format.parse("1")).to eq(nil)
+    expect(format.parse("12")).to eq(nil)
+    expect(format.parse("12.3")).to eql(12.3)
+    expect(format.parse("12.34")).to eql(12.34)
+    expect(format.parse("12.345")).to eq(nil)
+  end
+
+  it "should parse numbers that match #0.0#,# correctly" do
+    format = Csvlint::Csvw::NumberFormat.new("#0.0#,#")
+    expect(format.parse("1")).to eq(nil)
+    expect(format.parse("12.3")).to eql(12.3)
+    expect(format.parse("12.34")).to eql(12.34)
+    expect(format.parse("12.345")).to eq(nil)
+    expect(format.parse("12.34,5")).to eql(12.345)
+    expect(format.parse("12.34,56")).to eql(nil)
+    expect(format.parse("12.34,567")).to eq(nil)
+    expect(format.parse("12.34,56,7")).to eql(nil)
+  end
+
+  it "should parse numbers that match 0.0##,### correctly" do
+    format = Csvlint::Csvw::NumberFormat.new("0.0##,###")
+    expect(format.parse("1")).to eq(nil)
+    expect(format.parse("12.3")).to eql(12.3)
+    expect(format.parse("12.34")).to eql(12.34)
+    expect(format.parse("12.345")).to eq(12.345)
+    expect(format.parse("12.3456")).to eql(nil)
+    expect(format.parse("12.345,6")).to eql(12.3456)
+    expect(format.parse("12.34,56")).to eql(nil)
+    expect(format.parse("12.345,67")).to eq(12.34567)
+    expect(format.parse("12.345,678")).to eql(12.345678)
+    expect(format.parse("12.345,67,8")).to eql(nil)
+  end
+
+  it "should parse numbers that match 0.000,### correctly" do
+    format = Csvlint::Csvw::NumberFormat.new("0.000,###")
+    expect(format.parse("1")).to eq(nil)
+    expect(format.parse("12.3")).to eql(nil)
+    expect(format.parse("12.34")).to eql(nil)
+    expect(format.parse("12.345")).to eq(12.345)
+    expect(format.parse("12.3456")).to eql(nil)
+    expect(format.parse("12.345,6")).to eql(12.3456)
+    expect(format.parse("12.34,56")).to eql(nil)
+    expect(format.parse("12.345,67")).to eq(12.34567)
+    expect(format.parse("12.345,678")).to eql(12.345678)
+    expect(format.parse("12.345,67,8")).to eql(nil)
+  end
+
+  it "should parse numbers that match 0.000,0# correctly" do
+    format = Csvlint::Csvw::NumberFormat.new("0.000,0#")
+    expect(format.parse("1")).to eq(nil)
+    expect(format.parse("12.3")).to eql(nil)
+    expect(format.parse("12.34")).to eql(nil)
+    expect(format.parse("12.345")).to eq(nil)
+    expect(format.parse("12.3456")).to eql(nil)
+    expect(format.parse("12.345,6")).to eql(12.3456)
+    expect(format.parse("12.34,56")).to eql(nil)
+    expect(format.parse("12.345,67")).to eq(12.34567)
+    expect(format.parse("12.345,678")).to eql(nil)
+    expect(format.parse("12.345,67,8")).to eql(nil)
+  end
+
+  it "should parse numbers that match 0.000,0## correctly" do
+    format = Csvlint::Csvw::NumberFormat.new("0.000,0##")
+    expect(format.parse("1")).to eq(nil)
+    expect(format.parse("12.3")).to eql(nil)
+    expect(format.parse("12.34")).to eql(nil)
+    expect(format.parse("12.345")).to eq(nil)
+    expect(format.parse("12.3456")).to eql(nil)
+    expect(format.parse("12.345,6")).to eql(12.3456)
+    expect(format.parse("12.34,56")).to eql(nil)
+    expect(format.parse("12.345,67")).to eq(12.34567)
+    expect(format.parse("12.345,678")).to eql(12.345678)
+    expect(format.parse("12.345,67,8")).to eql(nil)
+  end
+
+  it "should parse numbers that match 0.000,000 correctly" do
+    format = Csvlint::Csvw::NumberFormat.new("0.000,000")
+    expect(format.parse("1")).to eq(nil)
+    expect(format.parse("12.3")).to eql(nil)
+    expect(format.parse("12.34")).to eql(nil)
+    expect(format.parse("12.345")).to eq(nil)
+    expect(format.parse("12.3456")).to eql(nil)
+    expect(format.parse("12.345,6")).to eql(nil)
+    expect(format.parse("12.34,56")).to eql(nil)
+    expect(format.parse("12.345,67")).to eq(nil)
+    expect(format.parse("12.345,678")).to eql(12.345678)
+    expect(format.parse("12.345,67,8")).to eql(nil)
+  end
+
+  it "should parse numbers that match #0.###E#0 correctly" do
+    format = Csvlint::Csvw::NumberFormat.new("#0.###E#0")
+    expect(format.parse("1")).to eq(nil)
+    expect(format.parse("12.3")).to eq(nil)
+    expect(format.parse("12.34")).to eq(nil)
+    expect(format.parse("12.3E4")).to eql(12.3E4)
+    expect(format.parse("12.3E45")).to eql(12.3E45)
+    expect(format.parse("12.34E5")).to eql(12.34E5)
+  end
+
+  it "should parse numbers normally when there is no pattern" do
+    format = Csvlint::Csvw::NumberFormat.new()
+    expect(format.parse("1")).to eql(1)
+    expect(format.parse("-1")).to eql(-1)
+    expect(format.parse("12.3")).to eql(12.3)
+    expect(format.parse("12.34")).to eql(12.34)
+    expect(format.parse("12.3E4")).to eql(12.3E4)
+    expect(format.parse("12.3E45")).to eql(12.3E45)
+    expect(format.parse("12.34E5")).to eql(12.34E5)
+    expect(format.parse("12.34e5")).to eql(12.34E5)
+    expect(format.parse("-12.34")).to eql(-12.34)
+    expect(format.parse("1,234")).to eq(nil)
+    expect(format.parse("NaN").nan?).to eq(true)
+    expect(format.parse("INF")).to eql(Float::INFINITY)
+    expect(format.parse("-INF")).to eql(-Float::INFINITY)
+    expect(format.parse("123456.789F10")).to eq(nil)
+  end
+
+  it "should parse numbers including grouping separators when they are specified" do
+    format = Csvlint::Csvw::NumberFormat.new(nil, ",")
+    expect(format.parse("1")).to eql(1)
+    expect(format.parse("12.3")).to eql(12.3)
+    expect(format.parse("12.34")).to eql(12.34)
+    expect(format.parse("12.3E4")).to eql(12.3E4)
+    expect(format.parse("12.3E45")).to eql(12.3E45)
+    expect(format.parse("12.34E5")).to eql(12.34E5)
+    expect(format.parse("1,234")).to eql(1234)
+    expect(format.parse("1,234,567")).to eql(1234567)
+    expect(format.parse("1,,234")).to eq(nil)
+    expect(format.parse("NaN").nan?).to eq(true)
+    expect(format.parse("INF")).to eql(Float::INFINITY)
+    expect(format.parse("-INF")).to eql(-Float::INFINITY)
+  end
+
+end