reflekt 1.0.2 → 1.0.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7f9ff9a7d13d77e0e468cf961d6ef1dd6dd2c381b6d3d4fb1a1799b59aa1fdc6
-  data.tar.gz: 8bb82ca18b00bd0a1e329bd94557a164eff90fb607fbbcbfa6ef8b026f4619c9
+  metadata.gz: a9f733fd18e6885b020065ce5e52e352caf9bcdc38f3459ab4d322d4b1c7870e
+  data.tar.gz: 8715db31d91effbb04ba99a6b79f973bfd17ebd1c1976328d186c344cb7c2edc
 SHA512:
-  metadata.gz: 9d22878d22a93be41323d89b6a718808f78fa61c8cc186ddde480a5298ea1a1ae1fc49576141186d3dee7c02a29295c67a59e41aa732ec1e9dc3b4fd878e7add
-  data.tar.gz: 2d759df0674e8dc496ae92b585588b2a927c8aa7bda0368be8265705e1340af60ebe393c84b059dd2516d23cb8f7577b7baa4fe016f1a17ed3934a9fbcc084a2
+  metadata.gz: cbbd92db72d16a5e0fe31d526e820c8844b4ca514ee7eb85360e5a4e9d05dacd685c2a5af1f233653af0cd506f7c48cf46b16195975c5fe64ab5b6c43b633f74
+  data.tar.gz: af79125c63aae1e1437d133ae66d5a6fbd313baaf60295d864528f0388a2ba9c6b6d7d9ada8c8319f963db0c2dc8c40d6446d727ca0fdc3af80f64fa5d073cb5

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
@@ -19,17 +19,17 @@ class Execution
   attr_accessor :parent
   attr_accessor :child
   attr_accessor :control
-  attr_accessor :reflections
+  attr_accessor :experiments
   attr_accessor :is_reflecting
   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 experiments to create per action.
+  # @param stack [ActionStack] The shadow action call stack.
   ##
   def initialize(caller_object, method, reflect_amount, stack)
 
@@ -51,7 +51,7 @@ class Execution
 
     # Reflections.
     @control = nil
-    @reflections = Array.new(reflect_amount)
+    @experiments = Array.new(reflect_amount)
 
     # State.
     if @stack.peek() == nil
@@ -64,12 +64,12 @@ class Execution
 
   end
 
-  def has_empty_reflections?
-    @reflections.include? nil
+  def has_empty_experiments?
+    @experiments.include? nil
   end
 
   ##
-  # Is the Execution currently reflecting methods?
+  # Is the Action currently reflecting methods?
   ##
   def is_reflecting?
     @is_reflecting
@@ -79,7 +79,7 @@ class Execution
     if is_reflecting?
       return false
     end
-    if has_empty_reflections?
+    if has_empty_experiments?
       return false
     end
     return true

data/lib/action_stack.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/{Clone.rb → 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 → config.rb}

@@ -31,7 +31,7 @@ class Config
     }
 
     # 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 → control.rb}

@@ -2,13 +2,13 @@
 # A shapshot of real data.
 #
 # @note
-#   A control's @number property will always be zero.
+#   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
 #
@@ -18,43 +18,45 @@
 #   - :error [Symbol] The control reflection produces a system error.
 ################################################################################
 
-require 'Reflection'
-require 'MetaBuilder'
+require_relative 'reflection'
+require_relative 'meta_builder'
 
 class Control < Reflection
 
   ##
   # Reflect on a method.
   #
-  # Creates a shadow execution.
+  # Create 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/experiment.rb

@@ -0,0 +1,81 @@
+################################################################################
+# A snapshot of random data.
+#
+# @note
+#   A reflection's random values are generated from aggregated control rule sets.
+#
+# @nomenclature
+#   args, inputs/output and meta represent different stages of a value.
+#
+# @hierachy
+#   1. Action
+#   2. Experiment <- 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_relative 'reflection'
+require_relative 'meta_builder'
+
+class Experiment < Reflection
+
+  ##
+  # Reflect on a method.
+  #
+  # Create a shadow action.
+  # @param *args [Dynamic] The method's arguments.
+  ##
+  def reflect(*args)
+
+    # Get aggregated 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
+
+      # Create random arguments from aggregated rule sets.
+      unless input_rule_sets.nil?
+        args = randomize(args, input_rule_sets)
+      end
+
+      # Create metadata for each argument.
+      # TODO: Create metadata for other inputs such as instance variables.
+      @inputs = MetaBuilder.create_many(args)
+
+    end
+
+    # Action method with random arguments.
+    begin
+
+      # Run reflection.
+      output = @clone.send(@method, *args)
+      @output = MetaBuilder.create(output)
+
+      # Validate output against aggregated control rule sets.
+      unless output_rule_set.nil?
+        unless @aggregator.test_output(output, output_rule_set)
+          @status = :fail
+        end
+      end
+
+    # When a system error occurs.
+    rescue StandardError => message
+
+      @status = :fail
+      @message = message
+
+    end
+
+  end
+
+end

data/lib/{Meta.rb → 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,12 @@ class Meta
   end
 
   ##
-  # Each meta serializes metadata.
-  #
   # @return [Hash]
   ##
   def serialize()
-    {}
+    {
+      :type => @type
+    }
   end
 
   ##############################################################################

data/lib/meta/{ArrayMeta.rb → array_meta.rb}

@@ -1,4 +1,4 @@
-require 'Meta'
+require_relative '../meta'
 
 class ArrayMeta < Meta
 

data/lib/meta/{BooleanMeta.rb → boolean_meta.rb}

@@ -1,4 +1,4 @@
-require 'Meta'
+require_relative '../meta'
 
 class BooleanMeta < Meta
 

data/lib/meta/{FloatMeta.rb → float_meta.rb}

@@ -1,4 +1,4 @@
-require 'Meta'
+require_relative '../meta'
 
 class FloatMeta < Meta
 

data/lib/meta/{IntegerMeta.rb → integer_meta.rb}

@@ -1,4 +1,4 @@
-require 'Meta'
+require_relative '../meta'
 
 class IntegerMeta < Meta
 

data/lib/meta/{NullMeta.rb → null_meta.rb}

@@ -5,12 +5,12 @@
 #   A "null" value on serialized "inputs" and "output" also becomes a NullMeta.
 #
 # @hierachy
-#   1. Execution
+#   1. Action
 #   2. Reflection
 #   3. Meta <- YOU ARE HERE
 ################################################################################
 
-require 'Meta'
+require_relative '../meta'
 
 class NullMeta < Meta
 

data/lib/meta/{StringMeta.rb → string_meta.rb}

@@ -1,4 +1,4 @@
-require 'Meta'
+require_relative '../meta'
 
 class StringMeta < Meta
 

data/lib/{MetaBuilder.rb → meta_builder.rb}

@@ -5,9 +5,9 @@
 # @see lib/meta for each meta.
 ################################################################################
 
-require 'Meta'
+require_relative 'meta'
 # Require all meta.
-Dir[File.join(__dir__, 'meta', '*.rb')].each { |file| require file }
+Dir[File.join(__dir__, 'meta', '*.rb')].each { |file| require_relative file }
 
 class MetaBuilder
 

data/lib/reflection.rb

@@ -0,0 +1,148 @@
+################################################################################
+# A snapshot of real or random data.
+#
+# @pattern Abstract class
+#
+# @nomenclature
+#   args, inputs/output and meta represent different stages of a value.
+#
+# @hierachy
+#   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_relative 'clone'
+require_relative 'meta_builder'
+
+class Reflection
+
+  attr_reader :status
+
+  ##
+  # Create a reflection.
+  #
+  # @param action [Action] The Action that created this Reflection.
+  # @param number [Integer] Multiple Reflections can be created per Action.
+  # @param aggregator [RuleSetAggregator] The aggregated RuleSet for this class/method.
+  ##
+  def initialize(action, number, aggregator)
+
+    @action = action
+    @unique_id = action.unique_id + number
+    @number = number
+
+    # Dependency.
+    @aggregator = aggregator
+
+    # Caller.
+    @klass = action.klass
+    @method = action.method
+
+    # Metadata.
+    @inputs = nil
+    @output = nil
+
+    # Clone the action's calling object.
+    # TODO: Abstract away into Clone class.
+    @clone = action.caller_object.clone
+
+    # Result.
+    @status = :pass
+    @time = Time.now.to_i
+    @message = nil
+
+  end
+
+  ##
+  # Reflect on a method.
+  #
+  # Create a shadow action.
+  # @param *args [Dynamic] The method's arguments.
+  ##
+  def reflect(*args)
+    # Implemented by Control and Experiment.
+  end
+
+  ##
+  # Create random values for each argument from control reflections.
+  #
+  # @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.
+  ##
+  def randomize(args, input_rule_sets)
+
+    random_args = []
+
+    args.each_with_index do |arg, arg_num|
+
+      # 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
+
+    return random_args
+
+  end
+
+  ##
+  # 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 serialize()
+
+    # 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 = {
+      :eid => execution_id,
+      :aid => @action.unique_id,
+      :rid => @unique_id,
+      :num => @number,
+      :time => @time,
+      :class => @klass,
+      :method => @method,
+      :status => @status,
+      :message => @message,
+      :inputs => nil,
+      :output => nil,
+    }
+
+    unless @inputs.nil?
+      reflection[:inputs] = []
+      @inputs.each do |meta|
+        reflection[:inputs] << meta.serialize()
+      end
+    end
+
+    unless @output.nil?
+      reflection[:output] = @output.serialize()
+    end
+
+    return reflection
+
+  end
+
+end