reflekt 0.9.6 → 1.0.1

data/lib/ShadowStack.rb

@@ -1,7 +1,7 @@
 ################################################################################
-# SHADOW STACK
+# Track the executions in a shadow call stack.
 #
-# Track the executions in a call stack.
+# @pattern Stack
 ################################################################################
 
 class ShadowStack
@@ -20,37 +20,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

data/lib/meta/ArrayMeta.rb

@@ -0,0 +1,34 @@
+require 'Meta'
+
+class ArrayMeta < Meta
+
+  def initialize()
+
+    @type = :array
+    @min = nil
+    @max = nil
+    @length = nil
+
+  end
+
+  ##
+  # @param value [Array]
+  ##
+  def load(value)
+
+    @min = value.min()
+    @max = value.max()
+    @length = value.length()
+
+  end
+
+  def result()
+    {
+      :type => @type,
+      :max => @max,
+      :min => @min,
+      :length => @length
+    }
+  end
+
+end

data/lib/meta/BooleanMeta.rb

@@ -0,0 +1,26 @@
+require 'Meta'
+
+class BooleanMeta < Meta
+
+  def initialize()
+
+    @type = :bool
+    @value = nil
+
+  end
+
+  ##
+  # @param value [Boolean]
+  ##
+  def load(value)
+    @value = value.to_s
+  end
+
+  def result()
+    {
+      :type => @type,
+      :value => @value
+    }
+  end
+
+end

data/lib/meta/FloatMeta.rb

@@ -0,0 +1,26 @@
+require 'Meta'
+
+class FloatMeta < Meta
+
+  def initialize()
+
+    @type = :float
+    @value = nil
+
+  end
+
+  ##
+  # @param value [Float]
+  ##
+  def load(value)
+    @value = value
+  end
+
+  def result()
+    {
+      :type => @type,
+      :value => @value
+    }
+  end
+
+end

data/lib/meta/IntegerMeta.rb

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

data/lib/meta/StringMeta.rb

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

data/lib/rules/ArrayRule.rb

@@ -0,0 +1,88 @@
+require 'Rule'
+
+class ArrayRule < Rule
+
+  def initialize()
+
+    @type = :array
+    @min = nil
+    @max = nil
+    @min_length = nil
+    @max_length = nil
+
+  end
+
+  ##
+  # @param meta [ArrayMeta]
+  ##
+  def train(meta)
+
+    # Min value.
+    if @min.nil?
+      @min = meta[:min]
+    else
+      @min = meta[:min] if meta[:min] < @min
+    end
+
+    # Max value.
+    if @max.nil?
+      @max = meta[:max]
+    else
+      @max = meta[:max] if meta[:max] > @max
+    end
+
+    # Min length.
+    if @min_length.nil?
+      @min_length = meta[:length]
+    else
+      @min_length = meta[:length] if meta[:length] < @min_length
+    end
+
+    # Max length.
+    if @max_length.nil?
+      @max_length = meta[:length]
+    else
+      @max_length = meta[:length] if meta[:length] > @max_length
+    end
+
+  end
+
+  ##
+  # @param value [Array]
+  ##
+  def test(value)
+
+    # Min/max value.
+    return false if value.min() < @min
+    return false if value.max() > @max
+
+    # Min/max length.
+    return false if value.length < @min_length
+    return false if value.length > @max_length
+
+    true
+  end
+
+  def result()
+    {
+      :type => @type,
+      :min => @min,
+      :max => @max,
+      :min_length => @min_length,
+      :max_length => @max_length
+    }
+  end
+
+  def random()
+
+    array = Array.new(rand(@min_length..@max_length))
+
+    array.each_with_index do |item, index|
+      array[index] = rand(@min..@max)
+    end
+
+    return array
+
+  end
+
+end

data/lib/rules/BooleanRule.rb

@@ -0,0 +1,45 @@
+require 'set'
+require 'Rule'
+
+class BooleanRule < Rule
+
+  def initialize()
+
+    @type = :bool
+    @booleans = Set.new()
+
+  end
+
+  ##
+  # @param meta [BooleanMeta]
+  ##
+  def train(meta)
+
+    value = meta[:value]
+
+    unless value.nil?
+      @booleans << value
+    end
+
+  end
+
+  ##
+  # @param value [Boolean]
+  ##
+  def test(value)
+    @booleans.include? value
+  end
+
+  def result()
+    {
+      :type => @type,
+      :is_true => @booleans.include?,
+      :is_false => @booleans.include?
+    }
+  end
+
+  def random()
+    @booleans.to_a.sample
+  end
+
+end

data/lib/rules/FloatRule.rb

@@ -2,27 +2,56 @@ require 'Rule'
 
 class FloatRule < Rule
 
-  attr_accessor :min
-  attr_accessor :max
-
   def initialize()
-    super
 
+    @type = :float
     @min = nil
     @max = nil
-  end
 
-  def load(value)
-    @values << value
   end
 
-  def train()
-    # TODO.
+  ##
+  # @param meta [FloatMeta]
+  ##
+  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
+
   end
 
-  def validate(value)
-    # TODO.
+  ##
+  # @param value [Float]
+  ##
+  def test(value)
+
+    return false if value < @min
+    return false if value > @max
+
     true
   end
 
+  def result()
+    {
+      :type => @type,
+      :min => @min,
+      :max => @max
+    }
+  end
+
+  def random()
+    rand(@min..@max)
+  end
+
 end

data/lib/rules/IntegerRule.rb

@@ -3,24 +3,38 @@ require 'Rule'
 class IntegerRule < Rule
 
   def initialize()
+
+    @type = :int
     @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 +42,16 @@ class IntegerRule < Rule
     true
   end
 
+  def result()
+    {
+      :type => @type,
+      :min => @min,
+      :max => @max
+    }
+  end
+
+  def random()
+    rand(@min..@max)
+  end
+
 end