Class: Karafka::Core::Contractable::Contract

Inherits:
Object
  • Object
show all
Extended by:
Karafka::Core::Configurable
Defined in:
lib/karafka/core/contractable/contract.rb

Overview

Note:

This contract does NOT support rules inheritance as it was never needed in Karafka

Base contract for all the contracts that check data format

Class Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Methods included from Karafka::Core::Configurable

extended, included

Class Attribute Details

.rules ⇒ Array<Rule> (readonly)

Returns all the validation rules defined for a given contract.

Returns:

  • (Array<Rule>) —

    all the validation rules defined for a given contract


25
26
27
 
# File 'lib/karafka/core/contractable/contract.rb', line 25

def rules
  @rules
end

Class Method Details

.nested(path, &block) ⇒ Object

Allows for definition of a scope/namespace for nested validations

Examples:

nested(:key) do
  required(:inside) { |inside| inside.is_a?(String) }
end

Parameters:

  • path (Symbol) —

    path in the hash for nesting

  • block (Proc) —

    nested rule code or more nestings inside

[View source]

36
37
38
39
40
41
 
# File 'lib/karafka/core/contractable/contract.rb', line 36

def nested(path, &block)
  init_accu
  @nested << path
  instance_eval(&block)
  @nested.pop
end

.optional(*keys, &block) ⇒ Object

Parameters:

  • keys (Array<Symbol>) —

    single or full path

  • block (Proc) —

    validation rule

[View source]

55
56
57
58
 
# File 'lib/karafka/core/contractable/contract.rb', line 55

def optional(*keys, &block)
  init_accu
  @rules << Rule.new(@nested + keys, :optional, block).freeze
end

.required(*keys, &block) ⇒ Object

Defines a rule for a required field (required means, that will automatically create an error if missing)

Parameters:

  • keys (Array<Symbol>) —

    single or full path

  • block (Proc) —

    validation rule

[View source]

48
49
50
51
 
# File 'lib/karafka/core/contractable/contract.rb', line 48

def required(*keys, &block)
  init_accu
  @rules << Rule.new(@nested + keys, :required, block).freeze
end

.virtual(&block) ⇒ Object

Note:

Virtual rules have different result expectations. Please see contracts or specs for details.

Parameters:

  • block (Proc) —

    validation rule

[View source]

64
65
66
67
 
# File 'lib/karafka/core/contractable/contract.rb', line 64

def virtual(&block)
  init_accu
  @rules << Rule.new([], :virtual, block).freeze
end

Instance Method Details

#call(data) ⇒ Result

Runs the validation

Parameters:

  • data (Hash) —

    hash with data we want to validate

Returns:

  • (Result) —

    validaton result

[View source]

82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
 
# File 'lib/karafka/core/contractable/contract.rb', line 82

def call(data)
  errors = []

  self.class.rules.each do |rule|
    case rule.type
    when :required
      validate_required(data, rule, errors)
    when :optional
      validate_optional(data, rule, errors)
    when :virtual
      validate_virtual(data, rule, errors)
    end
  end

  Result.new(errors, self)
end

#validate!(data, error_class) ⇒ Boolean

Returns true.

Parameters:

  • data (Hash) —

    data for validation

  • error_class (Class) —

    error class that should be used when validation fails

Returns:

  • (Boolean) —

    true

Raises:

  • (StandardError) —

    any error provided in the error_class that inherits from the standard error

[View source]

104
105
106
107
108
109
110
 
# File 'lib/karafka/core/contractable/contract.rb', line 104

def validate!(data, error_class)
  result = call(data)

  return true if result.success?

  raise error_class, result.errors
end