reflekt 0.9.1 → 0.9.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3589292c5c5cba2f3d7c7d5e1d7e02ee1052afe7339929cfa058b787b89c3158
-  data.tar.gz: d33c6774d53d4b7a0978fcfc48fa00e22f3684ccd51e5d42676f01831fb84291
+  metadata.gz: 6df15da98e45aecc17c3594c000b6234f77afde5ce89541104bc3afe7eb5a221
+  data.tar.gz: 3f1446eb16bdcd214d3df924d0b2df0017bc26b073c5c94e36d1094849a9b1ef
 SHA512:
-  metadata.gz: 2e3120f544d87057b4783a4e6e76a9689844f17ed1ad602c8b2c5e5ee241285ef83e276b56fbdb33da0d167c68077eca6f851e859a28392718a26ed129ab18e7
-  data.tar.gz: 47d323198d8d27585ef5fb0d493eca120d0cd2ff532a6578ef3b7490ccbc9e4fc38757bab8fb2ad4ab6c05c0a9fd721b27a5925a90c95503c0de5d4fb7483e12
+  metadata.gz: e84519473c26febf3522119e66b25708abc1f05271c01b498debcb00c69eaf4b8bc244e43374737fef49e946304529c0efc2e6fceade3629c4ccef5503f1d3fa
+  data.tar.gz: 8faa3f80665504b4e5ffb182b7e9977234bd13e2f17aa5fac41636068b30ea07bfbf5aa580bee6deae2bb8e5fa6ea0ea7dc09505ce0a28bbf8797bb785aea0bb

data/lib/Accessor.rb

@@ -0,0 +1,38 @@
+################################################################################
+# ACCESSOR
+#
+# Access variables via one object to avoid polluting the caller class scope.
+#
+# Some variables are not accessed via Accessor:
+#   - @reflekt_counts on the instance
+#   - @reflekt_enabled on the instance
+#   - @@reflekt_skipped_methods on the instance's singleton class
+################################################################################
+
+class Accessor
+
+  attr_accessor :setup
+  attr_accessor :db
+  attr_accessor :stack
+  attr_accessor :ruler
+  attr_accessor :renderer
+  attr_accessor :path
+  attr_accessor :output_path
+  attr_accessor :reflect_amount
+  attr_accessor :reflect_limit
+
+  def initialize()
+
+    @setup = nil
+    @db = nil
+    @stack = nil
+    @ruler = nil
+    @renderer = nil
+    @path = nil
+    @output_path = nil
+    @reflect_amount = nil
+    @reflect_limit = nil
+
+  end
+
+end

data/lib/Control.rb

@@ -2,6 +2,32 @@ require 'Reflection'
 
 class Control < Reflection
 
-  # TODO.
+  ##
+  # 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)
+
+    @inputs = *args
+
+    # Action method with new arguments.
+    begin
+      @output = @clone.send(@method, *@inputs)
+    # When fail.
+    rescue StandardError => message
+      @status = :fail
+      @message = message
+    # When pass.
+    else
+      @status = :pass
+    end
+
+  end
 
 end

data/lib/Execution.rb

@@ -1,24 +1,56 @@
 class Execution
 
-  attr_accessor :object
+  attr_accessor :unique_id
+  attr_accessor :caller_object
   attr_accessor :caller_id
   attr_accessor :caller_class
+  attr_accessor :klass
+  attr_accessor :method
+  attr_accessor :base
   attr_accessor :parent
   attr_accessor :child
   attr_accessor :control
   attr_accessor :reflections
   attr_accessor :is_reflecting
+  attr_accessor :is_base
 
-  def initialize(object, reflection_count)
+  ##
+  # Create Execution.
+  #
+  # @param Object object - The calling object.
+  # @param Symbol method - The calling method.
+  # @param Integer number - The number of reflections to create per execution.
+  # @param ShadowStack stack - The shadow execution call stack.
+  ##
+  def initialize(caller_object, method, number, stack)
 
-    @object = object
-    @caller_id = object.object_id
-    @caller_class = object.class
+    @time = Time.now.to_i
+    @unique_id = @time + rand(1..99999)
+    @base = nil
     @parent = nil
     @child = nil
 
-    @control = []
-    @reflections = Array.new(reflection_count)
+    # Dependency.
+    @stack = stack
+
+    # Caller.
+    @caller_object = caller_object
+    @caller_id = caller_object.object_id
+    @caller_class = caller_object.class
+    @klass = @caller_class.to_s.to_sym
+    @method = method
+
+    # Reflections.
+    @control = nil
+    @reflections = Array.new(number)
+
+    # State.
+    if @stack.peek() == nil
+      @is_base = true
+    else
+      @is_base = false
+      @base = @stack.base()
+    end
     @is_reflecting = false
 
   end

data/lib/Reflection.rb

@@ -1,35 +1,38 @@
 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)
+  ##
+  # Create a Reflection.
+  #
+  # @param Execution execution - The Execution that created this Reflection.
+  # @param Integer number - Multiple Reflections can be created per Execution.
+  # @param Ruler ruler - The RuleSets for this class/method.
+  ##
+  def initialize(execution, number, ruler)
 
     @execution = execution
-    @method = method
-    @is_control = is_control
+    @unique_id = execution.unique_id + number
+    @number = number
+
+    # Dependency.
+    @ruler = ruler
+
+    # Caller.
+    @klass = execution.klass
+    @method = execution.method
 
-    # Clone the execution's object.
-    @clone = execution.object.clone
+    # Arguments.
+    @inputs = []
+    @output = nil
+
+    # Clone the execution's calling object.
+    @clone = execution.caller_object.clone
     @clone_id = nil
 
     # Result.
-    @status = nil
+    @status = :pass
     @time = Time.now.to_i
-    @input = []
-    @output = nil
 
   end
 
@@ -38,51 +41,78 @@ class Reflection
   #
   # Creates a shadow execution stack.
   #
-  # @param method - The name of the method.
-  # @param *args - The method arguments.
+  # @param *args - The method's 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
+    # Get RuleSets.
+    input_rule_sets = @ruler.get_input_rule_sets(@klass, @method)
+    output_rule_set = @ruler.get_output_rule_set(@klass, @method)
+
+    # Create deviated arguments.
+    args.each do |arg|
+      case arg
+      when Integer
+        @inputs << rand(999)
+      else
+        @inputs << arg
       end
     end
 
     # Action method with new arguments.
     begin
-      @output = @clone.send(@method, *@input)
+
+      # Validate input with controls.
+      unless input_rule_sets.nil?
+        unless @ruler.validate_inputs(@inputs, input_rule_sets)
+          @status = :fail
+        end
+      end
+
+      # Run reflection.
+      @output = @clone.send(@method, *@inputs)
+
+      # Validate output with controls.
+      unless output_rule_set.nil?
+        unless @ruler.validate_output(@output, output_rule_set)
+          @status = :fail
+        end
+      end
+
     # When fail.
     rescue StandardError => message
-      @status = MESSAGE
+      @status = :fail
       @message = message
-    # When pass.
-    else
-      @status = PASS
     end
 
   end
 
   def result()
+
+    # The ID of the first execution in the ShadowStack.
+    base_id = nil
+    unless @execution.base == nil
+      base_id = @execution.base.unique_id
+    end
+
     # Build reflection.
     reflection = {
-      TIME => @time,
-      STATUS => @status,
-      INPUT => normalize_input(@input),
-      OUTPUT => normalize_output(@output),
-      MESSAGE => @message
+      :base_id => base_id,
+      :exe_id => @execution.unique_id,
+      :ref_id => @unique_id,
+      :ref_num => @number,
+      :time => @time,
+      :class => @klass,
+      :method => @method,
+      :status => @status,
+      :input => normalize_input(@inputs),
+      :output => normalize_output(@output),
+      :message => @message
     }
+
+    return reflection
   end
 
   ##
@@ -95,11 +125,10 @@ class Reflection
     inputs = []
     args.each do |arg|
       input = {
-        TYPE => arg.class.to_s,
-        VALUE => normalize_value(arg)
+        :type => arg.class.to_s
       }
       if (arg.class == Array)
-        input[COUNT] = arg.count
+        input[:count] = arg.count
       end
       inputs << input
     end
@@ -112,20 +141,19 @@ class Reflection
   # @param input - The actual output.
   # @return - A generic output representation.
   ##
-  def normalize_output(input)
+  def normalize_output(arg)
 
-    output = {
-      TYPE => input.class.to_s,
-      VALUE => normalize_value(input)
+    input = {
+      :type => arg.class.to_s
     }
 
-    if (input.class == Array || input.class == Hash)
-      output[COUNT] = input.count
-    elsif (input.class == TrueClass || input.class == FalseClass)
-      output[TYPE] = :Boolean
+    if (arg.class == Array || arg.class == Hash)
+      input[:count] = arg.count
+    elsif (arg.class == TrueClass || arg.class == FalseClass)
+      input[:type] = :Boolean
     end
 
-    return output
+    return input
 
   end
 

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

@@ -1,37 +1,32 @@
-require 'set'
-require 'erb'
-require 'rowdb'
-require 'Control'
-require 'Execution'
-require 'Reflection'
-require 'ShadowStack'
-
 ################################################################################
-# REFLEKT
+# REFLEKT - By Maedi Prichard.
 #
 # 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.
+# Many Refections are created per Execution.
+# Each Reflection executes on a ShadowStack on cloned data.
 # Then flow is returned to the original method and normal execution continues.
 #
 # Usage:
-#
 #   class ExampleClass
 #     prepend Reflekt
 ################################################################################
 
-module Reflekt
-
-  # The amount of reflections to create per method call.
-  @@reflekt_reflect_amount = 2
+require 'set'
+require 'erb'
+require 'rowdb'
+require 'Accessor'
+require 'Control'
+require 'Execution'
+require 'Reflection'
+require 'Renderer'
+require 'Ruler'
+require 'ShadowStack'
 
-  # 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
+module Reflekt
 
   def initialize(*args)
 
-    @reflection_counts = {}
+    @reflekt_counts = {}
 
     # Get instance methods.
     # TODO: Include parent methods like "Array.include?".
@@ -40,23 +35,24 @@ module Reflekt
       # Don't process skipped methods.
       next if self.class.reflekt_skipped?(method)
 
-      @reflection_counts[method] = 0
+      @reflekt_counts[method] = 0
 
       # When method called in flow.
       self.define_singleton_method(method) do |*args|
 
         # Don't reflect when limit reached.
-        unless @reflection_counts[method] >= @@reflection_limit
+        unless @reflekt_counts[method] >= @@reflekt.reflect_limit
 
           # Get current execution.
-          execution = @@reflekt_stack.peek()
+          execution = @@reflekt.stack.peek()
 
           # When stack empty or past execution done reflecting.
           if execution.nil? || execution.has_finished_reflecting?
 
             # Create execution.
-            execution = Execution.new(self, @@reflekt_reflect_amount)
-            @@reflekt_stack.push(execution)
+            execution = Execution.new(self, method, @@reflekt.reflect_amount, @@reflekt.stack)
+
+            @@reflekt.stack.push(execution)
 
           end
 
@@ -66,47 +62,43 @@ module Reflekt
           if execution.has_empty_reflections? && !execution.is_reflecting?
             execution.is_reflecting = true
 
-            class_name = execution.caller_class.to_s
-            method_name = method.to_s
-
             # Create control.
-            control = Control.new(execution, method, true)
+            control = Control.new(execution, 1, @@reflekt.ruler)
             execution.control = control
 
             # Execute control.
             control.reflect(*args)
 
             # Save control.
-            @@reflekt_db.get("#{class_name}.#{method_name}.controls").push(control.result())
+            @@reflekt.db.get("controls").push(control.result())
 
             # Multiple reflections per execution.
             execution.reflections.each_with_index do |value, index|
 
               # Create reflection.
-              reflection = Reflection.new(execution, method, false)
+              reflection = Reflection.new(execution, index + 1, @@reflekt.ruler)
               execution.reflections[index] = reflection
 
               # Execute reflection.
               reflection.reflect(*args)
+              @reflekt_counts[method] = @reflekt_counts[method] + 1
 
               # Save reflection.
-              @@reflekt_db.get("#{class_name}.#{method_name}.reflections").push(reflection.result())
+              @@reflekt.db.get("reflections").push(reflection.result())
 
             end
 
             # Save results.
-            @@reflekt_db.write()
+            @@reflekt.db.write()
 
             # Render results.
-            reflekt_render()
+            @@reflekt.renderer.render()
 
             execution.is_reflecting = false
           end
 
         end
 
-        @reflection_counts[method] = @reflection_counts[method] + 1
-
         # Continue execution / shadow execution.
         super *args
 
@@ -119,42 +111,17 @@ module Reflekt
 
   end
 
-  ##
-  # Render results.
-  ##
-  def reflekt_render()
-
-    # 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|
-      f.write rendered
-    end
-
-    # Add JS.
-    javascript = File.read("#{@@reflekt_path}/web/script.js")
-    File.open("#{@@reflekt_output_path}/script.js", 'w+') do |f|
-      f.write javascript
-    end
-
-    # Add CSS.
-    stylesheet = File.read("#{@@reflekt_path}/web/style.css")
-    File.open("#{@@reflekt_output_path}/style.css", 'w+') do |f|
-      f.write stylesheet
-    end
-
-  end
-
   private
 
   def self.prepended(base)
+
     # Prepend class methods to the instance's singleton class.
     base.singleton_class.prepend(SingletonClassMethods)
 
-    @@reflekt_setup ||= reflekt_setup_class
+    # Setup class.
+    @@reflekt = Accessor.new()
+    @@reflekt.setup ||= reflekt_setup_class
+
   end
 
   # Setup class.
@@ -165,26 +132,58 @@ module Reflekt
     $ENV[:reflekt] ||= $ENV[:reflekt] = {}
 
     # Set configuration.
-    @@reflekt_path = File.dirname(File.realpath(__FILE__))
+    @@reflekt.path = File.dirname(File.realpath(__FILE__))
 
-    # Create reflection tree.
-    @@reflekt_stack = ShadowStack.new()
-
-    # Build reflections directory.
+    # Get reflections directory path from config.
     if $ENV[:reflekt][:output_path]
-      @@reflekt_output_path = File.join($ENV[:reflekt][:output_path], 'reflections')
-    # Build reflections directory in current execution path.
+      @@reflekt.output_path = File.join($ENV[:reflekt][:output_path], 'reflections')
+    # Get reflections directory path from current execution path.
     else
-      @@reflekt_output_path = File.join(Dir.pwd, 'reflections')
+      @@reflekt.output_path = File.join(Dir.pwd, 'reflections')
     end
+
     # Create reflections directory.
-    unless Dir.exist? @@reflekt_output_path
-      Dir.mkdir(@@reflekt_output_path)
+    unless Dir.exist? @@reflekt.output_path
+      Dir.mkdir(@@reflekt.output_path)
     end
 
     # Create database.
-    @@reflekt_db = Rowdb.new(@@reflekt_output_path + '/db.json')
-    @@reflekt_db.defaults({ :reflekt => { :api_version => 1 }}).write()
+    @@reflekt.db = Rowdb.new(@@reflekt.output_path + '/db.js')
+    @@reflekt.db.defaults({ :reflekt => { :api_version => 1 }})
+
+    # Create shadow execution stack.
+    @@reflekt.stack = ShadowStack.new()
+
+    # Create rules.
+    @@reflekt.ruler = Ruler.new()
+    # TODO: Fix Rowdb.get(path) not returning values at path after Rowdb.push()?
+    values = @@reflekt.db.value()
+    values.each do |klass, class_values|
+
+      class_values.each do |method_name, method_items|
+        next if method_items.nil?
+        next unless method_items.class == Hash
+        if method_items.key? "controls"
+
+          method = method_name.to_sym
+
+          @@reflekt.ruler.load(klass, method, method_items['controls'])
+          @@reflekt.ruler.train(klass, method)
+
+        end
+      end
+
+    end
+
+    # The amount of reflections to create per method call.
+    @@reflekt.reflect_amount = 2
+
+    # Limit the amount of reflections that can be created per instance method.
+    # A method called thousands of times doesn't need that many reflections.
+    @@reflekt.reflect_limit = 10
+
+    # Create renderer.
+    @@reflekt.renderer = Renderer.new(@@reflekt.path, @@reflekt.output_path)
 
     return true
   end
@@ -208,7 +207,7 @@ module Reflekt
     end
 
     def reflekt_limit(amount)
-      @@reflection_limit = amount
+      @@reflekt.reflect_limit = amount
     end
 
   end