csvlint 0.1.1 → 0.1.2

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    MDgwMGE1ZmY5ZWE2MzM2ODhhMTFhZjM5NTkyZTNkZWExZjFkN2I0Mw==
+    NjUyMGZlNGIyNjM4ZmU1OGVjMDc3Y2U2YmQ0NWEzMzM3ZGFkYzA0Yw==
   data.tar.gz: !binary |-
-    OTRhZTljMTc5ZDlmZDVlMmQ2ZDU2MTFmYmRlNGUyMGIyMTI3NTBmOQ==
+    NzYzMjUxY2NlZmE4ODY3NjYwNTU4NzUyMmE2NTU0NjM1MmQ0YzI4NQ==
 SHA512:
   metadata.gz: !binary |-
-    ZDE4YWVlNGYzY2E5OGJjM2ZkZjA0MzQwMWE1Yzg5YTI3YzM0MjNkMmFhNjFj
-    YmY3YzYzN2E5NDk1NDM4YmNmMGY1ZWRlNmExZWI0NmYzZmQzNTc2N2ZiOTMx
-    YzU2MjhiMmE4YTc2NTVmNzE4YWI4ZDZjOWM5MDlhNTRlY2RkMzE=
+    ODQwMGQzMjY4NGQzNGY5ZGY1Nzg3ODc5MDI3M2E3NmNmNzUwNzU1MzBjNjNk
+    YzRiMjE3NTJlNTc5YWI2NjhkNGJjNDcxNzVkMDgyZmRkYjZlYWFmZjUyOWQx
+    ZmVkOWRjZDJhMGU4M2QyYmI0YzZmMDBlYWRhMjFmNGFlZmJmZTg=
   data.tar.gz: !binary |-
-    NDY1ODhkODdlZDJlYzMyMTQ1NzFlYzAyNTYyN2YzMGE1NTM2Yzg1NWRiYTQ5
-    NmQ1ODE5MzNmOTU4ZjhmNmZjNWQwNWU1N2E5OTdmOWMyZmZiYjE4ZmVhNmVh
-    YzdmN2VmNjY1NjFkMDdmYTc0YzZiNTk2YWQxMWZkMmRkNmVhODg=
+    ZjhkODBhMWU1ODFjN2JiNjQ3ZjBlZmFkNzAwMmVhOTNiYzgwNDNjM2RjODg5
+    YWE2NGUwNjk1M2JlYWFjZmVlY2U0YjNmMTZmM2U4YTFlMDcyMGViNWU3NWY2
+    NTY5NmIyNmE5ZjYwNDkwOTE1NjQ2MWRiZGU0ZGRhM2MxMTEyYjU=

data/README.md

@@ -221,7 +221,7 @@ Schema validation provides some additional types of error and warning messages:
 * `:min_length` (error) -- a column with a `minLength` constraint has a value that is too short
 * `:max_length` (error) -- a column with a `maxLength` constraint has a value that is too long
 * `:pattern` (error) --  a column with a `pattern` constraint has a value that doesn't match the regular expression
-* `:header_name` (warning) -- the header in the CSV has a column name that doesn't match the schema
+* `:malformed_header` (warning) -- the header in the CSV doesn't match the schema
 * `:missing_column` (warning) -- a row in the CSV file has a missing column, that is specified in the schema. This is a warning only, as it may be legitimate
 * `:extra_column` (warning) -- a row in the CSV file has extra column.
 * `:unique` (error) -- a column with a `unique` constraint contains non-unique values

data/lib/csvlint/field.rb

@@ -105,8 +105,12 @@ module Csvlint
           'http://www.w3.org/2001/XMLSchema#float'   => lambda { |value, constraints| Float value },
           'http://www.w3.org/2001/XMLSchema#double'   => lambda { |value, constraints| Float value },
           'http://www.w3.org/2001/XMLSchema#anyURI'  => lambda do |value, constraints|
-            u = URI.parse value
-            raise ArgumentError unless u.kind_of?(URI::HTTP) || u.kind_of?(URI::HTTPS)
+            begin
+              u = URI.parse value
+              raise ArgumentError unless u.kind_of?(URI::HTTP) || u.kind_of?(URI::HTTPS)
+            rescue URI::InvalidURIError
+              raise ArgumentError
+            end
             u
           end,
           'http://www.w3.org/2001/XMLSchema#boolean' => lambda do |value, constraints|

data/lib/csvlint/schema.rb

@@ -16,9 +16,13 @@ module Csvlint
 
     def validate_header(header)
       reset
-      header.each_with_index do |name,i|
-        build_warnings(:header_name, :schema, nil, i+1, name) if fields[i].name != name
+
+      found_header = header.join(',')
+      expected_header = @fields.map{ |f| f.name }.join(',')
+      if found_header != expected_header
+        build_warnings(:malformed_header, :schema, 1, nil, found_header, expected_header)
       end
+
       return valid?
     end
         

data/lib/csvlint/version.rb

@@ -1,3 +1,3 @@
 module Csvlint
-  VERSION = "0.1.1"
+  VERSION = "0.1.2"
 end

data/spec/field_spec.rb

@@ -1,45 +1,45 @@
 require 'spec_helper'
 
 describe Csvlint::Field do
-  
+
   it "should validate required fields" do
     field = Csvlint::Field.new("test", { "required" => true } )
-    expect( field.validate_column( nil ) ).to be(false)  
+    expect( field.validate_column( nil ) ).to be(false)
     expect( field.errors.first.category ).to be(:schema)
     expect( field.validate_column( "" ) ).to be(false)
     expect( field.validate_column( "data" ) ).to be(true)
   end
-  
+
   it "should include the failed constraints" do
     field = Csvlint::Field.new("test", { "required" => true } )
-    expect( field.validate_column( nil ) ).to be(false)  
+    expect( field.validate_column( nil ) ).to be(false)
     expect( field.errors.first.constraints ).to eql( { "required" => true } )
   end
-  
+
   it "should validate minimum length" do
     field = Csvlint::Field.new("test", { "minLength" => 3 } )
     expect( field.validate_column( nil ) ).to be(false)
-    expect( field.validate_column( "" ) ).to be(false)    
+    expect( field.validate_column( "" ) ).to be(false)
     expect( field.validate_column( "ab" ) ).to be(false)
     expect( field.validate_column( "abc" ) ).to be(true)
-    expect( field.validate_column( "abcd" ) ).to be(true)    
+    expect( field.validate_column( "abcd" ) ).to be(true)
   end
-  
+
   it "should validate maximum length" do
     field = Csvlint::Field.new("test", { "maxLength" => 3 } )
     expect( field.validate_column( nil ) ).to be(true)
-    expect( field.validate_column( "" ) ).to be(true)    
+    expect( field.validate_column( "" ) ).to be(true)
     expect( field.validate_column( "ab" ) ).to be(true)
     expect( field.validate_column( "abc" ) ).to be(true)
     expect( field.validate_column( "abcd" ) ).to be(false)
   end
-  
+
   it "should validate against regex" do
     field = Csvlint::Field.new("test", { "pattern" => "\{[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}\}"} )
     expect( field.validate_column( "abc") ).to be(false)
-    expect( field.validate_column( "{3B0DA29C-C89A-4FAA-918A-0000074FA0E0}") ).to be(true)  
+    expect( field.validate_column( "{3B0DA29C-C89A-4FAA-918A-0000074FA0E0}") ).to be(true)
   end
-  
+
   it "should apply combinations of constraints" do
     field = Csvlint::Field.new("test", { "required"=>true, "pattern" => "\{[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}\}"} )
     expect( field.validate_column( "abc") ).to be(false)
@@ -47,9 +47,9 @@ describe Csvlint::Field do
 
     expect( field.validate_column( nil ) ).to be(false)
     expect( field.errors.first.constraints ).to eql( { "required"=>true } )
-    
-    expect( field.validate_column( "{3B0DA29C-C89A-4FAA-918A-0000074FA0E0}") ).to be(true)  
-    
+
+    expect( field.validate_column( "{3B0DA29C-C89A-4FAA-918A-0000074FA0E0}") ).to be(true)
+
   end
 
   it "should enforce uniqueness for a column" do
@@ -65,13 +65,13 @@ describe Csvlint::Field do
       field = Csvlint::Field.new("test", { "type" => "http://www.w3.org/2001/XMLSchema#int" })
       expect( field.validate_column("")).to be(true)
     end
-    
+
     it "validates strings" do
       field = Csvlint::Field.new("test", { "type" => "http://www.w3.org/2001/XMLSchema#string" })
       expect( field.validate_column("42")).to be(true)
       expect( field.validate_column("forty-two")).to be(true)
     end
-    
+
     it "validates ints" do
       field = Csvlint::Field.new("test", { "type" => "http://www.w3.org/2001/XMLSchema#int" })
       expect( field.validate_column("42")).to be(true)
@@ -82,7 +82,7 @@ describe Csvlint::Field do
       field = Csvlint::Field.new("test", { "type" => "http://www.w3.org/2001/XMLSchema#integer" })
       expect( field.validate_column("42")).to be(true)
       expect( field.validate_column("forty-two")).to be(false)
-    end        
+    end
 
     it "validates floats" do
       field = Csvlint::Field.new("test", { "type" => "http://www.w3.org/2001/XMLSchema#float" })
@@ -98,6 +98,11 @@ describe Csvlint::Field do
       expect(field.validate_column("42.0")).to be(false)
     end
 
+    it "works with invalid URIs" do
+      field = Csvlint::Field.new("test", { "type" => "http://www.w3.org/2001/XMLSchema#anyURI" })
+      expect(field.validate_column("£123")).to be(false)
+    end
+
     it "validates booleans" do
       field = Csvlint::Field.new("test", { "type" => "http://www.w3.org/2001/XMLSchema#boolean" })
       expect(field.validate_column("true")).to be(true)
@@ -137,111 +142,111 @@ describe Csvlint::Field do
         expect(field.validate_column("1")).to be(true)
       end
     end
-    
+
     context "when validating ranges" do
-      
+
       it "should enforce minimum values" do
-        field = Csvlint::Field.new("test", { 
+        field = Csvlint::Field.new("test", {
             "type" => "http://www.w3.org/2001/XMLSchema#int",
             "minimum" => "40"
         })
         expect( field.validate_column("42")).to be(true)
 
-        field = Csvlint::Field.new("test", { 
+        field = Csvlint::Field.new("test", {
             "type" => "http://www.w3.org/2001/XMLSchema#int",
             "minimum" => "40"
         })
-        expect( field.validate_column("39")).to be(false)     
+        expect( field.validate_column("39")).to be(false)
         expect( field.errors.first.type ).to eql(:below_minimum)
       end
-      
+
       it "should enforce maximum values" do
-        field = Csvlint::Field.new("test", { 
+        field = Csvlint::Field.new("test", {
             "type" => "http://www.w3.org/2001/XMLSchema#int",
             "maximum" => "40"
         })
         expect( field.validate_column("39")).to be(true)
 
-        field = Csvlint::Field.new("test", { 
+        field = Csvlint::Field.new("test", {
             "type" => "http://www.w3.org/2001/XMLSchema#int",
             "maximum" => "40"
         })
-        expect( field.validate_column("41")).to be(false)        
+        expect( field.validate_column("41")).to be(false)
         expect( field.errors.first.type ).to eql(:above_maximum)
 
-      end      
+      end
     end
-    
+
     context "when validating dates" do
       it "should validate a date time" do
-        field = Csvlint::Field.new("test", { 
+        field = Csvlint::Field.new("test", {
              "type" => "http://www.w3.org/2001/XMLSchema#dateTime"
          })
          expect( field.validate_column("2014-02-17T11:09:00Z")).to be(true)
          expect( field.validate_column("invalid-date")).to be(false)
-        expect( field.validate_column("2014-02-17")).to be(false)          
+        expect( field.validate_column("2014-02-17")).to be(false)
       end
       it "should validate a date" do
-        field = Csvlint::Field.new("test", { 
+        field = Csvlint::Field.new("test", {
              "type" => "http://www.w3.org/2001/XMLSchema#date"
          })
          expect( field.validate_column("2014-02-17T11:09:00Z")).to be(false)
          expect( field.validate_column("invalid-date")).to be(false)
-        expect( field.validate_column("2014-02-17")).to be(true)          
+        expect( field.validate_column("2014-02-17")).to be(true)
       end
       it "should validate a time" do
-        field = Csvlint::Field.new("test", { 
+        field = Csvlint::Field.new("test", {
              "type" => "http://www.w3.org/2001/XMLSchema#time"
          })
          expect( field.validate_column("11:09:00")).to be(true)
          expect( field.validate_column("2014-02-17T11:09:00Z")).to be(false)
-         expect( field.validate_column("not-a-time")).to be(false)     
-         expect( field.validate_column("27:97:00")).to be(false)   
+         expect( field.validate_column("not-a-time")).to be(false)
+         expect( field.validate_column("27:97:00")).to be(false)
       end
       it "should validate a year" do
-        field = Csvlint::Field.new("test", { 
+        field = Csvlint::Field.new("test", {
              "type" => "http://www.w3.org/2001/XMLSchema#gYear"
          })
          expect( field.validate_column("1999")).to be(true)
          expect( field.validate_column("2525")).to be(true)
          expect( field.validate_column("0001")).to be(true)
          expect( field.validate_column("2014-02-17T11:09:00Z")).to be(false)
-         expect( field.validate_column("not-a-time")).to be(false)     
-         expect( field.validate_column("27:97:00")).to be(false)   
+         expect( field.validate_column("not-a-time")).to be(false)
+         expect( field.validate_column("27:97:00")).to be(false)
       end
       it "should validate a year-month" do
-        field = Csvlint::Field.new("test", { 
+        field = Csvlint::Field.new("test", {
              "type" => "http://www.w3.org/2001/XMLSchema#gYearMonth"
          })
          expect( field.validate_column("1999-12")).to be(true)
          expect( field.validate_column("2525-01")).to be(true)
          expect( field.validate_column("2014-02-17T11:09:00Z")).to be(false)
-         expect( field.validate_column("not-a-time")).to be(false)     
-         expect( field.validate_column("27:97:00")).to be(false)   
+         expect( field.validate_column("not-a-time")).to be(false)
+         expect( field.validate_column("27:97:00")).to be(false)
       end
       it "should allow user to specify custom date time pattern" do
-        field = Csvlint::Field.new("test", { 
+        field = Csvlint::Field.new("test", {
              "type" => "http://www.w3.org/2001/XMLSchema#dateTime",
              "datePattern" => "%Y-%m-%d %H:%M:%S"
          })
          expect( field.validate_column("1999-12-01 10:00:00")).to be(true)
          expect( field.validate_column("invalid-date")).to be(false)
-        expect( field.validate_column("2014-02-17")).to be(false)  
-        expect( field.errors.first.constraints ).to eql( { 
+        expect( field.validate_column("2014-02-17")).to be(false)
+        expect( field.errors.first.constraints ).to eql( {
              "type" => "http://www.w3.org/2001/XMLSchema#dateTime",
              "datePattern" => "%Y-%m-%d %H:%M:%S"
          })
-         
+
       end
       it "should allow user to compare dates" do
-        field = Csvlint::Field.new("test", { 
+        field = Csvlint::Field.new("test", {
              "type" => "http://www.w3.org/2001/XMLSchema#dateTime",
              "datePattern" => "%Y-%m-%d %H:%M:%S",
              "minimum" => "1990-01-01 10:00:00"
          })
          expect( field.validate_column("1999-12-01 10:00:00")).to be(true)
-         expect( field.validate_column("1989-12-01 10:00:00")).to be(false)        
+         expect( field.validate_column("1989-12-01 10:00:00")).to be(false)
       end
     end
   end
-end
+end

data/spec/schema_spec.rb

@@ -94,16 +94,50 @@ describe Csvlint::Schema do
       
       expect( schema.validate_header(["wrong", "required"]) ).to eql(true)
       expect( schema.warnings.size ).to eql(1)
-      expect( schema.warnings.first.type).to eql(:header_name)
-      expect( schema.warnings.first.content).to eql("wrong")
-      expect( schema.warnings.first.column).to eql(1)
-      expect( schema.warnings.first.category).to eql(:schema)
-      
+      expect( schema.warnings.first.row ).to eql(1)
+      expect( schema.warnings.first.type ).to eql(:malformed_header)
+      expect( schema.warnings.first.content ).to eql('wrong,required')
+      expect( schema.warnings.first.column ).to eql(nil)
+      expect( schema.warnings.first.category ).to eql(:schema)
+      expect( schema.warnings.first.constraints ).to eql('minimum,required')
+
       expect( schema.validate_header(["minimum", "Required"]) ).to eql(true)
       expect( schema.warnings.size ).to eql(1)
 
-    end        
-  end  
+    end
+
+    it "should warn if column count is less than field count" do
+      minimum = Csvlint::Field.new("minimum", { "minLength" => 3 } )
+      required = Csvlint::Field.new("required", { "required" => true } )
+      schema = Csvlint::Schema.new("http://example.org", [minimum, required] )
+
+      expect( schema.validate_header(["minimum"]) ).to eql(true)
+      expect( schema.warnings.size ).to eql(1)
+      expect( schema.warnings.first.row ).to eql(1)
+      expect( schema.warnings.first.type ).to eql(:malformed_header)
+      expect( schema.warnings.first.content ).to eql("minimum")
+      expect( schema.warnings.first.column ).to eql(nil)
+      expect( schema.warnings.first.category ).to eql(:schema)
+      expect( schema.warnings.first.constraints ).to eql('minimum,required')
+
+    end
+
+    it "should warn if column count is more than field count" do
+      minimum = Csvlint::Field.new("minimum", { "minLength" => 3 } )
+      schema = Csvlint::Schema.new("http://example.org", [minimum] )
+
+      expect( schema.validate_header(["wrong", "required"]) ).to eql(true)
+      expect( schema.warnings.size ).to eql(1)
+      expect( schema.warnings.first.row ).to eql(1)
+      expect( schema.warnings.first.type ).to eql(:malformed_header)
+      expect( schema.warnings.first.content ).to eql("wrong,required")
+      expect( schema.warnings.first.column ).to eql(nil)
+      expect( schema.warnings.first.category ).to eql(:schema)
+      expect( schema.warnings.first.constraints ).to eql('minimum')
+
+    end
+
+  end
   
   context "when parsing JSON Tables" do
     

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: csvlint
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - pezholio
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-07-13 00:00:00.000000000 Z
+date: 2015-07-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: mime-types