reflekt 1.0.5 → 1.0.10

data/lib/rule_set_aggregator.rb

@@ -0,0 +1,260 @@
+################################################################################
+# Aggregate control metadata into rule sets.
+# Validate reflections against aggregated controls.
+#
+# @pattern Singleton
+#
+# @hierachy
+#   1. RuleSetAggregator <- YOU ARE HERE
+#   2. RuleSet
+#   3. Rule
+################################################################################
+
+require_relative 'rule_set'
+
+module Reflekt
+  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
+
+    ##
+    # 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
+
+        ##
+        # 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)
+
+      # 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
+
+      # 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)
+
+      # Default result to PASS.
+      result = true
+
+      # 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?
+
+          rule_set = input_rule_sets[arg_num]
+
+          unless rule_set.test(input)
+            result = false
+          end
+
+        end
+      end
+
+      return result
+
+    end
+
+    ##
+    # 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
+
+      unless output_rule_set.nil?
+
+        # Validate output rule set for that argument.
+        unless output_rule_set.test(output)
+          result = false
+        end
+
+      end
+
+      return result
+
+    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 the base rule type for a data type.
+    ##
+    def self.value_to_rule_type(value)
+
+      data_type = value.class
+
+      rule_types = {
+        Array      => ArrayRule,
+        TrueClass  => BooleanRule,
+        FalseClass => BooleanRule,
+        Float      => FloatRule,
+        Integer    => IntegerRule,
+        NilClass   => NullRule,
+        String     => StringRule
+      }
+
+      return rule_types[data_type]
+
+    end
+
+    def self.testable?(args, input_rule_sets)
+
+      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
+
+      end
+
+      return true
+
+    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
+
+    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
+
+    end
+
+  end
+end

data/lib/rules/array_rule.rb

@@ -0,0 +1,94 @@
+require_relative '../rule'
+
+module Reflekt
+  class ArrayRule < Rule
+
+    def initialize()
+      @type = :array
+      @min = nil
+      @max = nil
+      @min_length = nil
+      @max_length = nil
+    end
+
+    ##
+    # @param meta [ArrayMeta]
+    ##
+    def train(meta)
+      if Meta.numeric? meta[:min]
+        # Min value.
+        meta_min = meta[:min].to_i
+        if @min.nil?
+          @min = meta_min
+        else
+          @min = meta_min if meta_min < @min
+        end
+
+        # Max value.
+        meta_max = meta[:max].to_i
+        if @max.nil?
+          @max = meta_max
+        else
+          @max = meta_max if meta_max > @max
+        end
+      end
+
+      # Min length.
+      if @min_length.nil?
+        @min_length = meta[:length]
+      else
+        @min_length = meta[:length] if meta[:length] < @min_length
+      end
+
+      # Max length.
+      if @max_length.nil?
+        @max_length = meta[:length]
+      else
+        @max_length = meta[:length] if meta[:length] > @max_length
+      end
+    end
+
+    ##
+    # @param value [Array]
+    ##
+    def test(value)
+      # Handle empty value.
+      return true if value.empty? && @min_length == 0 && @max_length == 0
+
+      unless value.empty?
+        # Numbers only; if the value is a string then there will be no min/max.
+        unless @min.nil? || @max.nil?
+          return false if value.min() < @min
+          return false if value.max() > @max
+        end
+
+        # Min/max length.
+        return false if value.length < @min_length
+        return false if value.length > @max_length
+      end
+
+      true
+    end
+
+    def result()
+      {
+        :type => @type,
+        :min => @min,
+        :max => @max,
+        :min_length => @min_length,
+        :max_length => @max_length
+      }
+    end
+
+    def random()
+      array = Array.new(rand(@min_length..@max_length))
+
+      array.each_with_index do |item, index|
+        array[index] = rand(@min..@max)
+      end
+
+      return array
+    end
+
+  end
+end

data/lib/rules/boolean_rule.rb

@@ -0,0 +1,43 @@
+require 'set'
+require_relative '../rule'
+
+module Reflekt
+  class BooleanRule < Rule
+
+    def initialize()
+      @type = :bool
+      @booleans = Set.new()
+    end
+
+    ##
+    # @param meta [BooleanMeta]
+    ##
+    def train(meta)
+      value = meta[:value]
+
+      unless value.nil?
+        @booleans << value
+      end
+    end
+
+    ##
+    # @param value [Boolean]
+    ##
+    def test(value)
+      # Booleans are stored as strings.
+      @booleans.include? value.to_s
+    end
+
+    def result()
+      {
+        :type => @type,
+        :booleans => @booleans
+      }
+    end
+
+    def random()
+      @booleans.to_a.sample
+    end
+
+  end
+end

data/lib/rules/float_rule.rb

@@ -0,0 +1,55 @@
+require_relative '../rule'
+
+module Reflekt
+  class FloatRule < Rule
+
+    def initialize()
+      @type = :float
+      @min = nil
+      @max = nil
+    end
+
+    ##
+    # @param meta [FloatMeta]
+    ##
+    def train(meta)
+      value = meta[:value]
+
+      if @min.nil?
+        @min = value
+      else
+        @min = value if value < @min
+      end
+
+      if @max.nil?
+        @max = value
+      else
+        @max = value if value > @max
+      end
+    end
+
+    ##
+    # @param value [Float]
+    ##
+    def test(value)
+      # Numbers only; if the value is a string then there will be no min/max.
+      unless @min.nil? || @max.nil?
+        return false if value < @min
+        return false if value > @max
+      end
+    end
+
+    def result()
+      {
+        :type => @type,
+        :min => @min,
+        :max => @max
+      }
+    end
+
+    def random()
+      rand(@min..@max)
+    end
+
+  end
+end