Module: Aequitas::Rule::Numericalness

Included in:
Equal, GreaterThan, GreaterThanOrEqual, Integer, LessThan, LessThanOrEqual, NonInteger, NotEqual
Defined in:
lib/aequitas/rule/numericalness.rb,
lib/aequitas/rule/numericalness/equal.rb,
lib/aequitas/rule/numericalness/integer.rb,
lib/aequitas/rule/numericalness/less_than.rb,
lib/aequitas/rule/numericalness/not_equal.rb,
lib/aequitas/rule/numericalness/non_integer.rb,
lib/aequitas/rule/numericalness/greater_than.rb,
lib/aequitas/rule/numericalness/less_than_or_equal.rb,
lib/aequitas/rule/numericalness/greater_than_or_equal.rb

Defined Under Namespace

Classes: Equal, GreaterThan, GreaterThanOrEqual, Integer, LessThan, LessThanOrEqual, NonInteger, NotEqual

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Instance Attribute Details

#expected ⇒ Object (readonly)

Returns the value of attribute expected.



44
45
46
 
# File 'lib/aequitas/rule/numericalness.rb', line 44

def expected
  @expected
end

Class Method Details

.included(validator) ⇒ Object 



11
12
13
 
# File 'lib/aequitas/rule/numericalness.rb', line 11

def self.included(validator)
  validator.equalize_on *(validator.superclass.equalizer.keys + [:expected])
end

.rules_for(attribute_name, options) ⇒ Object

TODO: move options normalization into the validator macros?



16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
 
# File 'lib/aequitas/rule/numericalness.rb', line 16

def self.rules_for(attribute_name, options)
  options = options.dup

  int = scour_options_of_keys(options, [:only_integer, :integer_only])

  gt  = scour_options_of_keys(options, [:gt,  :greater_than])
  lt  = scour_options_of_keys(options, [:lt,  :less_than])
  gte = scour_options_of_keys(options, [:gte, :greater_than_or_equal_to])
  lte = scour_options_of_keys(options, [:lte, :less_than_or_equal_to])
  eq  = scour_options_of_keys(options, [:eq,  :equal, :equals, :exactly, :equal_to])
  ne  = scour_options_of_keys(options, [:ne,  :not_equal_to])

  rules = []
  rules << Integer.new(attribute_name, options)                                    if int
  rules << NonInteger.new(attribute_name, options)                                 if !int
  rules << GreaterThan.new(attribute_name, options.merge(:expected => gt))         if gt
  rules << LessThan.new(attribute_name, options.merge(:expected => lt))            if lt
  rules << GreaterThanOrEqual.new(attribute_name, options.merge(:expected => gte)) if gte
  rules << LessThanOrEqual.new(attribute_name, options.merge(:expected => lte))    if lte
  rules << Equal.new(attribute_name, options.merge(:expected => eq))               if eq
  rules << NotEqual.new(attribute_name, options.merge(:expected => ne))            if ne
  rules
end

.scour_options_of_keys(options, keys) ⇒ Object 



40
41
42
 
# File 'lib/aequitas/rule/numericalness.rb', line 40

def self.scour_options_of_keys(options, keys)
  keys.map { |key| options.delete(key) }.compact.first
end

Instance Method Details

#initialize(attribute_name, options) ⇒ Object 



46
47
48
49
50
 
# File 'lib/aequitas/rule/numericalness.rb', line 46

def initialize(attribute_name, options)
  super

  @expected = options[:expected]
end

#valid?(resource) ⇒ Boolean

Returns:

  • (Boolean) 


52
53
54
55
56
57
58
59
60
 
# File 'lib/aequitas/rule/numericalness.rb', line 52

def valid?(resource)
  # TODO: is it even possible for expected to be nil?
  #   if so, return a dummy validator when expected is nil
  return true if expected.nil?

  value = attribute_value(resource)

  skip?(value) || valid_numericalness?(value)
end