reflekt 0.9.6 → 1.0.1

data/lib/Execution.rb

@@ -1,24 +1,65 @@
+################################################################################
+# A shadow execution.
+#
+# @hierachy
+#   1. Execution <- YOU ARE HERE
+#   2. Reflection
+#   3. Meta
+################################################################################
+
 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 method [Symbol] The calling method.
+  # @param reflect_amount [Integer] The number of reflections to create per execution.
+  # @param stack [ShadowStack] The shadow execution call stack.
+  ##
+  def initialize(caller_object, method, reflect_amount, 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(reflect_amount)
+
+    # 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,39 @@
+################################################################################
+# Metadata for input and output.
+#
+# @pattern Abstract class
+# @see lib/meta for each meta.
+#
+# @hierachy
+#   1. Execution
+#   2. Reflection
+#   3. Meta <- YOU ARE HERE
+################################################################################
+
+class Meta
+
+  ##
+  # Each meta defines its type.
+  ##
+  def initialize()
+    @type = nil
+  end
+
+  ##
+  # 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,83 @@
+################################################################################
+# Create metadata.
+#
+# @pattern Builder
+# @see lib/meta for each meta.
+################################################################################
+
+require 'Meta'
+# Require all meta.
+Dir[File.join(__dir__, 'meta', '*.rb')].each { |file| require file }
+
+class MetaBuilder
+
+  ##
+  # Create meta.
+  #
+  # @param value
+  ##
+  def self.create(value)
+
+    meta = nil
+    data_type = value.class.to_s
+
+    # Create meta type for matching data type.
+    case data_type
+    when "Array"
+      meta = ArrayMeta.new()
+    when "TrueClass", "FalseClass"
+      meta = BooleanMeta.new()
+    when "Float"
+      meta = FloatMeta.new()
+    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
+
+  ##
+  # @param data_type [Type]
+  ##
+  def self.data_type_to_meta_type(value)
+
+    data_type = value.class
+
+    meta_types = {
+      Array      => :array,
+      TrueClass  => :bool,
+      FalseClass => :bool,
+      Float      => :float,
+      Integer    => :int,
+      String     => :string
+    }
+
+    return meta_types[data_type]
+
+  end
+
+end

data/lib/Reflection.rb

@@ -1,167 +1,185 @@
+################################################################################
+# A snapshot of simulated data.
+#
+# @nomenclature
+#   args, inputs/output and meta represent different stages of a value.
+#
+# @hierachy
+#   1. Execution
+#   2. Reflection <- YOU ARE HERE
+#   3. Meta
+################################################################################
+
+require 'Clone'
+require 'MetaBuilder'
+
 class Reflection
 
-  # Keys.
-  TIME    = "t"
-  INPUT   = "i"
-  OUTPUT  = "o"
-  TYPE    = "T"
-  COUNT   = "C"
-  VALUE   = "V"
-  STATUS  = "s"
-  MESSAGE = "m"
-  # Values.
-  PASS    = "p"
-  FAIL    = "f"
-
-  attr_accessor :clone
+  attr_reader :status
 
   ##
   # Create a Reflection.
   #
-  # @param Execution execution - The Execution that created this Reflection.
-  # @param Symbol klass - The class of the method being called.
-  # @param Symbol method - The method that is being called.
-  # @param Ruler ruler - The RuleSets for this class/method.
+  # @status
+  #   - :pass The reflection passes the rules.
+  #   - :fail The reflection fails the rules or produces a system error.
+  #   - :error The control reflection produces a system error.
+  #
+  # @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, klass, method, ruler)
+  def initialize(execution, number, aggregator)
 
     @execution = execution
-    @klass = klass
-    @method = method
-    @ruler = ruler
+    @unique_id = execution.unique_id + number
+    @number = number
+
+    # Dependency.
+    @aggregator = aggregator
 
-    # Arguments.
-    @inputs = []
+    # Caller.
+    @klass = execution.klass
+    @method = execution.method
+
+    # Metadata.
+    @inputs = nil
     @output = nil
 
-    # Clone the execution's object.
-    @clone = execution.object.clone
-    @clone_id = nil
+    # Clone the execution's calling object.
+    # TODO: Abstract away into Clone class.
+    @clone = execution.caller_object.clone
 
     # Result.
-    @status = PASS
+    @status = :pass
     @time = Time.now.to_i
+    @message = nil
 
   end
 
   ##
   # Reflect on a method.
   #
-  # Creates a shadow execution stack.
-  #
-  # @param *args - The method's arguments.
-  #
-  # @return - A reflection hash.
+  # Creates a shadow execution.
+  # @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)
-
-    # Create deviated arguments.
-    args.each do |arg|
-      case arg
-      when Integer
-        @inputs << rand(999)
-      else
-        @inputs << arg
-      end
-    end
+    # Get aggregated rule sets.
+    input_rule_sets = @aggregator.get_input_rule_sets(@klass, @method)
+    output_rule_set = @aggregator.get_output_rule_set(@klass, @method)
 
-    # Action method with new arguments.
-    begin
+    # When arguments exist.
+    unless args.size == 0
 
-      # Validate input with controls.
+      # When aggregated rule sets exist.
       unless input_rule_sets.nil?
-        unless @ruler.validate_inputs(@inputs, input_rule_sets)
-          @status = FAIL
+
+        # Randomize arguments from rule sets.
+        args = randomize(args, input_rule_sets)
+
+        # Validate arguments against aggregated rule sets.
+        unless @aggregator.test_inputs(args, input_rule_sets)
+          @status = :fail
         end
+
       end
 
+      # Create metadata for each argument.
+      # TODO: Create metadata for other inputs such as properties on the instance.
+      @inputs = MetaBuilder.create_many(args)
+
+    end
+
+    # Action method with new/old arguments.
+    begin
+
       # Run reflection.
-      @output = @clone.send(@method, *@inputs)
+      output = @clone.send(@method, *args)
+      @output = MetaBuilder.create(output)
 
-      # Validate output with controls.
+      # Validate output with aggregated control rule sets.
       unless output_rule_set.nil?
-        unless @ruler.validate_output(@output, output_rule_set)
-          @status = FAIL
+        unless @aggregator.test_output(output, output_rule_set)
+          @status = :fail
         end
       end
 
-    # When fail.
+    # When a system error occurs.
     rescue StandardError => message
-      @status = FAIL
+
+      @status = :fail
       @message = message
+
     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 from control reflections.
+  #
+  # @param args [Dynamic] The arguments to create random values for.
+  # @param input_rule_sets [Array] Aggregated rule sets for each argument.
   #
-  # @param args - The actual inputs.
-  # @return - A generic inputs representation.
+  # @return [Dynamic] Random arguments.
   ##
-  def normalize_input(args)
-    inputs = []
-    args.each do |arg|
-      input = {
-        TYPE => arg.class.to_s,
-        VALUE => normalize_value(arg)
-      }
-      if (arg.class == Array)
-        input[COUNT] = arg.count
-      end
-      inputs << input
+  def randomize(args, input_rule_sets)
+
+    random_args = []
+
+    args.each_with_index do |arg, arg_num|
+
+      rule_type = Aggregator.value_to_rule_type(arg)
+      agg_rule = input_rule_sets[arg_num].rules[rule_type]
+
+      random_args << agg_rule.random()
+
     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)
+    # 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 => nil,
+      :output => nil,
+    }
 
-    unless value.nil?
-      value = value.to_s.gsub(/\r?\n/, " ").to_s
-      if value.length >= 30
-        value = value[0, value.rindex(/\s/,30)].rstrip() + '...'
+    unless @inputs.nil?
+      reflection[:inputs] = []
+      @inputs.each do |meta|
+        reflection[:inputs] << meta.result()
       end
     end
 
-    return value
+    unless @output.nil?
+      reflection[:output] = @output.result()
+    end
+
+    return reflection
 
   end