module Valhammer::Validations

Constants

VALHAMMER_EXCLUDED_FIELDS

Public Instance Methods

valhammer(&bl) click to toggle source
# File lib/valhammer/validations.rb, line 34
def valhammer(&bl)
  @valhammer_indexes = connection.indexes(table_name)
  config = DisabledFieldConfig.perform(&bl)

  columns_hash.each do |name, column|
    valhammer_validate(name, column, config)
  end
end

Private Instance Methods

case_sensitive?(column) click to toggle source
# File lib/valhammer/validations.rb, line 154
def case_sensitive?(column)
  return true unless column.respond_to?(:case_sensitive?)

  column.case_sensitive?
end
valhammer_assoc_name(field) click to toggle source
# File lib/valhammer/validations.rb, line 149
def valhammer_assoc_name(field)
  reflect_on_all_associations(:belongs_to)
    .find { |a| a.foreign_key == field }.try(:name)
end
valhammer_exclude?(field) click to toggle source
# File lib/valhammer/validations.rb, line 139
def valhammer_exclude?(field)
  field == primary_key || VALHAMMER_EXCLUDED_FIELDS.include?(field)
end
valhammer_field_config(config, field) click to toggle source
# File lib/valhammer/validations.rb, line 62
def valhammer_field_config(config, field)
  Hash.new(true).merge(config[field.to_s] || {})
end
valhammer_inclusion(validations, column, opts) click to toggle source
# File lib/valhammer/validations.rb, line 87
def valhammer_inclusion(validations, column, opts)
  return unless opts[:inclusion] && column.type == :boolean

  validations[:inclusion] = { in: [false, true], allow_nil: column.null }
end
valhammer_info(column) click to toggle source
# File lib/valhammer/validations.rb, line 134
def valhammer_info(column)
  "#{valhammer_log_key(column)} (type=:#{column.type} " \
    "null=#{column.null || 'false'} limit=#{column.limit || 'nil'})"
end
valhammer_length(validations, column, opts) click to toggle source
# File lib/valhammer/validations.rb, line 125
def valhammer_length(validations, column, opts)
  return unless opts[:length] && column.type == :string && column.limit
  validations[:length] = { maximum: column.limit }
end
valhammer_log_key(column) click to toggle source
# File lib/valhammer/validations.rb, line 130
def valhammer_log_key(column)
  "`#{table_name}`.`#{column.name}`"
end
valhammer_numeric(validations, column, opts) click to toggle source
# File lib/valhammer/validations.rb, line 112
def valhammer_numeric(validations, column, opts)
  return if !opts[:numericality] || defined_enums.key?(column.name)

  case column.type
  when :integer
    validations[:numericality] = { only_integer: true,
                                   allow_nil: true }
  when :decimal
    validations[:numericality] = { only_integer: false,
                                   allow_nil: true }
  end
end
valhammer_presence(validations, column, opts) click to toggle source
# File lib/valhammer/validations.rb, line 81
def valhammer_presence(validations, column, opts)
  return unless opts[:presence] && column.type != :boolean

  validations[:presence] = true unless column.null
end
valhammer_unique(validations, column, opts) click to toggle source
# File lib/valhammer/validations.rb, line 93
def valhammer_unique(validations, column, opts)
  return unless opts[:uniqueness]

  unique_keys = valhammer_unique_keys(column)
  return unless unique_keys.one?

  scope = unique_keys.first.columns[0..-2]
  validations[:uniqueness] = valhammer_unique_opts(column, scope)
end
valhammer_unique_keys(column) click to toggle source
# File lib/valhammer/validations.rb, line 143
def valhammer_unique_keys(column)
  @valhammer_indexes.select do |i|
    i.unique && !i.where && i.columns.last == column.name
  end
end
valhammer_unique_opts(column, scope) click to toggle source
# File lib/valhammer/validations.rb, line 103
def valhammer_unique_opts(column, scope)
  nullable = scope.select { |c| columns_hash[c].null }
  opts = { allow_nil: true,
           case_sensitive: case_sensitive?(column) }
  opts[:scope] = scope.map(&:to_sym) if scope.any?
  opts[:if] = -> { nullable.all? { |c| send(c) } } if nullable.any?
  opts
end
valhammer_validate(name, column, config) click to toggle source
# File lib/valhammer/validations.rb, line 45
def valhammer_validate(name, column, config)
  return if valhammer_exclude?(name)

  assoc_name = valhammer_assoc_name(name)
  return valhammer_validate_assoc(assoc_name, column, config) if assoc_name

  opts = valhammer_field_config(config, name)
  validations = valhammer_validations(column, opts)
  validates(name, validations) unless validations.empty?
end
valhammer_validate_assoc(assoc_name, column, config) click to toggle source
# File lib/valhammer/validations.rb, line 56
def valhammer_validate_assoc(assoc_name, column, config)
  opts = valhammer_field_config(config, assoc_name)
  return if column.null || !opts[:presence]
  validates(assoc_name, presence: true)
end
valhammer_validations(column, opts) click to toggle source
# File lib/valhammer/validations.rb, line 66
def valhammer_validations(column, opts)
  validations = {}
  valhammer_presence(validations, column, opts)
  valhammer_inclusion(validations, column, opts)
  valhammer_unique(validations, column, opts)
  valhammer_numeric(validations, column, opts)
  valhammer_length(validations, column, opts)

  if Valhammer.config.verbose?
    logger.debug("Valhammer options for #{valhammer_log_key(column)} " \
                 "are: #{validations.inspect}")
  end
  validations
end