reflekt 0.9.8 → 1.0.3

data/lib/Rule.rb

@@ -1,12 +1,20 @@
 ################################################################################
-# All rules behave the same.
+# A pattern that metadata follows.
+#
+# @pattern Abstract class
+#
+# @hierachy
+#   1. Aggregator
+#   2. RuleSet
+#   3. Rule <- YOU ARE HERE
 #
-# @pattern Abstract class.
 # @see lib/rules for rules.
 ################################################################################
 
 class Rule
 
+  attr_reader :type
+
   ##
   # Each rule trains on metadata to determine its boundaries.
   #
@@ -25,7 +33,7 @@ class Rule
   end
 
   ##
-  # Each rule provides metadata.
+  # Each rule provides results.
   #
   # @return [Hash]
   ##
@@ -33,4 +41,12 @@ class Rule
     {}
   end
 
+  ##
+  # Each rule provides a random example that matches the rule's boundaries.
+  #
+  # @return [Dynamic] A random value.
+  ##
+  def random()
+  end
+
 end

data/lib/RuleSet.rb

@@ -1,87 +1,90 @@
 ################################################################################
-# A collection of rules that validate a value.
+# A collection of rules that validate metadata.
+#
+# @patterns
+#   - Dependency Injection
+#   - Builder
+#
+# @hierachy
+#   1. Aggregator
+#   2. RuleSet <- YOU ARE HERE
+#   3. Rule
 ################################################################################
 
 require 'set'
+require 'MetaBuilder'
+require_relative './meta/NullMeta.rb'
 
 class RuleSet
 
   attr_accessor :rules
 
-  def initialize()
+  ##
+  # @param meta_map [Hash] The rules to apply to each data type.
+  ##
+  def initialize(meta_map)
+
+    # The rules that apply to meta types.
+    @meta_map = meta_map
+
+    # The types of meta this rule set applies to.
+    # Rules are only validated on their supported meta type.
+    @meta_types = Set.new()
 
     @rules = {}
-    @types = Set.new()
 
   end
 
-  def self.create_sets(args)
+  ##
+  # Train rule set on metadata.
+  #
+  # @param meta [Hash] The metadata to train on.
+  ##
+  def train(meta)
 
-    rule_sets = []
+    # Track supported meta types.
+    meta_type = meta[:type]
+    @meta_types << meta_type
 
-    args.each do |arg|
-      rule_sets << self.create_set(arg)
-    end
+    # Get rule types for this meta type.
+    if @meta_map.key? meta_type
+      @meta_map[meta_type].each do |rule_type|
 
-    rule_sets
-  end
+        # Ensure rule exists.
+        if @rules[rule_type].nil?
+          @rules[rule_type] = rule_type.new()
+        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
+        # Train rule.
+        @rules[rule_type].train(meta)
+
+      end
     end
 
-    rule_set
   end
 
   ##
-  # Train rule set on metadata.
-  #
-  # @param meta [Meta] The metadata to train on.
+  # @param value [Dynamic]
   ##
-  def train(meta)
+  def test(value)
 
-    # 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
+    result = true
+    meta_type = MetaBuilder.data_type_to_meta_type(value)
+
+    # Fail if value's meta type not testable by rule set.
+    unless @meta_types.include? meta_type
+      return false
     end
 
-    # Train rule.
-    unless rule.nil?
-      rule.train(meta)
+    @rules.each do |klass, rule|
+      if (rule.type == meta_type)
+        unless rule.test(value)
+           result = false
+        end
+      end
     end
 
-    return self
+    return result
 
   end
 
@@ -102,4 +105,5 @@ class RuleSet
 
   end
 
+
 end

data/lib/ShadowStack.rb

@@ -1,5 +1,7 @@
 ################################################################################
 # Track the executions in a shadow call stack.
+#
+# @pattern Stack
 ################################################################################
 
 class ShadowStack

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 serialize()
+    {
+      :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 serialize()
+    {
+      :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 serialize()
+    {
+      :type => @type,
+      :value => @value
+    }
+  end
+
+end

data/lib/meta/IntegerMeta.rb

@@ -4,6 +4,7 @@ class IntegerMeta < Meta
 
   def initialize()
 
+    @type = :int
     @value = nil
 
   end
@@ -12,14 +13,12 @@ class IntegerMeta < Meta
   # @param value [Integer]
   ##
   def load(value)
-
     @value = value
-
   end
 
-  def result()
+  def serialize()
     {
-      :type => :int,
+      :type => @type,
       :value => @value
     }
   end

data/lib/meta/NullMeta.rb

@@ -0,0 +1,34 @@
+################################################################################
+# A reprsentation of a null value.
+#
+# @note
+#   A "null" value on serialized "inputs" and "output" also becomes a NullMeta.
+#
+# @hierachy
+#   1. Execution
+#   2. Reflection
+#   3. Meta <- YOU ARE HERE
+################################################################################
+
+require 'Meta'
+
+class NullMeta < Meta
+
+  def initialize()
+    @type = :null
+  end
+
+  ##
+  # @param value [NilClass]
+  ##
+  def load(value)
+    # No need to load a value for null meta.
+  end
+
+  def serialize()
+    {
+      :type => @type,
+    }
+  end
+
+end

data/lib/meta/StringMeta.rb

@@ -4,22 +4,21 @@ class StringMeta < Meta
 
   def initialize()
 
+    @type = :string
     @length = nil
 
   end
 
   ##
-  # @param value [Integer]
+  # @param value [String]
   ##
   def load(value)
-
     @length = value.length
-
   end
 
-  def result()
+  def serialize()
     {
-      :type => :string,
+      :type => @type,
       :length => @length
     }
   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