reflekt 0.9.9 → 1.0.4

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
@@ -19,10 +28,10 @@ class Execution
   #
   # @param object [Object] The calling object.
   # @param method [Symbol] The calling method.
-  # @param number [Integer] The number of reflections to create per execution.
+  # @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

@@ -3,10 +3,22 @@
 #
 # @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.
   #
@@ -16,12 +28,44 @@ class Meta
   end
 
   ##
-  # Each meta provides metadata.
+  # Each meta serializes metadata.
   #
   # @return [Hash]
   ##
-  def result()
+  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

@@ -6,8 +6,8 @@
 ################################################################################
 
 require 'Meta'
-require_relative './meta/IntegerMeta'
-require_relative './meta/StringMeta'
+# Require all meta.
+Dir[File.join(__dir__, 'meta', '*.rb')].each { |file| require file }
 
 class MetaBuilder
 
@@ -19,9 +19,16 @@ class MetaBuilder
   def self.create(value)
 
     meta = nil
+    data_type = value.class.to_s
 
-    # Creates values for matching data type.
-    case 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"
@@ -53,4 +60,25 @@ class MetaBuilder
 
   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,20 +1,30 @@
 ################################################################################
-# A snapshot of simulated data.
+# A snapshot of random 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/values are the same thing but at a different stage of lifecycle.
+#   args, inputs/output and meta represent different stages of a value.
 #
 # @hierachy
 #   1. Execution
-#   2. Reflection
-#   3. RuleSet
+#   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.
@@ -37,83 +47,91 @@ class Reflection
     @method = execution.method
 
     # Metadata.
-    @inputs = []
+    @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.
+  # Creates a shadow execution.
   # @param *args [Dynamic] The method's arguments.
   ##
   def reflect(*args)
 
-    # 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)
+    # Get aggregated rule sets.
+    input_rule_sets = @aggregator.get_input_rule_sets(@klass, @method)
+    output_rule_set = @aggregator.get_output_rule_set(@klass, @method)
 
-    # Create random arguments.
-    new_args = randomize(args)
+    # When arguments exist.
+    unless args.size == 0
 
-    # Create metadata for each argument.
-    @inputs = MetaBuilder.create_many(new_args)
+      # Create random arguments from aggregated rule sets.
+      unless input_rule_sets.nil?
+        args = randomize(args, input_rule_sets)
+      end
 
-    # Action method with new arguments.
-    begin
+      # Create metadata for each argument.
+      # TODO: Create metadata for other inputs such as properties on the instance.
+      @inputs = MetaBuilder.create_many(args)
 
-      # 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
+    end
+
+    # Action method with new/old arguments.
+    begin
 
       # Run reflection.
-      output = @clone.send(@method, *new_args)
+      output = @clone.send(@method, *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)
+      # Validate output against aggregated control rule sets.
+      unless output_rule_set.nil?
+        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
 
   ##
-  # Create random values for each argument.
+  # Create random values for each argument from control reflections.
+  #
+  # @param args [Dynamic] The arguments to mirror random values for.
+  # @param input_rule_sets [Array] Aggregated rule sets for each argument.
   #
-  # @param args [Dynamic] The arguments to create random values for.
   # @return [Dynamic] Random arguments.
   ##
-  def randomize(args)
+  def randomize(args, input_rule_sets)
 
     random_args = []
 
-    args.each do |arg|
-      case arg
-      when Integer
-        random_args << rand(999)
-      else
-        random_args << arg
-      end
+    args.each_with_index do |arg, arg_num|
+
+      # Get a random rule in the rule set.
+      rules = input_rule_sets[arg_num].rules
+      agg_rule = rules[rules.keys.sample]
+
+      # Create a random value that follows that rule.
+      random_args << agg_rule.random()
+
     end
 
     return random_args
@@ -125,7 +143,7 @@ class Reflection
   #
   # @return [Hash] Reflection metadata.
   ##
-  def result()
+  def serialize()
 
     # The ID of the first execution in the ShadowStack.
     base_id = nil
@@ -144,11 +162,19 @@ class Reflection
       :method => @method,
       :status => @status,
       :message => @message,
-      :inputs => [],
-      :output => @output,
+      :inputs => nil,
+      :output => nil,
     }
-    @inputs.each do |meta|
-      reflection[:inputs] << meta.result()
+
+    unless @inputs.nil?
+      reflection[:inputs] = []
+      @inputs.each do |meta|
+        reflection[:inputs] << meta.serialize()
+      end
+    end
+
+    unless @output.nil?
+      reflection[:output] = @output.serialize()
     end
 
     return reflection

data/lib/Reflekt.rb

@@ -34,6 +34,7 @@ module Reflekt
 
   def initialize(*args)
 
+    # TODO: Store counts on @@reflekt and key by instance ID.
     @reflekt_counts = {}
 
     # Get child and parent instance methods.
@@ -49,72 +50,94 @@ module Reflekt
       # When method called in flow.
       self.define_singleton_method(method) do |*args|
 
-        # Get current execution.
-        execution = @@reflekt.stack.peek()
+        # When Reflekt enabled and control reflection has executed without error.
+        if @@reflekt.config.enabled && !@@reflekt.error
 
-        # Don't reflect when reflect limit reached or method skipped.
-        unless (@reflekt_counts[method] >= @@reflekt.config.reflect_limit) || self.class.reflekt_skipped?(method)
+          # Get current execution.
+          execution = @@reflekt.stack.peek()
 
-          # When stack empty or past execution done reflecting.
-          if execution.nil? || execution.has_finished_reflecting?
+          # Don't reflect when reflect limit reached or method skipped.
+          unless (@reflekt_counts[method] >= @@reflekt.config.reflect_limit) || self.class.reflekt_skipped?(method)
 
-            # Create execution.
-            execution = Execution.new(self, method, @@reflekt.config.reflect_amount, @@reflekt.stack)
+            # When stack empty or past execution done reflecting.
+            if execution.nil? || execution.has_finished_reflecting?
 
-            @@reflekt.stack.push(execution)
+              # Create execution.
+              execution = Execution.new(self, method, @@reflekt.config.reflect_amount, @@reflekt.stack)
 
-          end
+              @@reflekt.stack.push(execution)
+
+            end
 
-          ##
-          # Reflect the execution.
-          #
-          # The first method call in the Execution creates a Reflection.
-          # Subsequent method calls are shadow executions on cloned objects.
-          ##
-          if execution.has_empty_reflections? && !execution.is_reflecting?
-            execution.is_reflecting = true
+            ##
+            # Reflect the execution.
+            #
+            # The first method call in the execution creates a reflection.
+            # Then method calls are shadow executions which return to the reflection.
+            ##
+            if execution.has_empty_reflections? && !execution.is_reflecting?
+              execution.is_reflecting = true
 
-            # Create control.
-            control = Control.new(execution, 1, @@reflekt.aggregator)
-            execution.control = control
+              # Create control.
+              control = Control.new(execution, 0, @@reflekt.aggregator)
+              execution.control = control
 
-            # Execute control.
-            control.reflect(*args)
+              # Execute control.
+              control.reflect(*args)
 
-            # Save control.
-            @@reflekt.db.get("controls").push(control.result())
+              # Stop reflecting when control fails to execute.
+              if control.status == :error
+                @@reflekt.error = true
+              # Continue reflecting when control executes succesfully.
+              else
 
-            # Multiple reflections per execution.
-            execution.reflections.each_with_index do |value, index|
+                # Save control as reflection.
+                @@reflekt.db.get("reflections").push(control.serialize())
 
-              # Create reflection.
-              reflection = Reflection.new(execution, index + 1, @@reflekt.aggregator)
-              execution.reflections[index] = reflection
+                # Multiple reflections per execution.
+                execution.reflections.each_with_index do |value, index|
 
-              # Execute reflection.
-              reflection.reflect(*args)
-              @reflekt_counts[method] = @reflekt_counts[method] + 1
+                  # Create reflection.
+                  reflection = Reflection.new(execution, index + 1, @@reflekt.aggregator)
+                  execution.reflections[index] = reflection
 
-              # Save reflection.
-              @@reflekt.db.get("reflections").push(reflection.result())
+                  # Execute reflection.
+                  reflection.reflect(*args)
+                  @reflekt_counts[method] = @reflekt_counts[method] + 1
 
-            end
+                  # Save reflection.
+                  @@reflekt.db.get("reflections").push(reflection.serialize())
+
+                end
+
+                # Save control.
+                @@reflekt.db.get("controls").push(control.serialize())
+
+                # Save results.
+                @@reflekt.db.write()
 
-            # Save results.
-            @@reflekt.db.write()
+                # Render results.
+                @@reflekt.renderer.render()
 
-            # Render results.
-            @@reflekt.renderer.render()
+              end
+
+              execution.is_reflecting = false
+            end
 
-            execution.is_reflecting = false
           end
 
-        end
+          # Don't execute skipped methods when reflecting.
+          unless execution.is_reflecting? && self.class.reflekt_skipped?(method)
+
+            # Continue execution / shadow execution.
+            super *args
+
+          end
 
-        # Don't execute skipped methods when reflecting.
-        unless execution.is_reflecting? && self.class.reflekt_skipped?(method)
+        # When Reflekt disabled or control reflection failed.
+        else
 
-          # Continue execution / shadow execution.
+          # Continue execution.
           super *args
 
         end