reflekt 0.9.2 → 0.9.8

data/lib/Reflekt.rb

@@ -0,0 +1,205 @@
+################################################################################
+# Reflective testing.
+#
+# @author
+#   Maedi Prichard
+#
+# @flow
+#   1. An Execution is created on method call.
+#   2. Many Refections are created per Execution.
+#   3. Each Reflection executes on cloned data.
+#   4. Flow is returned to the original method.
+#
+# @usage
+#   class ExampleClass
+#     prepend Reflekt
+################################################################################
+
+require 'set'
+require 'erb'
+require 'rowdb'
+require 'Accessor'
+require 'Aggregator'
+require 'Control'
+require 'Execution'
+require 'Reflection'
+require 'Renderer'
+require 'ShadowStack'
+
+module Reflekt
+
+  def initialize(*args)
+
+    @reflekt_counts = {}
+
+    # Get instance methods.
+    # TODO: Include parent methods like "Array.include?".
+    self.class.instance_methods(false).each do |method|
+
+      # Don't process skipped methods.
+      next if self.class.reflekt_skipped?(method)
+
+      @reflekt_counts[method] = 0
+
+      # When method called in flow.
+      self.define_singleton_method(method) do |*args|
+
+        # Don't reflect when limit reached.
+        unless @reflekt_counts[method] >= @@reflekt.reflect_limit
+
+          # Get current execution.
+          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, method, @@reflekt.reflect_amount, @@reflekt.stack)
+
+            @@reflekt.stack.push(execution)
+
+          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
+
+            # Create control.
+            control = Control.new(execution, 1, @@reflekt.aggregator)
+            execution.control = control
+
+            # Execute control.
+            control.reflect(*args)
+
+            # Save control.
+            @@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, index + 1, @@reflekt.aggregator)
+              execution.reflections[index] = reflection
+
+              # Execute reflection.
+              reflection.reflect(*args)
+              @reflekt_counts[method] = @reflekt_counts[method] + 1
+
+              # Save reflection.
+              @@reflekt.db.get("reflections").push(reflection.result())
+
+            end
+
+            # Save results.
+            @@reflekt.db.write()
+
+            # Render results.
+            @@reflekt.renderer.render()
+
+            execution.is_reflecting = false
+          end
+
+        end
+
+        # Continue execution / shadow execution.
+        super *args
+
+      end
+
+    end
+
+    # Continue initialization.
+    super
+
+  end
+
+  private
+
+  def self.prepended(base)
+
+    # Prepend class methods to the instance's singleton class.
+    base.singleton_class.prepend(SingletonClassMethods)
+
+    # Setup class.
+    @@reflekt = Accessor.new()
+    @@reflekt.setup ||= reflekt_setup_class
+
+  end
+
+  # Setup class.
+  def self.reflekt_setup_class()
+
+    # Receive configuration.
+    $ENV ||= {}
+    $ENV[:reflekt] ||= $ENV[:reflekt] = {}
+    $ENV[:reflekt][:output_directory] = "reflections"
+
+    # Set configuration.
+    @@reflekt.path = File.dirname(File.realpath(__FILE__))
+
+    # Get reflections directory path from config or current execution path.
+    if $ENV[:reflekt][:output_path]
+      @@reflekt.output_path = File.join($ENV[:reflekt][:output_path], $ENV[:reflekt][:output_directory])
+    else
+      @@reflekt.output_path = File.join(Dir.pwd, $ENV[:reflekt][:output_directory])
+    end
+
+    # Create reflections directory.
+    unless Dir.exist? @@reflekt.output_path
+      Dir.mkdir(@@reflekt.output_path)
+    end
+
+    # Create database.
+    @@reflekt.db = Rowdb.new(@@reflekt.output_path + '/db.js')
+    @@reflekt.db.defaults({ :reflekt => { :api_version => 1 }})
+    # @TODO Fix Rowdb.get(path) not returning values at path after Rowdb.push()
+    db = @@reflekt.db.value()
+
+    # Create shadow stack.
+    @@reflekt.stack = ShadowStack.new()
+
+    # Create aggregated rule sets.
+    @@reflekt.aggregator = Aggregator.new()
+    @@reflekt.aggregator.train(db[:controls])
+
+    # 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
+
+  module SingletonClassMethods
+
+    @@reflekt_skipped_methods = Set.new()
+
+    ##
+    # Skip a method.
+    #
+    # @param method [Symbol] The method name.
+    ##
+    def reflekt_skip(method)
+      @@reflekt_skipped_methods.add(method)
+    end
+
+    def reflekt_skipped?(method)
+      return true if @@reflekt_skipped_methods.include?(method)
+      false
+    end
+
+    def reflekt_limit(amount)
+      @@reflekt.reflect_limit = amount
+    end
+
+  end
+
+end

data/lib/Renderer.rb

@@ -0,0 +1,39 @@
+class Renderer
+
+  def initialize(path, output_path)
+
+    @path = path
+    @output_path = output_path
+
+  end
+
+  ##
+  # Place files in output path.
+  ##
+  def render()
+
+    filenames = [
+      "bundle.js",
+      "index.html",
+      "package-lock.json",
+      "package.json",
+      "README.md",
+      "server.js"
+    ]
+
+    filenames.each do |filename|
+      file = File.read(File.join(@path, "web", filename))
+      File.open(File.join(@output_path, filename), 'w+') do |f|
+        f.write file
+      end
+    end
+
+    file = File.read(File.join(@path, "web", "gitignore.txt"))
+    File.open(File.join(@output_path, ".gitignore"), 'w+') do |f|
+      f.write file
+    end
+
+  end
+
+
+end

data/lib/Rule.rb

@@ -1,38 +1,36 @@
-require 'set'
+################################################################################
+# All rules behave the same.
+#
+# @pattern Abstract class.
+# @see lib/rules for rules.
+################################################################################
 
 class Rule
 
-  attr_accessor :type
-  attr_accessor :min
-  attr_accessor :max
-  attr_accessor :length
-  attr_accessor :types
-  attr_accessor :values
-
-  def initialize()
-
-    @types = Set.new
-    @values = Set.new
-    @min = nil
-    @max = nil
-    @length = nil
-
-  end
-
   ##
-  # A parameter can accept multiple input types.
-  # Duplicates will not be added to the set.
+  # Each rule trains on metadata to determine its boundaries.
+  #
+  # @param meta [Meta]
   ##
-  def add_type(type)
-    @types.add(type)
+  def train(meta)
   end
 
-  def add_value(value)
-    @values.add(value)
+  ##
+  # Each rule validates a value with its boundaries.
+  #
+  # @param value [Dynamic]
+  # @return [Boolean] Whether the value passes or fails.
+  ##
+  def test(value)
   end
 
-  def is_number?
-    @types.include? Integer
+  ##
+  # Each rule provides metadata.
+  #
+  # @return [Hash]
+  ##
+  def result()
+    {}
   end
 
 end

data/lib/RuleSet.rb

@@ -0,0 +1,105 @@
+################################################################################
+# A collection of rules that validate a value.
+################################################################################
+
+require 'set'
+
+class RuleSet
+
+  attr_accessor :rules
+
+  def initialize()
+
+    @rules = {}
+    @types = Set.new()
+
+  end
+
+  def self.create_sets(args)
+
+    rule_sets = []
+
+    args.each do |arg|
+      rule_sets << self.create_set(arg)
+    end
+
+    rule_sets
+  end
+
+  def self.create_set(value)
+
+    rule_set = RuleSet.new()
+    value_type = value.class.to_s
+
+    # Creates values for matching data type.
+    case value_type
+    when "Integer"
+      rule = IntegerRule.new()
+      rule.train(arg)
+      rule_set.rules[IntegerRule] = rule
+    when "String"
+      rule = StringRule.new()
+      rule.train(arg)
+      rule_set.rules[StringRule] = rule
+    end
+
+    rule_set
+  end
+
+  ##
+  # Train rule set on metadata.
+  #
+  # @param meta [Meta] The metadata to train on.
+  ##
+  def train(meta)
+
+    # Track data type.
+    @types << meta.class
+    type = meta.class.to_s
+
+    # Get rule for this data type.
+    rule = nil
+    case type
+    when "Integer"
+      unless @rules.key? IntegerRule
+        rule = IntegerRule.new()
+        @rules[IntegerRule] = rule
+      else
+        rule = @rules[IntegerRule]
+      end
+    when "String"
+      unless @rules.key? StringRule
+        rule = StringRule.new()
+        @rules[StringRule] = rule
+      else
+        rule = @rules[IntegerRule]
+      end
+    end
+
+    # Train rule.
+    unless rule.nil?
+      rule.train(meta)
+    end
+
+    return self
+
+  end
+
+  ##
+  # Get the results of the rules.
+  #
+  # @return [Array] The rules.
+  ##
+  def result()
+
+    rules = {}
+
+    @rules.each do |key, rule|
+      rules[rule.class] = rule.result()
+    end
+
+    return rules
+
+  end
+
+end

data/lib/ShadowStack.rb

@@ -1,7 +1,5 @@
 ################################################################################
-# SHADOW STACK
-#
-# Track the executions in a call stack.
+# Track the executions in a shadow call stack.
 ################################################################################
 
 class ShadowStack
@@ -20,37 +18,25 @@ class ShadowStack
   end
 
   ##
-  # Push Execution.
+  # Place Execution at the top of stack.
   #
-  # @param object - The object being executed.
-  # @param args - The arguments being executed.
-  #
-  # @return Execution - The new execution.
+  # @param execution [Execution] The execution to place.
+  # @return [Execution] The placed execution.
   ##
   def push(execution)
 
-    # Reference previous execution.
+    # Place first execution at bottom of stack.
     if @bottom.nil?
       @bottom = execution
+    # Connect subsequent executions to each other.
     else
-      execution.child = @top
       @top.parent = execution
+      execution.child = @top
     end
 
-    # Place new execution at the top of the stack.
+    # Place execution at top of 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