wjordan213-csvlint 0.2.8

data/lib/csvlint/csvw/date_format.rb

@@ -0,0 +1,182 @@
+module Csvlint
+  module Csvw
+    class DateFormat
+
+      attr_reader :pattern
+
+      def initialize(pattern, datatype=nil)
+        @pattern = pattern
+
+        if @pattern.nil?
+          @regexp = DEFAULT_REGEXP[datatype]
+          @type = datatype
+        else
+          test_pattern = pattern.clone
+          test_pattern.gsub!(/S+/, "")
+          FIELDS.keys.sort_by{|f| -f.length}.each do |field|
+            test_pattern.gsub!(field, "")
+          end
+          raise Csvw::DateFormatError, "unrecognised date field symbols in date format" if test_pattern =~ /[GyYuUrQqMLlwWdDFgEecahHKkjJmsSAzZOvVXx]/
+
+          @regexp = DATE_PATTERN_REGEXP[@pattern]
+          @type = @regexp.nil? ? "http://www.w3.org/2001/XMLSchema#time" : "http://www.w3.org/2001/XMLSchema#date"
+          @regexp = @regexp || TIME_PATTERN_REGEXP[@pattern]
+          @type = @regexp.nil? ? "http://www.w3.org/2001/XMLSchema#dateTime" : @type
+          @regexp = @regexp || DATE_TIME_PATTERN_REGEXP[@pattern]
+
+          if @regexp.nil?
+            regexp = @pattern
+
+            @type = "http://www.w3.org/2001/XMLSchema#date" if !(regexp =~ /HH/) && regexp =~ /yyyy/
+            @type = "http://www.w3.org/2001/XMLSchema#time" if regexp =~ /HH/ && !(regexp =~ /yyyy/)
+            @type = "http://www.w3.org/2001/XMLSchema#dateTime" if regexp =~ /HH/ && regexp =~ /yyyy/
+
+            regexp = regexp.sub("HH", FIELDS["HH"].to_s)
+            regexp = regexp.sub("mm", FIELDS["mm"].to_s)
+            if @pattern =~ /ss\.S+/
+              max_fractional_seconds = @pattern.split(".")[-1].length
+              regexp = regexp.sub(/ss\.S+$/, "(?<second>#{FIELDS["ss"]}(\.[0-9]{1,#{max_fractional_seconds}})?)")
+            else
+              regexp = regexp.sub("ss", "(?<second>#{FIELDS["ss"]})")
+            end
+
+            if regexp =~ /yyyy/
+              regexp = regexp.sub("yyyy", FIELDS["yyyy"].to_s)
+              regexp = regexp.sub("MM", FIELDS["MM"].to_s)
+              regexp = regexp.sub("M", FIELDS["M"].to_s)
+              regexp = regexp.sub("dd", FIELDS["dd"].to_s)
+              regexp = regexp.sub(/d(?=[-T \/\.])/, FIELDS["d"].to_s)
+            end
+
+            regexp = regexp.sub("XXX", FIELDS["XXX"].to_s)
+            regexp = regexp.sub("XX", FIELDS["XX"].to_s)
+            regexp = regexp.sub("X", FIELDS["X"].to_s)
+            regexp = regexp.sub("xxx", FIELDS["xxx"].to_s)
+            regexp = regexp.sub("xx", FIELDS["xx"].to_s)
+            regexp = regexp.sub(/x(?!:)/, FIELDS["x"].to_s)
+
+            @regexp = Regexp.new("^#{regexp}$")
+          end
+        end
+      end
+
+      def match(value)
+        value =~ @regexp ? true : false
+      end
+
+      def parse(value)
+        match = @regexp.match(value)
+        return nil if match.nil?
+        # STDERR.puts(@regexp)
+        # STDERR.puts(value)
+        # STDERR.puts(match.inspect)
+        case @type
+        when "http://www.w3.org/2001/XMLSchema#date"
+          begin
+            return Date.new(match["year"].to_i, match["month"].to_i, match["day"].to_i)
+          rescue ArgumentError
+            return nil
+          end
+        when "http://www.w3.org/2001/XMLSchema#dateTime"
+          begin
+            return DateTime.new(match["year"].to_i, match["month"].to_i, match["day"].to_i, match["hour"].to_i, match["minute"].to_i, (match.names.include?("second") ? match["second"].to_f : 0), match.names.include?("timezone") && match["timezone"] ? match["timezone"] : '')
+          rescue ArgumentError
+            return nil
+          end
+        else
+          value = {}
+          match.names.each do |field|
+            unless match[field].nil?
+              case field
+              when "timezone"
+                tz = match["timezone"]
+                tz = "+00:00" if tz == 'Z'
+                tz += ':00' if tz.length == 3
+                tz = "#{tz[0..2]}:#{tz[3..4]}" unless tz =~ /:/
+                value["timezone"] = tz
+              when "second"
+                value["second"] = match["second"].to_f
+              else
+                value[field] = match[field].to_i
+              end
+            end
+          end
+          return value
+        end
+      end
+
+      private
+        FIELDS = {
+          "yyyy" => /(?<year>-?([1-9][0-9]{3,}|0[0-9]{3}))/,
+          "MM" => /(?<month>0[1-9]|1[0-2])/,
+          "M" => /(?<month>[1-9]|1[0-2])/,
+          "dd" => /(?<day>0[1-9]|[12][0-9]|3[01])/,
+          "d" => /(?<day>[1-9]|[12][0-9]|3[01])/,
+          "HH" => /(?<hour>[01][0-9]|2[0-3])/,
+          "mm" => /(?<minute>[0-5][0-9])/,
+          "ss" => /([0-6][0-9])/,
+          "X" => /(?<timezone>Z|[-+]((0[0-9]|1[0-3])([0-5][0-9])?|14(00)?))/,
+          "XX" => /(?<timezone>Z|[-+]((0[0-9]|1[0-3])[0-5][0-9]|1400))/,
+          "XXX" => /(?<timezone>Z|[-+]((0[0-9]|1[0-3]):[0-5][0-9]|14:00))/,
+          "x" => /(?<timezone>[-+]((0[0-9]|1[0-3])([0-5][0-9])?|14(00)?))/,
+          "xx" => /(?<timezone>[-+]((0[0-9]|1[0-3])[0-5][0-9]|1400))/,
+          "xxx" => /(?<timezone>[-+]((0[0-9]|1[0-3]):[0-5][0-9]|14:00))/,
+        }
+
+        DATE_PATTERN_REGEXP = {
+          "yyyy-MM-dd" => Regexp.new("^#{FIELDS["yyyy"]}-#{FIELDS["MM"]}-#{FIELDS["dd"]}$"),
+          "yyyyMMdd" => Regexp.new("^#{FIELDS["yyyy"]}#{FIELDS["MM"]}#{FIELDS["dd"]}$"),
+          "dd-MM-yyyy" => Regexp.new("^#{FIELDS["dd"]}-#{FIELDS["MM"]}-#{FIELDS["yyyy"]}$"),
+          "d-M-yyyy" => Regexp.new("^#{FIELDS["d"]}-#{FIELDS["M"]}-#{FIELDS["yyyy"]}$"),
+          "MM-dd-yyyy" => Regexp.new("^#{FIELDS["MM"]}-#{FIELDS["dd"]}-#{FIELDS["yyyy"]}$"),
+          "M-d-yyyy" => Regexp.new("^#{FIELDS["M"]}-#{FIELDS["d"]}-#{FIELDS["yyyy"]}$"),
+          "dd/MM/yyyy" => Regexp.new("^#{FIELDS["dd"]}/#{FIELDS["MM"]}/#{FIELDS["yyyy"]}$"),
+          "d/M/yyyy" => Regexp.new("^#{FIELDS["d"]}/#{FIELDS["M"]}/#{FIELDS["yyyy"]}$"),
+          "MM/dd/yyyy" => Regexp.new("^#{FIELDS["MM"]}/#{FIELDS["dd"]}/#{FIELDS["yyyy"]}$"),
+          "M/d/yyyy" => Regexp.new("^#{FIELDS["M"]}/#{FIELDS["d"]}/#{FIELDS["yyyy"]}$"),
+          "dd.MM.yyyy" => Regexp.new("^#{FIELDS["dd"]}.#{FIELDS["MM"]}.#{FIELDS["yyyy"]}$"),
+          "d.M.yyyy" => Regexp.new("^#{FIELDS["d"]}.#{FIELDS["M"]}.#{FIELDS["yyyy"]}$"),
+          "MM.dd.yyyy" => Regexp.new("^#{FIELDS["MM"]}.#{FIELDS["dd"]}.#{FIELDS["yyyy"]}$"),
+          "M.d.yyyy" => Regexp.new("^#{FIELDS["M"]}.#{FIELDS["d"]}.#{FIELDS["yyyy"]}$")
+        }
+
+        TIME_PATTERN_REGEXP = {
+          "HH:mm:ss" => Regexp.new("^#{FIELDS["HH"]}:#{FIELDS["mm"]}:(?<second>#{FIELDS["ss"]})$"),
+          "HHmmss" => Regexp.new("^#{FIELDS["HH"]}#{FIELDS["mm"]}(?<second>#{FIELDS["ss"]})$"),
+          "HH:mm" => Regexp.new("^#{FIELDS["HH"]}:#{FIELDS["mm"]}$"),
+          "HHmm" => Regexp.new("^#{FIELDS["HH"]}#{FIELDS["mm"]}$")
+        }
+
+        DATE_TIME_PATTERN_REGEXP = {
+          "yyyy-MM-ddTHH:mm:ss" => Regexp.new("^#{FIELDS["yyyy"]}-#{FIELDS["MM"]}-#{FIELDS["dd"]}T#{FIELDS["HH"]}:#{FIELDS["mm"]}:(?<second>#{FIELDS["ss"]})$"),
+          "yyyy-MM-ddTHH:mm" => Regexp.new("^#{FIELDS["yyyy"]}-#{FIELDS["MM"]}-#{FIELDS["dd"]}T#{FIELDS["HH"]}:#{FIELDS["mm"]}$")
+        }
+
+        DEFAULT_REGEXP = {
+          "http://www.w3.org/2001/XMLSchema#date" =>
+            Regexp.new("^#{FIELDS["yyyy"]}-#{FIELDS["MM"]}-#{FIELDS["dd"]}#{FIELDS["XXX"]}?$"),
+          "http://www.w3.org/2001/XMLSchema#dateTime" =>
+            Regexp.new("^#{FIELDS["yyyy"]}-#{FIELDS["MM"]}-#{FIELDS["dd"]}T#{FIELDS["HH"]}:#{FIELDS["mm"]}:(?<second>#{FIELDS["ss"]}(\.[0-9]+)?)#{FIELDS["XXX"]}?$"),
+          "http://www.w3.org/2001/XMLSchema#dateTimeStamp" =>
+            Regexp.new("^#{FIELDS["yyyy"]}-#{FIELDS["MM"]}-#{FIELDS["dd"]}T#{FIELDS["HH"]}:#{FIELDS["mm"]}:(?<second>#{FIELDS["ss"]}(\.[0-9]+)?)#{FIELDS["XXX"]}$"),
+          "http://www.w3.org/2001/XMLSchema#gDay" =>
+            Regexp.new("^---#{FIELDS["dd"]}#{FIELDS["XXX"]}?$"),
+          "http://www.w3.org/2001/XMLSchema#gMonth" =>
+            Regexp.new("^--#{FIELDS["MM"]}#{FIELDS["XXX"]}?$"),
+          "http://www.w3.org/2001/XMLSchema#gMonthDay" =>
+            Regexp.new("^--#{FIELDS["MM"]}-#{FIELDS["dd"]}#{FIELDS["XXX"]}?$"),
+          "http://www.w3.org/2001/XMLSchema#gYear" =>
+            Regexp.new("^#{FIELDS["yyyy"]}#{FIELDS["XXX"]}?$"),
+          "http://www.w3.org/2001/XMLSchema#gYearMonth" =>
+            Regexp.new("^#{FIELDS["yyyy"]}-#{FIELDS["MM"]}#{FIELDS["XXX"]}?$"),
+          "http://www.w3.org/2001/XMLSchema#time" =>
+            Regexp.new("^#{FIELDS["HH"]}:#{FIELDS["mm"]}:(?<second>#{FIELDS["ss"]}(\.[0-9]+)?)#{FIELDS["XXX"]}?$")
+        }
+
+    end
+
+    class DateFormatError < StandardError
+
+    end
+  end
+end

data/lib/csvlint/csvw/metadata_error.rb

@@ -0,0 +1,13 @@
+module Csvlint
+  module Csvw
+    class MetadataError < StandardError
+
+      attr_reader :path
+
+      def initialize(path=nil)
+        @path = path
+      end
+
+    end
+  end
+end

data/lib/csvlint/csvw/number_format.rb

@@ -0,0 +1,211 @@
+module Csvlint
+  module Csvw
+    class NumberFormat
+
+      attr_reader :pattern, :prefix, :numeric_part, :suffix, :grouping_separator, :decimal_separator, :primary_grouping_size, :secondary_grouping_size, :fractional_grouping_size
+
+      def initialize(pattern=nil, grouping_separator=nil, decimal_separator=".")
+        @pattern = pattern
+        @grouping_separator = grouping_separator || (@pattern.nil? ? nil : ",")
+        @decimal_separator = decimal_separator || "."
+        if pattern.nil?
+          @regexp = Regexp.new("^(([-+]?[0-9]+(#{Regexp.escape(@decimal_separator)}[0-9]+)?([Ee][-+]?[0-9]+)?[%‰]?)|NaN|INF|-INF)$")
+        else
+          numeric_part_regexp = Regexp.new("(?<numeric_part>([0#Ee]|#{Regexp.escape(@grouping_separator)}|#{Regexp.escape(@decimal_separator)})+)")
+          number_format_regexp = Regexp.new("^(?<prefix>.*?)#{numeric_part_regexp}(?<suffix>.*?)$")
+          match = number_format_regexp.match(pattern)
+          raise Csvw::NumberFormatError, "invalid number format" if match.nil?
+
+          @prefix = match["prefix"]
+          @numeric_part = match["numeric_part"]
+          @suffix = match["suffix"]
+
+          parts = @numeric_part.split("E")
+          mantissa_part = parts[0]
+          exponent_part = parts[1] || ""
+          mantissa_parts = mantissa_part.split(@decimal_separator)
+          # raise Csvw::NumberFormatError, "more than two decimal separators in number format" if parts.length > 2
+          integer_part = mantissa_parts[0]
+          fractional_part = mantissa_parts[1] || ""
+
+          @integer_pattern = exponent_part == "" && fractional_part == ""
+
+          min_integer_digits = integer_part.gsub(@grouping_separator, "").gsub("#", "").length
+          min_fraction_digits = fractional_part.gsub(@grouping_separator, "").gsub("#", "").length
+          max_fraction_digits = fractional_part.gsub(@grouping_separator, "").length
+          min_exponent_digits = exponent_part.gsub("#", "").length
+          max_exponent_digits = exponent_part.length
+
+          integer_parts = integer_part.split(@grouping_separator)[1..-1]
+          @primary_grouping_size = integer_parts[-1].length rescue 0
+          @secondary_grouping_size = integer_parts[-2].length rescue @primary_grouping_size
+
+          fractional_parts = fractional_part.split(@grouping_separator)[0..-2]
+          @fractional_grouping_size = fractional_parts[0].length rescue 0
+
+          numeric_part_regexp = "[-+]?"
+
+          if @primary_grouping_size == 0
+            integer_regexp = "[0-9]*[0-9]{#{min_integer_digits}}"
+          else
+            leading_regexp = "([0-9]{0,#{@secondary_grouping_size - 1}}#{Regexp.escape(@grouping_separator)})?"
+            secondary_groups = "([0-9]{#{@secondary_grouping_size}}#{Regexp.escape(@grouping_separator)})*"
+            if min_integer_digits > @primary_grouping_size
+              remaining_req_digits = min_integer_digits - @primary_grouping_size
+              req_secondary_groups = remaining_req_digits / @secondary_grouping_size > 0 ? "([0-9]{#{@secondary_grouping_size}}#{Regexp.escape(@grouping_separator)}){#{remaining_req_digits / @secondary_grouping_size}}" : ""
+              if remaining_req_digits % @secondary_grouping_size > 0
+                final_req_digits = "[0-9]{#{@secondary_grouping_size - (remaining_req_digits % @secondary_grouping_size)}}"
+                final_opt_digits = "[0-9]{0,#{@secondary_grouping_size - (remaining_req_digits % @secondary_grouping_size)}}"
+                integer_regexp = "((#{leading_regexp}#{secondary_groups}#{final_req_digits})|#{final_opt_digits})[0-9]{#{remaining_req_digits % @secondary_grouping_size}}#{Regexp.escape(@grouping_separator)}#{req_secondary_groups}[0-9]{#{@primary_grouping_size}}"
+              else
+                integer_regexp = "(#{leading_regexp}#{secondary_groups})?#{req_secondary_groups}[0-9]{#{@primary_grouping_size}}"
+              end
+            else
+              final_req_digits = @primary_grouping_size > min_integer_digits ? "[0-9]{#{@primary_grouping_size - min_integer_digits}}" : ""
+              final_opt_digits = @primary_grouping_size > min_integer_digits ? "[0-9]{0,#{@primary_grouping_size - min_integer_digits}}" : ""
+              integer_regexp = "((#{leading_regexp}#{secondary_groups}#{final_req_digits})|#{final_opt_digits})[0-9]{#{min_integer_digits}}"
+            end
+          end
+
+          numeric_part_regexp += integer_regexp
+
+          if max_fraction_digits > 0
+            if @fractional_grouping_size == 0
+              fractional_regexp = ""
+              fractional_regexp += "[0-9]{#{min_fraction_digits}}" if min_fraction_digits > 0
+              fractional_regexp += "[0-9]{0,#{max_fraction_digits - min_fraction_digits}}" unless min_fraction_digits == max_fraction_digits
+              fractional_regexp = "#{Regexp.escape(@decimal_separator)}#{fractional_regexp}"
+              fractional_regexp = "(#{fractional_regexp})?" if min_fraction_digits == 0
+              numeric_part_regexp += fractional_regexp
+            else
+              fractional_regexp = ""
+
+              if min_fraction_digits > 0
+                if min_fraction_digits >= @fractional_grouping_size
+                  # first group of required digits - something like "[0-9]{3}"
+                  fractional_regexp += "[0-9]{#{@fractional_grouping_size}}"
+                  # additional groups of required digits - something like "(,[0-9]{3}){1}"
+                  fractional_regexp += "(#{Regexp.escape(@grouping_separator)}[0-9]{#{@fractional_grouping_size}}){#{min_fraction_digits / @fractional_grouping_size - 1}}" if min_fraction_digits / @fractional_grouping_size > 1
+                  fractional_regexp += "#{Regexp.escape(@grouping_separator)}" if min_fraction_digits % @fractional_grouping_size > 0
+                end
+                # additional required digits - something like ",[0-9]{1}"
+                fractional_regexp += "[0-9]{#{min_fraction_digits % @fractional_grouping_size}}" if min_fraction_digits % @fractional_grouping_size > 0
+
+                opt_fractional_digits = max_fraction_digits - min_fraction_digits
+                if opt_fractional_digits > 0
+                  fractional_regexp += "("
+
+                  if min_fraction_digits % @fractional_grouping_size > 0
+                    # optional fractional digits to complete the group
+                    fractional_regexp += "[0-9]{0,#{[opt_fractional_digits, @fractional_grouping_size - (min_fraction_digits % @fractional_grouping_size)].min}}"
+                    fractional_regexp += "|"
+                    fractional_regexp += "[0-9]{#{[opt_fractional_digits, @fractional_grouping_size - (min_fraction_digits % @fractional_grouping_size)].min}}"
+                  else
+                    fractional_regexp += "(#{Regexp.escape(@grouping_separator)}[0-9]{1,#{@fractional_grouping_size}})?"
+                    fractional_regexp += "|"
+                    fractional_regexp += "#{Regexp.escape(@grouping_separator)}[0-9]{#{@fractional_grouping_size}}"
+                  end
+
+                  remaining_opt_fractional_digits = opt_fractional_digits - (@fractional_grouping_size - (min_fraction_digits % @fractional_grouping_size))
+                  if remaining_opt_fractional_digits > 0
+                    if remaining_opt_fractional_digits % @fractional_grouping_size > 0
+                      # optional fraction digits in groups
+                      fractional_regexp += "(#{Regexp.escape(@grouping_separator)}[0-9]{#{@fractional_grouping_size}}){0,#{remaining_opt_fractional_digits / @fractional_grouping_size}}" if remaining_opt_fractional_digits > @fractional_grouping_size
+                      # remaining optional fraction digits
+                      fractional_regexp += "(#{Regexp.escape(@grouping_separator)}[0-9]{1,#{remaining_opt_fractional_digits % @fractional_grouping_size}})?"
+                    else
+                      # optional fraction digits in groups
+                      fractional_regexp += "(#{Regexp.escape(@grouping_separator)}[0-9]{#{@fractional_grouping_size}}){0,#{(remaining_opt_fractional_digits / @fractional_grouping_size) - 1}}" if remaining_opt_fractional_digits > @fractional_grouping_size
+                      # remaining optional fraction digits
+                      fractional_regexp += "(#{Regexp.escape(@grouping_separator)}[0-9]{1,#{@fractional_grouping_size}})?"
+                    end
+
+                    # optional fraction digits in groups
+                    fractional_regexp += "(#{Regexp.escape(@grouping_separator)}[0-9]{#{@fractional_grouping_size}}){0,#{(remaining_opt_fractional_digits / @fractional_grouping_size) - 1}}" if remaining_opt_fractional_digits > @fractional_grouping_size
+                    # remaining optional fraction digits
+                    fractional_regexp += "(#{Regexp.escape(@grouping_separator)}[0-9]{1,#{remaining_opt_fractional_digits % @fractional_grouping_size}})?" if remaining_opt_fractional_digits % @fractional_grouping_size > 0
+                  end
+                  fractional_regexp += ")"
+                end
+              elsif max_fraction_digits % @fractional_grouping_size > 0
+                # optional fractional digits in groups
+                fractional_regexp += "([0-9]{#{@fractional_grouping_size}}#{Regexp.escape(@grouping_separator)}){0,#{max_fraction_digits / @fractional_grouping_size}}"
+                # remaining optional fraction digits
+                fractional_regexp += "(#{Regexp.escape(@grouping_separator)}[0-9]{1,#{max_fraction_digits % @fractional_grouping_size}})?" if max_fraction_digits % @fractional_grouping_size > 0
+              else
+                fractional_regexp += "([0-9]{#{@fractional_grouping_size}}#{Regexp.escape(@grouping_separator)}){0,#{(max_fraction_digits / @fractional_grouping_size) - 1}}" if max_fraction_digits > @fractional_grouping_size
+                fractional_regexp += "[0-9]{1,#{@fractional_grouping_size}}"
+              end
+              fractional_regexp = "#{Regexp.escape(@decimal_separator)}#{fractional_regexp}"
+              fractional_regexp = "(#{fractional_regexp})?" if min_fraction_digits == 0
+              numeric_part_regexp += fractional_regexp
+            end
+          end
+
+          if max_exponent_digits > 0
+            numeric_part_regexp += "E"
+            numeric_part_regexp += "[0-9]{0,#{max_exponent_digits - min_exponent_digits}}" unless max_exponent_digits == min_exponent_digits
+            numeric_part_regexp += "[0-9]{#{min_exponent_digits}}" unless min_exponent_digits == 0
+          end
+
+          @regexp = Regexp.new("^(?<prefix>#{Regexp.escape(@prefix)})(?<numeric_part>#{numeric_part_regexp})(?<suffix>#{suffix})$")
+        end
+      end
+
+      def match(value)
+        value =~ @regexp ? true : false
+      end
+
+      def parse(value)
+        if @pattern.nil?
+          return nil if !@grouping_separator.nil? && value =~ Regexp.new("((^#{Regexp.escape(@grouping_separator)})|#{Regexp.escape(@grouping_separator)}{2})")
+          value.gsub!(@grouping_separator, "") unless @grouping_separator.nil?
+          if value =~ INTEGER_REGEXP
+            case value[-1]
+            when "%"
+              return value.to_f / 100
+            when "‰"
+              return value.to_f / 1000
+            else
+              return value.to_i
+            end
+          elsif value =~ @regexp
+            case value
+            when "NaN"
+              return Float::NAN
+            when "INF"
+              return Float::INFINITY
+            when "-INF"
+              return -Float::INFINITY
+            else
+              case value[-1]
+              when "%"
+                return value.to_f / 100
+              when "‰"
+                return value.to_f / 1000
+              else
+                return value.to_f
+              end
+            end
+          else
+            return nil
+          end
+        else
+          match = @regexp.match(value)
+          return nil if match.nil?
+          number = match["numeric_part"].gsub(@grouping_separator, "")
+          return number.to_i if @integer_pattern
+          return number.to_f
+        end
+      end
+
+      private
+        INTEGER_REGEXP = /^[-+]?[0-9]+[%‰]?$/
+
+    end
+
+    class NumberFormatError < StandardError
+
+    end
+  end
+end

data/lib/csvlint/csvw/property_checker.rb

@@ -0,0 +1,761 @@
+module Csvlint
+  module Csvw
+    class PropertyChecker
+
+      class << self
+
+        def check_property(property, value, base_url, lang)
+          if PROPERTIES.include? property
+            return PROPERTIES[property].call(value, base_url, lang)
+          elsif property =~ /^([a-z]+):/ && NAMESPACES.include?(property.split(":")[0])
+            value, warnings = check_common_property_value(value, base_url, lang)
+            return value, warnings, :annotation
+          else
+            return value, :invalid_property, nil
+          end
+        end
+
+        private
+          def check_common_property_value(value, base_url, lang)
+            case value
+            when Hash
+              value = value.clone
+              warnings = []
+              value.each do |p,v|
+                case p
+                when "@context"
+                  raise Csvlint::Csvw::MetadataError.new(p), "common property has @context property"
+                when "@list"
+                  raise Csvlint::Csvw::MetadataError.new(p), "common property has @list property"
+                when "@set"
+                  raise Csvlint::Csvw::MetadataError.new(p), "common property has @set property"
+                when "@type"
+                  if value["@value"] && BUILT_IN_DATATYPES.include?(v)
+                  elsif !value["@value"] && BUILT_IN_TYPES.include?(v)
+                  elsif v =~ /^([a-z]+):/ && NAMESPACES.include?(v.split(":")[0])
+                  else
+                    # must be an absolute URI
+                    begin
+                      raise Csvlint::Csvw::MetadataError.new(), "common property has invalid @type (#{v})" if URI(v).scheme.nil?
+                    rescue
+                      raise Csvlint::Csvw::MetadataError.new(), "common property has invalid @type (#{v})"
+                    end
+                  end
+                when "@id"
+                  unless base_url.nil?
+                    begin
+                      v = URI.join(base_url, v)
+                    rescue
+                      raise Csvlint::Csvw::MetadataError.new(), "common property has invalid @id (#{v})"
+                    end
+                  end
+                when "@value"
+                  raise Csvlint::Csvw::MetadataError.new(), "common property with @value has both @language and @type" if value["@type"] && value["@language"]
+                  raise Csvlint::Csvw::MetadataError.new(), "common property with @value has properties other than @language or @type" unless value.except("@type").except("@language").except("@value").empty?
+                when "@language"
+                  raise Csvlint::Csvw::MetadataError.new(), "common property with @language lacks a @value" unless value["@value"]
+                  raise Csvlint::Csvw::MetadataError.new(), "common property has invalid @language (#{v})" unless v =~ BCP47_LANGUAGE_REGEXP || v.nil?
+                else
+                  if p[0] == "@"
+                    raise Csvlint::Csvw::MetadataError.new(), "common property has property other than @id, @type, @value or @language beginning with @ (#{p})"
+                  end
+                end
+                if v.instance_of? Hash
+                  v, w = check_common_property_value(v, base_url, lang)
+                  warnings += Array(w)
+                end
+                value[p] = v
+              end
+              return value, warnings
+            else
+              return value, nil
+            end
+          end
+
+          def convert_value_facet(value, property, datatype)
+            if value[property]
+              if DATE_FORMAT_DATATYPES.include?(datatype)
+                format = Csvlint::Csvw::DateFormat.new(nil, datatype)
+                v = format.parse(value[property])
+                if v.nil?
+                  value.delete(property)
+                  return [":invalid_#{property}".to_sym]
+                else
+                  value[property] = v
+                  return []
+                end
+              elsif NUMERIC_FORMAT_DATATYPES.include?(datatype)
+                return []
+              else
+                raise Csvlint::Csvw::MetadataError.new("datatype.#{property}"), "#{property} is only allowed for numeric, date/time and duration types"
+              end
+            end
+            return []
+          end
+
+          def array_property(type)
+            return lambda { |value, base_url, lang|
+              return value, nil, type if value.instance_of? Array
+              return false, :invalid_value, type
+            }
+          end
+
+          def boolean_property(type)
+            return lambda { |value, base_url, lang|
+              return value, nil, type if value == true || value == false
+              return false, :invalid_value, type
+            }
+          end
+
+          def string_property(type)
+            return lambda { |value, base_url, lang|
+              return value, nil, type if value.instance_of? String
+              return "", :invalid_value, type
+            }
+          end
+
+          def numeric_property(type)
+            return lambda { |value, base_url, lang|
+              return value, nil, type if value.kind_of?(Integer) && value >= 0
+              return nil, :invalid_value, type
+            }
+          end
+
+          def link_property(type)
+            return lambda { |value, base_url, lang|
+              raise Csvlint::Csvw::MetadataError.new(), "URL #{value} starts with _:" if value.to_s =~ /^_:/
+              return (base_url.nil? ? URI(value) : URI.join(base_url, value)), nil, type if value.instance_of? String
+              return base_url, :invalid_value, type
+            }
+          end
+
+          def language_property(type)
+            return lambda { |value, base_url, lang|
+              return value, nil, type if value =~ BCP47_REGEXP
+              return nil, :invalid_value, type
+            }
+          end
+
+          def natural_language_property(type)
+            return lambda { |value, base_url, lang|
+              warnings = []
+              if value.instance_of? String
+                return { lang => [ value ] }, nil, type
+              elsif value.instance_of? Array
+                valid_titles = []
+                value.each do |title|
+                  if title.instance_of? String
+                    valid_titles << title
+                  else
+                    warnings << :invalid_value
+                  end
+                end
+                return { lang => valid_titles }, warnings, type
+              elsif value.instance_of? Hash
+                value = value.clone
+                value.each do |l,v|
+                  if l =~ BCP47_REGEXP
+                    valid_titles = []
+                    Array(v).each do |title|
+                      if title.instance_of? String
+                        valid_titles << title
+                      else
+                        warnings << :invalid_value
+                      end
+                    end
+                    value[l] = valid_titles
+                  else
+                    value.delete(l)
+                    warnings << :invalid_language
+                  end
+                end
+                warnings << :invalid_value if value.empty?
+                return value, warnings, type
+              else
+                return {}, :invalid_value, type
+              end
+            }
+          end
+
+          def column_reference_property(type)
+            return lambda { |value, base_url, lang|
+              return Array(value), nil, type
+            }
+          end
+
+
+      end
+
+        PROPERTIES = {
+          # context properties
+          "@language" => language_property(:context),
+          "@base" => link_property(:context),
+          # common properties
+          "@id" => link_property(:common),
+          "notes" => array_property(:common),
+          "suppressOutput" => boolean_property(:common),
+          # inherited properties
+          "null" => lambda { |value, base_url, lang|
+            case value
+            when String
+              return [value], nil, :inherited
+            when Array
+              values = []
+              warnings = []
+              value.each do |v|
+                if v.instance_of? String
+                  values << v
+                else
+                  warnings << :invalid_value
+                end
+              end
+              return values, warnings, :inherited
+            else
+              return [""], :invalid_value, :inherited
+            end
+          },
+          "default" => string_property(:inherited),
+          "separator" => lambda { |value, base_url, lang|
+            return value, nil, :inherited if value.instance_of?(String) || value.nil?
+            return nil, :invalid_value, :inherited
+          },
+          "lang" => language_property(:inherited),
+          "datatype" => lambda { |value, base_url, lang|
+            value = value.clone
+            warnings = []
+            if value.instance_of? Hash
+              if value["@id"]
+                raise Csvlint::Csvw::MetadataError.new("datatype.@id"), "datatype @id must not be the id of a built-in datatype (#{value["@id"]})" if BUILT_IN_DATATYPES.values.include?(value["@id"])
+                v,w,t = PROPERTIES["@id"].call(value["@id"], base_url, lang)
+                unless w.nil?
+                  warnings << w
+                  value.delete("@id")
+                end
+              end
+
+              if value["base"]
+                if BUILT_IN_DATATYPES.include? value["base"]
+                  value["base"] = BUILT_IN_DATATYPES[value["base"]]
+                else
+                  value["base"] = BUILT_IN_DATATYPES["string"]
+                  warnings << :invalid_datatype_base
+                end
+              else
+                value["base"] = BUILT_IN_DATATYPES["string"]
+              end
+            elsif BUILT_IN_DATATYPES.include? value
+              value = { "@id" => BUILT_IN_DATATYPES[value] }
+            else
+              value = { "@id" => BUILT_IN_DATATYPES["string"] }
+              warnings << :invalid_value
+            end
+
+            unless STRING_DATATYPES.include?(value["base"]) || BINARY_DATATYPES.include?(value["base"])
+              raise Csvlint::Csvw::MetadataError.new("datatype.length"), "datatypes based on #{value["base"]} cannot have a length facet" if value["length"]
+              raise Csvlint::Csvw::MetadataError.new("datatype.minLength"), "datatypes based on #{value["base"]} cannot have a minLength facet" if value["minLength"]
+              raise Csvlint::Csvw::MetadataError.new("datatype.maxLength"), "datatypes based on #{value["base"]} cannot have a maxLength facet" if value["maxLength"]
+            end
+
+            if value["minimum"]
+              value["minInclusive"] = value["minimum"]
+              value.delete("minimum")
+            end
+            if value["maximum"]
+              value["maxInclusive"] = value["maximum"]
+              value.delete("maximum")
+            end
+
+            warnings += convert_value_facet(value, "minInclusive", value["base"])
+            warnings += convert_value_facet(value, "minExclusive", value["base"])
+            warnings += convert_value_facet(value, "maxInclusive", value["base"])
+            warnings += convert_value_facet(value, "maxExclusive", value["base"])
+
+            raise Csvlint::Csvw::MetadataError.new(""), "datatype cannot specify both minimum/minInclusive (#{value["minInclusive"]}) and minExclusive (#{value["minExclusive"]}" if value["minInclusive"] && value["minExclusive"]
+            raise Csvlint::Csvw::MetadataError.new(""), "datatype cannot specify both maximum/maxInclusive (#{value["maxInclusive"]}) and maxExclusive (#{value["maxExclusive"]}" if value["maxInclusive"] && value["maxExclusive"]
+            raise Csvlint::Csvw::MetadataError.new(""), "datatype minInclusive (#{value["minInclusive"]}) cannot be more than maxInclusive (#{value["maxInclusive"]}" if value["minInclusive"] && value["maxInclusive"] && value["minInclusive"] > value["maxInclusive"]
+            raise Csvlint::Csvw::MetadataError.new(""), "datatype minInclusive (#{value["minInclusive"]}) cannot be more than or equal to maxExclusive (#{value["maxExclusive"]}" if value["minInclusive"] && value["maxExclusive"] && value["minInclusive"] >= value["maxExclusive"]
+            raise Csvlint::Csvw::MetadataError.new(""), "datatype minExclusive (#{value["minExclusive"]}) cannot be more than or equal to maxExclusive (#{value["maxExclusive"]}" if value["minExclusive"] && value["maxExclusive"] && value["minExclusive"] > value["maxExclusive"]
+            raise Csvlint::Csvw::MetadataError.new(""), "datatype minExclusive (#{value["minExclusive"]}) cannot be more than maxInclusive (#{value["maxInclusive"]}" if value["minExclusive"] && value["maxInclusive"] && value["minExclusive"] >= value["maxInclusive"]
+
+            raise Csvlint::Csvw::MetadataError.new(""), "datatype length (#{value["length"]}) cannot be less than minLength (#{value["minLength"]}" if value["length"] && value["minLength"] && value["length"] < value["minLength"]
+            raise Csvlint::Csvw::MetadataError.new(""), "datatype length (#{value["length"]}) cannot be more than maxLength (#{value["maxLength"]}" if value["length"] && value["maxLength"] && value["length"] > value["maxLength"]
+            raise Csvlint::Csvw::MetadataError.new(""), "datatype minLength (#{value["minLength"]}) cannot be more than maxLength (#{value["maxLength"]}" if value["minLength"] && value["maxLength"] && value["minLength"] > value["maxLength"]
+
+            if value["format"]
+              if REGEXP_FORMAT_DATATYPES.include?(value["base"])
+                begin
+                  value["format"] = Regexp.new(value["format"])
+                rescue RegexpError
+                  value.delete("format")
+                  warnings << :invalid_regex
+                end
+              elsif NUMERIC_FORMAT_DATATYPES.include?(value["base"])
+                value["format"] = { "pattern" => value["format"] } if value["format"].instance_of? String
+                begin
+                  value["format"] = Csvlint::Csvw::NumberFormat.new(value["format"]["pattern"], value["format"]["groupChar"], value["format"]["decimalChar"] || ".")
+                rescue Csvlint::Csvw::NumberFormatError
+                  value["format"] = Csvlint::Csvw::NumberFormat.new(nil, value["format"]["groupChar"], value["format"]["decimalChar"] || ".")
+                  warnings << :invalid_number_format
+                end
+              elsif value["base"] == "http://www.w3.org/2001/XMLSchema#boolean"
+                if value["format"].instance_of? String
+                  value["format"] = value["format"].split("|")
+                  unless value["format"].length == 2
+                    value.delete("format")
+                    warnings << :invalid_boolean_format
+                  end
+                else
+                  value.delete("format")
+                  warnings << :invalid_boolean_format
+                end
+              elsif DATE_FORMAT_DATATYPES.include?(value["base"])
+                if value["format"].instance_of? String
+                  begin
+                    value["format"] = Csvlint::Csvw::DateFormat.new(value["format"])
+                  rescue Csvlint::CsvDateFormatError
+                    value.delete("format")
+                    warnings << :invalid_date_format
+                  end
+                else
+                  value.delete("format")
+                  warnings << :invalid_date_format
+                end
+              end
+            end
+            return value, warnings, :inherited
+          },
+          "required" => boolean_property(:inherited),
+          "ordered" => boolean_property(:inherited),
+          "aboutUrl" => string_property(:inherited),
+          "propertyUrl" => string_property(:inherited),
+          "valueUrl" => string_property(:inherited),
+          "textDirection" => lambda { |value, base_url, lang|
+            value = value.to_sym
+            return value, nil, :inherited if [:ltr, :rtl, :auto, :inherit].include? value
+            return :inherit, :invalid_value, :inherited
+          },
+          # column level properties
+          "virtual" => boolean_property(:column),
+          "titles" => natural_language_property(:column),
+          "name" => lambda { |value, base_url, lang|
+            return value, nil, :column if value.instance_of?(String) && value =~ NAME_REGEXP
+            return nil, :invalid_value, :column
+          },
+          # table level properties
+          "transformations" => lambda { |value, base_url, lang|
+            transformations = []
+            warnings = []
+            if value.instance_of? Array
+              value.each_with_index do |transformation,i|
+                if transformation.instance_of? Hash
+                  transformation = transformation.clone
+                  transformation.each do |p,v|
+                    if p == "@id"
+                      raise Csvlint::Csvw::MetadataError.new("transformations[#{i}].@id"), "@id starts with _:" if v =~ /^_:/
+                    elsif p == "@type"
+                      raise Csvlint::Csvw::MetadataError.new("transformations[#{i}].@type"), "@type of transformation is not 'Template'" if v != 'Template'
+                    elsif p == "url"
+                    elsif p == "titles"
+                    else
+                      v, warning, type = check_property(p, v, base_url, lang)
+                      unless type == :transformation && (warning.nil? || warning.empty?)
+                        value.delete(p)
+                        warnings << :invalid_property unless type == :transformation
+                        warnings += Array(warning)
+                      end
+                    end
+                  end
+                  transformations << transformation
+                else
+                  warnings << :invalid_transformation
+                end
+              end
+            else
+              warnings << :invalid_value
+            end
+            return transformations, warnings, :table
+          },
+          "tableDirection" => lambda { |value, base_url, lang|
+            value = value.to_sym
+            return value, nil, :table if [:ltr, :rtl, :auto].include? value
+            return :auto, :invalid_value, :table
+          },
+          "tableSchema" => lambda { |value, base_url, lang|
+            schema_base_url = base_url
+            schema_lang = lang
+            if value.instance_of? String
+              schema_url = URI.join(base_url, value).to_s
+              schema_base_url = schema_url
+              schema_ref = schema_url.start_with?("file:") ? File.new(schema_url[5..-1]) : schema_url
+              schema = JSON.parse( open(schema_ref).read )
+              schema["@id"] = schema["@id"] ? URI.join(schema_url, schema["@id"]).to_s : schema_url
+              if schema["@context"]
+                if schema["@context"].instance_of?(Array) && schema["@context"].length > 1
+                  schema_base_url = schema["@context"][1]["@base"] ? URI.join(schema_base_url, schema["@context"][1]["@base"]).to_s : schema_base_url
+                  schema_lang = schema["@context"][1]["@language"] || schema_lang
+                end
+                schema.delete("@context")
+              end
+            elsif value.instance_of? Hash
+              schema = value.clone
+            else
+              return {}, :invalid_value, :table
+            end
+            warnings = []
+            schema.each do |p,v|
+              if p == "@id"
+                raise Csvlint::Csvw::MetadataError.new("tableSchema.@id"), "@id starts with _:" if v =~ /^_:/
+              elsif p == "@type"
+                raise Csvlint::Csvw::MetadataError.new("tableSchema.@type"), "@type of schema is not 'Schema'" if v != 'Schema'
+              else
+                v, warning, type = check_property(p, v, schema_base_url, schema_lang)
+                if (type == :schema || type == :inherited) && (warning.nil? || warning.empty?)
+                  schema[p] = v
+                else
+                  schema.delete(p)
+                  warnings << :invalid_property unless (type == :schema || type == :inherited)
+                  warnings += Array(warning)
+                end
+              end
+            end
+            return schema, warnings, :table
+          },
+          "url" => link_property(:table),
+          "dialect" => lambda { |value, base_url, lang|
+            if value.instance_of? Hash
+              value = value.clone
+              warnings = []
+              value.each do |p,v|
+                if p == "@id"
+                  raise Csvlint::Csvw::MetadataError.new("dialect.@id"), "@id starts with _:" if v =~ /^_:/
+                elsif p == "@type"
+                  raise Csvlint::Csvw::MetadataError.new("dialect.@type"), "@type of dialect is not 'Dialect'" if v != 'Dialect'
+                else
+                  v, warning, type = check_property(p, v, base_url, lang)
+                  if type == :dialect && (warning.nil? || warning.empty?)
+                    value[p] = v
+                  else
+                    value.delete(p)
+                    warnings << :invalid_property unless type == :dialect
+                    warnings += Array(warning)
+                  end
+                end
+              end
+              return value, warnings, :table
+            else
+              return {}, :invalid_value, :table
+            end
+          },
+          # dialect properties
+          "commentPrefix" => string_property(:dialect),
+          "delimiter" => string_property(:dialect),
+          "doubleQuote" => boolean_property(:dialect),
+          "encoding" => lambda { |value, base_url, lang|
+            return value, nil, :dialect if VALID_ENCODINGS.include? value
+            return nil, :invalid_value, :dialect
+          },
+          "header" => boolean_property(:dialect),
+          "headerRowCount" => numeric_property(:dialect),
+          "lineTerminators" => array_property(:dialect),
+          "quoteChar" => string_property(:dialect),
+          "skipBlankRows" => boolean_property(:dialect),
+          "skipColumns" => numeric_property(:dialect),
+          "skipInitialSpace" => boolean_property(:dialect),
+          "skipRows" => numeric_property(:dialect),
+          "trim" => lambda { |value, base_url, lang|
+            value = :true if value == true || value == "true"
+            value = :false if value == false || value == "false"
+            value = :start if value == "start"
+            value = :end if value == "end"
+            return value, nil, :dialect if [:true, :false, :start, :end].include? value
+            return true, :invalid_value, :dialect
+          },
+          # schema properties
+          "columns" => lambda { |value, base_url, lang| return value, nil, :schema },
+          "primaryKey" => column_reference_property(:schema),
+          "foreignKeys" => lambda { |value, base_url, lang|
+            foreign_keys = []
+            warnings = []
+            if value.instance_of? Array
+              value.each_with_index do |foreign_key,i|
+                if foreign_key.instance_of? Hash
+                  foreign_key = foreign_key.clone
+                  foreign_key.each do |p,v|
+                    v, warning, type = check_property(p, v, base_url, lang)
+                    if type == :foreign_key && (warning.nil? || warning.empty?)
+                      foreign_key[p] = v
+                    elsif p =~ /:/
+                      raise Csvlint::Csvw::MetadataError.new("foreignKey.#{p}"), "foreignKey includes a prefixed (common) property"
+                    else
+                      foreign_key.delete(p)
+                      warnings << :invalid_property unless type == :foreign_key
+                      warnings += Array(warning)
+                    end
+                  end
+                  foreign_keys << foreign_key
+                else
+                  warnings << :invalid_foreign_key
+                end
+              end
+            else
+              warnings << :invalid_value
+            end
+            return foreign_keys, warnings, :schema
+          },
+          "rowTitles" => column_reference_property(:schema),
+          # transformation properties
+          "targetFormat" => lambda { |value, base_url, lang| return value, nil, :transformation },
+          "scriptFormat" => lambda { |value, base_url, lang| return value, nil, :transformation },
+          "source" => lambda { |value, base_url, lang| return value, nil, :transformation },
+          # foreignKey properties
+          "columnReference" => column_reference_property(:foreign_key),
+          "reference" => lambda { |value, base_url, lang|
+            if value.instance_of? Hash
+              value = value.clone
+              warnings = []
+              value.each do |p,v|
+                if ["resource", "schemaReference", "columnReference"].include? p
+                  v, warning, type = check_property(p, v, base_url, lang)
+                  if warning.nil? || warning.empty?
+                    value[p] = v
+                  else
+                    value.delete(p)
+                    warnings += Array(warning)
+                  end
+                elsif p =~ /:/
+                  raise Csvlint::Csvw::MetadataError.new("foreignKey.reference.#{p}"), "foreignKey reference includes a prefixed (common) property"
+                else
+                  value.delete(p)
+                  warnings << :invalid_property
+                end
+              end
+              raise Csvlint::Csvw::MetadataError.new("foreignKey.reference.columnReference"), "foreignKey reference columnReference is missing" unless value["columnReference"]
+              raise Csvlint::Csvw::MetadataError.new("foreignKey.reference"), "foreignKey reference does not have either resource or schemaReference" unless value["resource"] || value["schemaReference"]
+              raise Csvlint::Csvw::MetadataError.new("foreignKey.reference"), "foreignKey reference has both resource and schemaReference" if value["resource"] && value["schemaReference"]
+              return value, warnings, :foreign_key
+            else
+              raise Csvlint::Csvw::MetadataError.new("foreignKey.reference"), "foreignKey reference is not an object"
+            end
+          },
+          # foreignKey reference properties
+          "resource" => lambda { |value, base_url, lang| return value, nil, :foreign_key_reference },
+          "schemaReference" => lambda { |value, base_url, lang|
+            return URI.join(base_url, value).to_s, nil, :foreign_key_reference
+          }
+        }
+
+        NAMESPACES = {
+          "dcat" => "http://www.w3.org/ns/dcat#",
+          "qb" => "http://purl.org/linked-data/cube#",
+          "grddl" => "http://www.w3.org/2003/g/data-view#",
+          "ma" => "http://www.w3.org/ns/ma-ont#",
+          "org" => "http://www.w3.org/ns/org#",
+          "owl" => "http://www.w3.org/2002/07/owl#",
+          "prov" => "http://www.w3.org/ns/prov#",
+          "rdf" => "http://www.w3.org/1999/02/22-rdf-syntax-ns#",
+          "rdfa" => "http://www.w3.org/ns/rdfa#",
+          "rdfs" => "http://www.w3.org/2000/01/rdf-schema#",
+          "rif" => "http://www.w3.org/2007/rif#",
+          "rr" => "http://www.w3.org/ns/r2rml#",
+          "sd" => "http://www.w3.org/ns/sparql-service-description#",
+          "skos" => "http://www.w3.org/2004/02/skos/core#",
+          "skosxl" => "http://www.w3.org/2008/05/skos-xl#",
+          "wdr" => "http://www.w3.org/2007/05/powder#",
+          "void" => "http://rdfs.org/ns/void#",
+          "wdrs" => "http://www.w3.org/2007/05/powder-s#",
+          "xhv" => "http://www.w3.org/1999/xhtml/vocab#",
+          "xml" => "http://www.w3.org/XML/1998/namespace",
+          "xsd" => "http://www.w3.org/2001/XMLSchema#",
+          "cc" => "http://creativecommons.org/ns#",
+          "ctag" => "http://commontag.org/ns#",
+          "dc" => "http://purl.org/dc/terms/",
+          "dcterms" => "http://purl.org/dc/terms/",
+          "dc11" => "http://purl.org/dc/elements/1.1/",
+          "foaf" => "http://xmlns.com/foaf/0.1/",
+          "gr" => "http://purl.org/goodrelations/v1#",
+          "ical" => "http://www.w3.org/2002/12/cal/icaltzd#",
+          "og" => "http://ogp.me/ns#",
+          "rev" => "http://purl.org/stuff/rev#",
+          "sioc" => "http://rdfs.org/sioc/ns#",
+          "v" => "http://rdf.data-vocabulary.org/#",
+          "vcard" => "http://www.w3.org/2006/vcard/ns#",
+          "schema" => "http://schema.org/"
+        }
+
+        BCP47_REGULAR_REGEXP = "(art-lojban|cel-gaulish|no-bok|no-nyn|zh-guoyu|zh-hakka|zh-min|zh-min-nan|zh-xiang)"
+        BCP47_IRREGULAR_REGEXP = "(en-GB-oed|i-ami|i-bnn|i-default|i-enochian|i-hak|i-klingon|i-lux|i-mingo|i-navajo|i-pwn|i-tao|i-tay|i-tsu|sgn-BE-FR|sgn-BE-NL|sgn-CH-DE)"
+        BCP47_GRANDFATHERED_REGEXP = "(?<grandfathered>" + BCP47_IRREGULAR_REGEXP + "|" + BCP47_REGULAR_REGEXP + ")"
+        BCP47_PRIVATE_USE_REGEXP = "(?<privateUse>x(-[A-Za-z0-9]{1,8})+)"
+        BCP47_SINGLETON_REGEXP = "[0-9A-WY-Za-wy-z]"
+        BCP47_EXTENSION_REGEXP = "(?<extension>" + BCP47_SINGLETON_REGEXP + "(-[A-Za-z0-9]{2,8})+)"
+        BCP47_VARIANT_REGEXP = "(?<variant>[A-Za-z0-9]{5,8}|[0-9][A-Za-z0-9]{3})"
+        BCP47_REGION_REGEXP = "(?<region>[A-Za-z]{2}|[0-9]{3})"
+        BCP47_SCRIPT_REGEXP = "(?<script>[A-Za-z]{4})"
+        BCP47_EXTLANG_REGEXP = "(?<extlang>[A-Za-z]{3}(-[A-Za-z]{3}){0,2})"
+        BCP47_LANGUAGE_REGEXP = "(?<language>([A-Za-z]{2,3}(-" + BCP47_EXTLANG_REGEXP + ")?)|[A-Za-z]{4}|[A-Za-z]{5,8})"
+        BCP47_LANGTAG_REGEXP = "(" + BCP47_LANGUAGE_REGEXP + "(-" + BCP47_SCRIPT_REGEXP + ")?" + "(-" + BCP47_REGION_REGEXP + ")?" + "(-" + BCP47_VARIANT_REGEXP + ")*" + "(-" + BCP47_EXTENSION_REGEXP + ")*" + "(-" + BCP47_PRIVATE_USE_REGEXP + ")?" + ")"
+        BCP47_LANGUAGETAG_REGEXP = "^(" + BCP47_GRANDFATHERED_REGEXP + "|" + BCP47_LANGTAG_REGEXP + "|" + BCP47_PRIVATE_USE_REGEXP + ")$"
+        BCP47_REGEXP = Regexp.new(BCP47_LANGUAGETAG_REGEXP)
+
+        NAME_REGEXP = /^([A-Za-z0-9]|(%[A-F0-9][A-F0-9]))([A-Za-z0-9_]|(%[A-F0-9][A-F0-9]))*$/
+
+        BUILT_IN_TYPES = ["TableGroup", "Table", "Schema", "Column", "Dialect", "Template", "Datatype"]
+
+        REGEXP_FORMAT_DATATYPES = [
+          "http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral",
+          "http://www.w3.org/1999/02/22-rdf-syntax-ns#HTML",
+          "http://www.w3.org/ns/csvw#JSON",
+          "http://www.w3.org/2001/XMLSchema#anyAtomicType",
+          "http://www.w3.org/2001/XMLSchema#anyURI",
+          "http://www.w3.org/2001/XMLSchema#base64Binary",
+          "http://www.w3.org/2001/XMLSchema#duration",
+          "http://www.w3.org/2001/XMLSchema#dayTimeDuration",
+          "http://www.w3.org/2001/XMLSchema#yearMonthDuration",
+          "http://www.w3.org/2001/XMLSchema#hexBinary",
+          "http://www.w3.org/2001/XMLSchema#QName",
+          "http://www.w3.org/2001/XMLSchema#string",
+          "http://www.w3.org/2001/XMLSchema#normalizedString",
+          "http://www.w3.org/2001/XMLSchema#token",
+          "http://www.w3.org/2001/XMLSchema#language",
+          "http://www.w3.org/2001/XMLSchema#Name",
+          "http://www.w3.org/2001/XMLSchema#NMTOKEN"
+        ]
+
+        STRING_DATATYPES = [
+          "http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral",
+          "http://www.w3.org/1999/02/22-rdf-syntax-ns#HTML",
+          "http://www.w3.org/ns/csvw#JSON",
+          "http://www.w3.org/2001/XMLSchema#string",
+          "http://www.w3.org/2001/XMLSchema#normalizedString",
+          "http://www.w3.org/2001/XMLSchema#token",
+          "http://www.w3.org/2001/XMLSchema#language",
+          "http://www.w3.org/2001/XMLSchema#Name",
+          "http://www.w3.org/2001/XMLSchema#NMTOKEN"
+        ]
+
+        BINARY_DATATYPES = [
+          "http://www.w3.org/2001/XMLSchema#base64Binary",
+          "http://www.w3.org/2001/XMLSchema#hexBinary"
+        ]
+
+        NUMERIC_FORMAT_DATATYPES = [
+          "http://www.w3.org/2001/XMLSchema#decimal",
+          "http://www.w3.org/2001/XMLSchema#integer",
+          "http://www.w3.org/2001/XMLSchema#long",
+          "http://www.w3.org/2001/XMLSchema#int",
+          "http://www.w3.org/2001/XMLSchema#short",
+          "http://www.w3.org/2001/XMLSchema#byte",
+          "http://www.w3.org/2001/XMLSchema#nonNegativeInteger",
+          "http://www.w3.org/2001/XMLSchema#positiveInteger",
+          "http://www.w3.org/2001/XMLSchema#unsignedLong",
+          "http://www.w3.org/2001/XMLSchema#unsignedInt",
+          "http://www.w3.org/2001/XMLSchema#unsignedShort",
+          "http://www.w3.org/2001/XMLSchema#unsignedByte",
+          "http://www.w3.org/2001/XMLSchema#nonPositiveInteger",
+          "http://www.w3.org/2001/XMLSchema#negativeInteger",
+          "http://www.w3.org/2001/XMLSchema#double",
+          "http://www.w3.org/2001/XMLSchema#float"
+        ]
+
+        DATE_FORMAT_DATATYPES = [
+          "http://www.w3.org/2001/XMLSchema#date",
+          "http://www.w3.org/2001/XMLSchema#dateTime",
+          "http://www.w3.org/2001/XMLSchema#dateTimeStamp",
+          "http://www.w3.org/2001/XMLSchema#time"
+        ]
+
+        BUILT_IN_DATATYPES = {
+          "number" => "http://www.w3.org/2001/XMLSchema#double",
+          "binary" => "http://www.w3.org/2001/XMLSchema#base64Binary",
+          "datetime" => "http://www.w3.org/2001/XMLSchema#dateTime",
+          "any" => "http://www.w3.org/2001/XMLSchema#anyAtomicType",
+          "xml" => "http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral",
+          "html" => "http://www.w3.org/1999/02/22-rdf-syntax-ns#HTML",
+          "json" => "http://www.w3.org/ns/csvw#JSON",
+          "anyAtomicType" => "http://www.w3.org/2001/XMLSchema#anyAtomicType",
+          "anyURI" => "http://www.w3.org/2001/XMLSchema#anyURI",
+          "base64Binary" => "http://www.w3.org/2001/XMLSchema#base64Binary",
+          "boolean" => "http://www.w3.org/2001/XMLSchema#boolean",
+          "date" => "http://www.w3.org/2001/XMLSchema#date",
+          "dateTime" => "http://www.w3.org/2001/XMLSchema#dateTime",
+          "dateTimeStamp" => "http://www.w3.org/2001/XMLSchema#dateTimeStamp",
+          "decimal" => "http://www.w3.org/2001/XMLSchema#decimal",
+          "integer" => "http://www.w3.org/2001/XMLSchema#integer",
+          "long" => "http://www.w3.org/2001/XMLSchema#long",
+          "int" => "http://www.w3.org/2001/XMLSchema#int",
+          "short" => "http://www.w3.org/2001/XMLSchema#short",
+          "byte" => "http://www.w3.org/2001/XMLSchema#byte",
+          "nonNegativeInteger" => "http://www.w3.org/2001/XMLSchema#nonNegativeInteger",
+          "positiveInteger" => "http://www.w3.org/2001/XMLSchema#positiveInteger",
+          "unsignedLong" => "http://www.w3.org/2001/XMLSchema#unsignedLong",
+          "unsignedInt" => "http://www.w3.org/2001/XMLSchema#unsignedInt",
+          "unsignedShort" => "http://www.w3.org/2001/XMLSchema#unsignedShort",
+          "unsignedByte" => "http://www.w3.org/2001/XMLSchema#unsignedByte",
+          "nonPositiveInteger" => "http://www.w3.org/2001/XMLSchema#nonPositiveInteger",
+          "negativeInteger" => "http://www.w3.org/2001/XMLSchema#negativeInteger",
+          "double" => "http://www.w3.org/2001/XMLSchema#double",
+          "duration" => "http://www.w3.org/2001/XMLSchema#duration",
+          "dayTimeDuration" => "http://www.w3.org/2001/XMLSchema#dayTimeDuration",
+          "yearMonthDuration" => "http://www.w3.org/2001/XMLSchema#yearMonthDuration",
+          "float" => "http://www.w3.org/2001/XMLSchema#float",
+          "gDay" => "http://www.w3.org/2001/XMLSchema#gDay",
+          "gMonth" => "http://www.w3.org/2001/XMLSchema#gMonth",
+          "gMonthDay" => "http://www.w3.org/2001/XMLSchema#gMonthDay",
+          "gYear" => "http://www.w3.org/2001/XMLSchema#gYear",
+          "gYearMonth" => "http://www.w3.org/2001/XMLSchema#gYearMonth",
+          "hexBinary" => "http://www.w3.org/2001/XMLSchema#hexBinary",
+          "QName" => "http://www.w3.org/2001/XMLSchema#QName",
+          "string" => "http://www.w3.org/2001/XMLSchema#string",
+          "normalizedString" => "http://www.w3.org/2001/XMLSchema#normalizedString",
+          "token" => "http://www.w3.org/2001/XMLSchema#token",
+          "language" => "http://www.w3.org/2001/XMLSchema#language",
+          "Name" => "http://www.w3.org/2001/XMLSchema#Name",
+          "NMTOKEN" => "http://www.w3.org/2001/XMLSchema#NMTOKEN",
+          "time" => "http://www.w3.org/2001/XMLSchema#time"
+        }
+
+        VALID_ENCODINGS = [
+          "utf-8",
+          "ibm866",
+          "iso-8859-2",
+          "iso-8859-3",
+          "iso-8859-4",
+          "iso-8859-5",
+          "iso-8859-6",
+          "iso-8859-7",
+          "iso-8859-8",
+          "iso-8859-8-i",
+          "iso-8859-10",
+          "iso-8859-13",
+          "iso-8859-14",
+          "iso-8859-15",
+          "iso-8859-16",
+          "koi8-r",
+          "koi8-u",
+          "macintosh",
+          "windows-874",
+          "windows-1250",
+          "windows-1251",
+          "windows-1252",
+          "windows-1253",
+          "windows-1254",
+          "windows-1255",
+          "windows-1256",
+          "windows-1257",
+          "windows-1258",
+          "x-mac-cyrillic",
+          "gb18030",
+          "hz-gb-2312",
+          "big5",
+          "euc-jp",
+          "iso-2022-jp",
+          "shift_jis",
+          "euc-kr",
+          "replacement",
+          "utf-16be",
+          "utf-16le",
+          "x-user-defined"
+        ]
+    end
+  end
+end