reflekt 1.0.1 → 1.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cfaf70b43c12867f93934b6b1f2e0d672486b3331369c9c85c0646e54bfc18d2
-  data.tar.gz: 437bbcdd66ae77ec202360255386edc10d69bcfb2da5b41816b0aed3c3151285
+  metadata.gz: 7f9ff9a7d13d77e0e468cf961d6ef1dd6dd2c381b6d3d4fb1a1799b59aa1fdc6
+  data.tar.gz: 8bb82ca18b00bd0a1e329bd94557a164eff90fb607fbbcbfa6ef8b026f4619c9
 SHA512:
-  metadata.gz: 789f134df80a4cb9455274cd36d968f83903f6c474b6974d451ecfea1910799121f815eeecb9162a3b0ea2417f52983f1bb4557a5dd9b729fbdfa3e7325a6b99
-  data.tar.gz: 3bfb838fb97dda4989fba353db654b9498ce2ff8112f880d0bb5c926ae58865e05916701ec81cf393486b0b279af308a349245c970242879774c172bf12e2e7c
+  metadata.gz: 9d22878d22a93be41323d89b6a718808f78fa61c8cc186ddde480a5298ea1a1ae1fc49576141186d3dee7c02a29295c67a59e41aa732ec1e9dc3b4fd878e7add
+  data.tar.gz: 2d759df0674e8dc496ae92b585588b2a927c8aa7bda0368be8265705e1340af60ebe393c84b059dd2516d23cb8f7577b7baa4fe016f1a17ed3934a9fbcc084a2

data/lib/Aggregator.rb

@@ -49,10 +49,7 @@ class Aggregator
       unless control["inputs"].nil?
         control["inputs"].each_with_index do |meta, arg_num|
 
-          # TODO: Remove once "Fix Rowdb.get(path)" bug fixed.
-          meta = meta.transform_keys(&:to_sym)
-          # Deserialize meta type to symbol.
-          meta[:type] = meta[:type].to_sym
+          meta = Meta.deserialize(meta)
 
           # Get rule set.
           rule_set = get_input_rule_set(klass, method, arg_num)
@@ -79,7 +76,7 @@ class Aggregator
       end
 
       # Train on metadata.
-      output_rule_set.train(control["output"])
+      output_rule_set.train(Meta.deserialize(control["output"]))
 
     end
 
@@ -177,6 +174,7 @@ class Aggregator
       FalseClass => BooleanRule,
       Float      => FloatRule,
       Integer    => IntegerRule,
+      NilClass   => NullRule,
       String     => StringRule
     }
 
@@ -184,6 +182,21 @@ class Aggregator
 
   end
 
+  def self.testable?(args, input_rule_sets)
+
+    args.each_with_index do |arg, arg_num|
+
+      rule_type = value_to_rule_type(arg)
+      if input_rule_sets[arg_num].rules[rule_type].nil?
+        return false
+      end
+
+    end
+
+    return true
+
+  end
+
   ##############################################################################
   # HELPERS
   ##############################################################################

data/lib/Config.rb

@@ -26,6 +26,7 @@ class Config
       :bool   => [BooleanRule],
       :int    => [IntegerRule],
       :float  => [FloatRule],
+      :null   => [NullRule],
       :string => [StringRule]
     }
 

data/lib/Control.rb

@@ -1,12 +1,21 @@
 ################################################################################
 # A shapshot of real data.
 #
-# A control's @number property will always be zero.
+# @note
+#   A control's @number property will always be zero.
+#
+# @nomenclature
+#   args, inputs/output and meta represent different stages of a value.
 #
 # @hierachy
 #   1. Execution
 #   2. Control <- YOU ARE HERE
 #   3. Meta
+#
+# @status
+#   - :pass [Symbol] The reflection passes the rules.
+#   - :fail [Symbol] The reflection fails the rules or produces a system error.
+#   - :error [Symbol] The control reflection produces a system error.
 ################################################################################
 
 require 'Reflection'

data/lib/Meta.rb

@@ -28,12 +28,44 @@ class Meta
   end
 
   ##
-  # Each meta provides metadata.
+  # Each meta serializes metadata.
   #
   # @return [Hash]
   ##
-  def result()
+  def serialize()
     {}
   end
 
+  ##############################################################################
+  # CLASS
+  ##############################################################################
+
+  ##
+  # Deserialize metadata.
+  #
+  # @todo Deserialize should create a Meta object.
+  # @todo Require each Meta type to handle its own deserialization.
+  #
+  # @param meta [Hash] The metadata to deserialize.
+  # @param meta [Hash]
+  ##
+  def self.deserialize(meta)
+
+    # Convert nil meta into NullMeta.
+    # Meta is nil when there are no @inputs or @output on the method.
+    if meta.nil?
+      return NullMeta.new().serialize()
+    end
+
+    # Symbolize keys.
+    # TODO: Remove once "Fix Rowdb.get(path)" bug fixed.
+    meta = meta.transform_keys(&:to_sym)
+
+    # Symbolize type value.
+    meta[:type] = meta[:type].to_sym
+
+    return meta
+
+  end
+
 end

data/lib/MetaBuilder.rb

@@ -73,6 +73,7 @@ class MetaBuilder
       FalseClass => :bool,
       Float      => :float,
       Integer    => :int,
+      NilClass   => :null,
       String     => :string
     }
 

data/lib/Reflection.rb

@@ -1,6 +1,10 @@
 ################################################################################
 # A snapshot of simulated data.
 #
+# @note
+#   A reflection's random value is within the bounds of aggregated control rule sets
+#   as well as as the arg type being inputted into the current control reflection.
+#
 # @nomenclature
 #   args, inputs/output and meta represent different stages of a value.
 #
@@ -8,6 +12,11 @@
 #   1. Execution
 #   2. Reflection <- YOU ARE HERE
 #   3. Meta
+#
+# @status
+#   - :pass [Symbol] The reflection passes the rules.
+#   - :fail [Symbol] The reflection fails the rules or produces a system error.
+#   - :error [Symbol] The control reflection produces a system error.
 ################################################################################
 
 require 'Clone'
@@ -20,11 +29,6 @@ class Reflection
   ##
   # Create a Reflection.
   #
-  # @status
-  #   - :pass The reflection passes the rules.
-  #   - :fail The reflection fails the rules or produces a system error.
-  #   - :error The control reflection produces a system error.
-  #
   # @param execution [Execution] The Execution that created this Reflection.
   # @param number [Integer] Multiple Reflections can be created per Execution.
   # @param aggregator [Aggregator] The aggregated RuleSet for this class/method.
@@ -72,14 +76,17 @@ class Reflection
     # When arguments exist.
     unless args.size == 0
 
-      # When aggregated rule sets exist.
+      # Create random arguments from aggregated rule sets.
       unless input_rule_sets.nil?
 
-        # Randomize arguments from rule sets.
-        args = randomize(args, input_rule_sets)
+        # Base random arguments on the types of the current arguments.
+        if Aggregator.testable?(args, input_rule_sets)
+
+          args = randomize(args, input_rule_sets)
 
-        # Validate arguments against aggregated rule sets.
-        unless @aggregator.test_inputs(args, input_rule_sets)
+        # TODO: Fallback to argument types from aggregated control rule sets
+        # when arg types not testable or reflect_amount above 3.
+        else
           @status = :fail
         end
 
@@ -98,7 +105,7 @@ class Reflection
       output = @clone.send(@method, *args)
       @output = MetaBuilder.create(output)
 
-      # Validate output with aggregated control rule sets.
+      # Validate output against aggregated control rule sets.
       unless output_rule_set.nil?
         unless @aggregator.test_output(output, output_rule_set)
           @status = :fail
@@ -145,7 +152,7 @@ class Reflection
   #
   # @return [Hash] Reflection metadata.
   ##
-  def result()
+  def serialize()
 
     # The ID of the first execution in the ShadowStack.
     base_id = nil
@@ -171,12 +178,12 @@ class Reflection
     unless @inputs.nil?
       reflection[:inputs] = []
       @inputs.each do |meta|
-        reflection[:inputs] << meta.result()
+        reflection[:inputs] << meta.serialize()
       end
     end
 
     unless @output.nil?
-      reflection[:output] = @output.result()
+      reflection[:output] = @output.serialize()
     end
 
     return reflection

data/lib/Reflekt.rb

@@ -92,7 +92,7 @@ module Reflekt
               else
 
                 # Save control as reflection.
-                @@reflekt.db.get("reflections").push(control.result())
+                @@reflekt.db.get("reflections").push(control.serialize())
 
                 # Multiple reflections per execution.
                 execution.reflections.each_with_index do |value, index|
@@ -106,12 +106,12 @@ module Reflekt
                   @reflekt_counts[method] = @reflekt_counts[method] + 1
 
                   # Save reflection.
-                  @@reflekt.db.get("reflections").push(reflection.result())
+                  @@reflekt.db.get("reflections").push(reflection.serialize())
 
                 end
 
                 # Save control.
-                @@reflekt.db.get("controls").push(control.result())
+                @@reflekt.db.get("controls").push(control.serialize())
 
                 # Save results.
                 @@reflekt.db.write()

data/lib/RuleSet.rb

@@ -13,6 +13,7 @@
 
 require 'set'
 require 'MetaBuilder'
+require_relative './meta/NullMeta.rb'
 
 class RuleSet
 
@@ -37,40 +38,44 @@ class RuleSet
   ##
   # 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?
+    # Track supported meta types.
+    meta_type = meta[:type]
+    @meta_types << meta_type
 
-      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] = 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
 
   end
 
+  ##
+  # @param value [Dynamic]
+  ##
   def test(value)
-    result = true
 
-    # Only test data type on rule of matching meta type.
+    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)
@@ -80,6 +85,7 @@ class RuleSet
     end
 
     return result
+
   end
 
   ##

data/lib/meta/ArrayMeta.rb

@@ -22,7 +22,7 @@ class ArrayMeta < Meta
 
   end
 
-  def result()
+  def serialize()
     {
       :type => @type,
       :max => @max,

data/lib/meta/BooleanMeta.rb

@@ -16,7 +16,7 @@ class BooleanMeta < Meta
     @value = value.to_s
   end
 
-  def result()
+  def serialize()
     {
       :type => @type,
       :value => @value

data/lib/meta/FloatMeta.rb

@@ -16,7 +16,7 @@ class FloatMeta < Meta
     @value = value
   end
 
-  def result()
+  def serialize()
     {
       :type => @type,
       :value => @value

data/lib/meta/IntegerMeta.rb

@@ -16,7 +16,7 @@ class IntegerMeta < Meta
     @value = value
   end
 
-  def result()
+  def serialize()
     {
       :type => @type,
       :value => @value

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

@@ -16,7 +16,7 @@ class StringMeta < Meta
     @length = value.length
   end
 
-  def result()
+  def serialize()
     {
       :type => @type,
       :length => @length

data/lib/rules/BooleanRule.rb

@@ -27,14 +27,16 @@ class BooleanRule < Rule
   # @param value [Boolean]
   ##
   def test(value)
-    @booleans.include? value
+
+    # Booleans are stored as strings.
+    @booleans.include? value.to_s
+
   end
 
   def result()
     {
       :type => @type,
-      :is_true => @booleans.include?,
-      :is_false => @booleans.include?
+      :booleans => @booleans
     }
   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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: reflekt
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.0.2
 platform: ruby
 authors:
 - Maedi Prichard
@@ -48,11 +48,13 @@ files:
 - lib/meta/BooleanMeta.rb
 - lib/meta/FloatMeta.rb
 - lib/meta/IntegerMeta.rb
+- lib/meta/NullMeta.rb
 - lib/meta/StringMeta.rb
 - lib/rules/ArrayRule.rb
 - lib/rules/BooleanRule.rb
 - lib/rules/FloatRule.rb
 - lib/rules/IntegerRule.rb
+- lib/rules/NullRule.rb
 - lib/rules/StringRule.rb
 - lib/web/README.md
 - lib/web/bundle.js