Module: ForestAdminDatasourceMongoid::Parser::Validation

Includes:
ForestAdminDatasourceToolkit::Components::Query::ConditionTree
Included in:
Collection, Utils::Schema::FieldsGenerator
Defined in:
lib/forest_admin_datasource_mongoid/parser/validation.rb

Instance Method Summary collapse

Instance Method Details

#get_validations(model, column) ⇒ Object 



5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
 
# File 'lib/forest_admin_datasource_mongoid/parser/validation.rb', line 5

def get_validations(model, column)
  return [] if column.is_a?(Hash)

  validations = []
  # NOTICE: Do not consider validations if a before_validation Active Records
  #         Callback is detected.
  default_callback_excluded = [:normalize_changed_in_place_attributes]
  return validations if model._validation_callbacks
                             .reject { |callback| default_callback_excluded.include?(callback.filter) }
                             .map(&:kind).include?(:before)

  if model._validators? && model._validators[column.name.to_sym].size.positive?
    model._validators[column.name.to_sym].each do |validator|
      # NOTICE: Do not consider conditional validations
      next if validator.options[:if] || validator.options[:unless] || validator.options[:on]

      case validator.class.to_s
      when Mongoid::Validatable::PresenceValidator.to_s
        validations << { operator: Operators::PRESENT }
      when ActiveModel::Validations::NumericalityValidator.to_s
        validations = parse_numericality_validator(validator, validations)
      when Mongoid::Validatable::LengthValidator.to_s
        validations = parse_length_validator(validator, validations, column)
      when Mongoid::Validatable::FormatValidator.to_s
        validations = parse_format_validator(validator, validations)
      end
    end
  end

  validations
end

#parse_format_validator(validator, parsed_validations) ⇒ Object 



68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
 
# File 'lib/forest_admin_datasource_mongoid/parser/validation.rb', line 68

def parse_format_validator(validator, parsed_validations)
  validator.options.each do |option, value|
    case option
    when :with
      options = /\?([imx]){0,3}/.match(validator.options[:with].to_s)
      options = options && options[1] ? options[1] : ''
      regex = value.source

      # NOTICE: Transform a Ruby regex into a JS one
      regex = regex.sub('\\A', '^').sub('\\Z', '$').sub('\\z', '$').gsub(/\n+|\s+/, '')

      parsed_validations << { operator: Operators::CONTAINS, value: "/#{regex}/#{options}" }
    end
  end

  parsed_validations
end

#parse_length_validator(validator, parsed_validations, column) ⇒ Object 



50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
 
# File 'lib/forest_admin_datasource_mongoid/parser/validation.rb', line 50

def parse_length_validator(validator, parsed_validations, column)
  return unless get_column_type(column) == 'String'

  validator.options.each do |option, value|
    case option
    when :minimum
      parsed_validations << { operator: Operators::LONGER_THAN, value: value }
    when :maximum
      parsed_validations << { operator: Operators::SHORTER_THAN, value: value }
    when :is
      parsed_validations << { operator: Operators::LONGER_THAN, value: value }
      parsed_validations << { operator: Operators::SHORTER_THAN, value: value }
    end
  end

  parsed_validations
end

#parse_numericality_validator(validator, parsed_validations) ⇒ Object 



37
38
39
40
41
42
43
44
45
46
47
48
 
# File 'lib/forest_admin_datasource_mongoid/parser/validation.rb', line 37

def parse_numericality_validator(validator, parsed_validations)
  validator.options.each do |option, value|
    case option
    when :greater_than, :greater_than_or_equal_to
      parsed_validations << { operator: Operators::GREATER_THAN, value: value }
    when :less_than, :less_than_or_equal_to
      parsed_validations << { operator: Operators::LESS_THAN, value: value }
    end
  end

  parsed_validations
end