csvlint 1.0.0 → 1.2.0

data/features/step_definitions/parse_csv_steps.rb

@@ -12,31 +12,31 @@ Given(/^it is stored at the url "(.*?)"$/) do |url|
   charset = @encoding || "UTF-8"
   headers = {"Content-Type" => "#{content_type}; charset=#{charset}"}
   headers["Link"] = @link if @link
-  stub_request(:get, url).to_return(:status => 200, :body => @csv, :headers => headers)
-  stub_request(:get, URI.join(url, '/.well-known/csvm')).to_return(:status => 404)
-  stub_request(:get, url + '-metadata.json').to_return(:status => 404)
-  stub_request(:get, URI.join(url, 'csv-metadata.json')).to_return(:status => 404)
+  stub_request(:get, url).to_return(status: 200, body: @csv, headers: headers)
+  stub_request(:get, URI.join(url, "/.well-known/csvm")).to_return(status: 404)
+  stub_request(:get, url + "-metadata.json").to_return(status: 404)
+  stub_request(:get, URI.join(url, "csv-metadata.json")).to_return(status: 404)
 end
 
 Given(/^it is stored at the url "(.*?)" with no character set$/) do |url|
   @url = url
   content_type = @content_type || "text/csv"
-  stub_request(:get, url).to_return(:status => 200, :body => @csv, :headers => {"Content-Type" => "#{content_type}"})
-  stub_request(:get, URI.join(url, '/.well-known/csvm')).to_return(:status => 404)
-  stub_request(:get, url + '-metadata.json').to_return(:status => 404)
-  stub_request(:get, URI.join(url, 'csv-metadata.json')).to_return(:status => 404)
+  stub_request(:get, url).to_return(status: 200, body: @csv, headers: {"Content-Type" => content_type.to_s})
+  stub_request(:get, URI.join(url, "/.well-known/csvm")).to_return(status: 404)
+  stub_request(:get, url + "-metadata.json").to_return(status: 404)
+  stub_request(:get, URI.join(url, "csv-metadata.json")).to_return(status: 404)
 end
 
 When(/^I ask if the CSV is valid$/) do
   @csv_options ||= default_csv_options
-  @validator = Csvlint::Validator.new( @url, @csv_options )
+  @validator = Csvlint::Validator.new(@url, @csv_options)
   @valid = @validator.valid?
 end
 
 Then(/^I should get the value of true$/) do
-  expect( @valid ).to be(true)
+  expect(@valid).to be(true)
 end
 
 Then(/^I should get the value of false$/) do
-  expect( @valid ).to be(false)
+  expect(@valid).to be(false)
 end

data/features/step_definitions/schema_validation_steps.rb

@@ -10,24 +10,24 @@ end
 
 Given(/^I have a metadata file called "([^"]*)"$/) do |filename|
   @schema_type = :csvw_metadata
-  @schema_json = File.read( File.join( File.dirname(__FILE__), "..", "fixtures", filename ) )
+  @schema_json = File.read(File.join(File.dirname(__FILE__), "..", "fixtures", filename))
 end
 
-Given(/^the (schema|metadata) is stored at the url "(.*?)"$/) do |schema_type,schema_url|
+Given(/^the (schema|metadata) is stored at the url "(.*?)"$/) do |schema_type, schema_url|
   @schema_url = schema_url
-  stub_request(:get, @schema_url).to_return(:status => 200, :body => @schema_json.to_str)
+  stub_request(:get, @schema_url).to_return(status: 200, body: @schema_json.to_str)
 end
 
 Given(/^there is a file at "(.*?)" with the content:$/) do |url, content|
-  stub_request(:get, url).to_return(:status => 200, :body => content.to_str)
+  stub_request(:get, url).to_return(status: 200, body: content.to_str)
 end
 
-Given(/^I have a file called "(.*?)" at the url "(.*?)"$/) do |filename,url|
-  content = File.read( File.join( File.dirname(__FILE__), "..", "fixtures", filename ) )
-  content_type = filename =~ /.csv$/ ? "text/csv" : "application/csvm+json"
-  stub_request(:get, url).to_return(:status => 200, :body => content, :headers => {"Content-Type" => "#{content_type}; charset=UTF-8"})
+Given(/^I have a file called "(.*?)" at the url "(.*?)"$/) do |filename, url|
+  content = File.read(File.join(File.dirname(__FILE__), "..", "fixtures", filename))
+  content_type = /.csv$/.match?(filename) ? "text/csv" : "application/csvm+json"
+  stub_request(:get, url).to_return(status: 200, body: content, headers: {"Content-Type" => "#{content_type}; charset=UTF-8"})
 end
 
 Given(/^there is no file at the url "(.*?)"$/) do |url|
-  stub_request(:get, url).to_return(:status => 404)
-end
+  stub_request(:get, url).to_return(status: 404)
+end

data/features/step_definitions/sources_steps.rb

@@ -3,5 +3,5 @@ Given(/^it is parsed as a StringIO$/) do
 end
 
 Given(/^I parse a file called "(.*?)"$/) do |filename|
-  @url = File.new( File.join( File.dirname(__FILE__), "..", "fixtures", filename ) )
+  @url = File.new(File.join(File.dirname(__FILE__), "..", "fixtures", filename))
 end

data/features/step_definitions/validation_errors_steps.rb

@@ -2,14 +2,14 @@ When(/^I ask if there are errors$/) do
   @csv_options ||= default_csv_options
 
   if @schema_json
-    if @schema_type == :json_table
-      @schema = Csvlint::Schema.from_json_table( @schema_url || "http://example.org ", JSON.parse(@schema_json) )
+    @schema = if @schema_type == :json_table
+      Csvlint::Schema.from_json_table(@schema_url || "http://example.org ", JSON.parse(@schema_json))
     else
-      @schema = Csvlint::Schema.from_csvw_metadata( @schema_url || "http://example.org ", JSON.parse(@schema_json) )
+      Csvlint::Schema.from_csvw_metadata(@schema_url || "http://example.org ", JSON.parse(@schema_json))
     end
   end
 
-  @validator = Csvlint::Validator.new( @url, @csv_options, @schema )
+  @validator = Csvlint::Validator.new(@url, @csv_options, @schema)
   @errors = @validator.errors
 end
 
@@ -19,10 +19,10 @@ When(/^I carry out CSVW validation$/) do
   begin
     if @schema_json
       json = JSON.parse(@schema_json)
-      if @schema_type == :json_table
-        @schema = Csvlint::Schema.from_json_table( @schema_url || "http://example.org ", json )
+      @schema = if @schema_type == :json_table
+        Csvlint::Schema.from_json_table(@schema_url || "http://example.org ", json)
       else
-        @schema = Csvlint::Schema.from_csvw_metadata( @schema_url || "http://example.org ", json )
+        Csvlint::Schema.from_csvw_metadata(@schema_url || "http://example.org ", json)
       end
     end
 
@@ -30,12 +30,12 @@ When(/^I carry out CSVW validation$/) do
       @errors = []
       @warnings = []
       @schema.tables.keys.each do |table_url|
-        validator = Csvlint::Validator.new( table_url, @csv_options, @schema )
+        validator = Csvlint::Validator.new(table_url, @csv_options, @schema)
         @errors += validator.errors
         @warnings += validator.warnings
       end
     else
-      validator = Csvlint::Validator.new( @url, @csv_options, @schema )
+      validator = Csvlint::Validator.new(@url, @csv_options, @schema)
       @errors = validator.errors
       @warnings = validator.warnings
     end
@@ -49,42 +49,42 @@ end
 Then(/^there should be errors$/) do
   # 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
+  expect(@errors.count).to be > 0
 end
 
 Then(/^there should not be errors$/) do
-  expect( @errors.count ).to eq(0)
+  expect(@errors.count).to eq(0)
 end
 
 Then(/^there should be (\d+) error$/) do |count|
-  expect( @errors.count ).to eq( count.to_i )
+  expect(@errors.count).to eq(count.to_i)
 end
 
 Then(/^that error should have the type "(.*?)"$/) do |type|
-  expect( @errors.first.type ).to eq( type.to_sym )
+  expect(@errors.first.type).to eq(type.to_sym)
 end
 
 Then(/^that error should have the row "(.*?)"$/) do |row|
-  expect( @errors.first.row ).to eq( row.to_i )
+  expect(@errors.first.row).to eq(row.to_i)
 end
 
 Then(/^that error should have the column "(.*?)"$/) do |column|
-  expect( @errors.first.column ).to eq( column.to_i )
+  expect(@errors.first.column).to eq(column.to_i)
 end
 
 Then(/^that error should have the content "(.*)"$/) do |content|
-  expect( @errors.first.content.chomp ).to eq( content.chomp )
+  expect(@errors.first.content.chomp).to eq(content.chomp)
 end
 
 Then(/^that error should have no content$/) do
-  expect( @errors.first.content ).to eq( nil )
+  expect(@errors.first.content).to eq(nil)
 end
 
 Given(/^I have a CSV that doesn't exist$/) do
   @url = "http//www.example.com/fake-csv.csv"
-  stub_request(:get, @url).to_return(:status => 404)
+  stub_request(:get, @url).to_return(status: 404)
 end
 
 Then(/^there should be no "(.*?)" errors$/) do |type|
-  @errors.each do |error| error.type.should_not == type.to_sym end
+  @errors.each { |error| error.type.should_not == type.to_sym }
 end

data/features/step_definitions/validation_info_steps.rb

@@ -1,22 +1,22 @@
 Given(/^I ask if there are info messages$/) do
   @csv_options ||= default_csv_options
-  
+
   if @schema_json
-    if @schema_type == :json_table
-      @schema = Csvlint::Schema.from_json_table( @schema_url || "http://example.org ", JSON.parse(@schema_json) )
+    @schema = if @schema_type == :json_table
+      Csvlint::Schema.from_json_table(@schema_url || "http://example.org ", JSON.parse(@schema_json))
     else
-      @schema = Csvlint::Schema.from_csvw_metadata( @schema_url || "http://example.org ", JSON.parse(@schema_json) )
+      Csvlint::Schema.from_csvw_metadata(@schema_url || "http://example.org ", JSON.parse(@schema_json))
     end
   end
-  
-  @validator = Csvlint::Validator.new( @url, @csv_options, @schema ) 
+
+  @validator = Csvlint::Validator.new(@url, @csv_options, @schema)
   @info_messages = @validator.info_messages
 end
 
 Then(/^there should be (\d+) info messages?$/) do |num|
-  expect( @info_messages.count ).to eq( num.to_i )
+  expect(@info_messages.count).to eq(num.to_i)
 end
 
 Then(/^one of the messages should have the type "(.*?)"$/) do |msg_type|
-  expect( @info_messages.find{|x| x.type == msg_type.to_sym} ).to be_present
-end
+  expect(@info_messages.find { |x| x.type == msg_type.to_sym }).to be_present
+end

data/features/step_definitions/validation_warnings_steps.rb

@@ -12,35 +12,35 @@ Given(/^I do not set an encoding header$/) do
 end
 
 Given(/^I have a CSV file called "(.*?)"$/) do |filename|
-  @csv = File.read( File.join( File.dirname(__FILE__), "..", "fixtures", filename ) )
+  @csv = File.read(File.join(File.dirname(__FILE__), "..", "fixtures", filename))
 end
 
 When(/^I ask if there are warnings$/) do
   @csv_options ||= default_csv_options
   if @schema_json
-    if @schema_type == :json_table
-      @schema = Csvlint::Schema.from_json_table( @schema_url || "http://example.org ", JSON.parse(@schema_json) )
+    @schema = if @schema_type == :json_table
+      Csvlint::Schema.from_json_table(@schema_url || "http://example.org ", JSON.parse(@schema_json))
     else
-      @schema = Csvlint::Schema.from_csvw_metadata( @schema_url || "http://example.org ", JSON.parse(@schema_json) )
+      Csvlint::Schema.from_csvw_metadata(@schema_url || "http://example.org ", JSON.parse(@schema_json))
     end
   end
 
-  @validator = Csvlint::Validator.new( @url, @csv_options, @schema )
+  @validator = Csvlint::Validator.new(@url, @csv_options, @schema)
   @warnings = @validator.warnings
 end
 
 Then(/^there should be warnings$/) do
-  expect( @warnings.count ).to be > 0
+  expect(@warnings.count).to be > 0
 end
 
 Then(/^there should not be warnings$/) do
   # this test is only used for CSVW testing, and :inconsistent_values warnings don't count in CSVW
   @warnings.delete_if { |w| [:inconsistent_values, :check_options].include?(w.type) }
-  expect( @warnings.count ).to eq(0)
+  expect(@warnings.count).to eq(0)
 end
 
 Then(/^there should be (\d+) warnings$/) do |count|
-  expect( @warnings.count ).to eq( count.to_i )
+  expect(@warnings.count).to eq(count.to_i)
 end
 
 Given(/^the content type is set to "(.*?)"$/) do |type|
@@ -48,13 +48,13 @@ Given(/^the content type is set to "(.*?)"$/) do |type|
 end
 
 Then(/^that warning should have the row "(.*?)"$/) do |row|
-  expect( @warnings.first.row ).to eq( row.to_i )
+  expect(@warnings.first.row).to eq(row.to_i)
 end
 
 Then(/^that warning should have the column "(.*?)"$/) do |column|
-  expect( @warnings.first.column ).to eq( column.to_i )
+  expect(@warnings.first.column).to eq(column.to_i)
 end
 
 Then(/^that warning should have the type "(.*?)"$/) do |type|
-  expect( @warnings.first.type ).to eq( type.to_sym )
+  expect(@warnings.first.type).to eq(type.to_sym)
 end

data/features/support/aruba.rb

@@ -1,12 +1,12 @@
-require 'aruba'
-require 'aruba/cucumber'
+require "aruba"
+require "aruba/cucumber"
 
-require 'csvlint/cli'
+require "csvlint/cli"
 
 module Csvlint
   class CliRunner
     # Allow everything fun to be injected from the outside while defaulting to normal implementations.
-    def initialize(argv, stdin = STDIN, stdout = STDOUT, stderr = STDERR, kernel = Kernel)
+    def initialize(argv, stdin = $stdin, stdout = $stdout, stderr = $stderr, kernel = Kernel)
       @argv, @stdin, @stdout, @stderr, @kernel = argv, stdin, stdout, stderr, kernel
     end
 
@@ -22,11 +22,11 @@ module Csvlint
 
         # Thor::Base#start does not have a return value, assume success if no exception is raised.
         0
-      rescue StandardError => e
+      rescue => e
         # The ruby interpreter would pipe this to STDERR and exit 1 in the case of an unhandled exception
         b = e.backtrace
         @stderr.puts("#{b.shift}: #{e.message} (#{e.class})")
-        @stderr.puts(b.map{|s| "\tfrom #{s}"}.join("\n"))
+        @stderr.puts(b.map { |s| "\tfrom #{s}" }.join("\n"))
         1
       rescue SystemExit => e
         e.status

data/features/support/earl_formatter.rb

@@ -1,33 +1,33 @@
-require 'rdf'
-require 'rdf/turtle'
+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/" ]
+    @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)
@@ -40,27 +40,27 @@ class EarlFormatter
       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 ]
+    @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 ]
+    @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|
+    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
   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")
 
+  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/env.rb

@@ -1,23 +1,22 @@
-require 'coveralls'
-Coveralls.wear_merged!('test_frameworks')
+require "coveralls"
+Coveralls.wear_merged!("test_frameworks")
 
-$:.unshift File.join( File.dirname(__FILE__), "..", "..", "lib")
+$:.unshift File.join(File.dirname(__FILE__), "..", "..", "lib")
 
-require 'rspec/expectations'
-require 'cucumber/rspec/doubles'
-require 'csvlint'
-require 'byebug'
+require "rspec/expectations"
+require "cucumber/rspec/doubles"
+require "csvlint"
+require "byebug"
 
-require 'spork'
+require "spork"
 
 Spork.each_run do
-  require 'csvlint'
+  require "csvlint"
 end
 
 class CustomWorld
   def default_csv_options
-    return {
-    }
+    {}
   end
 end