reflekt 1.0.1 → 1.0.6

data/lib/meta/null_meta.rb

@@ -0,0 +1,34 @@
+################################################################################
+# A reprsentation of a null value.
+#
+# @note
+#   A "null" value on serialized "inputs" and "output" also becomes a NullMeta.
+#
+# @hierachy
+#   1. Action
+#   2. Reflection
+#   3. Meta <- YOU ARE HERE
+################################################################################
+
+require_relative '../meta'
+
+class NullMeta < Meta
+
+  def initialize()
+    @type = :null
+  end
+
+  ##
+  # @param value [NilClass]
+  ##
+  def load(value)
+    # No need to load a value for null meta.
+  end
+
+  def serialize()
+    {
+      :type => @type,
+    }
+  end
+
+end

data/lib/meta/{StringMeta.rb → string_meta.rb}

@@ -1,4 +1,4 @@
-require 'Meta'
+require_relative '../meta'
 
 class StringMeta < Meta
 
@@ -16,7 +16,7 @@ class StringMeta < Meta
     @length = value.length
   end
 
-  def result()
+  def serialize()
     {
       :type => @type,
       :length => @length

data/lib/{MetaBuilder.rb → meta_builder.rb}

@@ -5,9 +5,9 @@
 # @see lib/meta for each meta.
 ################################################################################
 
-require 'Meta'
+require_relative 'meta'
 # Require all meta.
-Dir[File.join(__dir__, 'meta', '*.rb')].each { |file| require file }
+Dir[File.join(__dir__, 'meta', '*.rb')].each { |file| require_relative file }
 
 class MetaBuilder
 
@@ -73,6 +73,7 @@ class MetaBuilder
       FalseClass => :bool,
       Float      => :float,
       Integer    => :int,
+      NilClass   => :null,
       String     => :string
     }
 

data/lib/reflection.rb

@@ -0,0 +1,148 @@
+################################################################################
+# A snapshot of real or random data.
+#
+# @pattern Abstract class
+#
+# @nomenclature
+#   args, inputs/output and meta represent different stages of a value.
+#
+# @hierachy
+#   1. Action
+#   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_relative 'clone'
+require_relative 'meta_builder'
+
+class Reflection
+
+  attr_reader :status
+
+  ##
+  # Create a reflection.
+  #
+  # @param action [Action] The Action that created this Reflection.
+  # @param number [Integer] Multiple Reflections can be created per Action.
+  # @param aggregator [RuleSetAggregator] The aggregated RuleSet for this class/method.
+  ##
+  def initialize(action, number, aggregator)
+
+    @action = action
+    @unique_id = action.unique_id + number
+    @number = number
+
+    # Dependency.
+    @aggregator = aggregator
+
+    # Caller.
+    @klass = action.klass
+    @method = action.method
+
+    # Metadata.
+    @inputs = nil
+    @output = nil
+
+    # Clone the action's calling object.
+    # TODO: Abstract away into Clone class.
+    @clone = action.caller_object.clone
+
+    # Result.
+    @status = :pass
+    @time = Time.now.to_i
+    @message = nil
+
+  end
+
+  ##
+  # Reflect on a method.
+  #
+  # Create a shadow action.
+  # @param *args [Dynamic] The method's arguments.
+  ##
+  def reflect(*args)
+    # Implemented by Control and Experiment.
+  end
+
+  ##
+  # 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.
+  #
+  # @return [Dynamic] Random arguments.
+  ##
+  def randomize(args, input_rule_sets)
+
+    random_args = []
+
+    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
+
+  end
+
+  ##
+  # Get the results of the reflection.
+  #
+  # @keys
+  #   - eid [Integer] Execution ID
+  #   - aid [Integer] Action ID
+  #   - rid [Integer] Reflection ID
+  #   - num [Integer] Reflection number
+  #
+  # @return [Hash] Reflection metadata.
+  ##
+  def serialize()
+
+    # Create execution ID from the ID of the first action in   the ActionStack.
+    execution_id = @action.unique_id
+    unless @action.base.nil?
+      execution_id = @action.base.unique_id
+    end
+
+    # Build reflection.
+    reflection = {
+      :eid => execution_id,
+      :aid => @action.unique_id,
+      :rid => @unique_id,
+      :num => @number,
+      :time => @time,
+      :class => @klass,
+      :method => @method,
+      :status => @status,
+      :message => @message,
+      :inputs => nil,
+      :output => nil,
+    }
+
+    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
+
+  end
+
+end

data/lib/{Reflekt.rb → reflekt.rb}

@@ -6,8 +6,8 @@
 # @flow
 #   1. Reflekt is prepended to a class and setup.
 #   2. When a class insantiates so does Reflekt.
-#   3. An Execution is created on method call.
-#   4. Many Refections are created per Execution.
+#   3. An Action is created on method call.
+#   4. Many Refections are created per Action.
 #   5. Each Reflection executes on cloned data.
 #   6. Flow is returned to the original method.
 #
@@ -19,16 +19,16 @@
 require 'set'
 require 'erb'
 require 'rowdb'
-require 'Accessor'
-require 'Aggregator'
-require 'Config'
-require 'Control'
-require 'Execution'
-require 'Reflection'
-require 'Renderer'
-require 'ShadowStack'
+require_relative 'accessor'
+require_relative 'action'
+require_relative 'action_stack'
+require_relative 'config'
+require_relative 'control'
+require_relative 'experiment'
+require_relative 'renderer'
+require_relative 'rule_set_aggregator'
 # Require all rules.
-Dir[File.join(__dir__, 'rules', '*.rb')].each { |file| require file }
+Dir[File.join(__dir__, 'rules', '*.rb')].each { |file| require_relative file }
 
 module Reflekt
 
@@ -53,34 +53,34 @@ module Reflekt
         # When Reflekt enabled and control reflection has executed without error.
         if @@reflekt.config.enabled && !@@reflekt.error
 
-          # Get current execution.
-          execution = @@reflekt.stack.peek()
+          # Get current action.
+          action = @@reflekt.stack.peek()
 
           # Don't reflect when reflect limit reached or method skipped.
           unless (@reflekt_counts[method] >= @@reflekt.config.reflect_limit) || self.class.reflekt_skipped?(method)
 
-            # When stack empty or past execution done reflecting.
-            if execution.nil? || execution.has_finished_reflecting?
+            # When stack empty or past action done reflecting.
+            if action.nil? || action.has_finished_reflecting?
 
-              # Create execution.
-              execution = Execution.new(self, method, @@reflekt.config.reflect_amount, @@reflekt.stack)
+              # Create action.
+              action = Action.new(self, method, @@reflekt.config.reflect_amount, @@reflekt.stack)
 
-              @@reflekt.stack.push(execution)
+              @@reflekt.stack.push(action)
 
             end
 
             ##
-            # Reflect the execution.
+            # Reflect the action.
             #
-            # The first method call in the execution creates a reflection.
-            # Then method calls are shadow executions which return to the reflection.
+            # The first method call in the action creates a reflection.
+            # Then method calls are shadow actions which return to the reflection.
             ##
-            if execution.has_empty_reflections? && !execution.is_reflecting?
-              execution.is_reflecting = true
+            if action.has_empty_experiments? && !action.is_reflecting?
+              action.is_reflecting = true
 
               # Create control.
-              control = Control.new(execution, 0, @@reflekt.aggregator)
-              execution.control = control
+              control = Control.new(action, 0, @@reflekt.aggregator)
+              action.control = control
 
               # Execute control.
               control.reflect(*args)
@@ -91,27 +91,27 @@ module Reflekt
               # Continue reflecting when control executes succesfully.
               else
 
-                # Save control as reflection.
-                @@reflekt.db.get("reflections").push(control.result())
+                # Save control as a reflection.
+                @@reflekt.db.get("reflections").push(control.serialize())
 
-                # Multiple reflections per execution.
-                execution.reflections.each_with_index do |value, index|
+                # Multiple experiments per action.
+                action.experiments.each_with_index do |value, index|
 
-                  # Create reflection.
-                  reflection = Reflection.new(execution, index + 1, @@reflekt.aggregator)
-                  execution.reflections[index] = reflection
+                  # Create experiment.
+                  experiment = Experiment.new(action, index + 1, @@reflekt.aggregator)
+                  action.experiments[index] = experiment
 
-                  # Execute reflection.
-                  reflection.reflect(*args)
+                  # Execute experiment.
+                  experiment.reflect(*args)
                   @reflekt_counts[method] = @reflekt_counts[method] + 1
 
-                  # Save reflection.
-                  @@reflekt.db.get("reflections").push(reflection.result())
+                  # Save experiment.
+                  @@reflekt.db.get("reflections").push(experiment.serialize())
 
                 end
 
                 # Save control.
-                @@reflekt.db.get("controls").push(control.result())
+                @@reflekt.db.get("controls").push(control.serialize())
 
                 # Save results.
                 @@reflekt.db.write()
@@ -121,15 +121,15 @@ module Reflekt
 
               end
 
-              execution.is_reflecting = false
+              action.is_reflecting = false
             end
 
           end
 
           # Don't execute skipped methods when reflecting.
-          unless execution.is_reflecting? && self.class.reflekt_skipped?(method)
+          unless action.is_reflecting? && self.class.reflekt_skipped?(method)
 
-            # Continue execution / shadow execution.
+            # Continue action / shadow action.
             super *args
 
           end
@@ -137,7 +137,7 @@ module Reflekt
         # When Reflekt disabled or control reflection failed.
         else
 
-          # Continue execution.
+          # Continue action.
           super *args
 
         end
@@ -180,7 +180,7 @@ module Reflekt
     # Set configuration.
     @@reflekt.path = File.dirname(File.realpath(__FILE__))
 
-    # Get reflections directory path from config or current execution path.
+    # Get reflections directory path from config or current action path.
     if @@reflekt.config.output_path
       @@reflekt.output_path = File.join(@@reflekt.config.output_path, @@reflekt.config.output_directory)
     else
@@ -199,10 +199,10 @@ module Reflekt
     db = @@reflekt.db.value()
 
     # Create shadow stack.
-    @@reflekt.stack = ShadowStack.new()
+    @@reflekt.stack = ActionStack.new()
 
     # Create aggregated rule sets.
-    @@reflekt.aggregator = Aggregator.new(@@reflekt.config.meta_map)
+    @@reflekt.aggregator = RuleSetAggregator.new(@@reflekt.config.meta_map)
     @@reflekt.aggregator.train(db[:controls])
 
     # Create renderer.

data/lib/{Rule.rb → rule.rb}

@@ -4,7 +4,7 @@
 # @pattern Abstract class
 #
 # @hierachy
-#   1. Aggregator
+#   1. RuleSetAggregator
 #   2. RuleSet
 #   3. Rule <- YOU ARE HERE
 #

data/lib/{RuleSet.rb → rule_set.rb}

@@ -6,13 +6,14 @@
 #   - Builder
 #
 # @hierachy
-#   1. Aggregator
+#   1. RuleSetAggregator
 #   2. RuleSet <- YOU ARE HERE
 #   3. Rule
 ################################################################################
 
 require 'set'
-require 'MetaBuilder'
+require_relative 'meta_builder'
+require_relative 'meta/null_meta.rb'
 
 class RuleSet
 
@@ -37,40 +38,44 @@ class RuleSet
   ##
   # Train rule set on metadata.
   #
-  # @param meta [Meta] The metadata to train on.
+  # @param meta [Hash] The metadata to train on.
   ##
   def train(meta)
 
-    unless meta.nil? || meta[:type].nil?
+    # Track supported meta types.
+    meta_type = meta[:type]
+    @meta_types << meta_type
 
-      meta_type = meta[:type]
-      @meta_types << meta_type
+    # Get rule types for this meta type.
+    if @meta_map.key? meta_type
+      @meta_map[meta_type].each do |rule_type|
 
-      # Get rule types for this meta type.
-      if @meta_map.key? meta_type
-        @meta_map[meta_type].each do |rule_type|
-
-          # Ensure rule exists.
-          if @rules[rule_type].nil?
-            @rules[rule_type] = rule_type.new()
-          end
+        # Ensure rule exists.
+        if @rules[rule_type].nil?
+          @rules[rule_type] = rule_type.new()
+        end
 
-          # Train rule.
-          @rules[rule_type].train(meta)
+        # Train rule.
+        @rules[rule_type].train(meta)
 
-        end
       end
-
     end
 
   end
 
+  ##
+  # @param value [Dynamic]
+  ##
   def test(value)
-    result = true
 
-    # Only test data type on rule of matching meta type.
+    result = true
     meta_type = MetaBuilder.data_type_to_meta_type(value)
 
+    # Fail if value's meta type not testable by rule set.
+    unless @meta_types.include? meta_type
+      return false
+    end
+
     @rules.each do |klass, rule|
       if (rule.type == meta_type)
         unless rule.test(value)
@@ -80,6 +85,7 @@ class RuleSet
     end
 
     return result
+
   end
 
   ##