reflekt 1.0.9 → 1.0.10

data/lib/rule.rb

@@ -12,43 +12,43 @@
 ################################################################################
 
 module Reflekt
-class Rule
+  class Rule
 
-  attr_reader :type
+    attr_reader :type
 
-  ##
-  # Each rule trains on metadata to determine its boundaries.
-  #
-  # @param meta [Meta]
-  ##
-  def train(meta)
-  end
+    ##
+    # Each rule trains on metadata to determine its boundaries.
+    #
+    # @param meta [Meta]
+    ##
+    def train(meta)
+    end
 
-  ##
-  # Each rule validates a value with its boundaries.
-  #
-  # @param value [Dynamic]
-  # @return [Boolean] Whether the value passes or fails.
-  ##
-  def test(value)
-  end
+    ##
+    # Each rule validates a value with its boundaries.
+    #
+    # @param value [Dynamic]
+    # @return [Boolean] Whether the value passes or fails.
+    ##
+    def test(value)
+    end
 
-  ##
-  # Each rule provides results.
-  #
-  # @return [Hash]
-  ##
-  def result()
-    {}
-  end
+    ##
+    # Each rule provides results.
+    #
+    # @return [Hash]
+    ##
+    def result()
+      {}
+    end
 
-  ##
-  # Each rule provides a random example that matches the rule's boundaries.
-  #
-  # @return [Dynamic] A random value.
-  ##
-  def random()
-  end
+    ##
+    # Each rule provides a random example that matches the rule's boundaries.
+    #
+    # @return [Dynamic] A random value.
+    ##
+    def random()
+    end
 
-end
+  end
 end

data/lib/rule_set.rb

@@ -16,96 +16,95 @@ require_relative 'meta_builder'
 require_relative 'meta/null_meta.rb'
 
 module Reflekt
-class RuleSet
+  class RuleSet
 
-  attr_accessor :rules
+    attr_accessor :rules
 
-  ##
-  # @param meta_map [Hash] The rules to apply to each data type.
-  ##
-  def initialize(meta_map)
+    ##
+    # @param meta_map [Hash] The rules to apply to each data type.
+    ##
+    def initialize(meta_map)
 
-    # The rules that apply to meta types.
-    @meta_map = meta_map
+      # The rules that apply to meta types.
+      @meta_map = meta_map
 
-    # The types of meta this rule set applies to.
-    # Rules are only validated on their supported meta type.
-    @meta_types = Set.new()
+      # The types of meta this rule set applies to.
+      # Rules are only validated on their supported meta type.
+      @meta_types = Set.new()
 
-    @rules = {}
+      @rules = {}
 
-  end
+    end
 
-  ##
-  # Train rule set on metadata.
-  #
-  # @param meta [Hash] The metadata to train on.
-  ##
-  def train(meta)
+    ##
+    # Train rule set on metadata.
+    #
+    # @param meta [Hash] The metadata to train on.
+    ##
+    def train(meta)
 
-    # Track supported meta types.
-    meta_type = meta[:type]
-    @meta_types << meta_type
+      # Track supported meta types.
+      meta_type = meta[:type]
+      @meta_types << meta_type
 
-    # Get rule types for this meta type.
-    if @meta_map.key? meta_type
-      @meta_map[meta_type].each do |rule_type|
+      # Get rule types for this meta type.
+      if @meta_map.key? meta_type
+        @meta_map[meta_type].each do |rule_type|
 
-        # Ensure rule exists.
-        if @rules[rule_type].nil?
-          @rules[rule_type] = rule_type.new()
-        end
+          # Ensure rule exists.
+          if @rules[rule_type].nil?
+            @rules[rule_type] = rule_type.new()
+          end
 
-        # Train rule.
-        @rules[rule_type].train(meta)
+          # Train rule.
+          @rules[rule_type].train(meta)
 
+        end
       end
-    end
 
-  end
+    end
 
-  ##
-  # @param value [Dynamic]
-  ##
-  def test(value)
+    ##
+    # @param value [Dynamic]
+    ##
+    def test(value)
 
-    result = true
-    meta_type = MetaBuilder.data_type_to_meta_type(value)
+      result = true
+      meta_type = MetaBuilder.data_type_to_meta_type(value)
 
-    # Fail if value's meta type not testable by rule set.
-    unless @meta_types.include? meta_type
-      return false
-    end
+      # Fail if value's meta type not testable by rule set.
+      unless @meta_types.include? meta_type
+        return false
+      end
 
-    @rules.each do |klass, rule|
-      if (rule.type == meta_type)
-        unless rule.test(value)
-           result = false
+      @rules.each do |klass, rule|
+        if (rule.type == meta_type)
+          unless rule.test(value)
+             result = false
+          end
         end
       end
-    end
-
-    return result
 
-  end
+      return result
 
-  ##
-  # Get the results of the rules.
-  #
-  # @return [Array] The rules.
-  ##
-  def result()
+    end
+  
+    ##
+    # Get the results of the rules.
+    #
+    # @return [Array] The rules.
+    ##
+    def result()
+
+      rules = {}
+
+      @rules.each do |key, rule|
+        rules[rule.class] = rule.result()
+      end
 
-    rules = {}
+      return rules
 
-    @rules.each do |key, rule|
-      rules[rule.class] = rule.result()
     end
 
-    return rules
-
   end
-
-
-end
 end

data/lib/rule_set_aggregator.rb

@@ -13,250 +13,248 @@
 require_relative 'rule_set'
 
 module Reflekt
-class RuleSetAggregator
-
-  ##
-  # @param meta_map [Hash] The rules that apply to each meta type.
-  ##
-  def initialize(meta_map)
+  class RuleSetAggregator
+
+    ##
+    # @param meta_map [Hash] The rules that apply to each meta type.
+    ##
+    def initialize(meta_map)
+      @meta_map = meta_map
+      # Key rule sets by class and method.
+      @rule_sets = {}
+    end
 
-    @meta_map = meta_map
-    # Key rule sets by class and method.
-    @rule_sets = {}
+    ##
+    # Create aggregated rule sets from control metadata.
+    #
+    # @stage Called on setup.
+    # @param controls [Array] Controls with metadata.
+    # @TODO Revert string keys to symbols once "Fix Rowdb.get(path)" bug fixed.
+    ##
+    def train(controls)
+
+      # On first use there are no previous controls.
+      return if controls.nil?
+
+      controls.each do |control|
+
+        klass = control["class"].to_sym
+        method = control["method"].to_sym
+
+        ##
+        # INPUT
+        ##
+
+        # Singular null input.
+        if control["inputs"].nil?
+          train_input(klass, method, nil, 0)
+        # Multiple inputs.
+        else
+          control["inputs"].each_with_index do |meta, arg_num|
+            train_input(klass, method, meta, arg_num)
+          end
+        end
 
-  end
+        ##
+        # OUTPUT
+        ##
 
-  ##
-  # Create aggregated rule sets from control metadata.
-  #
-  # @stage Called on setup.
-  # @param controls [Array] Controls with metadata.
-  # @TODO Revert string keys to symbols once "Fix Rowdb.get(path)" bug fixed.
-  ##
-  def train(controls)
-
-    # On first use there are no previous controls.
-    return if controls.nil?
-
-    controls.each do |control|
-
-      klass = control["class"].to_sym
-      method = control["method"].to_sym
-
-      ##
-      # INPUT
-      ##
-
-      # Singular null input.
-      if control["inputs"].nil?
-        train_input(klass, method, nil, 0)
-      # Multiple inputs.
-      else
-        control["inputs"].each_with_index do |meta, arg_num|
-          train_input(klass, method, meta, arg_num)
+        # 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
-      end
 
-      ##
-      # OUTPUT
-      ##
+        # Train on metadata.
+        output_rule_set.train(Meta.deserialize(control["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(Meta.deserialize(control["output"]))
-
     end
 
-  end
+    def train_input(klass, method, meta, arg_num)
 
-  def train_input(klass, method, meta, arg_num)
+      # Get deserialized meta.
+      meta = Meta.deserialize(meta)
+
+      # 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
 
-    # Get deserialized meta.
-    meta = Meta.deserialize(meta)
+      # Train on metadata.
+      rule_set.train(meta)
 
-    # 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
+    ##
+    # Validate inputs.
+    #
+    # @stage Called when validating a control reflection.
+    # @param inputs [Array] The method's arguments.
+    # @param input_rule_sets [Array] The RuleSets to validate each input with.
+    ##
+    def test_inputs(inputs, input_rule_sets)
 
-  ##
-  # Validate inputs.
-  #
-  # @stage Called when validating a control reflection.
-  # @param inputs [Array] The method's arguments.
-  # @param input_rule_sets [Array] The RuleSets to validate each input with.
-  ##
-  def test_inputs(inputs, input_rule_sets)
+      # Default result to PASS.
+      result = true
 
-    # Default result to PASS.
-    result = true
+      # Validate each argument against each rule set for that argument.
+      inputs.each_with_index do |input, arg_num|
 
-    # Validate each argument against each rule set for that argument.
-    inputs.each_with_index do |input, arg_num|
+        unless input_rule_sets[arg_num].nil?
 
-      unless input_rule_sets[arg_num].nil?
+          rule_set = input_rule_sets[arg_num]
 
-        rule_set = input_rule_sets[arg_num]
+          unless rule_set.test(input)
+            result = false
+          end
 
-        unless rule_set.test(input)
-          result = false
         end
-
       end
-    end
 
-    return result
+      return result
 
-  end
+    end
 
-  ##
-  # Validate output.
-  #
-  # @stage Called when validating a reflection.
-  # @param output [Dynamic] The method's return value.
-  # @param output_rule_set [RuleSet] The RuleSet to validate the output with.
-  ##
-  def test_output(output, output_rule_set)
+    ##
+    # Validate output.
+    #
+    # @stage Called when validating a reflection.
+    # @param output [Dynamic] The method's return value.
+    # @param output_rule_set [RuleSet] The rule set to validate the output with.
+    ##
+    def test_output(output, output_rule_set)
 
-    # Default to a PASS result.
-    result = true
+      # Default to a PASS result.
+      result = true
 
-    unless output_rule_set.nil?
+      unless output_rule_set.nil?
+
+        # Validate output rule set for that argument.
+        unless output_rule_set.test(output)
+          result = false
+        end
 
-      # Validate output RuleSet for that argument.
-      unless output_rule_set.test(output)
-        result = false
       end
 
-    end
+      return result
 
-    return result
+    end
 
-  end
+    ##
+    # Get aggregated RuleSets for all inputs.
+    #
+    # @stage Called when building a reflection.
+    # @param klass [Symbol]
+    # @param method [Symbol]
+    # @return [Array]
+    ##
+    def get_input_rule_sets(klass, method)
+      @rule_sets.dig(klass, method, :inputs)
+    end
 
-  ##
-  # Get aggregated RuleSets for all inputs.
-  #
-  # @stage Called when building a reflection.
-  # @param klass [Symbol]
-  # @param method [Symbol]
-  # @return [Array]
-  ##
-  def get_input_rule_sets(klass, method)
-    @rule_sets.dig(klass, method, :inputs)
-  end
+    ##
+    # Get an aggregated RuleSet for an output.
+    #
+    # @stage Called when building a reflection.
+    # @param klass [Symbol]
+    # @param method [Symbol]
+    # @return [RuleSet]
+    ##
+    def get_output_rule_set(klass, method)
+      @rule_sets.dig(klass, method, :output)
+    end
 
-  ##
-  # Get an aggregated RuleSet for an output.
-  #
-  # @stage Called when building a reflection.
-  # @param klass [Symbol]
-  # @param method [Symbol]
-  # @return [RuleSet]
-  ##
-  def get_output_rule_set(klass, method)
-    @rule_sets.dig(klass, method, :output)
-  end
+    ##
+    # Get the base rule type for a data type.
+    ##
+    def self.value_to_rule_type(value)
 
-  ##
-  # Get the base rule type for a data type.
-  ##
-  def self.value_to_rule_type(value)
+      data_type = value.class
 
-    data_type = value.class
+      rule_types = {
+        Array      => ArrayRule,
+        TrueClass  => BooleanRule,
+        FalseClass => BooleanRule,
+        Float      => FloatRule,
+        Integer    => IntegerRule,
+        NilClass   => NullRule,
+        String     => StringRule
+      }
 
-    rule_types = {
-      Array      => ArrayRule,
-      TrueClass  => BooleanRule,
-      FalseClass => BooleanRule,
-      Float      => FloatRule,
-      Integer    => IntegerRule,
-      NilClass   => NullRule,
-      String     => StringRule
-    }
+      return rule_types[data_type]
 
-    return rule_types[data_type]
+    end
 
-  end
+    def self.testable?(args, input_rule_sets)
 
-  def self.testable?(args, input_rule_sets)
+      args.each_with_index do |arg, arg_num|
 
-    args.each_with_index do |arg, arg_num|
+        rule_type = value_to_rule_type(arg)
+        if input_rule_sets[arg_num].rules[rule_type].nil?
+          return false
+        end
 
-      rule_type = value_to_rule_type(arg)
-      if input_rule_sets[arg_num].rules[rule_type].nil?
-        return false
       end
 
-    end
+      return true
 
-    return true
+    end
 
-  end
+    ##############################################################################
+    # HELPERS
+    ##############################################################################
+
+    private
+
+    ##
+    # Get an aggregated RuleSet for an input.
+    #
+    # @param klass [Symbol]
+    # @param method [Symbol]
+    # @return [RuleSet]
+    ##
+    def get_input_rule_set(klass, method, arg_num)
+      @rule_sets.dig(klass, method, :inputs, arg_num)
+    end
 
-  ##############################################################################
-  # HELPERS
-  ##############################################################################
-
-  private
-
-  ##
-  # Get an aggregated RuleSet for an input.
-  #
-  # @param klass [Symbol]
-  # @param method [Symbol]
-  # @return [RuleSet]
-  ##
-  def get_input_rule_set(klass, method, arg_num)
-    @rule_sets.dig(klass, method, :inputs, arg_num)
-  end
+    ##
+    # Set an aggregated RuleSet for an input.
+    #
+    # @param klass [Symbol]
+    # @param method [Symbol]
+    ##
+    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
 
-  ##
-  # Set an aggregated RuleSet for an input.
-  #
-  # @param klass [Symbol]
-  # @param method [Symbol]
-  ##
-  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
 
-  end
+    ##
+    # Set an aggregated RuleSet for an output.
+    #
+    # @param klass [Symbol]
+    # @param method [Symbol]
+    # @param rule_set [RuleSet]
+    ##
+    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
 
-  ##
-  # Set an aggregated RuleSet for an output.
-  #
-  # @param klass [Symbol]
-  # @param method [Symbol]
-  # @param rule_set [RuleSet]
-  ##
-  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
 
   end
-
-end
 end