reflekt 1.0.0 → 1.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e94e86e6d558012df59e1aebfdbbb7c2bf70a2e849e9a186795a3e4d5cb648f0
-  data.tar.gz: 9db428f6c518c06fbddb83e0abd9920b9dc30344846827b5c9505c3f2bc111c9
+  metadata.gz: 457006f1c0a4fbe9a1ce47684aeeec980852cd966f29d07ac57751161f314d52
+  data.tar.gz: ca01fd9306ece9e1698aab0dcb4945a848a5a910625f8b9394b4f26aa7819514
 SHA512:
-  metadata.gz: e2a7ecf3adb9e06f7f3a09d507265c035bf3c641193711c64fea512b03973696c8ef9278d59eedf43ee83dd03a0f5f552026f0b2f6ba6182c6361bb35a211bf7
-  data.tar.gz: f002c69e490b63dd065e5f0ba0b40e9dcbbe980f71e7df66da01b1bc37b2dfe1081c9e58a3024b388b96628cc98422875a5b90f1e9227327f3241bc5d61450b0
+  metadata.gz: 1de336f083b2e90230453d3ce07cfb36981998587de2e126c88948da75a618ee57a68b32b9869865fb9353b45e85fadc293d98afc2c4669afe8fadc9761fda93
+  data.tar.gz: 0b00aa43ef7763bc11e93697446ca0e86114818f3e6238d28711d1038eef0c4bc58dc43b1f1f901ec58a4cdf6c9138493e63572a7d33a0363a591e908b38e751

data/lib/{Execution.rb → Action.rb}

@@ -1,13 +1,13 @@
 ################################################################################
-# A shadow execution.
+# A shadow action.
 #
 # @hierachy
-#   1. Execution <- YOU ARE HERE
+#   1. Action <- YOU ARE HERE
 #   2. Reflection
 #   3. Meta
 ################################################################################
 
-class Execution
+class Action
 
   attr_accessor :unique_id
   attr_accessor :caller_object
@@ -24,12 +24,12 @@ class Execution
   attr_accessor :is_base
 
   ##
-  # Create Execution.
+  # Create Action.
   #
   # @param object [Object] The calling object.
   # @param method [Symbol] The calling method.
-  # @param reflect_amount [Integer] The number of reflections to create per execution.
-  # @param stack [ShadowStack] The shadow execution call stack.
+  # @param reflect_amount [Integer] The number of reflections to create per action.
+  # @param stack [ActionStack] The shadow action call stack.
   ##
   def initialize(caller_object, method, reflect_amount, stack)
 
@@ -69,7 +69,7 @@ class Execution
   end
 
   ##
-  # Is the Execution currently reflecting methods?
+  # Is the Action currently reflecting methods?
   ##
   def is_reflecting?
     @is_reflecting

data/lib/ActionStack.rb

@@ -0,0 +1,44 @@
+################################################################################
+# Track the actions in a shadow call stack.
+#
+# @pattern Stack
+################################################################################
+
+class ActionStack
+
+  def initialize()
+    @bottom = nil
+    @top = nil
+  end
+
+  def peek()
+    @top
+  end
+
+  def base()
+    @bottom
+  end
+
+  ##
+  # Place Action at the top of stack.
+  #
+  # @param action [Action] The action to place.
+  # @return [Action] The placed action.
+  ##
+  def push(action)
+
+    # Place first action at bottom of stack.
+    if @bottom.nil?
+      @bottom = action
+    # Connect subsequent actions to each other.
+    else
+      @top.parent = action
+      action.child = @top
+    end
+
+    # Place action at top of stack.
+    @top = action
+
+  end
+
+end

data/lib/Aggregator.rb

@@ -46,24 +46,13 @@ class Aggregator
       # INPUT
       ##
 
-      unless control["inputs"].nil?
+      # Singular null input.
+      if control["inputs"].nil?
+        train_input(klass, method, nil, 0)
+      # Multiple inputs.
+      else
         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
-
-          # Get rule set.
-          rule_set = get_input_rule_set(klass, method, arg_num)
-          if rule_set.nil?
-            rule_set = RuleSet.new(@meta_map)
-            set_input_rule_set(klass, method, arg_num, rule_set)
-          end
-
-          # Train on metadata.
-          rule_set.train(meta)
-
+          train_input(klass, method, meta, arg_num)
         end
       end
 
@@ -79,16 +68,33 @@ class Aggregator
       end
 
       # Train on metadata.
-      output_rule_set.train(control["output"])
+      output_rule_set.train(Meta.deserialize(control["output"]))
 
     end
 
   end
 
+  def train_input(klass, method, meta, arg_num)
+
+    # Get deserialized meta.
+    meta = Meta.deserialize(meta)
+
+    # Get rule set.
+    rule_set = get_input_rule_set(klass, method, arg_num)
+    if rule_set.nil?
+      rule_set = RuleSet.new(@meta_map)
+      set_input_rule_set(klass, method, arg_num, rule_set)
+    end
+
+    # Train on metadata.
+    rule_set.train(meta)
+
+  end
+
   ##
   # Validate inputs.
   #
-  # @stage Called when validating a reflection.
+  # @stage Called when validating a control reflection.
   # @param inputs [Array] The method's arguments.
   # @param input_rule_sets [Array] The RuleSets to validate each input with.
   ##
@@ -177,6 +183,7 @@ class Aggregator
       FalseClass => BooleanRule,
       Float      => FloatRule,
       Integer    => IntegerRule,
+      NilClass   => NullRule,
       String     => StringRule
     }
 
@@ -184,6 +191,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/Clone.rb

@@ -7,17 +7,17 @@
 #   on object, not indirectly through clone which results in "undefined method".
 #
 # @hierachy
-#   1. Execution
+#   1. Action
 #   2. Reflection
 #   3. Clone <- YOU ARE HERE
 ################################################################################
 
 class Clone
 
-  def initialize(execution)
+  def initialize(action)
 
-    # Clone the execution's calling object.
-    @caller_object_clone = execution.caller_object.clone
+    # Clone the action's calling object.
+    @caller_object_clone = action.caller_object.clone
 
     # TODO: Clone any other instances that this clone references.
     # TODO: Replace clone's references to these new instances.

data/lib/Config.rb

@@ -26,11 +26,12 @@ class Config
       :bool   => [BooleanRule],
       :int    => [IntegerRule],
       :float  => [FloatRule],
+      :null   => [NullRule],
       :string => [StringRule]
     }
 
     # An absolute path to the directory that contains the output directory.
-    # Defaults to current execution path.
+    # Defaults to current action path.
     @output_path = nil
 
     # Name of output directory.

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 will always be 0.
+#
+# @nomenclature
+#   args, inputs/output and meta represent different stages of a value.
 #
 # @hierachy
-#   1. Execution
+#   1. Action
 #   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'
@@ -17,35 +26,37 @@ class Control < Reflection
   ##
   # Reflect on a method.
   #
-  # Creates a shadow execution.
+  # Creates a shadow action.
   # @param *args [Dynamic] The method's arguments.
   ##
   def reflect(*args)
 
-    # Get aggregated rule sets.
+    # Get trained rule sets.
     input_rule_sets = @aggregator.get_input_rule_sets(@klass, @method)
     output_rule_set = @aggregator.get_output_rule_set(@klass, @method)
 
+    # Fail when no trained rule sets.
+    if input_rule_sets.nil?
+      @status = :fail
+    end
+
     # When arguments exist.
     unless args.size == 0
 
-      # When aggregated rule sets exist.
+      # Validate arguments against trained rule sets.
       unless input_rule_sets.nil?
-
-        # Validate arguments against aggregated rule sets.
         unless @aggregator.test_inputs(args, input_rule_sets)
           @status = :fail
         end
-
       end
 
       # Create metadata for each argument.
-      # TODO: Create metadata for other inputs such as properties on the instance.
+      # TODO: Create metadata for other inputs such as instance variables.
       @inputs = MetaBuilder.create_many(args)
 
     end
 
-    # Action method with new/old arguments.
+    # Action method with real arguments.
     begin
 
       # Run reflection.

data/lib/Meta.rb

@@ -5,7 +5,7 @@
 # @see lib/meta for each meta.
 #
 # @hierachy
-#   1. Execution
+#   1. Action
 #   2. Reflection
 #   3. Meta <- YOU ARE HERE
 ################################################################################
@@ -16,7 +16,7 @@ class Meta
   # Each meta defines its type.
   ##
   def initialize()
-    @type = nil
+    @type = :null
   end
 
   ##
@@ -28,12 +28,44 @@ class Meta
   end
 
   ##
-  # Each meta provides metadata.
-  #
   # @return [Hash]
   ##
-  def result()
-    {}
+  def serialize()
+    {
+      :type => @type
+    }
+  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,13 +1,22 @@
 ################################################################################
-# A snapshot of simulated data.
+# A snapshot of random 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.
 #
 # @hierachy
-#   1. Execution
+#   1. Action
 #   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,35 +29,30 @@ 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 action [Action] The Action that created this Reflection.
+  # @param number [Integer] Multiple Reflections can be created per Action.
   # @param aggregator [Aggregator] The aggregated RuleSet for this class/method.
   ##
-  def initialize(execution, number, aggregator)
+  def initialize(action, number, aggregator)
 
-    @execution = execution
-    @unique_id = execution.unique_id + number
+    @action = action
+    @unique_id = action.unique_id + number
     @number = number
 
     # Dependency.
     @aggregator = aggregator
 
     # Caller.
-    @klass = execution.klass
-    @method = execution.method
+    @klass = action.klass
+    @method = action.method
 
     # Metadata.
     @inputs = nil
     @output = nil
 
-    # Clone the execution's calling object.
+    # Clone the action's calling object.
     # TODO: Abstract away into Clone class.
-    @clone = execution.caller_object.clone
+    @clone = action.caller_object.clone
 
     # Result.
     @status = :pass
@@ -60,7 +64,7 @@ class Reflection
   ##
   # Reflect on a method.
   #
-  # Creates a shadow execution.
+  # Creates a shadow action.
   # @param *args [Dynamic] The method's arguments.
   ##
   def reflect(*args)
@@ -69,36 +73,33 @@ class Reflection
     input_rule_sets = @aggregator.get_input_rule_sets(@klass, @method)
     output_rule_set = @aggregator.get_output_rule_set(@klass, @method)
 
+    # Fail when no trained rule sets.
+    if input_rule_sets.nil?
+      @status = :fail
+    end
+
     # 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)
-
-        # Validate arguments against aggregated rule sets.
-        unless @aggregator.test_inputs(args, input_rule_sets)
-          @status = :fail
-        end
-
       end
 
       # Create metadata for each argument.
-      # TODO: Create metadata for other inputs such as properties on the instance.
+      # TODO: Create metadata for other inputs such as instance variables.
       @inputs = MetaBuilder.create_many(args)
 
     end
 
-    # Action method with new/old arguments.
+    # Action method with random arguments.
     begin
 
       # Run 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
@@ -118,7 +119,7 @@ class Reflection
   ##
   # Create random values for each argument from control reflections.
   #
-  # @param args [Dynamic] The arguments to create random values for.
+  # @param args [Dynamic] The arguments to mirror random values for.
   # @param input_rule_sets [Array] Aggregated rule sets for each argument.
   #
   # @return [Dynamic] Random arguments.
@@ -129,9 +130,11 @@ class Reflection
 
     args.each_with_index do |arg, arg_num|
 
-      rule_type = Aggregator.value_to_rule_type(arg)
-      agg_rule = input_rule_sets[arg_num].rules[rule_type]
+      # Get a random rule in the rule set.
+      rules = input_rule_sets[arg_num].rules
+      agg_rule = rules[rules.keys.sample]
 
+      # Create a random value that follows that rule.
       random_args << agg_rule.random()
 
     end
@@ -143,22 +146,28 @@ class Reflection
   ##
   # Get the results of the reflection.
   #
+  # @keys
+  #   - eid [Integer] Execution ID
+  #   - aid [Integer] Action ID
+  #   - rid [Integer] Reflection ID
+  #   - num [Integer] Reflection number
+  #
   # @return [Hash] Reflection metadata.
   ##
-  def result()
+  def serialize()
 
-    # The ID of the first execution in the ShadowStack.
-    base_id = nil
-    unless @execution.base == nil
-      base_id = @execution.base.unique_id
+    # Create execution ID from the ID of the first action in   the ActionStack.
+    execution_id = @action.unique_id
+    unless @action.base.nil?
+      execution_id = @action.base.unique_id
     end
 
     # Build reflection.
     reflection = {
-      :base_id => base_id,
-      :exe_id => @execution.unique_id,
-      :ref_id => @unique_id,
-      :ref_num => @number,
+      :eid => execution_id,
+      :aid => @action.unique_id,
+      :rid => @unique_id,
+      :num => @number,
       :time => @time,
       :class => @klass,
       :method => @method,
@@ -171,12 +180,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