reflekt 1.0.4 → 1.0.9

data/lib/meta/{ArrayMeta.rb → array_meta.rb}

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

data/lib/meta/{BooleanMeta.rb → boolean_meta.rb}

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

data/lib/meta/{FloatMeta.rb → float_meta.rb}

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

data/lib/meta/{IntegerMeta.rb → integer_meta.rb}

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

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/object_meta.rb

@@ -0,0 +1,35 @@
+################################################################################
+# A reprsentation of a null value.
+#
+# @hierachy
+#   1. Action
+#   2. Reflection
+#   3. Meta <- YOU ARE HERE
+################################################################################
+
+require_relative '../meta'
+
+module Reflekt
+  class ObjectMeta < Meta
+
+    def initialize()
+      @type = :object
+      @class_type = nil
+    end
+
+    ##
+    # @param value [Dynamic] Any custom class.
+    ##
+    def load(value)
+      @class_type = value.class
+    end
+
+    def serialize()
+      {
+        :type => @type,
+        :class_type => @class_type
+      }
+    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,14 +5,20 @@
 # @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
 
   ##
-  # Create meta.
+  # Create meta type for matching data type.
+  #
+  # @flow
+  #   1. First return basic type
+  #   2. Then return custom type
+  #   3. Then return "nil" type
   #
   # @param value
   ##
@@ -21,7 +27,6 @@ class MetaBuilder
     meta = nil
     data_type = value.class.to_s
 
-    # Create meta type for matching data type.
     case data_type
     when "Array"
       meta = ArrayMeta.new()
@@ -33,6 +38,10 @@ class MetaBuilder
       meta = IntegerMeta.new()
     when "String"
       meta = StringMeta.new()
+    else
+      unless value.nil?
+        meta = ObjectMeta.new()
+      end
     end
 
     unless meta.nil?
@@ -77,8 +86,15 @@ class MetaBuilder
       String     => :string
     }
 
-    return meta_types[data_type]
+    if meta_types.key? data_type
+      return meta_types[data_type]
+    elsif value.nil?
+      return nil
+    else
+      return :object
+    end
 
   end
 
 end
+end

data/lib/reflection.rb

@@ -0,0 +1,123 @@
+################################################################################
+# 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
+
+  ##
+  # 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.