Class: CouchRest::Validation::GenericValidator

Inherits:
Object
  • Object
show all
Defined in:
lib/couchrest/validation/validators/generic_validator.rb

Overview

All validators extend this base class. Validators must:

  • Implement the initialize method to capture its parameters, also calling super to have this parent class capture the optional, general :if and :unless parameters.

  • Implement the call method, returning true or false. The call method provides the validation logic.

Author:

  • Guy van den Berg

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(field, opts = {}) ⇒ GenericValidator

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

All additional key/value pairs are passed through to the validator that is sub-classing this GenericValidator

Parameters:

  • field (String, Symbol) —

    The property specified for validation

  • :if<Symbol, (Hash) —

    a customizable set of options

  • :unless<Symbol, (Hash) —

    a customizable set of options



54
55
56
57
 
# File 'lib/couchrest/validation/validators/generic_validator.rb', line 54

def initialize(field, opts = {})
  @if_clause     = opts.delete(:if)
  @unless_clause = opts.delete(:unless)
end

Instance Attribute Details

#field_name ⇒ Object (readonly)

Returns the value of attribute field_name.



41
42
43
 
# File 'lib/couchrest/validation/validators/generic_validator.rb', line 41

def field_name
  @field_name
end

#if_clause ⇒ Object

Returns the value of attribute if_clause.



40
41
42
 
# File 'lib/couchrest/validation/validators/generic_validator.rb', line 40

def if_clause
  @if_clause
end

#unless_clause ⇒ Object

Returns the value of attribute unless_clause.



40
41
42
 
# File 'lib/couchrest/validation/validators/generic_validator.rb', line 40

def unless_clause
  @unless_clause
end

Instance Method Details

#==(other) ⇒ Object 



109
110
111
112
113
114
115
116
 
# File 'lib/couchrest/validation/validators/generic_validator.rb', line 109

def ==(other)
  self.class == other.class &&
  self.field_name == other.field_name &&
  self.class == other.class &&
  self.if_clause == other.if_clause &&
  self.unless_clause == other.unless_clause &&
  self.instance_variable_get(:@options) == other.instance_variable_get(:@options)
end

#add_error(target, message, field_name = :general) ⇒ Object

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.

TODO - should the field_name for a general message be :default???

Parameters:

  • target (Object) —

    the resource that has the error

  • message (String) —

    the message to add

  • field_name (Symbol) (defaults to: :general) —

    the name of the field that caused the error



69
70
71
 
# File 'lib/couchrest/validation/validators/generic_validator.rb', line 69

def add_error(target, message, field_name = :general)
  target.errors.add(field_name, message)
end

#call(target) ⇒ Boolean

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

Parameters:

  • target (Object) —

    the resource that the validator must be called against

Returns:

  • (Boolean) —

    true if valid, otherwise false

Raises:

  • (NotImplementedError) 


79
80
81
 
# File 'lib/couchrest/validation/validators/generic_validator.rb', line 79

def call(target)
  raise NotImplementedError, "CouchRest::Validation::GenericValidator::call must be overriden in a subclass"
end

#execute?(target) ⇒ Boolean

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

Parameters:

  • target (Object) —

    the resource that we check against

Returns:

  • (Boolean) —

    true if should be run, otherwise false



89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
 
# File 'lib/couchrest/validation/validators/generic_validator.rb', line 89

def execute?(target)
  if unless_clause = self.unless_clause
    if unless_clause.is_a?(Symbol)
      return false if target.send(unless_clause)
    elsif unless_clause.respond_to?(:call)
      return false if unless_clause.call(target)
    end
  end

  if if_clause = self.if_clause
    if if_clause.is_a?(Symbol)
      return target.send(if_clause)
    elsif if_clause.respond_to?(:call)
      return if_clause.call(target)
    end
  end

  true
end