reflekt 0.9.7 → 0.9.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6df15da98e45aecc17c3594c000b6234f77afde5ce89541104bc3afe7eb5a221
-  data.tar.gz: 3f1446eb16bdcd214d3df924d0b2df0017bc26b073c5c94e36d1094849a9b1ef
+  metadata.gz: c5b9e88d60fea03ebe06c430b489cb1295b8d56ec76f30982721a709a406f0af
+  data.tar.gz: 948f53a8b72f5befda3e175029edfdb017d98b3b8fd41998ab95b5f6b0a6b95e
 SHA512:
-  metadata.gz: e84519473c26febf3522119e66b25708abc1f05271c01b498debcb00c69eaf4b8bc244e43374737fef49e946304529c0efc2e6fceade3629c4ccef5503f1d3fa
-  data.tar.gz: 8faa3f80665504b4e5ffb182b7e9977234bd13e2f17aa5fac41636068b30ea07bfbf5aa580bee6deae2bb8e5fa6ea0ea7dc09505ce0a28bbf8797bb785aea0bb
+  metadata.gz: e70f287d10e70e3ac8ab3e01881ed6d8bb79f881c9af5530f39c7dd29997021ddf246d1129467503cfb3c6efb0589604648876c64bda917e8b970cb278a79fb3
+  data.tar.gz: ef005f855d7c3d1002eb059a73ecf742645841d4d3d0bd416a84b549e2e7d5b63a8bc216e8fe1404bf20c383a8e0a10c54740458e40382fa9591f9c67f3a075c

data/lib/Accessor.rb

@@ -1,9 +1,8 @@
 ################################################################################
-# ACCESSOR
-#
 # Access variables via one object to avoid polluting the caller class scope.
 #
-# Some variables are not accessed via Accessor:
+# @pattern Singleton
+# @note Some variables are not accessed via Accessor:
 #   - @reflekt_counts on the instance
 #   - @reflekt_enabled on the instance
 #   - @@reflekt_skipped_methods on the instance's singleton class
@@ -14,7 +13,7 @@ class Accessor
   attr_accessor :setup
   attr_accessor :db
   attr_accessor :stack
-  attr_accessor :ruler
+  attr_accessor :aggregator
   attr_accessor :renderer
   attr_accessor :path
   attr_accessor :output_path
@@ -26,7 +25,7 @@ class Accessor
     @setup = nil
     @db = nil
     @stack = nil
-    @ruler = nil
+    @aggregator = nil
     @renderer = nil
     @path = nil
     @output_path = nil

data/lib/{Ruler.rb → Aggregator.rb}

@@ -1,60 +1,64 @@
 ################################################################################
-# RULER
+# Aggregate reflection metadata into rule sets.
+# Validate reflection arguments against aggregates.
 #
-# Aggregates input/output from controls.
-# Creates and trains RuleSets from aggregated input/output.
-# Validates reflection input/output against RuleSets.
+# @pattern Singleton
+#
+# @hierachy
+#   1. Aggregator
+#   2. RuleSet
+#   3. Rule
 ################################################################################
 
 require 'RuleSet'
 
-class Ruler
+class Aggregator
 
   def initialize()
+
+    # Key rule sets by class and method.
     @rule_sets = {}
+
   end
 
   ##
-  # Get input RuleSets.
+  # Get aggregated RuleSets for all inputs.
   #
-  # @param Symbol klass
-  # @param Symbol method
-  #
-  # @return Array
+  # @param klass [Symbol]
+  # @param method [Symbol]
+  # @return [Array]
   ##
   def get_input_rule_sets(klass, method)
     return @rule_sets.dig(klass, method, :inputs)
   end
 
   ##
-  # Get input RuleSet.
-  #
-  # @param Symbol klass
-  # @param Symbol method
+  # Get an aggregated RuleSet for an input.
   #
-  # @return RuleSet
+  # @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
 
   ##
-  # Get output RuleSet.
-  #
-  # @param Symbol klass
-  # @param Symbol method
+  # Get an aggregated RuleSet for an output.
   #
-  # @return RuleSet.
+  # @param klass [Symbol]
+  # @param method [Symbol]
+  # @return [RuleSet]
   ##
   def get_output_rule_set(klass, method)
     @rule_sets.dig(klass, method, :output)
   end
 
   ##
-  # Set input RuleSet.
+  # Set an aggregated RuleSet for an input.
   #
-  # @param Symbol klass
-  # @param Symbol method
+  # @param klass [Symbol]
+  # @param method [Symbol]
   ##
   def set_input_rule_set(klass, method, arg_num, rule_set)
     # Set defaults.
@@ -66,11 +70,11 @@ class Ruler
   end
 
   ##
-  # Set output RuleSet.
+  # Set an aggregated RuleSet for an output.
   #
-  # @param Symbol klass
-  # @param Symbol method
-  # @param RuleSet rule_set
+  # @param klass [Symbol]
+  # @param method [Symbol]
+  # @param rule_set [RuleSet]
   ##
   def set_output_rule_set(klass, method, rule_set)
     # Set defaults.
@@ -81,57 +85,54 @@ class Ruler
   end
 
   ##
-  # Load RuleSets.
+  # Create aggregated rule sets from reflection metadata.
   #
-  # @param Symbol klass
-  # @param Symbol method
-  # @param Array controls
+  # @param reflections [Array] Controls with metadata.
   ##
-  def load(klass, method, controls)
+  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()
+            set_input_rule_set(klass, method, arg_num, rule_set)
+          end
 
-    # Create a RuleSet for each control's inputs/output.
-    controls.each_with_index do |control, index|
+          # Train on metadata.
+          rule_set.train(meta)
 
-      # Process inputs.
-      control[:inputs].each_with_index do |input, arg_num|
-        rule_set = get_input_rule_set(klass, method, arg_num)
-        if rule_set.nil?
-          rule_set = RuleSet.new()
-          set_input_rule_set(klass, method, arg_num, rule_set)
         end
-        rule_set.load(input[:type], input[:value])
       end
 
-      # Process output.
+      ##
+      # OUTPUT
+      ##
+
+      # Get rule set.
       output_rule_set = get_output_rule_set(klass, method)
       if output_rule_set.nil?
         output_rule_set = RuleSet.new()
         set_output_rule_set(klass, method, output_rule_set)
       end
-      output_rule_set.load(control[:output][:type], control[:output][:value])
-
-    end
-
-  end
-
-  ##
-  # Train RuleSets from controls.
-  #
-  # @param Symbol klass
-  # @param Symbol method
-  ##
-  def train(klass, method)
 
-    input_rule_sets = get_input_rule_sets(klass, method)
-    unless input_rule_sets.nil?
-      input_rule_sets.each do |input_rule_set|
-        input_rule_set.train()
-      end
-    end
+      # Train on metadata.
+      output_rule_set.train(reflection[:output])
 
-    output_rule_set = get_output_rule_set(klass, method)
-    unless output_rule_set.nil?
-      output_rule_set.train()
     end
 
   end
@@ -139,15 +140,15 @@ class Ruler
   ##
   # Validate inputs.
   #
-  # @param Array inputs - The method's arguments.
-  # @param Array input_rule_sets - The RuleSets to validate each input with.
+  # @param inputs [Array] The method's arguments.
+  # @param input_rule_sets [Array] The RuleSets to validate each input with.
   ##
   def validate_inputs(inputs, input_rule_sets)
 
     # Default to a PASS result.
     result = true
 
-    # Validate each argument against each rule set for that argument.
+    # Validate each argument against each RuleSet for that argument.
     inputs.each_with_index do |input, arg_num|
 
       unless input_rule_sets[arg_num].nil?
@@ -168,8 +169,8 @@ class Ruler
   ##
   # Validate output.
   #
-  # @param dynamic output - The method's return value.
-  # @param RuleSet output_rule_set - The RuleSet to validate the output with.
+  # @param output [Dynamic] The method's return value.
+  # @param output_rule_set [RuleSet] The RuleSet to validate the output with.
   ##
   def validate_output(output, output_rule_set)
 

data/lib/Control.rb

@@ -1,4 +1,14 @@
+################################################################################
+# A shapshot of real data.
+#
+# @hierachy
+#   1. Execution
+#   2. Control
+#   3. RuleSet
+################################################################################
+
 require 'Reflection'
+require 'MetaBuilder'
 
 class Control < Reflection
 
@@ -7,18 +17,18 @@ class Control < Reflection
   #
   # Creates a shadow execution stack.
   #
-  # @param method - The name of the method.
-  # @param *args - The method arguments.
-  #
-  # @return - A reflection hash.
+  # @param method [Symbol] The name of the method.
+  # @param *args [Args] The method arguments.
+  # @return [Hash] A reflection hash.
   ##
   def reflect(*args)
 
-    @inputs = *args
+    # Create metadata for each argument.
+    @inputs = MetaBuilder.create_many(args)
 
     # Action method with new arguments.
     begin
-      @output = @clone.send(@method, *@inputs)
+      output = @clone.send(@method, *args)
     # When fail.
     rescue StandardError => message
       @status = :fail

data/lib/Meta.rb

@@ -0,0 +1,27 @@
+################################################################################
+# Meta for input and output. All meta behave the same.
+#
+# @pattern Abstract class.
+# @see lib/meta for each meta.
+################################################################################
+
+class Meta
+
+  ##
+  # Each meta loads values.
+  #
+  # @param value [Dynamic]
+  ##
+  def load(value)
+  end
+
+  ##
+  # Each meta provides metadata.
+  #
+  # @return [Hash]
+  ##
+  def result()
+    {}
+  end
+
+end

data/lib/MetaBuilder.rb

@@ -0,0 +1,56 @@
+################################################################################
+# Create Meta.
+#
+# @pattern Builder.
+# @see lib/meta for each meta.
+################################################################################
+
+require 'Meta'
+require_relative './meta/IntegerMeta'
+require_relative './meta/StringMeta'
+
+class MetaBuilder
+
+  ##
+  # Create meta.
+  #
+  # @param value
+  ##
+  def self.create(value)
+
+    meta = nil
+
+    # Creates values for matching data type.
+    case value.class.to_s
+    when "Integer"
+      meta = IntegerMeta.new()
+    when "String"
+      meta = StringMeta.new()
+    end
+
+    unless meta.nil?
+      meta.load(value)
+    end
+
+    return meta
+
+  end
+
+  ##
+  # Create meta for multiple values.
+  #
+  # @param values
+  ##
+  def self.create_many(values)
+
+    meta = []
+
+    values.each do |value|
+      meta << self.create(value)
+    end
+
+    return meta
+
+  end
+
+end

data/lib/Reflection.rb

@@ -1,3 +1,17 @@
+################################################################################
+# A snapshot of simulated data.
+#
+# @nomenclature
+#   args/inputs/values are the same thing but at a different stage of lifecycle.
+#
+# @hierachy
+#   1. Execution
+#   2. Reflection
+#   3. RuleSet
+################################################################################
+
+require 'MetaBuilder'
+
 class Reflection
 
   attr_accessor :clone
@@ -5,24 +19,24 @@ class Reflection
   ##
   # Create a Reflection.
   #
-  # @param Execution execution - The Execution that created this Reflection.
-  # @param Integer number - Multiple Reflections can be created per Execution.
-  # @param Ruler ruler - The RuleSets for this class/method.
+  # @param execution [Execution] The Execution that created this Reflection.
+  # @param number [Integer] Multiple Reflections can be created per Execution.
+  # @param aggregator [Aggregator] The aggregated RuleSet for this class/method.
   ##
-  def initialize(execution, number, ruler)
+  def initialize(execution, number, aggregator)
 
     @execution = execution
     @unique_id = execution.unique_id + number
     @number = number
 
     # Dependency.
-    @ruler = ruler
+    @aggregator = aggregator
 
     # Caller.
     @klass = execution.klass
     @method = execution.method
 
-    # Arguments.
+    # Metadata.
     @inputs = []
     @output = nil
 
@@ -40,43 +54,37 @@ class Reflection
   # Reflect on a method.
   #
   # Creates a shadow execution stack.
-  #
-  # @param *args - The method's arguments.
-  #
-  # @return - A reflection hash.
+  # @param *args [Dynamic] The method's arguments.
   ##
   def reflect(*args)
 
-    # Get RuleSets.
-    input_rule_sets = @ruler.get_input_rule_sets(@klass, @method)
-    output_rule_set = @ruler.get_output_rule_set(@klass, @method)
+    # Get aggregated RuleSets.
+    agg_input_rule_sets = @aggregator.get_input_rule_sets(@klass, @method)
+    agg_output_rule_set = @aggregator.get_output_rule_set(@klass, @method)
 
-    # Create deviated arguments.
-    args.each do |arg|
-      case arg
-      when Integer
-        @inputs << rand(999)
-      else
-        @inputs << arg
-      end
-    end
+    # Create random arguments.
+    new_args = randomize(args)
+
+    # Create metadata for each argument.
+    @inputs = MetaBuilder.create_many(new_args)
 
     # Action method with new arguments.
     begin
 
-      # Validate input with controls.
-      unless input_rule_sets.nil?
-        unless @ruler.validate_inputs(@inputs, input_rule_sets)
+      # Validate input with aggregated control RuleSets.
+      unless agg_input_rule_sets.nil?
+        unless @aggregator.validate_inputs(new_args, agg_input_rule_sets)
           @status = :fail
         end
       end
 
       # Run reflection.
-      @output = @clone.send(@method, *@inputs)
+      output = @clone.send(@method, *new_args)
+      @output = MetaBuilder.create(output)
 
-      # Validate output with controls.
-      unless output_rule_set.nil?
-        unless @ruler.validate_output(@output, output_rule_set)
+      # Validate output with aggregated control RuleSets.
+      unless agg_output_rule_set.nil?
+        unless @aggregator.validate_output(output, agg_output_rule_set)
           @status = :fail
         end
       end
@@ -89,6 +97,34 @@ class Reflection
 
   end
 
+  ##
+  # Create random values for each argument.
+  #
+  # @param args [Dynamic] The arguments to create random values for.
+  # @return [Dynamic] Random arguments.
+  ##
+  def randomize(args)
+
+    random_args = []
+
+    args.each do |arg|
+      case arg
+      when Integer
+        random_args << rand(999)
+      else
+        random_args << arg
+      end
+    end
+
+    return random_args
+
+  end
+
+  ##
+  # Get the results of the reflection.
+  #
+  # @return [Hash] Reflection metadata.
+  ##
   def result()
 
     # The ID of the first execution in the ShadowStack.
@@ -107,66 +143,15 @@ class Reflection
       :class => @klass,
       :method => @method,
       :status => @status,
-      :input => normalize_input(@inputs),
-      :output => normalize_output(@output),
-      :message => @message
+      :message => @message,
+      :inputs => [],
+      :output => @output,
     }
-
-    return reflection
-  end
-
-  ##
-  # Normalize inputs.
-  #
-  # @param args - The actual inputs.
-  # @return - A generic inputs representation.
-  ##
-  def normalize_input(args)
-    inputs = []
-    args.each do |arg|
-      input = {
-        :type => arg.class.to_s
-      }
-      if (arg.class == Array)
-        input[:count] = arg.count
-      end
-      inputs << input
+    @inputs.each do |meta|
+      reflection[:inputs] << meta.result()
     end
-    inputs
-  end
 
-  ##
-  # Normalize output.
-  #
-  # @param input - The actual output.
-  # @return - A generic output representation.
-  ##
-  def normalize_output(arg)
-
-    input = {
-      :type => arg.class.to_s
-    }
-
-    if (arg.class == Array || arg.class == Hash)
-      input[:count] = arg.count
-    elsif (arg.class == TrueClass || arg.class == FalseClass)
-      input[:type] = :Boolean
-    end
-
-    return input
-
-  end
-
-  def normalize_value(value)
-
-    unless value.nil?
-      value = value.to_s.gsub(/\r?\n/, " ").to_s
-      if value.length >= 30
-        value = value[0, value.rindex(/\s/,30)].rstrip() + '...'
-      end
-    end
-
-    return value
+    return reflection
 
   end