Module: VirtualBox::AbstractModel::Validatable

Included in:
VirtualBox::AbstractModel
Defined in:
lib/virtualbox/abstract_model/validatable.rb

Overview

Provides validation methods for a class. Unlike ActiveRecord, validations are instance-level rather than class-level.

Instance Method Summary collapse

Instance Method Details

#__validates_extract_options(fields, defaults) ⇒ Object

Internal method. Should never be called.



162
163
164
 
# File 'lib/virtualbox/abstract_model/validatable.rb', line 162

def __validates_extract_options(fields, defaults)
  defaults.merge(fields.last.is_a?(Hash) ? fields.pop : {})
end

#add_error(field, error) ⇒ Object

Adds an error to a field. The error is a message.



22
23
24
25
 
# File 'lib/virtualbox/abstract_model/validatable.rb', line 22

def add_error(field, error)
  errors[field] ||= []
  errors[field].push(error)
end

#clear_errors ⇒ Object

Clears all the errors from a model.



28
29
30
 
# File 'lib/virtualbox/abstract_model/validatable.rb', line 28

def clear_errors
  @errors = {}
end

#errors ⇒ Hash

Returns the errors on a model. The structure of this is a hash, keyed by the field name. The value of each member in the hash is an array of error messages.



11
12
13
 
# File 'lib/virtualbox/abstract_model/validatable.rb', line 11

def errors
  @errors ||= {}
end

#errors_on(field) ⇒ Object

Returns the errors on a specific field. This returns nil if there are no errors, otherwise it returns an array of error messages.



17
18
19
 
# File 'lib/virtualbox/abstract_model/validatable.rb', line 17

def errors_on(field)
  @errors[field.to_sym]
end

#full_error_messages ⇒ Object 



32
33
34
35
36
37
38
39
40
41
 
# File 'lib/virtualbox/abstract_model/validatable.rb', line 32

def full_error_messages
  full_error_messages = Array.new
  errors.each do |field_name, messages|
    messages.each do |message|
      human_field_name = field_name.to_s.gsub('_', ' ').capitalize
      full_error_messages << "#{human_field_name} #{message}"
    end
  end
  full_error_messages
end

#valid? ⇒ Boolean

This method calls the validate method on the model (which any subclass is expected to implement), and then checks that the validations didn’t add any errors.



48
49
50
51
 
# File 'lib/virtualbox/abstract_model/validatable.rb', line 48

def valid?
  validate
  errors.empty?
end

#validate ⇒ Boolean

Subclasses should override this method. Validation can be done any way an implementer feels. Helper methods such as #validates_presence_of, #validates_inclusion_of, etc. exist, but they’re use isn’t required. #add_error can be used to add an error to any field. By convention this method should return true or false to signal any errors.



60
61
62
 
# File 'lib/virtualbox/abstract_model/validatable.rb', line 60

def validate
  true
end

#validates_format_of(*fields) ⇒ Object

Validates the format of a field with a given regular expression.

validates_format_of :foo, :with => /\d+/



94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
 
# File 'lib/virtualbox/abstract_model/validatable.rb', line 94

def validates_format_of(*fields)
  options = __validates_extract_options(fields, {
    :with => nil,
    :message => "is not properly formatted."
  })

  fields.collect { |field|
    value = send(field)
    # Use validates_presence_of if you need it to be set
    next if value.nil? || value.to_s.empty?
    if options[:with] && value =~ options[:with]
      true
    else
      add_error(field, options[:message])
      false
    end
  }.compact.all? { |v| v == true }
end

#validates_inclusion_of(*fields) ⇒ Object

Validates that a field’s value is within a specific range, array, etc.

validates_inclusion_of :foo, :in => [1,2,3]
validates_inclusion_of :bar, :in => (1..6)



141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
 
# File 'lib/virtualbox/abstract_model/validatable.rb', line 141

def validates_inclusion_of(*fields)
  options = __validates_extract_options(fields, {
    :in => nil,
    :message => "value %s is not included in the list."
  })

  fields.collect { |field|
    value = send(field)
    # Use validates_presence_of if you need it to be set
    return if value.nil? || value.to_s.empty?
    if options[:in] && options[:in].include?(value)
      true
    else
      message = options[:message] % value
      add_error(field, message)
      false
    end
  }.compact.all? { |v| v == true }
end

#validates_numericality_of(*fields) ⇒ Object

Validates the numericality of a specific field.

validates_numericality_of :field



117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
 
# File 'lib/virtualbox/abstract_model/validatable.rb', line 117

def validates_numericality_of(*fields)
  options = __validates_extract_options(fields, {
    :message => "is not a number."
  })

  fields.collect { |field|
    value = send(field)
    # Use validates_presence_of if you need it to be set
    next if value.nil? || value.to_s.empty?
    if value.is_a?(Numeric) && value.to_s =~ /^\d$/
      true
    else
      add_error(field, options[:message])
      false
    end
  }.compact.all? { |v| v == true }
end

#validates_presence_of(*fields) ⇒ Boolean

Validates the presence (non-emptiness) of a field or fields. This validation fails if the specified fields are either blank (“”) or nil.

Additionally, a custom error message can be specified:

validates_presence_of :foo, :bar
validates_presence_of :baz, :message => "must not be blank!"



74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
 
# File 'lib/virtualbox/abstract_model/validatable.rb', line 74

def validates_presence_of(*fields)
  options = __validates_extract_options(fields, {
    :message => "can't be blank."
  })

  fields.collect { |field|
    value = send(field)
    if value.nil? || value.to_s.empty?
      add_error(field, options[:message])
      false
    else
      true
    end
  }.compact.all? { |v| v == true }
end