csvlint 0.1.4 → 0.2.0

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]{#{@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