The Big Programming Thread - Page 912

class PropertyValidator < ActiveModel::Validator
  def validate(record)
    attributes = record.property_attributes_info

    attributes.each do |properties_attribute, definitions_attribute|
      @properties = {}
      @errors     = []

      next if skip_validation?(record[properties_attribute], record[definitions_attribute])

      @properties = record[properties_attribute]

      validate_properties(record[definitions_attribute])

      next if @errors.empty?

      record.errors.add(properties_attribute, @errors)
    end
  end

  private

  def skip_validation?(properties, definitions)
    properties.blank? || definitions.blank?
  end

  def validate_properties(definitions)
    @properties.each do |property_name, property_value|
      validate_property(property_name, property_value, definitions[property_name])
    end
  end

  def validate_property(property_name, property_value, definition)
    return @errors << "#{property_name} has no definition" if definition.blank?

    check_type(property_name, property_value, definition[:type_of_value])
    check_allowed_values(property_name, property_value, definition[:options])
    check_constraints(property_name, definition[:options])
  end

  def check_type(property_name, property_value, type)
    return if type_valid?(property_value, type)

    @errors << "#{property_name}: #{property_value} is not a #{type}"
  end

  def check_allowed_values(property_name, property_value, options)
    return if options.blank? || options[:allowed_values].blank?
    return if value_allowed?(property_value, options[:allowed_values])

    @errors << "#{property_name}: #{property_value} is not allowed"
  end

  def check_constraints(property_name, options)
    return if options.blank? || options[:constraints].blank?
    return if constraints_met?(options[:constraints])

    @errors << "#{property_name}: does not meet constraints"
  end

  def type_valid?(value, type)
    case type
    when 'string'
      value.is_a?(String)
    when 'integer'
      value.is_a?(Integer)
    when 'float'
      value.is_a?(Float)
    when 'boolean'
      value.is_a?(Boolean)
    else
      raise "Unknown property type \"#{type}\""
    end
  end

  def value_allowed?(value, allowed)
    case allowed[:type]
    when 'range'
      (allowed[:min]..allowed[:max]).include?(value)
    when 'array'
      allowed[:values].include?(value)
    else
      raise "Unknown allowed values type \"#{allowed[:type]}\""
    end
  end

  def constraints_met?(constraints)
    case constraints[:kind]
    when 'other_property_equals'
      constraints[:property_values].include?(@properties[constraints[:property_name]])
    when 'and'
      all_constraints_pass?(constraints)
    when 'or'
      any_constraints_pass?(constraints)
    else
      @errors << "Unknown constraint kind \"#{constraints[:kind]}\""
    end
  end

  def all_constraints_pass?(constraints)
    constraints[:constraints].each do |constraint|
      return false unless constraints_met?(constraint)
    end

    true
  end

  def any_constraints_pass?(constraints)
    constraints[:constraints].each do |constraint|
      return true if constraints_met?(constraint)
    end

    false
  end
end