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

#before_validation_callback?(model) ⇒ Boolean

Returns:

  • (Boolean) 


14
15
16
17
18
19
 
# File 'lib/forest_admin_datasource_mongoid/parser/validation.rb', line 14

def before_validation_callback?(model)
  default_callback_excluded = [:normalize_changed_in_place_attributes]
  model._validation_callbacks.any? do |callback|
    !default_callback_excluded.include?(callback.filter) && callback.kind == :before
  end
end

#get_validations(model, column) ⇒ Object 



6
7
8
9
10
11
12
 
# File 'lib/forest_admin_datasource_mongoid/parser/validation.rb', line 6

def get_validations(model, column)
  return [] if column.is_a?(Hash)
  return [] if before_validation_callback?(model)
  return [] unless model._validators? && model._validators[column.name.to_sym].size.positive?

  parse_column_validators(model._validators[column.name.to_sym], column)
end

#parse_column_validators(validators, column) ⇒ Object 



21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
 
# File 'lib/forest_admin_datasource_mongoid/parser/validation.rb', line 21

def parse_column_validators(validators, column)
  validations = []
  validators.each do |validator|
    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
  validations
end

#parse_format_validator(validator, parsed_validations) ⇒ Object 



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

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 



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

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 



40
41
42
43
44
45
46
47
48
49
50
51
 
# File 'lib/forest_admin_datasource_mongoid/parser/validation.rb', line 40

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