reflekt 0.9.2 → 0.9.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 21ac72b1a4f8bf9bd182f1d1ae5464d11aa87ab0f38c6fa418c9a3e73ff33a5d
-  data.tar.gz: bfd3a381c930d910e3b293e835877712734eecc2a51c7949e7f4747b67377058
+  metadata.gz: c5b9e88d60fea03ebe06c430b489cb1295b8d56ec76f30982721a709a406f0af
+  data.tar.gz: 948f53a8b72f5befda3e175029edfdb017d98b3b8fd41998ab95b5f6b0a6b95e
 SHA512:
-  metadata.gz: e9b62612aa60d91bf591eae59c9797c97e9b54fdafd58d2785ed4fdfa8c7bc256cd288e13dd9e83d4fd8d11fbdbe043ce0660f6ba82878f8fd5eabb224d691b0
-  data.tar.gz: 9a38959ce057bdf3f4e7e2091f0aa6666be940e356b5865952a7e9e7749958d77f8beb68d2fd8f9a252f047bb45bccc756b3f9af793c85e3031a4f0cab541c74
+  metadata.gz: e70f287d10e70e3ac8ab3e01881ed6d8bb79f881c9af5530f39c7dd29997021ddf246d1129467503cfb3c6efb0589604648876c64bda917e8b970cb278a79fb3
+  data.tar.gz: ef005f855d7c3d1002eb059a73ecf742645841d4d3d0bd416a84b549e2e7d5b63a8bc216e8fe1404bf20c383a8e0a10c54740458e40382fa9591f9c67f3a075c

data/lib/Accessor.rb

@@ -0,0 +1,37 @@
+################################################################################
+# Access variables via one object to avoid polluting the caller class scope.
+#
+# @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
+################################################################################
+
+class Accessor
+
+  attr_accessor :setup
+  attr_accessor :db
+  attr_accessor :stack
+  attr_accessor :aggregator
+  attr_accessor :renderer
+  attr_accessor :path
+  attr_accessor :output_path
+  attr_accessor :reflect_amount
+  attr_accessor :reflect_limit
+
+  def initialize()
+
+    @setup = nil
+    @db = nil
+    @stack = nil
+    @aggregator = nil
+    @renderer = nil
+    @path = nil
+    @output_path = nil
+    @reflect_amount = nil
+    @reflect_limit = nil
+
+  end
+
+end

data/lib/Aggregator.rb

@@ -0,0 +1,193 @@
+################################################################################
+# Aggregate reflection metadata into rule sets.
+# Validate reflection arguments against aggregates.
+#
+# @pattern Singleton
+#
+# @hierachy
+#   1. Aggregator
+#   2. RuleSet
+#   3. Rule
+################################################################################
+
+require 'RuleSet'
+
+class Aggregator
+
+  def initialize()
+
+    # Key rule sets by class and method.
+    @rule_sets = {}
+
+  end
+
+  ##
+  # Get aggregated RuleSets for all inputs.
+  #
+  # @param klass [Symbol]
+  # @param method [Symbol]
+  # @return [Array]
+  ##
+  def get_input_rule_sets(klass, method)
+    return @rule_sets.dig(klass, method, :inputs)
+  end
+
+  ##
+  # 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
+
+  ##
+  # Get an aggregated RuleSet for an output.
+  #
+  # @param klass [Symbol]
+  # @param method [Symbol]
+  # @return [RuleSet]
+  ##
+  def get_output_rule_set(klass, method)
+    @rule_sets.dig(klass, method, :output)
+  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
+
+  ##
+  # Create aggregated rule sets from reflection metadata.
+  #
+  # @param reflections [Array] Controls with metadata.
+  ##
+  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
+
+          # 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()
+        set_output_rule_set(klass, method, output_rule_set)
+      end
+
+      # Train on metadata.
+      output_rule_set.train(reflection[:output])
+
+    end
+
+  end
+
+  ##
+  # Validate inputs.
+  #
+  # @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 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.
+  #
+  # @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)
+
+    # 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
+
+end

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,25 +17,25 @@ 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)
 
-    @input = *args
+    # Create metadata for each argument.
+    @inputs = MetaBuilder.create_many(args)
 
     # Action method with new arguments.
     begin
-      @output = @clone.send(@method, *@input)
+      output = @clone.send(@method, *args)
     # When fail.
     rescue StandardError => message
-      @status = FAIL
+      @status = :fail
       @message = message
     # When pass.
     else
-      @status = PASS
+      @status = :pass
     end
 
   end

data/lib/Execution.rb

@@ -1,24 +1,56 @@
 class Execution
 
-  attr_accessor :object
+  attr_accessor :unique_id
+  attr_accessor :caller_object
   attr_accessor :caller_id
   attr_accessor :caller_class
+  attr_accessor :klass
+  attr_accessor :method
+  attr_accessor :base
   attr_accessor :parent
   attr_accessor :child
   attr_accessor :control
   attr_accessor :reflections
   attr_accessor :is_reflecting
+  attr_accessor :is_base
 
-  def initialize(object, reflection_count)
+  ##
+  # Create Execution.
+  #
+  # @param Object object - The calling object.
+  # @param Symbol method - The calling method.
+  # @param Integer number - The number of reflections to create per execution.
+  # @param ShadowStack stack - The shadow execution call stack.
+  ##
+  def initialize(caller_object, method, number, stack)
 
-    @object = object
-    @caller_id = object.object_id
-    @caller_class = object.class
+    @time = Time.now.to_i
+    @unique_id = @time + rand(1..99999)
+    @base = nil
     @parent = nil
     @child = nil
 
-    @control = []
-    @reflections = Array.new(reflection_count)
+    # Dependency.
+    @stack = stack
+
+    # Caller.
+    @caller_object = caller_object
+    @caller_id = caller_object.object_id
+    @caller_class = caller_object.class
+    @klass = @caller_class.to_s.to_sym
+    @method = method
+
+    # Reflections.
+    @control = nil
+    @reflections = Array.new(number)
+
+    # State.
+    if @stack.peek() == nil
+      @is_base = true
+    else
+      @is_base = false
+      @base = @stack.base()
+    end
     @is_reflecting = false
 
   end

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,35 +1,52 @@
-class Reflection
+################################################################################
+# 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'
 
-  # Keys.
-  TIME    = "t"
-  INPUT   = "i"
-  OUTPUT  = "o"
-  TYPE    = "T"
-  COUNT   = "C"
-  VALUE   = "V"
-  STATUS  = "s"
-  MESSAGE = "m"
-  # Values.
-  PASS    = "p"
-  FAIL    = "f"
+class Reflection
 
   attr_accessor :clone
 
-  def initialize(execution, method, ruler)
+  ##
+  # Create a Reflection.
+  #
+  # @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, aggregator)
 
     @execution = execution
-    @method = method
-    @ruler = ruler
+    @unique_id = execution.unique_id + number
+    @number = number
+
+    # Dependency.
+    @aggregator = aggregator
+
+    # Caller.
+    @klass = execution.klass
+    @method = execution.method
 
-    # Clone the execution's object.
-    @clone = execution.object.clone
+    # Metadata.
+    @inputs = []
+    @output = nil
+
+    # Clone the execution's calling object.
+    @clone = execution.caller_object.clone
     @clone_id = nil
 
     # Result.
-    @status = nil
+    @status = :pass
     @time = Time.now.to_i
-    @inputs = []
-    @output = nil
 
   end
 
@@ -37,121 +54,104 @@ class Reflection
   # Reflect on a method.
   #
   # Creates a shadow execution stack.
-  #
-  # @param method - The name of the method.
-  # @param *args - The method arguments.
-  #
-  # @return - A reflection hash.
+  # @param *args [Dynamic] The method's arguments.
   ##
   def reflect(*args)
 
-    # Create deviated arguments.
-    args.each do |arg|
-      case arg
-      when Integer
-        @inputs << rand(999)
-      else
-        @inputs << arg
-      end
-    end
+    # 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 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 @ruler.nil?
-        if @ruler.validate_inputs(@execution.caller_class, @method, @inputs)
-          @status = PASS
-        else
-          @status = FAIL
+
+      # 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 aggregated control RuleSets.
+      unless agg_output_rule_set.nil?
+        unless @aggregator.validate_output(output, agg_output_rule_set)
+          @status = :fail
+        end
+      end
+
     # When fail.
     rescue StandardError => message
-      @status = FAIL
+      @status = :fail
       @message = message
-    # When pass.
-    else
-      # Validate output with controls.
-      unless @ruler.nil?
-        if @ruler.validate_output(@execution.caller_class, @method, @output)
-          @status = PASS
-        else
-          @status = FAIL
-        end
-        return
-      end
-      @status = PASS
     end
 
   end
 
-  def result()
-    # Build reflection.
-    reflection = {
-      TIME => @time,
-      STATUS => @status,
-      INPUT => normalize_input(@inputs),
-      OUTPUT => normalize_output(@output),
-      MESSAGE => @message
-    }
-  end
-
   ##
-  # Normalize inputs.
+  # Create random values for each argument.
   #
-  # @param args - The actual inputs.
-  # @return - A generic inputs representation.
+  # @param args [Dynamic] The arguments to create random values for.
+  # @return [Dynamic] Random arguments.
   ##
-  def normalize_input(args)
-    inputs = []
+  def randomize(args)
+
+    random_args = []
+
     args.each do |arg|
-      input = {
-        TYPE => arg.class.to_s,
-        VALUE => normalize_value(arg)
-      }
-      if (arg.class == Array)
-        input[COUNT] = arg.count
+      case arg
+      when Integer
+        random_args << rand(999)
+      else
+        random_args << arg
       end
-      inputs << input
     end
-    inputs
+
+    return random_args
+
   end
 
   ##
-  # Normalize output.
+  # Get the results of the reflection.
   #
-  # @param input - The actual output.
-  # @return - A generic output representation.
+  # @return [Hash] Reflection metadata.
   ##
-  def normalize_output(input)
-
-    output = {
-      TYPE => input.class.to_s,
-      VALUE => normalize_value(input)
-    }
+  def result()
 
-    if (input.class == Array || input.class == Hash)
-      output[COUNT] = input.count
-    elsif (input.class == TrueClass || input.class == FalseClass)
-      output[TYPE] = :Boolean
+    # The ID of the first execution in the ShadowStack.
+    base_id = nil
+    unless @execution.base == nil
+      base_id = @execution.base.unique_id
     end
 
-    return output
-
-  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
+    # Build reflection.
+    reflection = {
+      :base_id => base_id,
+      :exe_id => @execution.unique_id,
+      :ref_id => @unique_id,
+      :ref_num => @number,
+      :time => @time,
+      :class => @klass,
+      :method => @method,
+      :status => @status,
+      :message => @message,
+      :inputs => [],
+      :output => @output,
+    }
+    @inputs.each do |meta|
+      reflection[:inputs] << meta.result()
     end
 
-    return value
+    return reflection
 
   end