Parent

Class Index [+]

Quicksearch

DataMapper::Validations::GenericValidator

All validators extend this base class. Validators must:

@author Guy van den Berg @since 0.9

Attributes

if_clause[RW]
unless_clause[RW]
field_name[R]
options[R]
humanized_field_name[R]

Public Class Methods

new(field_name, options = {}) click to toggle source

Construct a validator. Capture the :if and :unless clauses when present.

@param [String, Symbol] field

  The property specified for validation.

@option [Symbol, Proc] :if

  The name of a method or a Proc to call to determine if the
  validation should occur.

@option [Symbol, Proc] :unless

  The name of a method or a Proc to call to determine if the
  validation should not occur.

@note

  All additional key/value pairs are passed through to the validator
  that is sub-classing this GenericValidator
    # File lib/dm-validations/validators/generic_validator.rb, line 37
37:       def initialize(field_name, options = {})
38:         @field_name           = field_name
39:         @options              = DataMapper::Ext::Hash.except(options, :if, :unless)
40:         @if_clause            = options[:if]
41:         @unless_clause        = options[:unless]
42:         @humanized_field_name = DataMapper::Inflector.humanize(@field_name)
43:       end

Public Instance Methods

==(other) click to toggle source

Returns true if validators are equal

Note that this intentionally do validate options equality

even though it is hard to imagine a situation when multiple validations will be used on the same field with the same conditions but different options, it happens to be the case every once in a while with inferred validations for strings/text and explicitly given validations with different option (usually as Range vs. max limit for inferred validation)

@api semipublic

     # File lib/dm-validations/validators/generic_validator.rb, line 153
153:       def ==(other)
154:         self.class == other.class &&
155:         self.field_name == other.field_name &&
156:         self.if_clause == other.if_clause &&
157:         self.unless_clause == other.unless_clause &&
158:         self.options == other.options
159:       end
add_error(target, message, field_name = :general) click to toggle source

Add an error message to a target resource. If the error corresponds to a specific field of the resource, add it to that field, otherwise add it as a :general message.

@param [Object] target

  The resource that has the error.

@param [String] message

  The message to add.

@param [Symbol] field_name

  The name of the field that caused the error.
    # File lib/dm-validations/validators/generic_validator.rb, line 58
58:       def add_error(target, message, field_name = :general)
59:         # TODO: should the field_name for a general message be :default???
60:         target.errors.add(field_name, message)
61:       end
call(target) click to toggle source

Call the validator. “call” is used so the operation is BoundMethod and Block compatible. This must be implemented in all concrete classes.

@param [Object] target

  The resource that the validator must be called against.

@return [Boolean]

  true if valid, otherwise false.
    # File lib/dm-validations/validators/generic_validator.rb, line 73
73:       def call(target)
74:         raise NotImplementedError, "#{self.class}#call must be implemented"
75:       end
evaluate_conditional_clause(target, clause) click to toggle source

@api private

     # File lib/dm-validations/validators/generic_validator.rb, line 99
 99:       def evaluate_conditional_clause(target, clause)
100:         if clause.kind_of?(Symbol)
101:           target.__send__(clause)
102:         elsif clause.respond_to?(:call)
103:           clause.call(target)
104:         end
105:       end
execute?(target) click to toggle source

Determines if this validator should be run against the target by evaluating the :if and :unless clauses optionally passed while specifying any validator.

@param [Object] target

  The resource that we check against.

@return [Boolean]

  true if should be run, otherwise false.

@api private

    # File lib/dm-validations/validators/generic_validator.rb, line 88
88:       def execute?(target)
89:         if unless_clause = self.unless_clause
90:           !evaluate_conditional_clause(target, unless_clause)
91:         elsif if_clause = self.if_clause
92:           evaluate_conditional_clause(target, if_clause)
93:         else
94:           true
95:         end
96:       end
inspect() click to toggle source
     # File lib/dm-validations/validators/generic_validator.rb, line 161
161:       def inspect
162:         "<##{self.class.name} @field_name='#{@field_name}' @if_clause=#{@if_clause.inspect} @unless_clause=#{@unless_clause.inspect} @options=#{@options.inspect}>"
163:       end
Also aliased as: to_s
optional?(value) click to toggle source

Test the value to see if it is blank or nil, and if it is allowed. Note that allowing blank without explicitly denying nil allows nil values, since nil.blank? is true.

@param [Object] value

  The value to test.

@return [Boolean]

  true if blank/nil is allowed, and the value is blank/nil.

@api private

     # File lib/dm-validations/validators/generic_validator.rb, line 129
129:       def optional?(value)
130:         if value.nil?
131:           @options[:allow_nil] ||
132:             (@options[:allow_blank] && !@options.has_key?(:allow_nil))
133:         elsif DataMapper::Ext.blank?(value)
134:           @options[:allow_blank]
135:         end
136:       end
set_optional_by_default(default = true) click to toggle source

Set the default value for allow_nil and allow_blank

@param [Boolean] default value

@api private

     # File lib/dm-validations/validators/generic_validator.rb, line 112
112:       def set_optional_by_default(default = true)
113:         [ :allow_nil, :allow_blank ].each do |key|
114:           @options[key] = true unless options.key?(key)
115:         end
116:       end
to_s() click to toggle source
Alias for: inspect

Private Instance Methods

get_resource_property(resource, property_name) click to toggle source

Get the corresponding Resource property, if it exists.

Note: DataMapper validations can be used on non-DataMapper resources. In such cases, the return value will be nil.

@api private

     # File lib/dm-validations/validators/generic_validator.rb, line 175
175:       def get_resource_property(resource, property_name)
176:         model = resource.model if resource.respond_to?(:model)
177:         repository = resource.repository               if model
178:         properties = model.properties(repository.name) if model
179:         properties[property_name]                      if properties
180:       end

Disabled; run with --debug to generate this.

[Validate]

Generated with the Darkfish Rdoc Generator 1.1.6.