csvlint 1.0.0 → 1.2.0

data/lib/csvlint/field.rb

@@ -1,196 +1,208 @@
 module Csvlint
-
   class Field
     include Csvlint::ErrorCollector
 
     attr_reader :name, :constraints, :title, :description
 
-    def initialize(name, constraints={}, title=nil, description=nil)
+    def initialize(name, constraints = {}, title = nil, description = nil)
       @name = name
       @constraints = constraints || {}
       @uniques = Set.new
       @title = title
       @description = description
+      @regex = nil
       reset
     end
 
-    def validate_column(value, row=nil, column=nil, all_errors=[])
+    def validate_column(value, row = nil, column = nil, all_errors = [])
       reset
-      unless all_errors.any?{|error| ((error.type == :invalid_regex) && (error.column == column))}
+      unless all_errors.any? { |error| ((error.type == :invalid_regex) && (error.column == column)) }
         validate_regex(value, row, column, all_errors)
       end
       validate_length(value, row, column)
       validate_values(value, row, column)
       parsed = validate_type(value, row, column)
-      validate_range(parsed, row, column) if parsed != nil
-      return valid?
+      validate_range(parsed, row, column) if !parsed.nil?
+      valid?
     end
 
     private
-      def validate_length(value, row, column)
-        if constraints["required"] == true
+
+    def validate_length(value, row, column)
+      if constraints["required"] == true
+        if value.nil? || value.length == 0
           build_errors(:missing_value, :schema, row, column, value,
-            { "required" => true }) if value.nil? || value.length == 0
+            {"required" => true})
         end
-        if constraints["minLength"]
+      end
+      if constraints["minLength"]
+        if value.nil? || value.length < constraints["minLength"]
           build_errors(:min_length, :schema, row, column, value,
-            { "minLength" => constraints["minLength"] }) if value.nil? || value.length < constraints["minLength"]
+            {"minLength" => constraints["minLength"]})
         end
-        if constraints["maxLength"]
-            build_errors(:max_length, :schema, row, column, value,
-             { "maxLength" => constraints["maxLength"] } ) if !value.nil? && value.length > constraints["maxLength"]
+      end
+      if constraints["maxLength"]
+        if !value.nil? && value.length > constraints["maxLength"]
+          build_errors(:max_length, :schema, row, column, value,
+            {"maxLength" => constraints["maxLength"]})
         end
       end
+    end
 
-      def validate_regex(value, row, column, all_errors)
-        pattern = constraints["pattern"]
-        if pattern
-          begin
-            Regexp.new(pattern)
+    def validate_regex(value, row, column, all_errors)
+      pattern = constraints["pattern"]
+      if pattern
+        begin
+          if !value.nil? && !value.match(@regex ||= Regexp.new(pattern))
             build_errors(:pattern, :schema, row, column, value,
-            { "pattern" => constraints["pattern"] } ) if !value.nil? && !value.match( constraints["pattern"] )
-          rescue RegexpError
-            build_regex_error(value, row, column, pattern, all_errors)
+              {"pattern" => constraints["pattern"]})
           end
+        rescue RegexpError
+          build_regex_error(value, row, column, pattern, all_errors)
         end
       end
+    end
 
-      def build_regex_error(value, row, column, pattern, all_errors)
-        return if @regex_error_exists
-        build_errors(:invalid_regex, :schema, nil, column, ("#{name}: Constraints: Pattern: #{pattern}"),
-          { "pattern" => constraints["pattern"] })
-        @regex_error_exists = true
-      end
+    def build_regex_error(value, row, column, pattern, all_errors)
+      return if @regex_error_exists
+      build_errors(:invalid_regex, :schema, nil, column, "#{name}: Constraints: Pattern: #{pattern}",
+        {"pattern" => constraints["pattern"]})
+      @regex_error_exists = true
+    end
 
-      def validate_values(value, row, column)
-        # If a pattern exists, raise an invalid regex error if it is not in
-        # valid regex form, else, if the value of the relevant field in the csv
-        # does not match the given regex pattern in the schema, raise a
-        # pattern error.
-        if constraints["unique"] == true
-          if @uniques.include? value
-            build_errors(:unique, :schema, row, column, value, { "unique" => true })
-          else
-            @uniques << value
-          end
+    def validate_values(value, row, column)
+      # If a pattern exists, raise an invalid regex error if it is not in
+      # valid regex form, else, if the value of the relevant field in the csv
+      # does not match the given regex pattern in the schema, raise a
+      # pattern error.
+      if constraints["unique"] == true
+        if @uniques.include? value
+          build_errors(:unique, :schema, row, column, value, {"unique" => true})
+        else
+          @uniques << value
         end
       end
+    end
 
-      def validate_type(value, row, column)
-        if constraints["type"] && value != ""
-          parsed = convert_to_type(value)
-          if parsed == nil
-            failed = { "type" => constraints["type"] }
-            failed["datePattern"] = constraints["datePattern"] if constraints["datePattern"]
-            build_errors(:invalid_type, :schema, row, column, value, failed)
-            return nil
-          end
-          return parsed
+    def validate_type(value, row, column)
+      if constraints["type"] && value != ""
+        parsed = convert_to_type(value)
+        if parsed.nil?
+          failed = {"type" => constraints["type"]}
+          failed["datePattern"] = constraints["datePattern"] if constraints["datePattern"]
+          build_errors(:invalid_type, :schema, row, column, value, failed)
+          return nil
         end
-        return nil
+        return parsed
       end
+      nil
+    end
 
-      def validate_range(value, row, column)
-        #TODO: we're ignoring issues with converting ranges to actual types, maybe we
-        #should generate a warning? The schema is invalid
-        if constraints["minimum"]
-          minimumValue = convert_to_type( constraints["minimum"] )
-          if minimumValue
+    def validate_range(value, row, column)
+      # TODO: we're ignoring issues with converting ranges to actual types, maybe we
+      # should generate a warning? The schema is invalid
+      if constraints["minimum"]
+        minimumValue = convert_to_type(constraints["minimum"])
+        if minimumValue
+          unless value >= minimumValue
             build_errors(:below_minimum, :schema, row, column, value,
-              { "minimum" => constraints["minimum"] }) unless value >= minimumValue
+              {"minimum" => constraints["minimum"]})
           end
         end
-        if constraints["maximum"]
-          maximumValue = convert_to_type( constraints["maximum"] )
-          if maximumValue
+      end
+      if constraints["maximum"]
+        maximumValue = convert_to_type(constraints["maximum"])
+        if maximumValue
+          unless value <= maximumValue
             build_errors(:above_maximum, :schema, row, column, value,
-            { "maximum" => constraints["maximum"] }) unless value <= maximumValue
+              {"maximum" => constraints["maximum"]})
           end
         end
       end
+    end
 
-      def convert_to_type(value)
-        parsed = nil
-        tv = TYPE_VALIDATIONS[constraints["type"]]
-        if tv
-          begin
-            parsed = tv.call value, constraints
-          rescue ArgumentError
-          end
+    def convert_to_type(value)
+      parsed = nil
+      tv = TYPE_VALIDATIONS[constraints["type"]]
+      if tv
+        begin
+          parsed = tv.call value, constraints
+        rescue ArgumentError
         end
-        return parsed
       end
+      parsed
+    end
 
-      TYPE_VALIDATIONS = {
-          'http://www.w3.org/2001/XMLSchema#string'  => lambda { |value, constraints| value },
-          'http://www.w3.org/2001/XMLSchema#int'     => lambda { |value, constraints| Integer value },
-          'http://www.w3.org/2001/XMLSchema#integer' => lambda { |value, constraints| Integer value },
-          '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|
-            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|
-            return true if ['true', '1'].include? value
-            return false if ['false', '0'].include? value
-            raise ArgumentError
-          end,
-          'http://www.w3.org/2001/XMLSchema#nonPositiveInteger' => lambda do |value, constraints|
-            i = Integer value
-            raise ArgumentError unless i <= 0
-            i
-          end,
-          'http://www.w3.org/2001/XMLSchema#negativeInteger' => lambda do |value, constraints|
-            i = Integer value
-            raise ArgumentError unless i < 0
-            i
-          end,
-          'http://www.w3.org/2001/XMLSchema#nonNegativeInteger' => lambda do |value, constraints|
-            i = Integer value
-            raise ArgumentError unless i >= 0
-            i
-          end,
-          'http://www.w3.org/2001/XMLSchema#positiveInteger' => lambda do |value, constraints|
-            i = Integer value
-            raise ArgumentError unless i > 0
-            i
-          end,
-          'http://www.w3.org/2001/XMLSchema#dateTime' => lambda do |value, constraints|
-            date_pattern = constraints["datePattern"] || "%Y-%m-%dT%H:%M:%SZ"
-            d = DateTime.strptime(value, date_pattern)
-            raise ArgumentError unless d.strftime(date_pattern) == value
-            d
-          end,
-          'http://www.w3.org/2001/XMLSchema#date' => lambda do |value, constraints|
-            date_pattern = constraints["datePattern"] || "%Y-%m-%d"
-            d = Date.strptime(value, date_pattern)
-            raise ArgumentError unless d.strftime(date_pattern) == value
-            d
-          end,
-          'http://www.w3.org/2001/XMLSchema#time' => lambda do |value, constraints|
-            date_pattern = constraints["datePattern"] || "%H:%M:%S"
-            d = DateTime.strptime(value, date_pattern)
-            raise ArgumentError unless d.strftime(date_pattern) == value
-            d
-          end,
-          'http://www.w3.org/2001/XMLSchema#gYear' => lambda do |value, constraints|
-            date_pattern = constraints["datePattern"] || "%Y"
-            d = Date.strptime(value, date_pattern)
-            raise ArgumentError unless d.strftime(date_pattern) == value
-            d
-          end,
-          'http://www.w3.org/2001/XMLSchema#gYearMonth' => lambda do |value, constraints|
-            date_pattern = constraints["datePattern"] || "%Y-%m"
-            d = Date.strptime(value, date_pattern)
-            raise ArgumentError unless d.strftime(date_pattern) == value
-            d
-          end,
-      }
+    TYPE_VALIDATIONS = {
+      "http://www.w3.org/2001/XMLSchema#string" => lambda { |value, constraints| value },
+      "http://www.w3.org/2001/XMLSchema#int" => lambda { |value, constraints| Integer value },
+      "http://www.w3.org/2001/XMLSchema#integer" => lambda { |value, constraints| Integer value },
+      "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|
+                                                     begin
+                                                       u = URI.parse value
+                                                       raise ArgumentError unless u.is_a?(URI::HTTP) || u.is_a?(URI::HTTPS)
+                                                     rescue URI::InvalidURIError
+                                                       raise ArgumentError
+                                                     end
+                                                     u
+                                                   end,
+      "http://www.w3.org/2001/XMLSchema#boolean" => lambda do |value, constraints|
+                                                      return true if ["true", "1"].include? value
+                                                      return false if ["false", "0"].include? value
+                                                      raise ArgumentError
+                                                    end,
+      "http://www.w3.org/2001/XMLSchema#nonPositiveInteger" => lambda do |value, constraints|
+                                                                 i = Integer value
+                                                                 raise ArgumentError unless i <= 0
+                                                                 i
+                                                               end,
+      "http://www.w3.org/2001/XMLSchema#negativeInteger" => lambda do |value, constraints|
+                                                              i = Integer value
+                                                              raise ArgumentError unless i < 0
+                                                              i
+                                                            end,
+      "http://www.w3.org/2001/XMLSchema#nonNegativeInteger" => lambda do |value, constraints|
+                                                                 i = Integer value
+                                                                 raise ArgumentError unless i >= 0
+                                                                 i
+                                                               end,
+      "http://www.w3.org/2001/XMLSchema#positiveInteger" => lambda do |value, constraints|
+                                                              i = Integer value
+                                                              raise ArgumentError unless i > 0
+                                                              i
+                                                            end,
+      "http://www.w3.org/2001/XMLSchema#dateTime" => lambda do |value, constraints|
+                                                       date_pattern = constraints["datePattern"] || "%Y-%m-%dT%H:%M:%SZ"
+                                                       d = DateTime.strptime(value, date_pattern)
+                                                       raise ArgumentError unless d.strftime(date_pattern) == value
+                                                       d
+                                                     end,
+      "http://www.w3.org/2001/XMLSchema#date" => lambda do |value, constraints|
+                                                   date_pattern = constraints["datePattern"] || "%Y-%m-%d"
+                                                   d = Date.strptime(value, date_pattern)
+                                                   raise ArgumentError unless d.strftime(date_pattern) == value
+                                                   d
+                                                 end,
+      "http://www.w3.org/2001/XMLSchema#time" => lambda do |value, constraints|
+                                                   date_pattern = constraints["datePattern"] || "%H:%M:%S"
+                                                   d = DateTime.strptime(value, date_pattern)
+                                                   raise ArgumentError unless d.strftime(date_pattern) == value
+                                                   d
+                                                 end,
+      "http://www.w3.org/2001/XMLSchema#gYear" => lambda do |value, constraints|
+                                                    date_pattern = constraints["datePattern"] || "%Y"
+                                                    d = Date.strptime(value, date_pattern)
+                                                    raise ArgumentError unless d.strftime(date_pattern) == value
+                                                    d
+                                                  end,
+      "http://www.w3.org/2001/XMLSchema#gYearMonth" => lambda do |value, constraints|
+                                                         date_pattern = constraints["datePattern"] || "%Y-%m"
+                                                         d = Date.strptime(value, date_pattern)
+                                                         raise ArgumentError unless d.strftime(date_pattern) == value
+                                                         d
+                                                       end
+    }
   end
 end

data/lib/csvlint/schema.rb

@@ -1,12 +1,10 @@
 module Csvlint
-
   class Schema
-
     include Csvlint::ErrorCollector
 
     attr_reader :uri, :fields, :title, :description
 
-    def initialize(uri, fields=[], title=nil, description=nil)
+    def initialize(uri, fields = [], title = nil, description = nil)
       @uri = uri
       @fields = fields
       @title = title
@@ -15,20 +13,19 @@ module Csvlint
     end
 
     class << self
-
       extend Gem::Deprecate
 
       def from_json_table(uri, json)
         fields = []
-        json["fields"].each do |field_desc|
-          fields << Csvlint::Field.new( field_desc["name"] , field_desc["constraints"],
-            field_desc["title"], field_desc["description"] )
-        end if json["fields"]
-        return Schema.new( uri , fields, json["title"], json["description"] )
+        json["fields"]&.each do |field_desc|
+          fields << Csvlint::Field.new(field_desc["name"], field_desc["constraints"],
+            field_desc["title"], field_desc["description"])
+        end
+        Schema.new(uri, fields, json["title"], json["description"])
       end
 
       def from_csvw_metadata(uri, json)
-        return Csvlint::Csvw::TableGroup.from_json(uri, json)
+        Csvlint::Csvw::TableGroup.from_json(uri, json)
       end
 
       # Deprecated method signature
@@ -44,64 +41,59 @@ module Csvlint
       end
 
       def load_from_string(uri, string, output_errors = true)
-        begin
-          json = JSON.parse( string )
-          if json["@context"]
-            uri = "file:#{File.expand_path(uri)}" unless uri.to_s =~ /^http(s)?/
-            return Schema.from_csvw_metadata(uri,json)
-          else
-            return Schema.from_json_table(uri,json)
-          end
-        rescue TypeError => e
-          # NO IDEA what this was even trying to do - SP 20160526
-
-        rescue Csvlint::Csvw::MetadataError => e
-          raise e
-        rescue => e
-          if output_errors === true
-            STDERR.puts e.class
-            STDERR.puts e.message
-            STDERR.puts e.backtrace
-          end
-          return Schema.new(nil, [], "malformed", "malformed")
+        json = JSON.parse(string)
+        if json["@context"]
+          uri = "file:#{File.expand_path(uri)}" unless /^http(s)?/.match?(uri.to_s)
+          Schema.from_csvw_metadata(uri, json)
+        else
+          Schema.from_json_table(uri, json)
         end
+      rescue TypeError => e
+        # NO IDEA what this was even trying to do - SP 20160526
+      rescue Csvlint::Csvw::MetadataError => e
+        raise e
+      rescue => e
+        if output_errors === true
+          warn e.class
+          warn e.message
+          warn e.backtrace
+        end
+        Schema.new(nil, [], "malformed", "malformed")
       end
-
     end
 
-    def validate_header(header, source_url=nil, validate=true)
+    def validate_header(header, source_url = nil, validate = true)
       reset
 
-      found_header = header.to_csv(:row_sep => '')
-      expected_header = @fields.map{ |f| f.name }.to_csv(:row_sep => '')
+      found_header = header.to_csv(row_sep: "")
+      expected_header = @fields.map { |f| f.name }.to_csv(row_sep: "")
       if found_header != expected_header
         build_warnings(:malformed_header, :schema, 1, nil, found_header, "expectedHeader" => expected_header)
       end
-      return valid?
+      valid?
     end
 
-    def validate_row(values, row=nil, all_errors=[], source_url=nil, validate=true)
+    def validate_row(values, row = nil, all_errors = [], source_url = nil, validate = true)
       reset
       if values.length < fields.length
         fields[values.size..-1].each_with_index do |field, i|
-          build_warnings(:missing_column, :schema, row, values.size+i+1)
+          build_warnings(:missing_column, :schema, row, values.size + i + 1)
         end
       end
       if values.length > fields.length
         values[fields.size..-1].each_with_index do |data_column, i|
-          build_warnings(:extra_column, :schema, row, fields.size+i+1)
+          build_warnings(:extra_column, :schema, row, fields.size + i + 1)
         end
       end
 
-      fields.each_with_index do |field,i|
+      fields.each_with_index do |field, i|
         value = values[i] || ""
-        result = field.validate_column(value, row, i+1, all_errors)
+        result = field.validate_column(value, row, i + 1, all_errors)
         @errors += fields[i].errors
         @warnings += fields[i].warnings
       end
 
-      return valid?
+      valid?
     end
-
   end
 end