csvlint 0.2.6 → 0.3.0

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    YjRlMTk0ZmM3ZjY0YmExNWY2YzgxNTFiNmYyMDc3OTdiMmIyOWQ2Ng==
+    MTJlZWM1ZDA0ZDMzMjBkM2I1OGUxYjM1NTIxZTA1NWVkODJlMDFiYQ==
   data.tar.gz: !binary |-
-    NWJkYzE4YTY4ODZjMWY3M2M5MDNkMjhhMjFhMmMyOGYyNTBmY2ZlZQ==
+    MWE1MWYzZjk3YjgwMTJhNzBjZGM4NTMyOGYzYTU1ZWM4ZDc4NTI2YQ==
 SHA512:
   metadata.gz: !binary |-
-    NjM1ZGJhNGU0ODE0NjY0YjQ3ZjU0ZjRjMmRkYmI1YjZmODQzZWM3YjUyYzMw
-    Y2U2MWM2YzY0NWU3NTVmYzJiOWNlZWVhZGY1ZjQyOWUzNWU3MWU5MDU0MDA2
-    MWM5MDM5ZmRkYTY3YzYxYWYzOGFmMGE1YzEzODFmMmM5MTdkZjQ=
+    MWU5NTAxZDVjMGI3YTNiYTBlNTJmODkxNTBkYzdiN2ExN2E3NGE2ZjI5M2Nl
+    ZGY0OWM3ZTVjODNiNjcyZDMwODhhNTc3ODIyZGMyMzUzYWE2ZTMyZmFmNGIw
+    NDFiYzc5YzNlNTFlODQ1ODE1YzZkMDU0MDdkMzE3MmVlNWUyYmU=
   data.tar.gz: !binary |-
-    NTc1NjQzZTM2M2FlYjZkYWQzNzljMmU1OTI3YTViMDc4MTc0ZWJiZjcxMzAy
-    MzhiNWFmNzg4MGQ5NzAxNzQ5NTRiNjAyNzU4YjMzN2Q4ZjlmNmZmZWVlYTEy
-    ZDhhOThjM2Y0MmYxMDJiYTk5NmQ3MzEwN2JlMTVjMjk4ZmVkYmM=
+    MjBhYTU1ZWMzNjcxMmU1NjU1ZjZkYTE5M2YwOTQ5NzYyOWYzNmM2NzkxNWJk
+    Y2VlM2JkMmRlYmNhNzM5MGI0ZDg2YWQzOTNhYzg1YjAyNDRiNTFiNmRlZjk4
+    Nzc0YjJlOWM0MGVmMjAzZTBiZjQwZTc4MTU5YTVjMGFiZDFjNmQ=

data/.gitattributes

@@ -1,2 +1,2 @@
-# Don't fuck with my CSV files
+# Don't mess with my CSV files
 *.csv binary

data/.gitignore

@@ -25,4 +25,4 @@ features/fixtures/csvw
 
 bin/run-csvw-tests
 
-features/csvw_json_transformation_tests.feature
+csvlint-earl.ttl

data/csvlint.gemspec

@@ -42,5 +42,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "pry"
   spec.add_development_dependency "github_changelog_generator"
   spec.add_development_dependency "aruba"
+  spec.add_development_dependency "rdf"
+  spec.add_development_dependency "rdf-turtle"
 
 end

data/features/fixtures/w3.org/.well-known/csvm

@@ -0,0 +1,4 @@
+{+url}-metadata.json
+csv-metadata.json
+{+url}.json
+csvm.json

data/features/step_definitions/validation_errors_steps.rb

@@ -47,7 +47,7 @@ When(/^I carry out CSVW validation$/) do
 end
 
 Then(/^there should be errors$/) do
-  # this test is only used for CSVW testing; :invalid_encoding masks lack of real errors
+  # this test is only used for CSVW testing; :invalid_encoding & :line_breaks mask lack of real errors
   @errors.delete_if { |e| e.instance_of?(Csvlint::ErrorMessage) && [:invalid_encoding, :line_breaks].include?(e.type) }
   expect( @errors.count ).to be > 0
 end

data/features/support/earl_formatter.rb

@@ -0,0 +1,66 @@
+require 'rdf'
+require 'rdf/turtle'
+
+class EarlFormatter
+  def initialize(step_mother, io, options)
+    output = RDF::Resource.new("")
+    @graph = RDF::Graph.new
+    @graph << [ CSVLINT, RDF.type, RDF::DOAP.Project ]
+    @graph << [ CSVLINT, RDF.type, EARL.TestSubject ]
+    @graph << [ CSVLINT, RDF.type, EARL.Software ]
+    @graph << [ CSVLINT, RDF::DOAP.name, "csvlint" ]
+    @graph << [ CSVLINT, RDF::DC.title, "csvlint" ]
+    @graph << [ CSVLINT, RDF::DOAP.description, "CSV validator" ]
+    @graph << [ CSVLINT, RDF::DOAP.homepage, RDF::Resource.new("https://github.com/theodi/csvlint.rb") ]
+    @graph << [ CSVLINT, RDF::DOAP.license, RDF::Resource.new("https://raw.githubusercontent.com/theodi/csvlint.rb/master/LICENSE.md") ]
+    @graph << [ CSVLINT, RDF::DOAP["programming-language"], "Ruby" ]
+    @graph << [ CSVLINT, RDF::DOAP.implements, RDF::Resource.new("http://www.w3.org/TR/tabular-data-model/") ]
+    @graph << [ CSVLINT, RDF::DOAP.implements, RDF::Resource.new("http://www.w3.org/TR/tabular-metadata/") ]
+    @graph << [ CSVLINT, RDF::DOAP.developer, ODI ]
+    @graph << [ CSVLINT, RDF::DOAP.maintainer, ODI ]
+    @graph << [ CSVLINT, RDF::DOAP.documenter, ODI ]
+    @graph << [ CSVLINT, RDF::FOAF.maker, ODI ]
+    @graph << [ CSVLINT, RDF::DC.creator, ODI ]
+    @graph << [ output, RDF::FOAF["primaryTopic"], CSVLINT ]
+    @graph << [ output, RDF::DC.issued, DateTime.now ]
+    @graph << [ output, RDF::FOAF.maker, ODI ]
+    @graph << [ ODI, RDF.type, RDF::FOAF.Organization ]
+    @graph << [ ODI, RDF.type, EARL.Assertor ]
+    @graph << [ ODI, RDF::FOAF.name, "Open Data Institute" ]
+    @graph << [ ODI, RDF::FOAF.homepage, "https://theodi.org/" ]
+  end
+
+  def scenario_name(keyword, name, file_colon_line, source_indent)
+    @test = RDF::Resource.new("http://www.w3.org/2013/csvw/tests/#{name.split(" ")[0]}")
+  end
+
+  def after_steps(steps)
+    passed = true
+    steps.each do |s|
+      passed = false unless s.status == :passed
+    end
+    a = RDF::Node.new
+    @graph << [ a, RDF.type, EARL.Assertion ]
+    @graph << [ a, EARL.assertedBy, ODI ]
+    @graph << [ a, EARL.subject, CSVLINT ]
+    @graph << [ a, EARL.test, @test ]
+    @graph << [ a, EARL.mode, EARL.automatic ]
+    r = RDF::Node.new
+    @graph << [ a, EARL.result, r ]
+    @graph << [ r, RDF.type, EARL.TestResult ]
+    @graph << [ r, EARL.outcome, passed ? EARL.passed : EARL.failed ]
+    @graph << [ r, RDF::DC.date, DateTime.now ]
+  end
+
+  def after_features(features)
+    RDF::Writer.for(:ttl).open("csvlint-earl.ttl", { :prefixes => { "earl" => EARL }, :standard_prefixes => true, :canonicalize => true, :literal_shorthand => true }) do |writer|
+      writer << @graph
+    end 
+  end
+
+  private
+    EARL = RDF::Vocabulary.new("http://www.w3.org/ns/earl#")
+    ODI = RDF::Resource.new("https://theodi.org/")
+    CSVLINT = RDF::Resource.new("https://github.com/theodi/csvlint.rb")
+
+end

data/features/support/load_tests.rb

@@ -2,9 +2,10 @@ require 'json'
 require 'open-uri'
 require 'uri'
 
-BASE_URI = "http://w3c.github.io/csvw/tests/"
+BASE_URI = "http://www.w3.org/2013/csvw/tests/"
 BASE_PATH = File.join(File.dirname(__FILE__), "..", "fixtures", "csvw")
-FEATURE_FILE_PATH = File.join(File.dirname(__FILE__), "..", "csvw_validation_tests.feature")
+FEATURE_BASE_PATH = File.join(File.dirname(__FILE__), "..")
+VALIDATION_FEATURE_FILE_PATH = File.join(FEATURE_BASE_PATH, "csvw_validation_tests.feature")
 SCRIPT_FILE_PATH = File.join(File.dirname(__FILE__), "..", "..", "bin", "run-csvw-tests")
 
 Dir.mkdir(BASE_PATH) unless Dir.exist?(BASE_PATH)
@@ -30,7 +31,7 @@ end
 
 File.open(SCRIPT_FILE_PATH, 'w') do |file|
 	File.chmod(0755, SCRIPT_FILE_PATH)
-	manifest = JSON.parse( open("http://w3c.github.io/csvw/tests/manifest-validation.jsonld").read )
+	manifest = JSON.parse( open("http://www.w3.org/2013/csvw/tests/manifest-validation.jsonld").read )
 	manifest["entries"].each do |entry|
 		type = "valid"
 		case entry["type"] 
@@ -52,11 +53,11 @@ File.open(SCRIPT_FILE_PATH, 'w') do |file|
 	end
 end unless File.exist? SCRIPT_FILE_PATH
 
-File.open(FEATURE_FILE_PATH, 'w') do |file|
-	file.puts "# Auto-generated file based on standard validation CSVW tests from http://w3c.github.io/csvw/tests/manifest-validation.jsonld"
+File.open(VALIDATION_FEATURE_FILE_PATH, 'w') do |file|
+	file.puts "# Auto-generated file based on standard validation CSVW tests from http://www.w3.org/2013/csvw/tests/manifest-validation.jsonld"
 	file.puts ""
 
-	manifest = JSON.parse( open("http://w3c.github.io/csvw/tests/manifest-validation.jsonld").read )
+	manifest = JSON.parse( open("http://www.w3.org/2013/csvw/tests/manifest-validation.jsonld").read )
 
 	file.puts "Feature: #{manifest["label"]}"
 	file.puts ""
@@ -83,11 +84,15 @@ File.open(FEATURE_FILE_PATH, 'w') do |file|
 				file.puts "\t\tAnd the metadata is stored at the url \"#{metadata}\""
 			end
 			provided_files << action_uri.to_s
-			missing_files = [				  
-  				URI.join(action_uri, '/.well-known/csvm').to_s,
-  				"#{action_uri}-metadata.json",
-  				URI.join(action_uri, 'csv-metadata.json').to_s
-			]
+			if entry["name"].include?("/.well-known/csvm")
+				file.puts "\t\tAnd I have a file called \"w3.org/.well-known/csvm\" at the url \"http://www.w3.org/.well-known/csvm\""
+	  			missing_files << "#{action_uri}.json"
+	  			missing_files << URI.join(action_uri, 'csvm.json').to_s
+			else
+				missing_files << URI.join(action_uri, '/.well-known/csvm').to_s
+			end
+  			missing_files << "#{action_uri}-metadata.json"
+  			missing_files << URI.join(action_uri, 'csv-metadata.json').to_s
 		end
 		entry["implicit"].each do |implicit|
 			implicit_uri, implicit_file = cache_file(implicit)
@@ -104,11 +109,11 @@ File.open(FEATURE_FILE_PATH, 'w') do |file|
 			file.puts "\t\tThen there should not be errors"
 			file.puts "\t\tAnd there should be warnings"
 		elsif entry["type"] == "csvt:NegativeValidationTest"
-	    file.puts "\t\tThen there should be errors"
+	    	file.puts "\t\tThen there should be errors"
 		else
-	    file.puts "\t\tThen there should not be errors"
-	    file.puts "\t\tAnd there should not be warnings"
+		    file.puts "\t\tThen there should not be errors"
+		    file.puts "\t\tAnd there should not be warnings"
 		end
 		file.puts "\t"
 	end
-end unless File.exist? FEATURE_FILE_PATH
+end unless File.exist? VALIDATION_FEATURE_FILE_PATH

data/lib/csvlint/csvw/column.rb

@@ -3,9 +3,9 @@ module Csvlint
     class Column
       include Csvlint::ErrorCollector
 
-      attr_reader :id, :about_url, :datatype, :default, :lang, :name, :null, :number, :ordered, :property_url, :required, :separator, :source_number, :suppress_output, :text_direction, :titles, :value_url, :virtual, :annotations
+      attr_reader :id, :about_url, :datatype, :default, :lang, :name, :null, :number, :ordered, :property_url, :required, :separator, :source_number, :suppress_output, :text_direction, :default_name, :titles, :value_url, :virtual, :annotations
 
-      def initialize(number, name, id: nil, about_url: nil, datatype: { "@id" => "http://www.w3.org/2001/XMLSchema#string" }, default: "", lang: "und", null: [""], ordered: false, property_url: nil, required: false, separator: nil, source_number: nil, suppress_output: false, text_direction: :inherit, titles: {}, value_url: nil, virtual: false, annotations: [], warnings: [])
+      def initialize(number, name, id: nil, about_url: nil, datatype: { "@id" => "http://www.w3.org/2001/XMLSchema#string" }, default: "", lang: "und", null: [""], ordered: false, property_url: nil, required: false, separator: nil, source_number: nil, suppress_output: false, text_direction: :inherit, default_name: nil, titles: {}, value_url: nil, virtual: false, annotations: [], warnings: [])
         @number = number
         @name = name
         @id = id
@@ -21,6 +21,7 @@ module Csvlint
         @source_number = source_number || number
         @suppress_output = suppress_output
         @text_direction = text_direction
+        @default_name = default_name
         @titles = titles
         @value_url = value_url
         @virtual = virtual
@@ -58,51 +59,64 @@ module Csvlint
           datatype: inherited_properties["datatype"] || { "@id" => "http://www.w3.org/2001/XMLSchema#string" },
           lang: inherited_properties["lang"] || "und",
           null: inherited_properties["null"] || [""],
-          property_url: column_desc["propertyUrl"],
+          default: inherited_properties["default"] || "",
+          about_url: inherited_properties["aboutUrl"],
+          property_url: inherited_properties["propertyUrl"],
+          value_url: inherited_properties["valueUrl"],
           required: inherited_properties["required"] || false,
           separator: inherited_properties["separator"],
+          ordered: inherited_properties["ordered"] || false,
+          default_name: column_properties["titles"] && column_properties["titles"][lang] ? column_properties["titles"][lang][0] : nil,
           titles: column_properties["titles"],
+          suppress_output: column_properties["suppressOutput"] ? column_properties["suppressOutput"] : false,
           virtual: column_properties["virtual"] || false,
           annotations: annotations,
           warnings: warnings
         )
       end
 
-      def validate_header(header)
+      def validate_header(header, strict)
         reset
-        valid_headers = @titles ? @titles.map{ |l,v| v if Column.languages_match(l, lang) }.flatten : []
-        build_errors(:invalid_header, :schema, 1, @number, header, @titles) unless valid_headers.include? header
+        if strict || @titles
+          valid_headers = @titles ? @titles.map{ |l,v| v if Column.languages_match(l, lang) }.flatten : []
+          unless valid_headers.include? header
+            if strict
+              build_errors(:invalid_header, :schema, 1, @number, header, @titles) 
+            else
+              build_warnings(:invalid_header, :schema, 1, @number, header, @titles)
+            end
+          end
+        end
         return valid?
       end
 
       def validate(string_value, row=nil)
         reset
-        values = parse(string_value || "", row)
-        # STDERR.puts "#{name} - #{string_value.inspect} - #{values.inspect}"
-        values.each do |value|
-          validate_required(value, row)
-          validate_format(value, row)
-          validate_length(value, row)
-          validate_value(value, row)
-        end unless values.nil?
-        validate_required(values, row) if values.nil?
-        return valid?
-      end
-
-      def parse(string_value, row=nil)
-        return nil if null.include? string_value
-        string_values = @separator.nil? ? [string_value] : string_value.split(@separator)
-        values = []
-        string_values.each do |s|
-          value, warning = DATATYPE_PARSER[@datatype["base"] || @datatype["@id"]].call(s, @datatype["format"])
-          if warning.nil?
-            values << value
-          else
-            build_errors(warning, :schema, row, @number, s, @datatype)
-            values << s
+        string_value = string_value || @default
+        if null.include? string_value
+          validate_required(nil, row)
+          values = nil
+          return values
+        else
+          string_values = @separator.nil? ? [string_value] : string_value.split(@separator)
+          values = []
+          string_values.each do |s|
+            invalid = false
+            value, warning = DATATYPE_PARSER[@datatype["base"] || @datatype["@id"]].call(s, @datatype["format"])
+            if warning.nil?
+              validate_required(value, row)
+              invalid = !validate_format(value, row) || invalid
+              invalid = !validate_length(value, row) || invalid
+              invalid = !validate_value(value, row) || invalid
+              values << (invalid ? { :invalid => s } : value)
+            else
+              build_errors(warning, :schema, row, @number, s, @datatype)
+              values << { :invalid => s }
+            end
           end
+          values = (values && @separator.nil?) ? values[0] : values
+          return values
         end
-        return values
       end
 
       private
@@ -132,32 +146,65 @@ module Csvlint
         end
 
         def validate_required(value, row)
-          build_errors(:required, :schema, row, number, value, { "required" => @required }) if @required && value.nil?
+          if @required && value.nil?
+            build_errors(:required, :schema, row, number, value, { "required" => @required }) 
+            return false
+          end
+          return true
         end
 
         def validate_length(value, row)
+          valid = true
           if datatype["length"] || datatype["minLength"] || datatype["maxLength"]
             length = value.length
             length = value.gsub(/==?$/,"").length * 3 / 4 if datatype["@id"] == "http://www.w3.org/2001/XMLSchema#base64Binary" || datatype["base"] == "http://www.w3.org/2001/XMLSchema#base64Binary"
             length = value.length / 2 if datatype["@id"] == "http://www.w3.org/2001/XMLSchema#hexBinary" || datatype["base"] == "http://www.w3.org/2001/XMLSchema#hexBinary"
 
-            build_errors(:min_length, :schema, row, number, value, { "minLength" => datatype["minLength"] }) if datatype["minLength"] && length < datatype["minLength"]
-            build_errors(:max_length, :schema, row, number, value, { "maxLength" => datatype["maxLength"] }) if datatype["maxLength"] && length > datatype["maxLength"]
-            build_errors(:length, :schema, row, number, value, { "length" => datatype["length"] }) if datatype["length"] && length != datatype["length"]
+            if datatype["minLength"] && length < datatype["minLength"]
+              build_errors(:min_length, :schema, row, number, value, { "minLength" => datatype["minLength"] }) 
+              valid = false
+            end
+            if datatype["maxLength"] && length > datatype["maxLength"]
+              build_errors(:max_length, :schema, row, number, value, { "maxLength" => datatype["maxLength"] }) 
+              valid = false
+            end
+            if datatype["length"] && length != datatype["length"]
+              build_errors(:length, :schema, row, number, value, { "length" => datatype["length"] }) 
+              valid = false
+            end
           end
+          return valid
         end
 
         def validate_format(value, row)
           if datatype["format"]
-            build_errors(:format, :schema, row, number, value, { "format" => datatype["format"] }) unless DATATYPE_FORMAT_VALIDATION[datatype["base"]].call(value, datatype["format"])
+            unless DATATYPE_FORMAT_VALIDATION[datatype["base"]].call(value, datatype["format"])
+              build_errors(:format, :schema, row, number, value, { "format" => datatype["format"] }) 
+              return false
+            end
           end
+          return true
         end
 
         def validate_value(value, row)
-          build_errors(:min_inclusive, :schema, row, number, value, { "minInclusive" => datatype["minInclusive"] }) if datatype["minInclusive"] && value < datatype["minInclusive"]
-          build_errors(:max_inclusive, :schema, row, number, value, { "maxInclusive" => datatype["maxInclusive"] }) if datatype["maxInclusive"] && value > datatype["maxInclusive"]
-          build_errors(:min_exclusive, :schema, row, number, value, { "minExclusive" => datatype["minExclusive"] }) if datatype["minExclusive"] && value <= datatype["minExclusive"]
-          build_errors(:max_exclusive, :schema, row, number, value, { "maxExclusive" => datatype["maxExclusive"] }) if datatype["maxExclusive"] && value >= datatype["maxExclusive"]
+          valid = true
+          if datatype["minInclusive"] && ((value.is_a? Hash) ? (value[:dateTime] < datatype["minInclusive"][:dateTime]) : (value < datatype["minInclusive"]))
+            build_errors(:min_inclusive, :schema, row, number, value, { "minInclusive" => datatype["minInclusive"] }) 
+            valid = false
+          end
+          if datatype["maxInclusive"] && ((value.is_a? Hash) ? (value[:dateTime] > datatype["maxInclusive"][:dateTime]) : (value > datatype["maxInclusive"]))
+            build_errors(:max_inclusive, :schema, row, number, value, { "maxInclusive" => datatype["maxInclusive"] }) 
+            valid = false
+          end
+          if datatype["minExclusive"] && ((value.is_a? Hash) ? (value[:dateTime] <= datatype["minExclusive"][:dateTime]) : (value <= datatype["minExclusive"]))
+            build_errors(:min_exclusive, :schema, row, number, value, { "minExclusive" => datatype["minExclusive"] }) 
+            valid = false
+          end
+          if datatype["maxExclusive"] && ((value.is_a? Hash) ? (value[:dateTime] >= datatype["maxExclusive"][:dateTime]) : (value >= datatype["maxExclusive"]))
+            build_errors(:max_exclusive, :schema, row, number, value, { "maxExclusive" => datatype["maxExclusive"] }) 
+            valid = false
+          end
+          return valid
         end
 
         REGEXP_VALIDATION = lambda { |value, format| value =~ format }
@@ -210,22 +257,23 @@ module Csvlint
           "http://www.w3.org/2001/XMLSchema#time" => NO_ADDITIONAL_VALIDATION
         }
 
+        TRIM_VALUE = lambda { |value, format| return value.strip, nil }
         ALL_VALUES_VALID = lambda { |value, format| return value, nil }
 
-        NUMERIC_PARSER = lambda { |value, format|
-          format = Csvlint::Csvw::NumberFormat.new() if format.nil?
+        NUMERIC_PARSER = lambda { |value, format, integer=false|
+          format = Csvlint::Csvw::NumberFormat.new(nil, nil, ".", integer) if format.nil?
           v = format.parse(value)
           return nil, :invalid_number if v.nil?
           return v, nil
         }
 
         DATATYPE_PARSER = {
-          "http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral" => ALL_VALUES_VALID,
-          "http://www.w3.org/1999/02/22-rdf-syntax-ns#HTML" => ALL_VALUES_VALID,
-          "http://www.w3.org/ns/csvw#JSON" => ALL_VALUES_VALID,
+          "http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral" => TRIM_VALUE,
+          "http://www.w3.org/1999/02/22-rdf-syntax-ns#HTML" => TRIM_VALUE,
+          "http://www.w3.org/ns/csvw#JSON" => TRIM_VALUE,
           "http://www.w3.org/2001/XMLSchema#anyAtomicType" => ALL_VALUES_VALID,
-          "http://www.w3.org/2001/XMLSchema#anyURI" => ALL_VALUES_VALID,
-          "http://www.w3.org/2001/XMLSchema#base64Binary" => ALL_VALUES_VALID,
+          "http://www.w3.org/2001/XMLSchema#anyURI" => TRIM_VALUE,
+          "http://www.w3.org/2001/XMLSchema#base64Binary" => TRIM_VALUE,
           "http://www.w3.org/2001/XMLSchema#boolean" => lambda { |value, format|
             if format.nil?
               return true, nil if ["true", "1"].include? value
@@ -243,11 +291,11 @@ module Csvlint
           "http://www.w3.org/2001/XMLSchema#dateTimeStamp" =>
             create_date_parser("http://www.w3.org/2001/XMLSchema#dateTimeStamp", :invalid_date_time_stamp),
           "http://www.w3.org/2001/XMLSchema#decimal" => lambda { |value, format|
-            return nil, :invalid_decimal if value =~ /(E|^(NaN|INF|-INF)$)/
+            return nil, :invalid_decimal if value =~ /(E|e|^(NaN|INF|-INF)$)/
             return NUMERIC_PARSER.call(value, format)
           },
           "http://www.w3.org/2001/XMLSchema#integer" => lambda { |value, format|
-            v, w = NUMERIC_PARSER.call(value, format)
+            v, w = NUMERIC_PARSER.call(value, format, true)
             return v, :invalid_integer unless w.nil?
             return nil, :invalid_integer unless v.kind_of? Integer
             return v, w
@@ -343,14 +391,14 @@ module Csvlint
             create_date_parser("http://www.w3.org/2001/XMLSchema#gYear", :invalid_gYear),
           "http://www.w3.org/2001/XMLSchema#gYearMonth" =>
             create_date_parser("http://www.w3.org/2001/XMLSchema#gYearMonth", :invalid_gYearMonth),
-          "http://www.w3.org/2001/XMLSchema#hexBinary" => ALL_VALUES_VALID,
-          "http://www.w3.org/2001/XMLSchema#QName" => ALL_VALUES_VALID,
+          "http://www.w3.org/2001/XMLSchema#hexBinary" => TRIM_VALUE,
+          "http://www.w3.org/2001/XMLSchema#QName" => TRIM_VALUE,
           "http://www.w3.org/2001/XMLSchema#string" => ALL_VALUES_VALID,
-          "http://www.w3.org/2001/XMLSchema#normalizedString" => ALL_VALUES_VALID,
-          "http://www.w3.org/2001/XMLSchema#token" => ALL_VALUES_VALID,
-          "http://www.w3.org/2001/XMLSchema#language" => ALL_VALUES_VALID,
-          "http://www.w3.org/2001/XMLSchema#Name" => ALL_VALUES_VALID,
-          "http://www.w3.org/2001/XMLSchema#NMTOKEN" => ALL_VALUES_VALID,
+          "http://www.w3.org/2001/XMLSchema#normalizedString" => TRIM_VALUE,
+          "http://www.w3.org/2001/XMLSchema#token" => TRIM_VALUE,
+          "http://www.w3.org/2001/XMLSchema#language" => TRIM_VALUE,
+          "http://www.w3.org/2001/XMLSchema#Name" => TRIM_VALUE,
+          "http://www.w3.org/2001/XMLSchema#NMTOKEN" => TRIM_VALUE,
           "http://www.w3.org/2001/XMLSchema#time" =>
             create_date_parser("http://www.w3.org/2001/XMLSchema#time", :invalid_time)
         }