reflekt 0.9.7 → 0.9.8

data/lib/Reflekt.rb

@@ -1,12 +1,16 @@
 ################################################################################
-# REFLEKT - By Maedi Prichard.
+# Reflective testing.
 #
-# An Execution is created each time a method is called.
-# 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.
+# @author
+#   Maedi Prichard
 #
-# Usage:
+# @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
 ################################################################################
@@ -15,11 +19,11 @@ require 'set'
 require 'erb'
 require 'rowdb'
 require 'Accessor'
+require 'Aggregator'
 require 'Control'
 require 'Execution'
 require 'Reflection'
 require 'Renderer'
-require 'Ruler'
 require 'ShadowStack'
 
 module Reflekt
@@ -63,7 +67,7 @@ module Reflekt
             execution.is_reflecting = true
 
             # Create control.
-            control = Control.new(execution, 1, @@reflekt.ruler)
+            control = Control.new(execution, 1, @@reflekt.aggregator)
             execution.control = control
 
             # Execute control.
@@ -76,7 +80,7 @@ module Reflekt
             execution.reflections.each_with_index do |value, index|
 
               # Create reflection.
-              reflection = Reflection.new(execution, index + 1, @@reflekt.ruler)
+              reflection = Reflection.new(execution, index + 1, @@reflekt.aggregator)
               execution.reflections[index] = reflection
 
               # Execute reflection.
@@ -130,16 +134,16 @@ module Reflekt
     # 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.
+    # Get reflections directory path from config or current execution path.
     if $ENV[:reflekt][:output_path]
-      @@reflekt.output_path = File.join($ENV[:reflekt][:output_path], 'reflections')
-    # Get reflections directory path from current execution path.
+      @@reflekt.output_path = File.join($ENV[:reflekt][:output_path], $ENV[:reflekt][:output_directory])
     else
-      @@reflekt.output_path = File.join(Dir.pwd, 'reflections')
+      @@reflekt.output_path = File.join(Dir.pwd, $ENV[:reflekt][:output_directory])
     end
 
     # Create reflections directory.
@@ -150,30 +154,15 @@ module Reflekt
     # 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 execution stack.
+    # Create shadow 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
+    # 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
@@ -186,16 +175,17 @@ module Reflekt
     @@reflekt.renderer = Renderer.new(@@reflekt.path, @@reflekt.output_path)
 
     return true
+
   end
 
   module SingletonClassMethods
 
-    @@reflekt_skipped_methods = Set.new
+    @@reflekt_skipped_methods = Set.new()
 
     ##
     # Skip a method.
     #
-    # @param method - A symbol representing the method name.
+    # @param method [Symbol] The method name.
     ##
     def reflekt_skip(method)
       @@reflekt_skipped_methods.add(method)

data/lib/Renderer.rb

@@ -28,6 +28,11 @@ class Renderer
       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
 
 

data/lib/Rule.rb

@@ -1,32 +1,36 @@
 ################################################################################
-# RULES
+# All rules behave the same.
 #
-# Abstract class.
-# See lib/rules for rules.
+# @pattern Abstract class.
+# @see lib/rules for rules.
 ################################################################################
 
-require 'set'
-
 class Rule
 
-  # Each rule intitalises itself.
-  def initialize()
-    @values = []
+  ##
+  # Each rule trains on metadata to determine its boundaries.
+  #
+  # @param meta [Meta]
+  ##
+  def train(meta)
   end
 
-  # Each rule loads up an array of values.
-  def load(value)
-    @values << value
+  ##
+  # Each rule validates a value with its boundaries.
+  #
+  # @param value [Dynamic]
+  # @return [Boolean] Whether the value passes or fails.
+  ##
+  def test(value)
   end
 
-  # Each rule trains on values to determine its boundaries.
-  def train()
-
-  end
-
-  # Each rule compares the values it's given with its boundaries.
-  def validate(value)
-
+  ##
+  # Each rule provides metadata.
+  #
+  # @return [Hash]
+  ##
+  def result()
+    {}
   end
 
 end

data/lib/RuleSet.rb

@@ -1,34 +1,64 @@
 ################################################################################
-# RULE POOL
-#
-# A collection of unique rules that validate an argument.
+# A collection of rules that validate a value.
 ################################################################################
 
 require 'set'
-require 'rules/FloatRule'
-require 'rules/IntegerRule'
-require 'rules/StringRule'
 
 class RuleSet
 
-  attr_accessor :types
   attr_accessor :rules
 
   def initialize()
 
-    @types = Set.new
     @rules = {}
+    @types = Set.new()
 
   end
 
-  def load(type, value)
+  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 << 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
@@ -46,34 +76,30 @@ class RuleSet
       end
     end
 
-    # Add value to rule.
+    # Train rule.
     unless rule.nil?
-      rule.load(value)
+      rule.train(meta)
     end
 
     return self
 
   end
 
-  def train()
+  ##
+  # Get the results of the rules.
+  #
+  # @return [Array] The rules.
+  ##
+  def result()
 
-    @rules.each do |klass, rule|
-      rule.train()
-    end
+    rules = {}
 
-  end
-
-  def validate_rule(value)
-    result = true
-
-    @rules.each do |klass, rule|
-
-      unless rule.validate(value)
-        result = false
-      end
+    @rules.each do |key, rule|
+      rules[rule.class] = rule.result()
     end
 
-    return result
+    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,24 +18,23 @@ 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

data/lib/meta/IntegerMeta.rb

@@ -0,0 +1,27 @@
+require 'Meta'
+
+class IntegerMeta < Meta
+
+  def initialize()
+
+    @value = nil
+
+  end
+
+  ##
+  # @param value [Integer]
+  ##
+  def load(value)
+
+    @value = value
+
+  end
+
+  def result()
+    {
+      :type => :int,
+      :value => @value
+    }
+  end
+
+end

data/lib/meta/StringMeta.rb

@@ -0,0 +1,27 @@
+require 'Meta'
+
+class StringMeta < Meta
+
+  def initialize()
+
+    @length = nil
+
+  end
+
+  ##
+  # @param value [Integer]
+  ##
+  def load(value)
+
+    @length = value.length
+
+  end
+
+  def result()
+    {
+      :type => :string,
+      :length => @length
+    }
+  end
+
+end

data/lib/rules/IntegerRule.rb

@@ -3,24 +3,37 @@ require 'Rule'
 class IntegerRule < Rule
 
   def initialize()
+
     @min = nil
     @max = nil
 
-    super
   end
 
-  def load(value)
-    @values << value.to_i
-  end
+  ##
+  # @param meta [IntegerMeta]
+  ##
+  def train(meta)
+
+    value = meta[:value]
+
+    if @min.nil?
+      @min = value
+    else
+      @min = value if value < @min
+    end
+
+    if @max.nil?
+      @max = value
+    else
+      @max = value if value > @max
+    end
 
-  def train()
-    numbers = @values.select {|num| num.class == Integer }
-    numbers.sort!
-    @min = numbers.first
-    @max = numbers.last
   end
 
-  def validate(value)
+  ##
+  # @param value [Integer]
+  ##
+  def test(value)
 
     return false if value < @min
     return false if value > @max
@@ -28,4 +41,11 @@ class IntegerRule < Rule
     true
   end
 
+  def result()
+    {
+      :type => :int,
+      :value => @min # Min/max are the same.
+    }
+  end
+
 end