Class: Dry::Validation::Evaluator

Inherits:
Object
  • Object
show all
Extended by:
Initializer
Defined in:
lib/dry/validation/evaluator.rb

Overview

Evaluator is the execution context for rules

Evaluators expose an API for setting failure messages and forward method calls to the contracts, so that you can use your contract methods within rule blocks

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(contract, options, &block) ⇒ Evaluator

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Initialize a new evaluator



66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
 
# File 'lib/dry/validation/evaluator.rb', line 66

def initialize(contract, options, &block)
  super(contract, options)

  @_options = options

  if block
    exec_opts = block_options.map { |key, value| [key, _options[value]] }.to_h
    instance_exec(exec_opts, &block)
  end

  macros.each do |args|
    macro = macro(*args.flatten(1))
    instance_exec(macro.extract_block_options(_options.merge(macro: macro)), &macro.block)
  end
end

Dynamic Method Handling

This class handles dynamic methods through the method_missing method

#method_missing(meth, *args, &block) ⇒ Object (private)

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Forward to the underlying contract



187
188
189
190
191
192
193
194
 
# File 'lib/dry/validation/evaluator.rb', line 187

def method_missing(meth, *args, &block)
  # yes, we do want to delegate to private methods too
  if _contract.respond_to?(meth, true)
    _contract.__send__(meth, *args, &block)
  else
    super
  end
end

Instance Attribute Details

#_context ⇒ Concurrent::Map (readonly)

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Returns:

  • (Concurrent::Map) 


43
 
# File 'lib/dry/validation/evaluator.rb', line 43

option :_context

#_contract ⇒ Contract (readonly)

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Returns:



23
 
# File 'lib/dry/validation/evaluator.rb', line 23

param :_contract

#_options ⇒ Hash (readonly)

Returns:

  • (Hash) 


61
62
63
 
# File 'lib/dry/validation/evaluator.rb', line 61

def _options
  @_options
end

#block_options ⇒ Hash<Symbol=>Symbol> (readonly)

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Returns:

  • (Hash<Symbol=>Symbol>) 


58
 
# File 'lib/dry/validation/evaluator.rb', line 58

option :block_options, default: proc { EMPTY_HASH }

#keys ⇒ Array<String, Symbol, Hash> (readonly)

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Returns:

  • (Array<String, Symbol, Hash>) 


33
 
# File 'lib/dry/validation/evaluator.rb', line 33

option :keys

#macros ⇒ Array<Symbol> (readonly)

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Returns:

  • (Array<Symbol>) 


38
 
# File 'lib/dry/validation/evaluator.rb', line 38

option :macros, optional: true, default: proc { EMPTY_ARRAY.dup }

#path ⇒ Dry::Schema::Path (readonly)

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Returns:

  • (Dry::Schema::Path) 


48
 
# File 'lib/dry/validation/evaluator.rb', line 48

option :path, default: proc { Dry::Schema::Path[(key = keys.first) ? key : ROOT_PATH] }

#result ⇒ Result (readonly)

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Returns:



28
 
# File 'lib/dry/validation/evaluator.rb', line 28

option :result

#values ⇒ Object (readonly)

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Returns:

  • (Object) 


53
 
# File 'lib/dry/validation/evaluator.rb', line 53

option :values

Instance Method Details

#base ⇒ Failures

Get ‘Failures` object for base errors

Returns:

See Also:



102
103
104
 
# File 'lib/dry/validation/evaluator.rb', line 102

def base
  @base ||= Failures.new
end

#error?(path) ⇒ Boolean

Check if there are any errors under the provided path

Parameters:

  • A (Symbol, String, Array) —

    Path-compatible spec

Returns:

  • (Boolean) 


173
174
175
 
# File 'lib/dry/validation/evaluator.rb', line 173

def error?(path)
  result.error?(path)
end

#failures ⇒ Array<Hash>

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Return aggregated failures

Returns:

  • (Array<Hash>) 


111
112
113
114
115
116
 
# File 'lib/dry/validation/evaluator.rb', line 111

def failures
  @failures ||= []
  @failures += @base.opts if defined?(@base)
  @failures.concat(@key.values.flat_map(&:opts)) if defined?(@key)
  @failures
end

#key(path = self.path) ⇒ Failures

Get ‘Failures` object for the default or provided path

Parameters:

  • path (Symbol, String, Hash, Array<Symbol>) (defaults to: self.path)

Returns:

See Also:



91
92
93
 
# File 'lib/dry/validation/evaluator.rb', line 91

def key(path = self.path)
  (@key ||= EMPTY_HASH.dup)[path] ||= Failures.new(path)
end

#key? ⇒ Boolean

Return if the value under the default key is available

This is useful when dealing with rules for optional keys

Examples:

rule(:age) do
  key.failure(:invalid) if key? && value < 18
end

Returns:

  • (Boolean) 


162
163
164
 
# File 'lib/dry/validation/evaluator.rb', line 162

def key?
  values.key?(key_name)
end

#key_name ⇒ Symbol

Return default (first) key name

Returns:

  • (Symbol) 


128
129
130
 
# File 'lib/dry/validation/evaluator.rb', line 128

def key_name
  @key_name ||= keys.first
end

#respond_to_missing?(meth, include_private = false) ⇒ Boolean

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Returns:

  • (Boolean) 


178
179
180
 
# File 'lib/dry/validation/evaluator.rb', line 178

def respond_to_missing?(meth, include_private = false)
  super || _contract.respond_to?(meth, true)
end

#value ⇒ Object

Return the value found under the first specified key

This is a convenient method that can be used in all the common cases where a rule depends on just one key and you want a quick access to the value

Examples:

rule(:age) do
  key.failure(:invalid) if value < 18
end

Returns:

  • (Object) 


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

def value
  values[key_name]
end

#with(new_opts, &block) ⇒ Object

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future. 



119
120
121
 
# File 'lib/dry/validation/evaluator.rb', line 119

def with(new_opts, &block)
  self.class.new(_contract, _options.merge(new_opts), &block)
end