reflekt 0.7.2 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d92d12a27556a25c258f83cf2983ffc2758a70c5cd359f4e7beafb862e88e68c
-  data.tar.gz: be5fa824eb0e6cd3bd15e03da504c40a65e471687881a5fbfcebc0d0906399fd
+  metadata.gz: e4d3c0c32672fd8813482a3f546032904d3d6f65e592fd4435eb7ada2bb1b201
+  data.tar.gz: d48f2b100986c4408db5cb055f4ebf1e6a50d99fa99dc6d98e8af8e5d8bcd66e
 SHA512:
-  metadata.gz: 9ffb39bc278932fd985731c7e509767e79c3356da41d7114a57cfe47a774bb97742ae283837859e2ff158ff84121e2b565c2bf25aff1ae0e8345671b9bd8da22
-  data.tar.gz: 3db51deab75140780e718e3536ab06696a1d0ef5308b1cbfcf2fb8a56dc9144905f22f2f53e918afcd7d1e962416134fc41a07676e17c4a16b935c70aece19fb
+  metadata.gz: 1422110bc34f7b88f8b4ba71359c408d38f3ebf72235735e51864fd0bd16c32fd5abc20e5cfa8a516478932800590f80f7f1b7b4d0dac3c0ebd18a3d8dfffd54
+  data.tar.gz: 4019f5868ca20d1aebfa9e4ddb2c5136782aa52185588cb44558f4725f51ea59f90bc75896e8bfac383151d7346bb534d98bc00a11a569c350d0c460fe3b31ab

data/lib/Execution.rb

@@ -0,0 +1,45 @@
+class Execution
+
+  attr_accessor :object
+  attr_accessor :caller_id
+  attr_accessor :caller_class
+  attr_accessor :parent
+  attr_accessor :child
+  attr_accessor :reflections
+  attr_accessor :is_reflecting
+
+  def initialize(object, reflection_count)
+
+    @object = object
+    @caller_id = object.object_id
+    @caller_class = object.class
+    @parent = nil
+    @child = nil
+
+    @reflections = Array.new(reflection_count)
+    @is_reflecting = false
+
+  end
+
+  def has_empty_reflections?
+    @reflections.include? nil
+  end
+
+  ##
+  # Is the Execution currently reflecting methods?
+  ##
+  def is_reflecting?
+    @is_reflecting
+  end
+
+  def has_finished_reflecting?
+    if is_reflecting?
+      return false
+    end
+    if has_empty_reflections?
+      return false
+    end
+    return true
+  end
+
+end

data/lib/Reflection.rb

@@ -0,0 +1,145 @@
+class Reflection
+
+  # Keys.
+  TIME    = "t"
+  INPUT   = "i"
+  OUTPUT  = "o"
+  TYPE    = "T"
+  COUNT   = "C"
+  VALUE   = "V"
+  STATUS  = "s"
+  MESSAGE = "m"
+  # Values.
+  PASS    = "p"
+  FAIL    = "f"
+
+  attr_accessor :clone
+
+  def initialize(execution, method, is_control)
+
+    @execution = execution
+    @method = method
+    @is_control = is_control
+
+    # Clone the execution's object.
+    @clone = execution.object.clone
+    @clone_id = nil
+
+    # Result.
+    @status = nil
+    @time = Time.now.to_i
+    @input = []
+    @output = nil
+
+  end
+
+  ##
+  # Reflect on a method.
+  #
+  # Creates a shadow execution stack.
+  #
+  # @param method - The name of the method.
+  # @param *args - The method arguments.
+  #
+  # @return - A reflection hash.
+  ##
+  def reflect(*args)
+
+    # Reflect on real world arguments.
+    if @is_control
+      @input = *args
+    # Reflect on deviated arguments.
+    else
+      args.each do |arg|
+        case arg
+        when Integer
+          @input << rand(9999)
+        else
+          @input << arg
+        end
+      end
+    end
+
+    # Action method with new arguments.
+    begin
+      @output = @clone.send(@method, *@input)
+    # When fail.
+    rescue StandardError => message
+      @status = MESSAGE
+      @message = message
+    # When pass.
+    else
+      @status = PASS
+    end
+
+  end
+
+  def result()
+    # Build reflection.
+    reflection = {
+      TIME => @time,
+      STATUS => @status,
+      INPUT => normalize_input(@input),
+      OUTPUT => normalize_output(@output),
+      MESSAGE => @message
+    }
+  end
+
+  ##
+  # Normalize inputs.
+  #
+  # @param args - The actual inputs.
+  # @return - A generic inputs representation.
+  ##
+  def normalize_input(args)
+    inputs = []
+    args.each do |arg|
+      input = {
+        TYPE => arg.class.to_s,
+        VALUE => normalize_value(arg)
+      }
+      if (arg.class == Array)
+        input[COUNT] = arg.count
+      end
+      inputs << input
+    end
+    inputs
+  end
+
+  ##
+  # Normalize output.
+  #
+  # @param input - The actual output.
+  # @return - A generic output representation.
+  ##
+  def normalize_output(input)
+
+    output = {
+      TYPE => input.class.to_s,
+      VALUE => normalize_value(input)
+    }
+
+    if (input.class == Array || input.class == Hash)
+      output[COUNT] = input.count
+    elsif (input.class == TrueClass || input.class == FalseClass)
+      output[TYPE] = :Boolean
+    end
+
+    return output
+
+  end
+
+  def normalize_value(value)
+
+    unless value.nil?
+      value = value.to_s.gsub(/\r?\n/, " ").to_s
+      if value.length >= 30
+        value = value[0, value.rindex(/\s/,30)].rstrip() + '...'
+      end
+    end
+
+    return value
+
+  end
+
+end

data/lib/ShadowStack.rb

@@ -0,0 +1,56 @@
+################################################################################
+# SHADOW STACK
+#
+# Track the executions in a call stack.
+################################################################################
+
+class ShadowStack
+
+  def initialize()
+    @bottom = nil
+    @top = nil
+  end
+
+  def peek()
+    @top
+  end
+
+  def base()
+    @bottom
+  end
+
+  ##
+  # Push Execution.
+  #
+  # @param object - The object being executed.
+  # @param args - The arguments being executed.
+  #
+  # @return Execution - The new execution.
+  ##
+  def push(execution)
+
+    # Reference previous execution.
+    if @bottom.nil?
+      @bottom = execution
+    else
+      execution.child = @top
+      @top.parent = execution
+    end
+
+    # Place new execution at the top of the stack.
+    @top = execution
+
+  end
+
+  def display
+    display_execution_tree(@bottom)
+  end
+
+  def display_execution_tree(execution)
+    p execution
+    unless execution.parent == nil
+      display_execution_tree(execution.parent)
+    end
+  end
+
+end

data/lib/reflekt.rb

@@ -1,11 +1,19 @@
 require 'set'
 require 'erb'
 require 'rowdb'
+require 'Execution'
+require 'Reflection'
+require 'ShadowStack'
 
 ################################################################################
 # REFLEKT
 #
-# Usage. Prepend to the class like so:
+# An Execution is created each time a method is called.
+# Multiple Refections are created per Execution.
+# These Reflections execute on a ShadowStack on cloned objects.
+# Then flow is returned to the original method and normal execution continues.
+#
+# Usage:
 #
 #   class ExampleClass
 #     prepend Reflekt
@@ -13,186 +21,105 @@ require 'rowdb'
 
 module Reflekt
 
-  # Reflection keys.
-  REFLEKT_TIME    = "t"
-  REFLEKT_INPUT   = "i"
-  REFLEKT_OUTPUT  = "o"
-  REFLEKT_TYPE    = "T"
-  REFLEKT_COUNT   = "C"
-  REFLEKT_VALUE   = "V"
-  REFLEKT_STATUS  = "s"
-  REFLEKT_MESSAGE = "m"
-  # Reflection values.
-  REFLEKT_PASS    = "p"
-  REFLEKT_FAIL    = "f"
-
-  @@reflekt_clone_count = 5
+  # The amount of reflections to create per method call.
+  @@reflekt_reflect_amount = 2
 
-  def initialize(*args)
+  # Limit the amount of reflections that can be created per instance method.
+  # A method called thousands of times doesn't need that many reflections.
+  @@reflection_limit = 10
 
-    @reflekt_forked = false
-    @reflekt_clones = []
+  def initialize(*args)
 
-    # Limit the amount of clones that can be created per instance.
-    # A method called thousands of times doesn't need that many reflections.
-    @reflekt_limit = 5
-    @reflekt_count = 0
+    @reflection_counts = {}
 
-    # Override methods.
+    # Get instance methods.
+    # TODO: Include parent methods like "Array.include?".
     self.class.instance_methods(false).each do |method|
-      self.define_singleton_method(method) do |*args|
 
-        # When method called in flow.
-        if @reflekt_forked
+      # Don't process skipped methods.
+      next if self.class.reflekt_skipped?(method)
 
-          if @reflekt_count < @reflekt_limit
-            unless self.class.deflekted?(method)
+      @reflection_counts[method] = 0
 
-              # Reflekt on method.
-              @reflekt_clones.each do |clone|
-                reflekt_action(clone, method, *args)
-              end
+      # When method called in flow.
+      self.define_singleton_method(method) do |*args|
 
-              # Save results.
-              @@reflekt_db.write()
+        # Don't reflect when limit reached.
+        unless @reflection_counts[method] >= @@reflection_limit
 
-              reflekt_render()
+          # Get current execution.
+          execution = @@reflekt_stack.peek()
 
-            end
-            @reflekt_count = @reflekt_count + 1
-          end
+          # When stack empty or past execution done reflecting.
+          if execution.nil? || execution.has_finished_reflecting?
 
-        end
+            # Create execution.
+            execution = Execution.new(self, @@reflekt_reflect_amount)
+            @@reflekt_stack.push(execution)
 
-        # Continue method flow.
-        super *args
-      end
+          end
 
-    end
+          # Reflect.
+          # 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
 
-    # Continue contructor flow.
-    super
+            # Multiple reflections per execution.
+            execution.reflections.each_with_index do |value, index|
 
-    # Create forks.
-    reflekt_fork()
+              # Flag first reflection is a control.
+              is_control = false
+              is_control = true if index == 0
 
-  end
+              # Create reflection.
+              reflection = Reflection.new(execution, method, is_control)
+              execution.reflections[index] = reflection
 
-  def reflekt_fork()
+              # Execute reflection.
+              reflection.reflect(*args)
 
-    @@reflekt_clone_count.times do |clone|
-      @reflekt_clones << self.clone
-    end
+              # Add result.
+              class_name = execution.caller_class.to_s
+              method_name = method.to_s
+              @@reflekt_db.get("#{class_name}.#{method_name}").push(reflection.result())
 
-    @reflekt_forked = true
+            end
 
-  end
+            # Save results.
+            @@reflekt_db.write()
+
+            # Render results.
+            reflekt_render()
 
-  def reflekt_action(clone, method, *args)
+            execution.is_reflecting = false
+          end
 
-    class_name = clone.class.to_s
-    method_name = method.to_s
+        end
 
-    # TODO: Create control fork. Get good value. Check against it.
+        @reflection_counts[method] = @reflection_counts[method] + 1
 
-    # Create new arguments that are deviations on inputted type.
-    input = []
+        # Continue execution / shadow execution.
+        super *args
 
-    args.each do |arg|
-      case arg
-      when Integer
-        input << rand(9999)
-      else
-        input << arg
       end
-    end
 
-    # Action method with new arguments.
-    begin
-      output = clone.send(method, *input)
-
-      # Build reflection.
-      reflection = {
-        REFLEKT_TIME => Time.now.to_i,
-        REFLEKT_INPUT => reflekt_normalize_input(input),
-        REFLEKT_OUTPUT => reflekt_normalize_output(output)
-      }
-
-    # When fail.
-  rescue StandardError => message
-      reflection[REFLEKT_STATUS] = REFLEKT_MESSAGE
-      reflection[REFLEKT_MESSAGE] = message
-    # When pass.
-    else
-      reflection[REFLEKT_STATUS] = REFLEKT_PASS
     end
 
-    # Save reflection.
-    @@reflekt_db.get("#{class_name}.#{method_name}").push(reflection)
-
-  end
+    # Continue initialization.
+    super
 
-  ##
-  # Normalize inputs.
-  #
-  # @param args - The actual inputs.
-  # @return - A generic inputs representation.
-  ##
-  def reflekt_normalize_input(args)
-    inputs = []
-    args.each do |arg|
-      input = {
-        REFLEKT_TYPE => arg.class.to_s,
-        REFLEKT_VALUE => reflekt_normalize_value(arg)
-      }
-      if (arg.class == Array)
-        input[REFLEKT_COUNT] = arg.count
-      end
-      inputs << input
-    end
-    inputs
   end
 
   ##
-  # Normalize output.
-  #
-  # @param output - The actual output.
-  # @return - A generic output representation.
+  # Render results.
   ##
-  def reflekt_normalize_output(output)
-
-    o = {
-      REFLEKT_TYPE => output.class.to_s,
-      REFLEKT_VALUE => reflekt_normalize_value(output)
-    }
-
-    if (output.class == Array || output.class == Hash)
-      o[REFLEKT_COUNT] = output.count
-    elsif (output.class == TrueClass || output.class == FalseClass)
-      o[REFLEKT_TYPE] = :Boolean
-    end
-
-    return o
-
-  end
-
-  def reflekt_normalize_value(value)
-
-    unless value.nil?
-      value = value.to_s.gsub(/\r?\n/, " ").to_s
-      if value.length >= 30
-        value = value[0, value.rindex(/\s/,30)].rstrip() + '...'
-      end
-    end
-
-    return value
-
-  end
-
   def reflekt_render()
 
-    # Render results.
+    # Get JSON.
     @@reflekt_json = File.read("#{@@reflekt_output_path}/db.json")
+
+    # Save HTML.
     template = File.read("#{@@reflekt_path}/web/template.html.erb")
     rendered = ERB.new(template).result(binding)
     File.open("#{@@reflekt_output_path}/index.html", 'w+') do |f|
@@ -225,20 +152,24 @@ module Reflekt
   # Setup class.
   def self.reflekt_setup_class()
 
-    # Receive configuration from host application.
+    # Receive configuration.
     $ENV ||= {}
     $ENV[:reflekt] ||= $ENV[:reflekt] = {}
 
+    # Set configuration.
     @@reflekt_path = File.dirname(File.realpath(__FILE__))
 
-    # Create "reflections" directory in configured path.
+    # Create reflection tree.
+    @@reflekt_stack = ShadowStack.new()
+
+    # Build reflections directory.
     if $ENV[:reflekt][:output_path]
       @@reflekt_output_path = File.join($ENV[:reflekt][:output_path], 'reflections')
-    # Create "reflections" directory in current execution path.
+    # Build reflections directory in current execution path.
     else
       @@reflekt_output_path = File.join(Dir.pwd, 'reflections')
     end
-
+    # Create reflections directory.
     unless Dir.exist? @@reflekt_output_path
       Dir.mkdir(@@reflekt_output_path)
     end
@@ -252,7 +183,7 @@ module Reflekt
 
   module SingletonClassMethods
 
-    @@deflekted_methods = Set.new
+    @@reflekt_skipped_methods = Set.new
 
     ##
     # Skip a method.
@@ -260,16 +191,16 @@ module Reflekt
     # @param method - A symbol representing the method name.
     ##
     def reflekt_skip(method)
-      @@deflekted_methods.add(method)
+      @@reflekt_skipped_methods.add(method)
     end
 
-    def deflekted?(method)
-      return true if @@deflekted_methods.include?(method)
+    def reflekt_skipped?(method)
+      return true if @@reflekt_skipped_methods.include?(method)
       false
     end
 
     def reflekt_limit(amount)
-      @reflekt_limit = amount
+      @@reflection_limit = amount
     end
 
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: reflekt
 version: !ruby/object:Gem::Version
-  version: 0.7.2
+  version: 0.9.0
 platform: ruby
 authors:
 - Maedi Prichard
@@ -30,11 +30,14 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- lib/Execution.rb
+- lib/Reflection.rb
+- lib/ShadowStack.rb
 - lib/reflekt.rb
 - lib/web/script.js
 - lib/web/style.css
 - lib/web/template.html.erb
-homepage: https://github.com/maedi/reflekt
+homepage: https://github.com/refIekt/reflekt
 licenses:
 - MPL-2.0
 metadata: {}