csvlint 1.0.0 → 1.1.0

data/lib/csvlint/csvw/table.rb

@@ -1,7 +1,6 @@
 module Csvlint
   module Csvw
     class Table
-
       include Csvlint::ErrorCollector
 
       attr_reader :columns, :dialect, :table_direction, :foreign_keys, :foreign_key_references, :id, :notes, :primary_key, :row_title_columns, :schema, :suppress_output, :transformations, :url, :annotations
@@ -26,13 +25,13 @@ module Csvlint
         @annotations = annotations
         reset
         @warnings += warnings
-        @errors += columns.map{|c| c.errors}.flatten
-        @warnings += columns.map{|c| c.warnings}.flatten
+        @errors += columns.map { |c| c.errors }.flatten
+        @warnings += columns.map { |c| c.warnings }.flatten
       end
 
       def validate_header(headers, strict)
         reset
-        headers.each_with_index do |header,i|
+        headers.each_with_index do |header, i|
           if columns[i]
             columns[i].validate_header(header, strict)
             @errors += columns[i].errors
@@ -43,26 +42,28 @@ module Csvlint
             build_warnings(:malformed_header, :schema, 1, nil, header, nil)
           end
         end # unless columns.empty?
-        return valid?
+        valid?
       end
 
-      def validate_row(values, row=nil, validate=false)
+      def validate_row(values, row = nil, validate = false)
         reset
-        values.each_with_index do |value,i|
-          column = columns[i]
-          if column
-            v = column.validate(value, row)
-            values[i] = v
-            @errors += column.errors
-            @warnings += column.warnings
-          else
-            build_errors(:too_many_values, :schema, row, nil, value, nil)
+        unless columns.empty?
+          values.each_with_index do |value, i|
+            column = columns[i]
+            if column
+              v = column.validate(value, row)
+              values[i] = v
+              @errors += column.errors
+              @warnings += column.warnings
+            else
+              build_errors(:too_many_values, :schema, row, nil, value, nil)
+            end
           end
-        end unless columns.empty?
+        end
         if validate
           unless @primary_key.nil?
             key = @primary_key.map { |column| column.validate(values[column.number - 1], row) }
-            colnum = if primary_key.length == 1 then primary_key[0].number else nil end
+            colnum = (primary_key.length == 1) ? primary_key[0].number : nil
             build_errors(:duplicate_key, :schema, row, colnum, key.join(","), @primary_key_values[key]) if @primary_key_values.include?(key)
             @primary_key_values[key] = row
           end
@@ -70,7 +71,7 @@ module Csvlint
           # so that later we can check whether those foreign keys reference these values
           @foreign_key_references.each do |foreign_key|
             referenced_columns = foreign_key["referenced_columns"]
-            key = referenced_columns.map{ |column| column.validate(values[column.number - 1], row) }
+            key = referenced_columns.map { |column| column.validate(values[column.number - 1], row) }
             known_values = @foreign_key_reference_values[foreign_key] = @foreign_key_reference_values[foreign_key] || {}
             known_values[key] = known_values[key] || []
             known_values[key] << row
@@ -80,12 +81,12 @@ module Csvlint
           # we might not have parsed those other tables
           @foreign_keys.each do |foreign_key|
             referencing_columns = foreign_key["referencing_columns"]
-            key = referencing_columns.map{ |column| column.validate(values[column.number - 1], row) }
+            key = referencing_columns.map { |column| column.validate(values[column.number - 1], row) }
             known_values = @foreign_key_values[foreign_key] = @foreign_key_values[foreign_key] || []
             known_values << key unless known_values.include?(key)
           end
         end
-        return valid?
+        valid?
       end
 
       def validate_foreign_keys
@@ -97,43 +98,43 @@ module Csvlint
           @errors += remote_table.errors unless remote_table == self
           @warnings += remote_table.warnings unless remote_table == self
         end
-        return valid?
+        valid?
       end
 
       def validate_foreign_key_references(foreign_key, remote_url, remote)
         reset
         local = @foreign_key_reference_values[foreign_key]
-        context = { "from" => { "url" => remote_url.to_s.split("/")[-1], "columns" => foreign_key["columnReference"] }, "to" => { "url" => @url.to_s.split("/")[-1], "columns" => foreign_key["reference"]["columnReference"] }}
-        colnum = if foreign_key["referencing_columns"].length == 1 then foreign_key["referencing_columns"][0].number else nil end
-        remote.each_with_index do |r,i|
+        context = {"from" => {"url" => remote_url.to_s.split("/")[-1], "columns" => foreign_key["columnReference"]}, "to" => {"url" => @url.to_s.split("/")[-1], "columns" => foreign_key["reference"]["columnReference"]}}
+        colnum = (foreign_key["referencing_columns"].length == 1) ? foreign_key["referencing_columns"][0].number : nil
+        remote.each_with_index do |r, i|
           if local[r]
-            build_errors(:multiple_matched_rows, :schema, i+1, colnum, r, context) if local[r].length > 1
+            build_errors(:multiple_matched_rows, :schema, i + 1, colnum, r, context) if local[r].length > 1
           else
-            build_errors(:unmatched_foreign_key_reference, :schema, i+1, colnum, r, context)
+            build_errors(:unmatched_foreign_key_reference, :schema, i + 1, colnum, r, context)
           end
         end
-        return valid?
+        valid?
       end
 
-      def self.from_json(table_desc, base_url=nil, lang="und", common_properties={}, inherited_properties={})
+      def self.from_json(table_desc, base_url = nil, lang = "und", common_properties = {}, inherited_properties = {})
         annotations = {}
         warnings = []
         columns = []
         table_properties = common_properties.clone
         inherited_properties = inherited_properties.clone
 
-        table_desc.each do |property,value|
-          if property =="@type"
-            raise Csvlint::Csvw::MetadataError.new("$.tables[?(@.url = '#{table_desc["url"]}')].@type"), "@type of table is not 'Table'" unless value == 'Table'
+        table_desc.each do |property, value|
+          if property == "@type"
+            raise Csvlint::Csvw::MetadataError.new("$.tables[?(@.url = '#{table_desc["url"]}')].@type"), "@type of table is not 'Table'" unless value == "Table"
           else
             v, warning, type = Csvw::PropertyChecker.check_property(property, value, base_url, lang)
-            warnings += Array(warning).map{ |w| Csvlint::ErrorMessage.new(w, :metadata, nil, nil, "#{property}: #{value}", nil) } unless warning.nil? || warning.empty?
+            warnings += Array(warning).map { |w| Csvlint::ErrorMessage.new(w, :metadata, nil, nil, "#{property}: #{value}", nil) } unless warning.nil? || warning.empty?
             if type == :annotation
               annotations[property] = v
             elsif type == :table || type == :common
               table_properties[property] = v
             elsif type == :column
-              warnings << Csvlint::ErrorMessage.new(:invalid_property, :metadata, nil, nil, "#{property}", nil)
+              warnings << Csvlint::ErrorMessage.new(:invalid_property, :metadata, nil, nil, property.to_s, nil)
             else
               inherited_properties[property] = v
             end
@@ -143,37 +144,35 @@ module Csvlint
         table_schema = table_properties["tableSchema"] || inherited_properties["tableSchema"]
         column_names = []
         foreign_keys = []
-        primary_key = nil
         if table_schema
           unless table_schema["columns"].instance_of? Array
             table_schema["columns"] = []
             warnings << Csvlint::ErrorMessage.new(:invalid_value, :metadata, nil, nil, "columns", nil)
           end
 
-          table_schema.each do |p,v|
+          table_schema.each do |p, v|
             unless ["columns", "primaryKey", "foreignKeys", "rowTitles"].include? p
               inherited_properties[p] = v
             end
           end
 
           virtual_columns = false
-          table_schema["columns"].each_with_index do |column_desc,i|
+          table_schema["columns"].each_with_index do |column_desc, i|
             if column_desc.instance_of? Hash
-              column = Csvlint::Csvw::Column.from_json(i+1, column_desc, base_url, lang, inherited_properties)
+              column = Csvlint::Csvw::Column.from_json(i + 1, column_desc, base_url, lang, inherited_properties)
               raise Csvlint::Csvw::MetadataError.new("$.tables[?(@.url = '#{table_desc["url"]}')].tableSchema.columns[#{i}].virtual"), "virtual columns before non-virtual column #{column.name || i}" if virtual_columns && !column.virtual
-              virtual_columns = virtual_columns || column.virtual
+              virtual_columns ||= column.virtual
               raise Csvlint::Csvw::MetadataError.new("$.tables[?(@.url = '#{table_desc["url"]}')].tableSchema.columns"), "multiple columns named #{column.name}" if column_names.include? column.name
               column_names << column.name unless column.name.nil?
               columns << column
             else
-              warnings << Csvlint::ErrorMessage.new(:invalid_column_description, :metadata, nil, nil, "#{column_desc}", nil)
+              warnings << Csvlint::ErrorMessage.new(:invalid_column_description, :metadata, nil, nil, column_desc.to_s, nil)
             end
           end
 
-          primary_key = table_schema["primaryKey"]
           primary_key_columns = []
           primary_key_valid = true
-          primary_key.each do |reference|
+          table_schema["primaryKey"]&.each do |reference|
             i = column_names.index(reference)
             if i
               primary_key_columns << columns[i]
@@ -181,10 +180,10 @@ module Csvlint
               warnings << Csvlint::ErrorMessage.new(:invalid_column_reference, :metadata, nil, nil, "primaryKey: #{reference}", nil)
               primary_key_valid = false
             end
-          end if primary_key
+          end
 
           foreign_keys = table_schema["foreignKeys"]
-          foreign_keys.each_with_index do |foreign_key, i|
+          foreign_keys&.each_with_index do |foreign_key, i|
             foreign_key_columns = []
             foreign_key["columnReference"].each do |reference|
               i = column_names.index(reference)
@@ -192,33 +191,31 @@ module Csvlint
               foreign_key_columns << columns[i]
             end
             foreign_key["referencing_columns"] = foreign_key_columns
-          end if foreign_keys
+          end
 
           row_titles = table_schema["rowTitles"]
           row_title_columns = []
-          row_titles.each_with_index do |row_title|
+          row_titles&.each do |row_title|
             i = column_names.index(row_title)
             raise Csvlint::Csvw::MetadataError.new("$.tables[?(@.url = '#{table_desc["url"]}')].tableSchema.rowTitles[#{i}]"), "rowTitles references non-existant column" unless i
             row_title_columns << columns[i]
-          end if row_titles
+          end
 
         end
 
-        return self.new(table_properties["url"],
+        new(table_properties["url"],
           id: table_properties["@id"],
           columns: columns,
           dialect: table_properties["dialect"],
           foreign_keys: foreign_keys || [],
           notes: table_properties["notes"] || [],
-          primary_key: primary_key_valid && !primary_key_columns.empty? ? primary_key_columns : nil,
+          primary_key: (primary_key_valid && !primary_key_columns.empty?) ? primary_key_columns : nil,
           row_title_columns: row_title_columns,
           schema: table_schema ? table_schema["@id"] : nil,
-          suppress_output: table_properties["suppressOutput"] ? table_properties["suppressOutput"] : false,
+          suppress_output: table_properties["suppressOutput"] || false,
           annotations: annotations,
-          warnings: warnings
-        )
+          warnings: warnings)
       end
-
     end
   end
 end

data/lib/csvlint/csvw/table_group.rb

@@ -1,7 +1,6 @@
 module Csvlint
   module Csvw
     class TableGroup
-
       include Csvlint::ErrorCollector
 
       attr_reader :url, :id, :tables, :notes, :annotations
@@ -13,11 +12,11 @@ module Csvlint
         @notes = notes
         @annotations = annotations
         @validated_tables = {}
-        @tables.each { |t,v| @validated_tables[t] = false }
+        @tables.each { |t, v| @validated_tables[t] = false }
         reset
         @warnings += warnings
-        @errors += @tables.map{|url,table| table.errors}.flatten
-        @warnings += @tables.map{|url,table| table.warnings}.flatten
+        @errors += @tables.map { |url, table| table.errors }.flatten
+        @warnings += @tables.map { |url, table| table.warnings }.flatten
       end
 
       def validate_header(header, table_url, strict)
@@ -27,10 +26,10 @@ module Csvlint
         table.validate_header(header, strict)
         @errors += table.errors
         @warnings += table.warnings
-        return valid?
+        valid?
       end
 
-      def validate_row(values, row=nil, all_errors=[], table_url, validate)
+      def validate_row(values, row = nil, all_errors = [], table_url, validate)
         reset
         table_url = "file:#{File.absolute_path(table_url)}" if table_url.instance_of? File
         @validated_tables[table_url] = true
@@ -38,19 +37,19 @@ module Csvlint
         table.validate_row(values, row, validate)
         @errors += table.errors
         @warnings += table.warnings
-        return valid?
+        valid?
       end
 
       def validate_foreign_keys
         reset
         unless @validated_tables.has_value?(false)
-          @tables.each do |table_url,table|
+          @tables.each do |table_url, table|
             table.validate_foreign_keys
             @errors += table.errors
             @warnings += table.warnings
           end
         end
-        return valid?
+        valid?
       end
 
       def self.from_json(url, json)
@@ -64,7 +63,7 @@ module Csvlint
 
         context = json["@context"]
         if context.instance_of?(Array) && context[1]
-          context[1].each do |property,value|
+          context[1].each do |property, value|
             v, warning, type = Csvw::PropertyChecker.check_property(property, value, base_url, lang)
             if warning.nil? || warning.empty?
               if type == :context
@@ -75,20 +74,22 @@ module Csvlint
               end
             else
               raise Csvlint::Csvw::MetadataError.new("$.@context"), "@context contains properties other than @base or @language (#{property})" unless ["@base", "@language"].include?(property)
-              warnings += Array(warning).map{ |w| Csvlint::ErrorMessage.new(w, :metadata, nil, nil, "@context: #{property}: #{value}", nil) }
+              warnings += Array(warning).map { |w| Csvlint::ErrorMessage.new(w, :metadata, nil, nil, "@context: #{property}: #{value}", nil) }
             end
           end
         end
         json.delete("@context")
 
-        if json["url"]
-          json = { "tables" => [ json ] }
-        end unless json["tables"]
+        unless json["tables"]
+          if json["url"]
+            json = {"tables" => [json]}
+          end
+        end
 
-        json.each do |property,value|
+        json.each do |property, value|
           unless VALID_PROPERTIES.include? property
             v, warning, type = Csvw::PropertyChecker.check_property(property, value, base_url, lang)
-            warnings += Array(warning).map{ |w| Csvlint::ErrorMessage.new(w, :metadata, nil, nil, "#{property}: #{value}", nil) } unless warning.nil? || warning.empty?
+            warnings += Array(warning).map { |w| Csvlint::ErrorMessage.new(w, :metadata, nil, nil, "#{property}: #{value}", nil) } unless warning.nil? || warning.empty?
             if type == :annotation
               annotations[property] = v
             elsif type == :common
@@ -96,14 +97,14 @@ module Csvlint
             elsif type == :inherited
               inherited_properties[property] = v
             else
-              warnings << Csvlint::ErrorMessage.new(:invalid_property, :metadata, nil, nil, "#{property}", nil)
+              warnings << Csvlint::ErrorMessage.new(:invalid_property, :metadata, nil, nil, property.to_s, nil)
             end
           end
         end
 
         id = common_properties["@id"]
 
-        raise Csvlint::Csvw::MetadataError.new("$.@type"), "@type of table group is not 'TableGroup'" if json["@type"] && json["@type"] != 'TableGroup'
+        raise Csvlint::Csvw::MetadataError.new("$.@type"), "@type of table group is not 'TableGroup'" if json["@type"] && json["@type"] != "TableGroup"
 
         raise Csvlint::Csvw::MetadataError.new("$"), "no tables property" unless json["tables"]
         raise Csvlint::Csvw::MetadataError.new("$.tables"), "empty tables property" if json["tables"].empty?
@@ -121,12 +122,12 @@ module Csvlint
             table = Csvlint::Csvw::Table.from_json(table_desc, base_url, lang, common_properties, inherited_properties)
             tables[table_url] = table
           else
-            warnings << Csvlint::ErrorMessage.new(:invalid_table_description, :metadata, nil, nil, "#{table_desc}", nil)
+            warnings << Csvlint::ErrorMessage.new(:invalid_table_description, :metadata, nil, nil, table_desc.to_s, nil)
           end
         end
 
         tables.each do |table_url, table|
-          table.foreign_keys.each_with_index do |foreign_key,i|
+          table.foreign_keys.each_with_index do |foreign_key, i|
             reference = foreign_key["reference"]
             if reference["resource"]
               resource = URI.join(base_url, reference["resource"]).to_s
@@ -134,7 +135,7 @@ module Csvlint
               raise Csvlint::Csvw::MetadataError.new("$.tables[?(@.url = '#{table_url}')].tableSchema.foreign_keys[#{i}].reference.resource"), "foreign key references table that does not exist (#{resource})" if referenced_table.nil?
             else
               schema_url = URI.join(base_url, reference["schemaReference"]).to_s
-              referenced_tables = tables.values.select{ |table| table.schema == schema_url }
+              referenced_tables = tables.values.select { |table| table.schema == schema_url }
               referenced_table = referenced_tables[0]
               raise Csvlint::Csvw::MetadataError.new("$.tables[?(@.url = '#{table_url}')].tableSchema.foreign_keys[#{i}].reference.schemaReference"), "foreign key references schema that is not used (#{schema_url})" if referenced_table.nil?
             end
@@ -154,12 +155,12 @@ module Csvlint
           end
         end
 
-        return self.new(base_url, id: id, tables: tables, notes: common_properties["notes"] || [], annotations: annotations, warnings: warnings)
+        new(base_url, id: id, tables: tables, notes: common_properties["notes"] || [], annotations: annotations, warnings: warnings)
       end
 
       private
-        VALID_PROPERTIES = ['tables', 'notes', '@type']
 
+      VALID_PROPERTIES = ["tables", "notes", "@type"]
     end
   end
 end

data/lib/csvlint/error_collector.rb

@@ -5,10 +5,12 @@ module Csvlint
     def build_errors(type, category = nil, row = nil, column = nil, content = nil, constraints = {})
       @errors << Csvlint::ErrorMessage.new(type, category, row, column, content, constraints)
     end
+
     # Creates a validation warning
     def build_warnings(type, category = nil, row = nil, column = nil, content = nil, constraints = {})
       @warnings << Csvlint::ErrorMessage.new(type, category, row, column, content, constraints)
     end
+
     # Creates a validation information message
     def build_info_messages(type, category = nil, row = nil, column = nil, content = nil, constraints = {})
       @info_messages << Csvlint::ErrorMessage.new(type, category, row, column, content, constraints)

data/lib/csvlint/error_message.rb

@@ -9,7 +9,6 @@ module Csvlint
       @column = column
       @content = content
       @constraints = constraints
-
     end
   end
 end