reflekt 1.0.3 → 1.0.8

data/lib/meta/{NullMeta.rb → null_meta.rb}

@@ -5,13 +5,14 @@
 #   A "null" value on serialized "inputs" and "output" also becomes a NullMeta.
 #
 # @hierachy
-#   1. Execution
+#   1. Action
 #   2. Reflection
 #   3. Meta <- YOU ARE HERE
 ################################################################################
 
-require 'Meta'
+require_relative '../meta'
 
+module Reflekt
 class NullMeta < Meta
 
   def initialize()
@@ -32,3 +33,4 @@ class NullMeta < Meta
   end
 
 end
+end

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

@@ -1,5 +1,6 @@
-require 'Meta'
+require_relative '../meta'
 
+module Reflekt
 class StringMeta < Meta
 
   def initialize()
@@ -24,3 +25,4 @@ class StringMeta < Meta
   end
 
 end
+end

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

@@ -5,10 +5,11 @@
 # @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 }
 
+module Reflekt
 class MetaBuilder
 
   ##
@@ -82,3 +83,4 @@ class MetaBuilder
   end
 
 end
+end

data/lib/reflection.rb

@@ -0,0 +1,150 @@
+################################################################################
+# 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'
+
+module Reflekt
+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
+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,22 +91,22 @@ module Reflekt
               # Continue reflecting when control executes succesfully.
               else
 
-                # Save control as reflection.
+                # 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.serialize())
+                  # Save experiment.
+                  @@reflekt.db.get("reflections").push(experiment.serialize())
 
                 end
 
@@ -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/{Renderer.rb → renderer.rb}

@@ -1,3 +1,4 @@
+module Reflekt
 class Renderer
 
   def initialize(path, output_path)
@@ -37,3 +38,4 @@ class Renderer
 
 
 end
+end

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

@@ -4,13 +4,14 @@
 # @pattern Abstract class
 #
 # @hierachy
-#   1. Aggregator
+#   1. RuleSetAggregator
 #   2. RuleSet
 #   3. Rule <- YOU ARE HERE
 #
 # @see lib/rules for rules.
 ################################################################################
 
+module Reflekt
 class Rule
 
   attr_reader :type
@@ -50,3 +51,4 @@ class Rule
   end
 
 end
+end

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

@@ -6,15 +6,16 @@
 #   - Builder
 #
 # @hierachy
-#   1. Aggregator
+#   1. RuleSetAggregator
 #   2. RuleSet <- YOU ARE HERE
 #   3. Rule
 ################################################################################
 
 require 'set'
-require 'MetaBuilder'
-require_relative './meta/NullMeta.rb'
+require_relative 'meta_builder'
+require_relative 'meta/null_meta.rb'
 
+module Reflekt
 class RuleSet
 
   attr_accessor :rules
@@ -107,3 +108,4 @@ class RuleSet
 
 
 end
+end

data/lib/{Aggregator.rb → rule_set_aggregator.rb}

@@ -5,14 +5,15 @@
 # @pattern Singleton
 #
 # @hierachy
-#   1. Aggregator <- YOU ARE HERE
+#   1. RuleSetAggregator <- YOU ARE HERE
 #   2. RuleSet
 #   3. Rule
 ################################################################################
 
-require 'RuleSet'
+require_relative 'rule_set'
 
-class Aggregator
+module Reflekt
+class RuleSetAggregator
 
   ##
   # @param meta_map [Hash] The rules that apply to each meta type.
@@ -46,21 +47,13 @@ class Aggregator
       # INPUT
       ##
 
-      unless control["inputs"].nil?
+      # Singular null input.
+      if control["inputs"].nil?
+        train_input(klass, method, nil, 0)
+      # Multiple inputs.
+      else
         control["inputs"].each_with_index do |meta, arg_num|
-
-          meta = Meta.deserialize(meta)
-
-          # Get rule set.
-          rule_set = get_input_rule_set(klass, method, arg_num)
-          if rule_set.nil?
-            rule_set = RuleSet.new(@meta_map)
-            set_input_rule_set(klass, method, arg_num, rule_set)
-          end
-
-          # Train on metadata.
-          rule_set.train(meta)
-
+          train_input(klass, method, meta, arg_num)
         end
       end
 
@@ -82,10 +75,27 @@ class Aggregator
 
   end
 
+  def train_input(klass, method, meta, arg_num)
+
+    # Get deserialized meta.
+    meta = Meta.deserialize(meta)
+
+    # Get rule set.
+    rule_set = get_input_rule_set(klass, method, arg_num)
+    if rule_set.nil?
+      rule_set = RuleSet.new(@meta_map)
+      set_input_rule_set(klass, method, arg_num, rule_set)
+    end
+
+    # Train on metadata.
+    rule_set.train(meta)
+
+  end
+
   ##
   # Validate inputs.
   #
-  # @stage Called when validating a reflection.
+  # @stage Called when validating a control reflection.
   # @param inputs [Array] The method's arguments.
   # @param input_rule_sets [Array] The RuleSets to validate each input with.
   ##
@@ -249,3 +259,4 @@ class Aggregator
   end
 
 end
+end