reflekt 0.9.7 → 1.0.2

data/lib/Execution.rb

@@ -1,3 +1,12 @@
+################################################################################
+# A shadow execution.
+#
+# @hierachy
+#   1. Execution <- YOU ARE HERE
+#   2. Reflection
+#   3. Meta
+################################################################################
+
 class Execution
 
   attr_accessor :unique_id
@@ -17,12 +26,12 @@ class Execution
   ##
   # 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.
+  # @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, number, stack)
+  def initialize(caller_object, method, reflect_amount, stack)
 
     @time = Time.now.to_i
     @unique_id = @time + rand(1..99999)
@@ -42,7 +51,7 @@ class Execution
 
     # Reflections.
     @control = nil
-    @reflections = Array.new(number)
+    @reflections = Array.new(reflect_amount)
 
     # State.
     if @stack.peek() == nil

data/lib/Meta.rb

@@ -0,0 +1,71 @@
+################################################################################
+# 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 serializes metadata.
+  #
+  # @return [Hash]
+  ##
+  def serialize()
+    {}
+  end
+
+  ##############################################################################
+  # CLASS
+  ##############################################################################
+
+  ##
+  # Deserialize metadata.
+  #
+  # @todo Deserialize should create a Meta object.
+  # @todo Require each Meta type to handle its own deserialization.
+  #
+  # @param meta [Hash] The metadata to deserialize.
+  # @param meta [Hash]
+  ##
+  def self.deserialize(meta)
+
+    # Convert nil meta into NullMeta.
+    # Meta is nil when there are no @inputs or @output on the method.
+    if meta.nil?
+      return NullMeta.new().serialize()
+    end
+
+    # Symbolize keys.
+    # TODO: Remove once "Fix Rowdb.get(path)" bug fixed.
+    meta = meta.transform_keys(&:to_sym)
+
+    # Symbolize type value.
+    meta[:type] = meta[:type].to_sym
+
+    return meta
+
+  end
+
+end

data/lib/MetaBuilder.rb

@@ -0,0 +1,84 @@
+################################################################################
+# 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,
+      NilClass   => :null,
+      String     => :string
+    }
+
+    return meta_types[data_type]
+
+  end
+
+end

data/lib/Reflection.rb

@@ -1,95 +1,158 @@
+################################################################################
+# A snapshot of simulated data.
+#
+# @note
+#   A reflection's random value is within the bounds of aggregated control rule sets
+#   as well as as the arg type being inputted into the current control reflection.
+#
+# @nomenclature
+#   args, inputs/output and meta represent different stages of a value.
+#
+# @hierachy
+#   1. Execution
+#   2. Reflection <- YOU ARE HERE
+#   3. Meta
+#
+# @status
+#   - :pass [Symbol] The reflection passes the rules.
+#   - :fail [Symbol] The reflection fails the rules or produces a system error.
+#   - :error [Symbol] The control reflection produces a system error.
+################################################################################
+
+require 'Clone'
+require 'MetaBuilder'
+
 class Reflection
 
-  attr_accessor :clone
+  attr_reader :status
 
   ##
   # 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.
-    @inputs = []
+    # Metadata.
+    @inputs = nil
     @output = nil
 
     # Clone the execution's calling object.
+    # TODO: Abstract away into Clone class.
     @clone = execution.caller_object.clone
-    @clone_id = nil
 
     # Result.
     @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.
+      # Create random arguments from aggregated rule sets.
       unless input_rule_sets.nil?
-        unless @ruler.validate_inputs(@inputs, input_rule_sets)
+
+        # Base random arguments on the types of the current arguments.
+        if Aggregator.testable?(args, input_rule_sets)
+
+          args = randomize(args, input_rule_sets)
+
+        # TODO: Fallback to argument types from aggregated control rule sets
+        # when arg types not testable or reflect_amount above 3.
+        else
           @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 against aggregated control rule sets.
       unless output_rule_set.nil?
-        unless @ruler.validate_output(@output, output_rule_set)
+        unless @aggregator.test_output(output, output_rule_set)
           @status = :fail
         end
       end
 
-    # When fail.
+    # When a system error occurs.
     rescue StandardError => message
+
       @status = :fail
       @message = message
+
     end
 
   end
 
-  def result()
+  ##
+  # 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.
+  #
+  # @return [Dynamic] Random arguments.
+  ##
+  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
+
+    return random_args
+
+  end
+
+  ##
+  # Get the results of the reflection.
+  #
+  # @return [Hash] Reflection metadata.
+  ##
+  def serialize()
 
     # The ID of the first execution in the ShadowStack.
     base_id = nil
@@ -107,66 +170,23 @@ class Reflection
       :class => @klass,
       :method => @method,
       :status => @status,
-      :input => normalize_input(@inputs),
-      :output => normalize_output(@output),
-      :message => @message
+      :message => @message,
+      :inputs => nil,
+      :output => nil,
     }
 
-    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
+    unless @inputs.nil?
+      reflection[:inputs] = []
+      @inputs.each do |meta|
+        reflection[:inputs] << meta.serialize()
       end
-      inputs << input
     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
+    unless @output.nil?
+      reflection[:output] = @output.serialize()
     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