Module: Validation::ClassMethods

Defined in:
lib/assistance/validation.rb

Overview

Validation class methods.

Constant Summary collapse

NUMBER_RE = 
/^\d*\.{0,1}\d+$/
INTEGER_RE = 
/\A[+-]?\d+\Z/

Instance Method Summary collapse

Instance Method Details

#has_validations? ⇒ Boolean

Returns true if validations are defined.

Returns:

  • (Boolean) 


120
121
122
 
# File 'lib/assistance/validation.rb', line 120

def has_validations?
  !validations.empty?
end

#skip_superclass_validations ⇒ Object 



135
136
137
 
# File 'lib/assistance/validation.rb', line 135

def skip_superclass_validations
  @skip_superclass_validations = true
end

#validate(o) ⇒ Object

Validates the given instance.



125
126
127
128
129
130
131
132
133
 
# File 'lib/assistance/validation.rb', line 125

def validate(o)
  if superclass.respond_to?(:validate) && !@skip_superclass_validations
    superclass.validate(o)
  end
  validations.each do |att, procs|
    v = o.send(att)
    procs.each {|p| p[o, att, v]}
  end
end

#validates(&block) ⇒ Object

Defines validations by converting a longhand block into a series of shorthand definitions. For example:

class MyClass
  include Validation
  validates do
    length_of :name, :minimum => 6
    length_of :password, :minimum => 8
  end
end

is equivalent to:

class MyClass
  include Validation
  validates_length_of :name, :minimum => 6
  validates_length_of :password, :minimum => 8
end



110
111
112
 
# File 'lib/assistance/validation.rb', line 110

def validates(&block)
  Generator.new(self, &block)
end

#validates_acceptance_of(*atts) ⇒ Object

Validates acceptance of an attribute.



151
152
153
154
155
156
157
158
159
160
161
162
 
# File 'lib/assistance/validation.rb', line 151

def validates_acceptance_of(*atts)
  opts = {
    :message => 'is not accepted',
    :allow_nil => true,
    :accept => '1'
  }.merge!(atts.extract_options!)
  
  validates_each(*atts) do |o, a, v|
    next if (v.nil? && opts[:allow_nil]) || (v.blank? && opts[:allow_blank])
    o.errors[a] << opts[:message] unless v == opts[:accept]
  end
end

#validates_confirmation_of(*atts) ⇒ Object

Validates confirmation of an attribute.



165
166
167
168
169
170
171
172
173
174
175
 
# File 'lib/assistance/validation.rb', line 165

def validates_confirmation_of(*atts)
  opts = {
    :message => 'is not confirmed',
  }.merge!(atts.extract_options!)
  
  validates_each(*atts) do |o, a, v|
    next if (v.nil? && opts[:allow_nil]) || (v.blank? && opts[:allow_blank])
    c = o.send(:"#{a}_confirmation")
    o.errors[a] << opts[:message] unless v == c
  end
end

#validates_each(*atts, &block) ⇒ Object

Adds a validation for each of the given attributes using the supplied block. The block must accept three arguments: instance, attribute and value, e.g.:

validates_each :name, :password do |object, attribute, value|
  object.errors[attribute] << 'is not nice' unless value.nice?
end



146
147
148
 
# File 'lib/assistance/validation.rb', line 146

def validates_each(*atts, &block)
  atts.each {|a| validations[a] << block}
end

#validates_format_of(*atts) ⇒ Object

Validates the format of an attribute.



178
179
180
181
182
183
184
185
186
187
188
189
190
191
 
# File 'lib/assistance/validation.rb', line 178

def validates_format_of(*atts)
  opts = {
    :message => 'is invalid',
  }.merge!(atts.extract_options!)
  
  unless opts[:with].is_a?(Regexp)
    raise ArgumentError, "A regular expression must be supplied as the :with option of the options hash"
  end
  
  validates_each(*atts) do |o, a, v|
    next if (v.nil? && opts[:allow_nil]) || (v.blank? && opts[:allow_blank])
    o.errors[a] << opts[:message] unless v.to_s =~ opts[:with]
  end
end

#validates_length_of(*atts) ⇒ Object

Validates the length of an attribute.



194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
 
# File 'lib/assistance/validation.rb', line 194

def validates_length_of(*atts)
  opts = {
    :too_long     => 'is too long',
    :too_short    => 'is too short',
    :wrong_length => 'is the wrong length'
  }.merge!(atts.extract_options!)
  
  validates_each(*atts) do |o, a, v|
    next if (v.nil? && opts[:allow_nil]) || (v.blank? && opts[:allow_blank])
    if m = opts[:maximum]
      o.errors[a] << (opts[:message] || opts[:too_long]) unless v && v.size <= m
    end
    if m = opts[:minimum]
      o.errors[a] << (opts[:message] || opts[:too_short]) unless v && v.size >= m
    end
    if i = opts[:is]
      o.errors[a] << (opts[:message] || opts[:wrong_length]) unless v && v.size == i
    end
    if w = opts[:within]
      o.errors[a] << (opts[:message] || opts[:wrong_length]) unless v && w.include?(v.size)
    end
  end
end

#validates_numericality_of(*atts) ⇒ Object

Validates whether an attribute is a number.



222
223
224
225
226
227
228
229
230
231
232
233
 
# File 'lib/assistance/validation.rb', line 222

def validates_numericality_of(*atts)
  opts = {
    :message => 'is not a number',
  }.merge!(atts.extract_options!)
  
  re = opts[:only_integer] ? INTEGER_RE : NUMBER_RE
  
  validates_each(*atts) do |o, a, v|
    next if (v.nil? && opts[:allow_nil]) || (v.blank? && opts[:allow_blank])
    o.errors[a] << opts[:message] unless v.to_s =~ re
  end
end

#validates_presence_of(*atts) ⇒ Object

Validates the presence of an attribute.



236
237
238
239
240
241
242
243
244
 
# File 'lib/assistance/validation.rb', line 236

def validates_presence_of(*atts)
  opts = {
    :message => 'is not present',
  }.merge!(atts.extract_options!)
  
  validates_each(*atts) do |o, a, v|
    o.errors[a] << opts[:message] unless v && !v.blank?
  end
end

#validations ⇒ Object

Returns the validations hash for the class.



115
116
117
 
# File 'lib/assistance/validation.rb', line 115

def validations
  @validations ||= Hash.new {|h, k| h[k] = []}
end