reflekt 0.9.9 → 1.0.0

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.
   #

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,24 @@ 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,
+      String     => :string
+    }
+
+    return meta_types[data_type]
+
+  end
+
 end

data/lib/Reflection.rb

@@ -2,23 +2,29 @@
 # A snapshot of simulated data.
 #
 # @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
 ################################################################################
 
+require 'Clone'
 require 'MetaBuilder'
 
 class Reflection
 
-  attr_accessor :clone
+  attr_reader :status
 
   ##
   # Create a Reflection.
   #
+  # @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.
@@ -37,83 +43,97 @@ 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)
+      # When aggregated rule sets exist.
+      unless input_rule_sets.nil?
 
-    # Action method with new arguments.
-    begin
+        # Randomize arguments from rule sets.
+        args = randomize(args, 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)
+        # 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, *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 with 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 create random values for.
+  # @param input_rule_sets [Array] Aggregated rule sets for each argument.
+  #
   # @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|
+
+      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
@@ -144,11 +164,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.result()
+      end
+    end
+
+    unless @output.nil?
+      reflection[:output] = @output.result()
     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.result())
 
-              # 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.result())
+
+                end
+
+                # Save control.
+                @@reflekt.db.get("controls").push(control.result())
+
+                # 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

data/lib/Rule.rb

@@ -13,6 +13,8 @@
 
 class Rule
 
+  attr_reader :type
+
   ##
   # Each rule trains on metadata to determine its boundaries.
   #
@@ -31,7 +33,7 @@ class Rule
   end
 
   ##
-  # Each rule provides metadata.
+  # Each rule provides results.
   #
   # @return [Hash]
   ##
@@ -39,4 +41,12 @@ class Rule
     {}
   end
 
+  ##
+  # Each rule provides a random example that matches the rule's boundaries.
+  #
+  # @return [Dynamic] A random value.
+  ##
+  def random()
+  end
+
 end

data/lib/RuleSet.rb

@@ -12,6 +12,7 @@
 ################################################################################
 
 require 'set'
+require 'MetaBuilder'
 
 class RuleSet
 
@@ -22,9 +23,14 @@ class RuleSet
   ##
   def initialize(meta_map)
 
+    # The rules that apply to meta types.
     @meta_map = meta_map
+
+    # The types of meta this rule set applies to.
+    # Rules are only validated on their supported meta type.
+    @meta_types = Set.new()
+
     @rules = {}
-    @types = Set.new()
 
   end
 
@@ -38,7 +44,7 @@ class RuleSet
     unless meta.nil? || meta[:type].nil?
 
       meta_type = meta[:type]
-      @types << meta_type
+      @meta_types << meta_type
 
       # Get rule types for this meta type.
       if @meta_map.key? meta_type
@@ -46,7 +52,7 @@ class RuleSet
 
           # Ensure rule exists.
           if @rules[rule_type].nil?
-            @rules << rule_type.new()
+            @rules[rule_type] = rule_type.new()
           end
 
           # Train rule.
@@ -55,10 +61,25 @@ class RuleSet
         end
       end
 
-      return self
+    end
+
+  end
+
+  def test(value)
+    result = true
+
+    # Only test data type on rule of matching meta type.
+    meta_type = MetaBuilder.data_type_to_meta_type(value)
 
+    @rules.each do |klass, rule|
+      if (rule.type == meta_type)
+        unless rule.test(value)
+           result = false
+        end
+      end
     end
 
+    return result
   end
 
   ##
@@ -78,4 +99,5 @@ class RuleSet
 
   end
 
+
 end