reflekt 0.9.9 → 1.0.4

data/lib/Rule.rb

@@ -13,6 +13,8 @@
 
 class Rule
 
+  attr_reader :type
+
   ##
   # Each rule trains on metadata to determine its boundaries.
   #
@@ -31,7 +33,7 @@ class Rule
   end
 
   ##
-  # Each rule provides metadata.
+  # Each rule provides results.
   #
   # @return [Hash]
   ##
@@ -39,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

@@ -12,6 +12,8 @@
 ################################################################################
 
 require 'set'
+require 'MetaBuilder'
+require_relative './meta/NullMeta.rb'
 
 class RuleSet
 
@@ -22,43 +24,68 @@ class RuleSet
   ##
   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
 
   ##
   # Train rule set on metadata.
   #
-  # @param meta [Meta] The metadata to train on.
+  # @param meta [Hash] The metadata to train on.
   ##
   def train(meta)
 
-    unless meta.nil? || meta[:type].nil?
-
-      meta_type = meta[:type]
-      @types << meta_type
+    # Track supported meta types.
+    meta_type = meta[:type]
+    @meta_types << meta_type
 
-      # Get rule types for this meta type.
-      if @meta_map.key? meta_type
-        @meta_map[meta_type].each do |rule_type|
+    # Get rule types for this meta type.
+    if @meta_map.key? meta_type
+      @meta_map[meta_type].each do |rule_type|
 
-          # Ensure rule exists.
-          if @rules[rule_type].nil?
-            @rules << rule_type.new()
-          end
+        # Ensure rule exists.
+        if @rules[rule_type].nil?
+          @rules[rule_type] = rule_type.new()
+        end
 
-          # Train rule.
-          @rules[rule_type].train(meta)
+        # Train rule.
+        @rules[rule_type].train(meta)
 
-        end
       end
+    end
 
-      return self
+  end
 
+  ##
+  # @param value [Dynamic]
+  ##
+  def test(value)
+
+    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
+
+    @rules.each do |klass, rule|
+      if (rule.type == meta_type)
+        unless rule.test(value)
+           result = false
+        end
+      end
     end
 
+    return result
+
   end
 
   ##
@@ -78,4 +105,5 @@ class RuleSet
 
   end
 
+
 end

data/lib/meta/ArrayMeta.rb

@@ -4,6 +4,7 @@ class ArrayMeta < Meta
 
   def initialize()
 
+    @type = :array
     @min = nil
     @max = nil
     @length = nil
@@ -21,9 +22,9 @@ class ArrayMeta < Meta
 
   end
 
-  def result()
+  def serialize()
     {
-      :type => :array,
+      :type => @type,
       :max => @max,
       :min => @min,
       :length => @length

data/lib/meta/BooleanMeta.rb

@@ -3,19 +3,22 @@ require 'Meta'
 class BooleanMeta < Meta
 
   def initialize()
+
+    @type = :bool
     @value = nil
+
   end
 
   ##
   # @param value [Boolean]
   ##
   def load(value)
-    @value = value
+    @value = value.to_s
   end
 
-  def result()
+  def serialize()
     {
-      :type => :bool,
+      :type => @type,
       :value => @value
     }
   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

@@ -3,7 +3,10 @@ require 'Meta'
 class IntegerMeta < Meta
 
   def initialize()
+
+    @type = :int
     @value = nil
+
   end
 
   ##
@@ -13,9 +16,9 @@ class IntegerMeta < Meta
     @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

@@ -3,7 +3,10 @@ require 'Meta'
 class StringMeta < Meta
 
   def initialize()
+
+    @type = :string
     @length = nil
+
   end
 
   ##
@@ -13,9 +16,9 @@ class StringMeta < Meta
     @length = value.length
   end
 
-  def result()
+  def serialize()
     {
-      :type => :string,
+      :type => @type,
       :length => @length
     }
   end

data/lib/rules/ArrayRule.rb

@@ -4,6 +4,7 @@ class ArrayRule < Rule
 
   def initialize()
 
+    @type = :array
     @min = nil
     @max = nil
     @min_length = nil
@@ -64,7 +65,7 @@ class ArrayRule < Rule
 
   def result()
     {
-      :type => :array,
+      :type => @type,
       :min => @min,
       :max => @max,
       :min_length => @min_length,
@@ -72,4 +73,16 @@ class ArrayRule < Rule
     }
   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

@@ -5,6 +5,7 @@ class BooleanRule < Rule
 
   def initialize()
 
+    @type = :bool
     @booleans = Set.new()
 
   end
@@ -27,16 +28,20 @@ class BooleanRule < Rule
   ##
   def test(value)
 
-    @booleans.include? value
+    # Booleans are stored as strings.
+    @booleans.include? value.to_s
 
   end
 
   def result()
     {
-      :type => :bool,
-      :is_true => @booleans.include?,
-      :is_false => @booleans.include?
+      :type => @type,
+      :booleans => @booleans
     }
   end
 
+  def random()
+    @booleans.to_a.sample
+  end
+
 end

data/lib/rules/FloatRule.rb

@@ -0,0 +1,57 @@
+require 'Rule'
+
+class FloatRule < Rule
+
+  def initialize()
+
+    @type = :float
+    @min = nil
+    @max = nil
+
+  end
+
+  ##
+  # @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
+
+  ##
+  # @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

@@ -4,6 +4,7 @@ class IntegerRule < Rule
 
   def initialize()
 
+    @type = :int
     @min = nil
     @max = nil
 
@@ -43,10 +44,14 @@ class IntegerRule < Rule
 
   def result()
     {
-      :type => :int,
+      :type => @type,
       :min => @min,
       :max => @max
     }
   end
 
+  def random()
+    rand(@min..@max)
+  end
+
 end

data/lib/rules/NullRule.rb

@@ -0,0 +1,36 @@
+require 'Rule'
+
+class NullRule < Rule
+
+  def initialize()
+    @type = :null
+  end
+
+  ##
+  # @param meta [NullMeta]
+  ##
+  def train(meta)
+    # No need to train. NullMeta is always null.
+  end
+
+  ##
+  # @param value [NilClass]
+  ##
+  def test(value)
+
+    return false unless value.nil?
+    return true
+
+  end
+
+  def result()
+    {
+      :type => @type
+    }
+  end
+
+  def random()
+    nil
+  end
+
+end