Class: Aggregator

Inherits:
Object
  • Object
show all
Defined in:
lib/Aggregator.rb

Instance Method Summary collapse

Constructor Details

#initialize(meta_map) ⇒ Aggregator

Returns a new instance of Aggregator.

Parameters:

  • meta_map (Hash) —

    The rules that apply to each meta type.



20
21
22
23
24
25
26
 
# File 'lib/Aggregator.rb', line 20

def initialize(meta_map)

  @meta_map = meta_map
  # Key rule sets by class and method.
  @rule_sets = {}

end

Instance Method Details

#get_input_rule_set(klass, method, arg_num) ⇒ RuleSet

Get an aggregated RuleSet for an input.

Parameters:

  • klass (Symbol)
  • method (Symbol)

Returns:



46
47
48
 
# File 'lib/Aggregator.rb', line 46

def get_input_rule_set(klass, method, arg_num)
  @rule_sets.dig(klass, method, :inputs, arg_num)
end

#get_input_rule_sets(klass, method) ⇒ Array

Get aggregated RuleSets for all inputs.

Parameters:

  • klass (Symbol)
  • method (Symbol)

Returns:

  • (Array) 


35
36
37
 
# File 'lib/Aggregator.rb', line 35

def get_input_rule_sets(klass, method)
  return @rule_sets.dig(klass, method, :inputs)
end

#get_output_rule_set(klass, method) ⇒ RuleSet

Get an aggregated RuleSet for an output.

Parameters:

  • klass (Symbol)
  • method (Symbol)

Returns:



57
58
59
 
# File 'lib/Aggregator.rb', line 57

def get_output_rule_set(klass, method)
  @rule_sets.dig(klass, method, :output)
end

#set_input_rule_set(klass, method, arg_num, rule_set) ⇒ Object

Set an aggregated RuleSet for an input.

Parameters:

  • klass (Symbol)
  • method (Symbol) 


67
68
69
70
71
72
73
74
 
# File 'lib/Aggregator.rb', line 67

def set_input_rule_set(klass, method, arg_num, rule_set)
  # Set defaults.
  @rule_sets[klass] = {} unless @rule_sets.key? klass
  @rule_sets[klass][method] = {} unless @rule_sets[klass].key? method
  @rule_sets[klass][method][:inputs] = [] unless @rule_sets[klass][method].key? :inputs
  # Set value.
  @rule_sets[klass][method][:inputs][arg_num] = rule_set
end

#set_output_rule_set(klass, method, rule_set) ⇒ Object

Set an aggregated RuleSet for an output.

Parameters:

  • klass (Symbol)
  • method (Symbol)
  • rule_set (RuleSet) 


83
84
85
86
87
88
89
 
# File 'lib/Aggregator.rb', line 83

def set_output_rule_set(klass, method, rule_set)
  # Set defaults.
  @rule_sets[klass] = {} unless @rule_sets.key? klass
  @rule_sets[klass][method] = {} unless @rule_sets[klass].key? method
  # Set value.
  @rule_sets[klass][method][:output] = rule_set
end

#train(reflections) ⇒ Object

Create aggregated rule sets from reflection metadata.

Parameters:

  • reflections (Array) —

    Controls with metadata.



96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
 
# File 'lib/Aggregator.rb', line 96

def train(reflections)

  # On first use there are no previous reflections.
  return if reflections.nil?

  reflections.each do |reflection|

    klass = reflection[:class]
    method = reflection[:method]

    ##
    # INPUT
    ##

    unless reflection[:inputs].nil?
      reflection[:inputs].each_with_index do |meta, arg_num|

        # Get rule set.
        rule_set = get_input_rule_set(klass, method, arg_num)
        if rule_set.nil?
          rule_set = RuleSet.new(@meta_map)
          set_input_rule_set(klass, method, arg_num, rule_set)
        end

        # Train on metadata.
        rule_set.train(meta)

      end
    end

    ##
    # OUTPUT
    ##

    # Get rule set.
    output_rule_set = get_output_rule_set(klass, method)
    if output_rule_set.nil?
      output_rule_set = RuleSet.new(@meta_map)
      set_output_rule_set(klass, method, output_rule_set)
    end

    # Train on metadata.
    output_rule_set.train(reflection[:output])

  end

end

#validate_inputs(inputs, input_rule_sets) ⇒ Object

Validate inputs.

Parameters:

  • inputs (Array) —

    The method’s arguments.

  • input_rule_sets (Array) —

    The RuleSets to validate each input with.



150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
 
# File 'lib/Aggregator.rb', line 150

def validate_inputs(inputs, input_rule_sets)

  # Default to a PASS result.
  result = true

  # Validate each argument against each RuleSet for that argument.
  inputs.each_with_index do |input, arg_num|

    unless input_rule_sets[arg_num].nil?

      rule_set = input_rule_sets[arg_num]

      unless rule_set.validate_rule(input)
        result = false
      end

    end
  end

  return result

end

#validate_output(output, output_rule_set) ⇒ Object

Validate output.

Parameters:

  • output (Dynamic) —

    The method’s return value.

  • output_rule_set (RuleSet) —

    The RuleSet to validate the output with.



179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
 
# File 'lib/Aggregator.rb', line 179

def validate_output(output, output_rule_set)

  # Default to a PASS result.
  result = true

  unless output_rule_set.nil?

    # Validate output RuleSet for that argument.
    unless output_rule_set.validate_rule(output)
      result = false
    end

  end

  return result

end