reflekt 1.0.5 → 1.0.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 457006f1c0a4fbe9a1ce47684aeeec980852cd966f29d07ac57751161f314d52
-  data.tar.gz: ca01fd9306ece9e1698aab0dcb4945a848a5a910625f8b9394b4f26aa7819514
+  metadata.gz: 3e5af4cf8808efaeb9b41e29c925aee883139afaea6fef303f060a91566a101b
+  data.tar.gz: cb877b7821ed829907c52387b5fc04ff3c986f05646170dceb3307cc14a4d648
 SHA512:
-  metadata.gz: 1de336f083b2e90230453d3ce07cfb36981998587de2e126c88948da75a618ee57a68b32b9869865fb9353b45e85fadc293d98afc2c4669afe8fadc9761fda93
-  data.tar.gz: 0b00aa43ef7763bc11e93697446ca0e86114818f3e6238d28711d1038eef0c4bc58dc43b1f1f901ec58a4cdf6c9138493e63572a7d33a0363a591e908b38e751
+  metadata.gz: 6200d9280ccdf2cd5cb1788d80e6795813e5dc7ca398ebca75e507aba2fc8e3bf116ec851f3d103c92eaa1e1a79fd0a6c3f14dc1f59cee74117a8a1f74f60e66
+  data.tar.gz: 9b28f16baeafa725c606c0ea458742f86d0b87cda0e95180658b66598a8a08a0efa46f706214d8e00e98eecfc766eadfafeeb47697cf297f62beef95e2ed452d

data/lib/accessor.rb

@@ -0,0 +1,45 @@
+################################################################################
+# Access variables via one object to avoid polluting the caller's scope.
+#
+# @pattern Singleton
+#
+# @note Variables not accessed via Accessor:
+#   - @reflekt_counts on the instance
+#   - @@reflekt_skipped_methods on the instance's singleton class
+################################################################################
+
+module Reflekt
+  class Accessor
+
+    attr_accessor :initialized
+    attr_accessor :counts
+    attr_accessor :error
+
+    attr_accessor :config
+    attr_accessor :db
+    attr_accessor :stack
+    attr_accessor :aggregator
+    attr_accessor :renderer
+
+    attr_accessor :package_path
+    attr_accessor :project_path
+    attr_accessor :output_path
+
+    def initialize()
+      @initialized = false
+      @counts = {}
+      @error = nil
+
+      @config = nil
+      @db = nil
+      @stack = nil
+      @aggregator = nil
+      @renderer = nil
+
+      @package_path = nil
+      @project_path = nil
+      @output_path = nil
+    end
+
+  end
+end

data/lib/action.rb

@@ -0,0 +1,127 @@
+################################################################################
+# A shadow action.
+#
+# @hierachy
+#   1. Action <- YOU ARE HERE
+#   2. Reflection
+#   3. Meta
+################################################################################
+
+module Reflekt
+  class Action
+    include LitCLI
+
+    attr_accessor :unique_id
+    attr_accessor :caller_object
+    attr_accessor :caller_id
+    attr_accessor :caller_class
+    attr_accessor :klass
+    attr_accessor :method
+    attr_accessor :base
+    attr_accessor :parent
+    attr_accessor :child
+    attr_accessor :control
+    attr_accessor :experiments
+    attr_accessor :is_actioned
+    attr_accessor :is_reflecting
+    attr_accessor :is_base
+
+    ##
+    # Create Action.
+    #
+    # @param object [Object] The calling object.
+    # @param method [Symbol] The calling method.
+    # @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, config, db, stack, aggregator)
+      @time = Time.now.to_i
+      @unique_id = @time + rand(1..99999)
+      @base = nil
+      @child = nil
+      @parent = nil
+
+      # Dependencies.
+      @db = db
+      @stack = stack
+      @aggregator = aggregator
+
+      # Caller.
+      @caller_object = caller_object
+      @caller_class = caller_object.class
+      @caller_id = caller_object.object_id
+      @klass = @caller_class.to_s.to_sym
+      @method = method
+
+      # Reflections.
+      @control = nil
+      @experiments = Array.new(config.reflect_amount)
+
+      # State.
+      @is_reflecting = false
+      if @stack.peek() == nil
+        @is_base = true
+      else
+        @is_base = false
+        @base = @stack.base()
+      end
+    end
+
+    def reflect(*args)
+
+      🔥"^ Create control for #{@method}()", :info, :control, @klass
+      @control = Control.new(self, 0, @aggregator)
+
+      @control.reflect(*args)
+      🔥"> Reflected control for #{@method}(): #{args}", @control.status, :result, @klass
+
+      # Stop reflecting when control fails to execute.
+      unless @control.status == :error
+
+        # Save control.
+        @db.get("controls").push(@control.serialize())
+        @db.get("reflections").push(@control.serialize())
+
+        # Multiple experiments per action.
+        @experiments.each_with_index do |value, index|
+
+          🔥"^ Create experiment ##{index + 1} for #{@method}()", :info, :experiment, @klass
+          experiment = Experiment.new(self, index + 1, @aggregator)
+          @experiments[index] = experiment
+
+          # Reflect experiment.
+          experiment.reflect(*args)
+          Reflekt.increase_count(@caller_object, @method)
+          🔥"> Reflected experiment ##{index + 1} for #{@method}()", experiment.status, :result, @klass
+
+          # Save experiment.
+          @db.get("reflections").push(experiment.serialize())
+        end
+
+        # Save results.
+        @db.write()
+      end
+    end
+
+    def is_actioned?
+      @is_actioned
+    end
+
+    # Is the action currently reflecting methods?
+    def is_reflecting?
+      @is_reflecting
+    end
+
+    def has_empty_experiments?
+      @experiments.include? nil
+    end
+
+    def has_finished_loop?
+      return false if is_actioned? == false
+      return false if is_reflecting?
+      return false if has_empty_experiments?
+
+      true
+    end
+  end
+end

data/lib/action_stack.rb

@@ -0,0 +1,44 @@
+################################################################################
+# Track the actions in a shadow call stack.
+#
+# @pattern Stack
+################################################################################
+
+module Reflekt
+  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)
+      # First time? Place 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
+end

data/lib/{Clone.rb → clone.rb}

@@ -12,20 +12,20 @@
 #   3. Clone <- YOU ARE HERE
 ################################################################################
 
-class Clone
+module Reflekt
+  class Clone
 
-  def initialize(action)
+    def initialize(action)
+      # Clone the action's calling object.
+      @caller_object_clone = action.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.
+    end
 
-    # TODO: Clone any other instances that this clone references.
-    # TODO: Replace clone's references to these new instances.
+    def action(method, *new_args)
+      @caller_object_clone.send(method, *new_args)
+    end
 
   end
-
-  def action(method, *new_args)
-    @caller_object_clone.send(method, *new_args)
-  end
-
 end

data/lib/config.rb

@@ -0,0 +1,48 @@
+module Reflekt
+  class Config
+
+    attr_accessor :enabled
+    attr_accessor :reflect_amount
+    attr_accessor :reflect_limit
+    attr_accessor :meta_map
+    attr_accessor :project_path
+    attr_accessor :output_directory
+
+    def initialize()
+
+      # Reflekt is enabled by default and should be disabled on production.
+      @enabled = true
+
+      # Reflekt is untracked in git by default.
+      @git_ignore = true
+
+      # The amount of reflections to create per method call.
+      # A control reflection is created in addition to this.
+      @reflect_amount = 5
+
+      # The maximum amount of reflections that can be created per instance per method.
+      # A method called thousands of times doesn't need that many reflections.
+      @reflect_limit = 10
+
+      # The rules that apply to meta types.
+      @meta_map = {
+        :array  => [ArrayRule],
+        :bool   => [BooleanRule],
+        :int    => [IntegerRule],
+        :float  => [FloatRule],
+        :null   => [NullRule],
+        :object => [ObjectRule],
+        :string => [StringRule]
+      }
+
+      # An absolute path to the project root directory.
+      # Defaults to current execution path.
+      @project_path = Dir.pwd
+
+      # Name of output directory.
+      @output_directory = "reflections"
+
+    end
+
+  end
+end

data/lib/control.rb

@@ -0,0 +1,81 @@
+################################################################################
+# A shapshot of real data.
+#
+# @note
+#   A control's @number will always be 0.
+#
+# @nomenclature
+#   args, inputs/output and meta represent different stages of a value.
+#
+# @hierachy
+#   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_relative 'reflection'
+require_relative 'meta_builder'
+
+module Reflekt
+  class Control < Reflection
+
+    ##
+    # Reflect on a method.
+    #
+    # Create a shadow action.
+    # @param *args [Dynamic] The method's arguments.
+    ##
+    def reflect(*args)
+      # 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
+        🔥"> No trained rule sets", :fail, :reflect
+      end
+
+      # When arguments exist.
+      unless args.size == 0
+        # Validate arguments against trained rule sets.
+        unless input_rule_sets.nil?
+          unless @aggregator.test_inputs(args, input_rule_sets)
+            @status = :fail
+            🔥"> Invalid inputs", @status, :reflect
+          end
+        end
+
+        🔥"> Create meta for #{@method}(): #{args}", :info, :meta, @klass
+        # TODO: Create metadata for other inputs such as instance variables.
+        @inputs = MetaBuilder.create_many(args)
+      end
+
+      # Action method with real arguments.
+      begin
+        # Run reflection.
+        output = @clone.send(@method, *args)
+        @output = MetaBuilder.create(output)
+
+        # Validate output with aggregated control rule sets.
+        unless @aggregator.test_output(output, output_rule_set)
+          @status = :fail
+          🔥"> Invalid output", @status, :reflect
+        end
+
+      # When a system error occurs.
+      rescue StandardError => message
+        @status = :error
+        @message = message
+
+        # TODO: Write log entry to /reflections/errors.txt
+        🔥"#{@method}() not reflected", :error, :control, @klass.class
+      end
+    end
+  end
+end

data/lib/experiment.rb

@@ -0,0 +1,99 @@
+################################################################################
+# 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'
+
+module Reflekt
+  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.
+        🔥"> Create meta for #{@method}(): #{args}", :info, :meta, @klass
+        @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
+
+    ##
+    # 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
+  end
+end