lite-validators 1.0.0

data/lib/lite/validators/base_validator.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+class BaseValidator < ActiveModel::EachValidator
+
+  def validate_each(record, attribute, value)
+    assign_attr_readers(record, attribute, value)
+    return if valid?
+
+    record.errors.add(attribute, *error_message)
+  end
+
+  private
+
+  attr_reader :record, :attribute, :value
+
+  def assign_attr_readers(record, attribute, value)
+    @record = record
+    @attribute = attribute
+    @value = value
+  end
+
+  # rubocop:disable Metrics/LineLength
+  def assert_valid_option!(name, collection, option: nil)
+    option ||= send(name)
+
+    [*option].each do |option_value|
+      next if collection.include?(option_value)
+
+      raise ArgumentError, "Unknown #{name}: #{option_value.inspect}. Valid options are: #{collection.map(&:inspect).join(', ')}"
+    end
+  end
+  # rubocop:enable Metrics/LineLength
+
+  def error_message
+    [options[:message] || :invalid]
+  end
+
+  def valid?
+    valid_length? && valid_attr?
+  end
+
+  def valid_attr?
+    valid_regexp?
+  end
+
+  def valid_length?
+    !value.to_s.strip.empty?
+  end
+
+  def valid_regexp?
+    value.to_s =~ self.class::REGEXP
+  end
+
+end

data/lib/lite/validators/boolean_validator.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+class BooleanValidator < BaseValidator
+
+  VALUES ||= %w[
+    1 0 t f true false
+  ].freeze
+
+  private
+
+  def valid_attr?
+    VALUES.include?(value.to_s.downcase)
+  end
+
+end

data/lib/lite/validators/compare_validator.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+class CompareValidator < BaseValidator
+
+  CHECKS ||= {
+    less_than: :<,
+    less_than_or_equal_to: :<=,
+    greater_than: :>,
+    greater_than_or_equal_to: :>=,
+    equal_to: :==,
+    not_equal_to: :!=
+  }.freeze
+
+  def validate_each(record, attribute, value)
+    assert_valid_to!
+    assert_valid_check!
+    super
+  end
+
+  private
+
+  def assert_valid_check!
+    assert_valid_option!(:check, CHECKS.keys)
+  end
+
+  def assert_valid_to!
+    return if options.key?(:to)
+
+    raise ArgumentError, 'Missing ":to" attribute for comparison.'
+  end
+
+  def check
+    options[:check] || :equal_to
+  end
+
+  def valid_attr?
+    other = record.send(options[:to])
+    value.send(CHECKS[check], other)
+  end
+
+end

data/lib/lite/validators/coordinate_validator.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+class CoordinateValidator < BaseValidator
+
+  BOUNDARIES ||= {
+    latitude: 90.0,
+    longitude: 180.0
+  }.freeze
+
+  def validate_each(record, attribute, value)
+    assert_valid_boundary!
+    super
+  end
+
+  private
+
+  def assert_valid_boundary!
+    assert_valid_option!(:boundary, BOUNDARIES.keys.push(:pair))
+  end
+
+  def boundary
+    options[:boundary] || :pair
+  end
+
+  def valid_attr?
+    case boundary
+    when :latitude then valid_boundary?(:latitude)
+    when :longitude then valid_boundary?(:longitude)
+    else valid_boundary?(:latitude, value.first) && valid_boundary?(:longitude, value.last)
+    end
+  end
+
+  def valid_boundary?(key, coordinate = nil)
+    (coordinate || value).to_f.abs <= BOUNDARIES[key]
+  end
+
+end

data/lib/lite/validators/credit_card_validator.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+class CreditCardValidator < BaseValidator
+
+  # NOTE: https://en.wikipedia.org/wiki/Payment_card_value#Issuer_identification_value_.28IIN.29
+
+  PROVIDERS ||= {
+    american_express: {
+      sizes: [15],
+      prefixes: [34, 37]
+    },
+    dankort: {
+      sizes: [16],
+      prefixes: [4571, 5019]
+    },
+    diners_club: {
+      sizes: (14..19),
+      prefixes: [36, (38..39), (54..55), (300..305), 3095]
+    },
+    discover: {
+      sizes: (16..19),
+      prefixes: [(64..65), 6011, (622_126..622_925), (624_000..626_999), (628_200..628_899)]
+    },
+    interpayment: {
+      sizes: (16..19),
+      prefixes: [636]
+    },
+    rupay: {
+      sizes: [16],
+      prefixes: [60, (6521..6522)]
+    },
+    jcb: {
+      sizes: (16..19),
+      prefixes: [(3528..3589)]
+    },
+    maestro: {
+      sizes: (12..19),
+      prefixes: [50, (56..69)]
+    },
+    maestro_uk: {
+      sizes: (12..19),
+      prefixes: [6759, 676_770, 676_774]
+    },
+    mastercard: {
+      sizes: [16],
+      prefixes: [(51..55), (2221..2720)]
+    },
+    mir: {
+      sizes: [16],
+      prefixes: [(2200..2204)]
+    },
+    nps_pridnestrovie: {
+      sizes: [16],
+      prefixes: [(6_054_740..6_054_744)]
+    },
+    troy: {
+      sizes: [16],
+      prefixes: [(979_200..979_289)]
+    },
+    uatp: {
+      sizes: [16],
+      prefixes: [1]
+    },
+    unionpay: {
+      sizes: (16..19),
+      prefixes: [62]
+    },
+    verve: {
+      sizes: [16, 19],
+      prefixes: [(506_099..506_198), (650_002..650_027)]
+    },
+    visa: {
+      sizes: [16],
+      prefixes: [4]
+    }
+  }.freeze
+
+  def validate_each(record, attribute, value)
+    assert_valid_provider!
+    super
+  end
+
+  private
+
+  def assert_valid_provider!
+    assert_valid_option!(:provider, PROVIDERS.keys.push(:all))
+  end
+
+  def checksum(value)
+    values = digits(value).reverse.map.with_index { |n, i| i.even? ? n * 2 : n }
+    total = values.reverse.inject(0) { |a, b| a + digits(b).inject(:+) }
+    checksum = 10 - (total % 10)
+    checksum == 10 ? 0 : checksum
+  end
+
+  def digits(value)
+    value.to_s.chars.map(&:to_i)
+  end
+
+  def encompasses?(subject, value)
+    case subject
+    when Array then subject.include?(value)
+    when Range then subject.cover?(value)
+    else subject == value
+    end
+  end
+
+  def prefix(subject, value)
+    nums = case subject
+           when Array, Range then subject.first
+           else subject
+           end
+
+    value.to_s[0..(nums.to_s.size - 1)].to_i
+  end
+
+  def provider
+    options[:provider] || :all
+  end
+
+  def valid_attr?
+    valid_size?(value) && valid_prefix?(value) && valid_checksum?
+  end
+
+  def valid_checksum?
+    nums = digits(value)
+    nums.pop == checksum(nums.join)
+  end
+
+  def valid_prefix?(value)
+    prefixes = PROVIDERS.dig(provider, :prefixes) || PROVIDERS.flat_map { |_, h| h[:prefixes] }
+
+    prefixes.any? do |subject|
+      iin = prefix(subject, value)
+      encompasses?(subject, iin)
+    end
+  end
+
+  def valid_size?(value)
+    sizes = PROVIDERS.dig(provider, :sizes) || (12..19)
+    encompasses?(sizes, value.to_s.size)
+  end
+
+end

data/lib/lite/validators/csv_validator.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require 'csv'
+
+class CsvValidator < FileSizeValidator
+
+  DIMENSIONS ||= %i[
+    columns rows
+  ].freeze
+
+  def validate_each(record, attribute, value)
+    assert_valid_dimensions!
+    assert_valid_checks!
+    assign_attr_readers(record, attribute, csv_dimensions(value.path))
+    valid?
+  rescue CSV::MalformedCSVError
+    record.errors.add(attribute, *error_message)
+  end
+
+  private
+
+  # rubocop:disable Metrics/LineLength, Style/GuardClause
+  def assert_valid_dimensions!
+    if dimensions.empty?
+      raise ArgumentError, "Missing atleast one dimension of #{DIMENSIONS.map(&:inspect).join(', ')} attribute for comparison."
+    else
+      assert_valid_option!(:dimensions, DIMENSIONS)
+    end
+  end
+  # rubocop:enable Metrics/LineLength, Style/GuardClause
+
+  def csv_dimensions(path)
+    dimension = { columns: 0, rows: 0 }
+
+    CSV.foreach(path) do |row|
+      dimension[:columns] = row.size if dimension[:rows].zero?
+      dimension[:rows] += 1
+    end
+
+    dimension
+  end
+
+  def checks
+    dimension_options = options.slice(:columns, :rows).values
+    dimension_options.flat_map(&:keys) & CHECKS.keys
+  end
+
+  def dimensions
+    options.keys
+  end
+
+  def error_message_for(dimension, check, check_value)
+    options[:message] || I18n.t(
+      "errors.messages.csv.#{check}",
+      error_options(check_value).merge(dimension: dimension)
+    )
+  end
+
+  def valid_attr?
+    options.slice(*DIMENSIONS).each do |dimension, dimension_value|
+      dimension_value.each do |check, check_value|
+        validate_check(dimension, check, check_value)
+      end
+    end
+  end
+
+  def validate_check(dimension, check, check_value)
+    return if valid_size?(value[dimension], check, check_value)
+
+    record.errors.add(attribute, error_message_for(dimension, check, check_value))
+  end
+
+end

data/lib/lite/validators/currency_validator.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class CurrencyValidator < BaseValidator
+
+  REGEXP ||= /^\d*+(\.\d{1,2})$/.freeze
+
+end

data/lib/lite/validators/cusip_validator.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+class CusipValidator < BaseValidator
+
+  REGEXP ||= /^[0-9A-Z]{9}$/.freeze
+
+  private
+
+  def valid_attr?
+    valid_regexp? && valid_checksum?
+  end
+
+  # rubocop:disable Metrics/AbcSize
+  def valid_checksum?
+    digits = value.chars.map { |chr| /[A-Z]/.match?(chr) ? (chr.ord - 55) : chr.to_i }
+
+    even_values = digits.values_at(*digits.each_index.select(&:even?))
+    odd_values = digits.values_at(*digits.each_index.select(&:odd?))
+
+    values = odd_values.map { |int| int * 2 }.zip(even_values).flatten
+    values = values.inject(0) { |sum, int| sum + (int / 10) + int % 10 }
+
+    ((10 - values) % 10) % 10
+  end
+  # rubocop:enable Metrics/AbcSize
+
+end

data/lib/lite/validators/email_validator.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+class EmailValidator < BaseValidator
+
+  REGEXP ||= /\A([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})\z/i.freeze
+
+  private
+
+  def valid_attr?
+    valid_regexp? && valid_domain?
+  end
+
+  def valid_domain?
+    return true unless options.key?(:domain)
+
+    [options[:domain]].flatten.any? { |domain| value.downcase.end_with?(".#{domain.downcase}") }
+  end
+
+end

data/lib/lite/validators/file_content_type_validator.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+class FileContentTypeValidator < BaseValidator
+
+  def validate_each(record, attribute, value)
+    assert_valid_include_or_exclude!
+    assign_attr_readers(record, attribute, value)
+    valid?
+  end
+
+  private
+
+  def assert_valid_include_or_exclude!
+    return if options.key?(:include) || options.key?(:exclude)
+
+    raise ArgumentError, 'Missing ":include" or ":exclude" attribute for comparison.'
+  end
+
+  def valid_attr?
+    options.slice(:include, :exclude).each do |option, option_value|
+      validate_check(option, option_value)
+    end
+  end
+
+  # rubocop:disable Style/CaseEquality
+  def valid_content_type?(option, option_value)
+    check = [*option_value].any? { |type| type === value.content_type }
+    option == :exclude ? !check : check
+  end
+  # rubocop:enable Style/CaseEquality
+
+  def validate_check(option, option_value)
+    return if valid_content_type?(option, option_value)
+
+    record.errors.add(attribute, *error_message)
+  end
+
+end

data/lib/lite/validators/file_extension_validator.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+class FileExtensionValidator < BaseValidator
+
+  def validate_each(record, attribute, value)
+    assert_valid_include_or_exclude!
+    assign_attr_readers(record, attribute, value)
+    valid?
+  end
+
+  private
+
+  def assert_valid_include_or_exclude!
+    return if options.key?(:include) || options.key?(:exclude)
+
+    raise ArgumentError, 'Missing ":include" or ":exclude" attribute for comparison.'
+  end
+
+  def check
+    options.key?(:exclude) ? :exclude : :include
+  end
+
+  def include_or_exclude
+    values = options[:include] || options[:exclude]
+    [*values]
+  end
+
+  # rubocop:disable Metrics/AbcSize
+  def valid_attr?
+    extension = File.extname(value.original_filename).tr('.', '')
+    return false if extension.empty?
+
+    included = include_or_exclude.any? { |ext| ext.to_s == extension }
+    included = !included if check == :exclude
+    return if included
+
+    record.errors.add(attribute, *error_message)
+  end
+  # rubocop:enable Metrics/AbcSize
+
+end

data/lib/lite/validators/file_size_validator.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+class FileSizeValidator < BaseValidator
+
+  CHECKS ||= {
+    in: :===,
+    less_than: :<,
+    less_than_or_equal_to: :<=,
+    greater_than: :>,
+    greater_than_or_equal_to: :>=,
+    equal_to: :==,
+    not_equal_to: :!=
+  }.freeze
+
+  def validate_each(record, attribute, value)
+    assert_valid_checks!
+    assign_attr_readers(record, attribute, value)
+    valid?
+  end
+
+  private
+
+  # rubocop:disable Metrics/LineLength, Style/GuardClause
+  def assert_valid_checks!
+    if checks.empty?
+      raise ArgumentError, "Missing atleast one check of #{CHECKS.keys.map(&:inspect).join(', ')} attribute for comparison."
+    else
+      assert_valid_option!(:checks, CHECKS.keys)
+    end
+  end
+  # rubocop:enable Metrics/LineLength, Style/GuardClause
+
+  def checks
+    options.keys & CHECKS.keys
+  end
+
+  def error_message_for(option, option_value)
+    options[:message] || I18n.t(
+      "errors.messages.file_size.#{option}",
+      error_options(option_value)
+    )
+  end
+
+  def error_options(option_value)
+    if option_value.is_a?(Range)
+      { min: option_value.min, max: option_value.max }
+    else
+      { count: option_value }
+    end
+  end
+
+  def valid_attr?
+    options.slice(*CHECKS.keys).each do |option, option_value|
+      validate_check(option, option_value)
+    end
+  end
+
+  def valid_size?(size, option, option_value)
+    return false if size.nil?
+
+    if option_value.is_a?(Range)
+      option_value.send(CHECKS[option], size)
+    else
+      size.send(CHECKS[option], option_value)
+    end
+  end
+
+  def validate_check(option, option_value)
+    size = value.respond_to?(:byte_size) ? value.byte_size : value.size
+    return if valid_size?(size, option, option_value)
+
+    record.errors.add(attribute, error_message_for(option, option_value))
+  end
+
+end

data/lib/lite/validators/hex_validator.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class HexValidator < BaseValidator
+
+  REGEXP ||= /^#?([A-Fa-f0-9]{6}|[A-Fa-f0-9]{3})$/.freeze
+
+end

data/lib/lite/validators/imei_validator.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+class ImeiValidator < BaseValidator
+
+  REGEXP ||= /\A[\d\.\:\-\s]+\z/i.freeze
+
+  private
+
+  def valid_attr?
+    valid_regexp? && valid_checksum?
+  end
+
+  def valid_checksum?
+    number = value.to_s.gsub(/\D/, '').reverse
+
+    total = 0
+    number.chars.each_with_index do |chr, idx|
+      result = chr.to_i
+      result *= 2 if idx.odd?
+      result = (1 + (result - 10)) if result >= 10
+      total += result
+    end
+
+    (total % 10).zero?
+  end
+
+end

data/lib/lite/validators/ip_address_validator.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require 'resolv'
+
+class IpAddressValidator < BaseValidator
+
+  REGEXP ||= {
+    ipv4: Resolv::IPv4::Regex,
+    ipv6: Resolv::IPv6::Regex
+  }.freeze
+
+  def validate_each(record, attribute, value)
+    assert_valid_protocol!
+    super
+  end
+
+  private
+
+  def assert_valid_protocol!
+    assert_valid_option!(:protocol, REGEXP.keys.push(:any))
+  end
+
+  def protocol
+    options[:protocol] || :any
+  end
+
+  def valid_attr?
+    case protocol
+    when :ipv4 then valid_regexp?(:ipv4)
+    when :ipv6 then valid_regexp?(:ipv6)
+    else valid_regexp?(:ipv4) || valid_regexp?(:ipv6)
+    end
+  end
+
+  def valid_regexp?(key)
+    value.to_s =~ REGEXP[key]
+  end
+
+end

data/lib/lite/validators/isbn_validator.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+class IsbnValidator < BaseValidator
+
+  CHARACTERS ||= %w[
+    0 1 2 3 4 5 6 7 8 9 0 x
+  ].freeze
+
+  private
+
+  def valid_attr?
+    values = value.to_s.gsub(/-| /, '').downcase.chars
+    [10, 13].include?(values.size) && values.all? { |chr| CHARACTERS.include?(chr) }
+  end
+
+end