reflekt 1.0.9 → 1.0.10

data/lib/reflekt.rb

@@ -3,14 +3,6 @@
 #
 # @author Maedi Prichard
 #
-# @flow
-#   1. Reflekt is prepended to a class and setup.
-#   2. When a class insantiates so does Reflekt.
-#   3. An Action is created on method call.
-#   4. Many Refections are created per Action.
-#   5. Each Reflection executes on cloned data.
-#   6. Flow is returned to the original method.
-#
 # @usage
 #   class ExampleClass
 #     prepend Reflekt
@@ -19,6 +11,8 @@
 require 'set'
 require 'erb'
 require 'rowdb'
+require 'lit_cli'
+
 require_relative 'accessor'
 require_relative 'action'
 require_relative 'action_stack'
@@ -27,193 +21,238 @@ require_relative 'control'
 require_relative 'experiment'
 require_relative 'renderer'
 require_relative 'rule_set_aggregator'
-# Require all rules.
+
+# Require all rules in rules directory.
 Dir[File.join(__dir__, 'rules', '*.rb')].each { |file| require_relative file }
 
 module Reflekt
+  include LitCLI
 
+  ##
+  # Setup Reflekt per class.
+  # Override methods on class instantiation.
+  #
+  # @scope self [Object] Refers to the class that Reflekt is prepended to.
+  ##
   def initialize(*args)
+    if @@reflekt.config.enabled
+      @reflekt_initialized = false
 
-    # TODO: Store counts on @@reflekt and key by instance ID.
-    @reflekt_counts = {}
+      🔥"Initialize", :info, :setup, self.class
 
-    # Get child and parent instance methods.
-    parent_instance_methods = self.class.superclass.instance_methods(false)
-    child_instance_methods = self.class.instance_methods(false)
-    instance_methods = parent_instance_methods + child_instance_methods
-
-    # TODO: Include core methods like "Array.include?".
-    instance_methods.each do |method|
+      # Override methods.
+      Reflekt.get_methods(self).each do |method|
+        Reflekt.setup_count(self, method)
+        Reflekt.override_method(self, method)
+      end
 
-      @reflekt_counts[method] = 0
+      @reflekt_initialized = true
+    end
 
-      # When method called in flow.
-      self.define_singleton_method(method) do |*args|
+    # Continue initialization.
+    super
+  end
 
-        # When Reflekt enabled and control reflection has executed without error.
-        if @@reflekt.config.enabled && !@@reflekt.error
+  ##
+  # Get child and parent instance methods.
+  #
+  # TODO: Include methods from all ancestors.
+  # TODO: Include core methods like "Array.include?".
+  ##
+  def self.get_methods(klass)
+    child_instance_methods = klass.class.instance_methods(false)
+    parent_instance_methods = klass.class.superclass.instance_methods(false)
 
-          # Get current action.
-          action = @@reflekt.stack.peek()
+    return child_instance_methods + parent_instance_methods
+  end
 
-          # Don't reflect when reflect limit reached or method skipped.
-          unless (@reflekt_counts[method] >= @@reflekt.config.reflect_limit) || self.class.reflekt_skipped?(method)
+  ##
+  # Override a method.
+  #
+  # @param klass [Dynamic] The class to override.
+  # @param method [Method] The method to override.
+  ##
+  def self.override_method(klass, method)
+    klass.define_singleton_method(method) do |*args|
 
-            # When stack empty or past action done reflecting.
-            if action.nil? || action.has_finished_reflecting?
+      # When method called in flow.
+      if @reflekt_initialized
+
+        ##
+        # Reflect-Execute loop.
+        #
+        # Reflect each method before finally executing it.
+        #
+        # @loop
+        #   1. The first method call creates an action
+        #   2. The action creates reflections and calls the method again
+        #   3. Subsequent method calls execute these reflections
+        #   4. Each reflection executes on cloned data
+        #   5. The original method call completes execution
+        #
+        # @see https://reflekt.dev/docs/reflect-execute-loop
+        ##
+
+        unless @@reflekt.error
 
-              # Create action.
-              action = Action.new(self, method, @@reflekt.config.reflect_amount, @@reflekt.stack)
+          action = @@reflekt.stack.peek()
 
-              @@reflekt.stack.push(action)
+          # New action when old action done reflecting.
+          if action.nil? || action.has_finished_loop?
+            🔥"^ Create action for #{method}()", :info, :action, klass.class
+            action = Action.new(klass, method, @@reflekt.config, @@reflekt.db, @@reflekt.stack, @@reflekt.aggregator)
+            @@reflekt.stack.push(action)
+          end
 
-            end
+          ##
+          # REFLECT
+          ##
 
-            ##
-            # Reflect the action.
-            #
-            # The first method call in the action creates a reflection.
-            # Then method calls are shadow actions which return to the reflection.
-            ##
-            if action.has_empty_experiments? && !action.is_reflecting?
+          unless action.is_reflecting? && klass.class.reflekt_skipped?(method) || Reflekt.count(klass, method) >= @@reflekt.config.reflect_limit
+            unless action.is_actioned?
+              action.is_actioned = true
               action.is_reflecting = true
 
-              # Create control.
-              control = Control.new(action, 0, @@reflekt.aggregator)
-              action.control = control
-
-              # Execute control.
-              control.reflect(*args)
-
-              # Stop reflecting when control fails to execute.
-              if control.status == :error
-                @@reflekt.error = true
-              # Continue reflecting when control executes succesfully.
-              else
-
-                # Save control as a reflection.
-                @@reflekt.db.get("reflections").push(control.serialize())
-
-                # Multiple experiments per action.
-                action.experiments.each_with_index do |value, index|
-
-                  # Create experiment.
-                  experiment = Experiment.new(action, index + 1, @@reflekt.aggregator)
-                  action.experiments[index] = experiment
-
-                  # Execute experiment.
-                  experiment.reflect(*args)
-                  @reflekt_counts[method] = @reflekt_counts[method] + 1
-
-                  # Save experiment.
-                  @@reflekt.db.get("reflections").push(experiment.serialize())
-
-                end
-
-                # Save control.
-                @@reflekt.db.get("controls").push(control.serialize())
-
-                # Save results.
-                @@reflekt.db.write()
-
-                # Render results.
-                @@reflekt.renderer.render()
-
+              action.reflect(*args)
+              if action.control.status == :error
+                @@reflekt.error = action.control.message
               end
 
+              # Render results.
+              @@reflekt.renderer.render()
+
               action.is_reflecting = false
             end
-
+          else
+            🔥"> Skip reflection of #{method}()", :skip, :reflect, klass.class
           end
 
-          # Don't execute skipped methods when reflecting.
-          unless action.is_reflecting? && self.class.reflekt_skipped?(method)
+          ##
+          # EXECUTE
+          ##
 
-            # Continue action / shadow action.
+          unless action.is_reflecting? && klass.class.reflekt_skipped?(method)
+            🔥"> Execute #{method}()", :info, :execute, klass.class
             super *args
-
           end
 
-        # When Reflekt disabled or control reflection failed.
+        # Finish execution if control encounters unrecoverable error.
         else
-
-          # Continue action.
+          🔥"Reflection error, finishing original execution...", :error, :reflect, klass.class
           super *args
-
         end
 
+      # When method called in constructor.
+      else
+        p "Reflection unsupported in constructor for #{method}()", :info, :setup, klass.class
+        super *args
       end
-
     end
+  end
 
-    # Continue initialization.
-    super
+  def self.setup_count(klass, method)
+    caller_id = klass.object_id
+    @@reflekt.counts[caller_id] = {} unless @@reflekt.counts.has_key? caller_id
+    @@reflekt.counts[caller_id][method] = 0 unless @@reflekt.counts[caller_id].has_key? method
+  end
+
+  def self.count(klass, method)
+    count = @@reflekt.counts.dig(klass.object_id, method) || 0
+    count
+  end
 
+  def self.increase_count(klass, method)
+    caller_id = klass.object_id
+    @@reflekt.counts[caller_id][method] = @@reflekt.counts[caller_id][method] + 1
   end
 
   ##
-  # Provide Config instance to block.
+  # Configure Config singleton.
   ##
   def self.configure
+    reflekt_setup_class()
+
     yield(@@reflekt.config)
   end
 
   private
 
   def self.prepended(base)
-
     # Prepend class methods to the instance's singleton class.
     base.singleton_class.prepend(SingletonClassMethods)
 
-    # Setup class.
-    @@reflekt = Accessor.new()
-    @@reflekt.setup ||= reflekt_setup_class
-
+    reflekt_setup_class()
   end
 
+  ##
   # Setup class.
+  #
+  # @paths
+  #   - package_path [String] Absolute path to the library itself.
+  #   - project_path [String] Absolute path to the project root.
+  #   - output_path [String] Absolute path to the reflections directory.
+  ##
   def self.reflekt_setup_class()
 
-    # Receive configuration.
-    @@reflekt.config = Config.new()
-
-    # Set configuration.
-    @@reflekt.path = File.dirname(File.realpath(__FILE__))
+    # Only setup once.
+    return if defined? @@reflekt
 
-    # Get reflections directory path from config or current action path.
-    if @@reflekt.config.output_path
-      @@reflekt.output_path = File.join(@@reflekt.config.output_path, @@reflekt.config.output_directory)
-    else
-      @@reflekt.output_path = File.join(Dir.pwd, @@reflekt.config.output_directory)
-    end
+    @@reflekt = Accessor.new()
+    @@reflekt.config = Config.new()
+    @@reflekt.stack = ActionStack.new()
 
-    # Create reflections directory.
+    # Setup paths.
+    @@reflekt.package_path = File.dirname(File.realpath(__FILE__))
+    @@reflekt.project_path = @@reflekt.config.project_path
+    @@reflekt.output_path = File.join(@@reflekt.project_path, @@reflekt.config.output_directory)
     unless Dir.exist? @@reflekt.output_path
       Dir.mkdir(@@reflekt.output_path)
     end
 
-    # Create database.
+    # Setup database.
     @@reflekt.db = Rowdb.new(@@reflekt.output_path + '/db.js')
     @@reflekt.db.defaults({ :reflekt => { :api_version => 1 }})
-    # @TODO Fix Rowdb.get(path) not returning values at path after Rowdb.push()
+    # TODO: Fix Rowdb.get(path) not returning values at path after Rowdb.push()
     db = @@reflekt.db.value()
 
-    # Create shadow stack.
-    @@reflekt.stack = ActionStack.new()
-
-    # Create aggregated rule sets.
+    # Train aggregated rule sets.
     @@reflekt.aggregator = RuleSetAggregator.new(@@reflekt.config.meta_map)
     @@reflekt.aggregator.train(db[:controls])
 
-    # Create renderer.
-    @@reflekt.renderer = Renderer.new(@@reflekt.path, @@reflekt.output_path)
+    # Setup renderer.
+    @@reflekt.renderer = Renderer.new(@@reflekt.package_path, @@reflekt.output_path)
+
+    LitCLI.configure do |config|
+      config.statuses = {
+        :info => { icon: "ℹ", color: :blue, styles: [:upcase] },
+        :pass => { icon: "✔", color: :green, styles: [:upcase] },
+        :save => { icon: "✔", color: :green, styles: [:upcase] },
+        :skip => { icon: "⨯", color: :yellow, styles: [:upcase] },
+        :warn => { icon: "⚠", color: :yellow, styles: [:upcase] },
+        :fail => { icon: "⨯", color: :red, styles: [:upcase] },
+        :error => { icon: "!", color: :red, styles: [:upcase] },
+        :debug => { icon: "?", color: :purple, styles: [:upcase] },
+      }
+      config.types = {
+        :setup => { styles: [:dim, :bold, :capitalize] },
+        :event => { color: :yellow, styles: [:bold, :capitalize] },
+        :reflect => { color: :yellow, styles: [:bold, :capitalize] },
+        :result => { color: :yellow, styles: [:bold, :capitalize] },
+        :action => { color: :red, styles: [:bold, :capitalize] },
+        :control => { color: :blue, styles: [:bold, :capitalize] },
+        :experiment => { color: :green, styles: [:bold, :capitalize] },
+        :execute => { color: :purple, styles: [:bold, :capitalize] },
+        :meta => { color: :blue, styles: [:bold, :capitalize] },
+      }
+    end
 
     return true
-
   end
 
+  ##
+  # Publicly accessible class methods in the class that Reflekt is prepended to.
+  ##
   module SingletonClassMethods
-
     @@reflekt_skipped_methods = Set.new()
 
     ##
@@ -233,11 +272,6 @@ module Reflekt
       return true if @@reflekt_skipped_methods.include?(method)
       false
     end
-
-    #def reflekt_limit(amount)
-    #  @@reflekt.reflect_limit = amount
-    #end
-
   end
 
 end

data/lib/renderer.rb

@@ -1,41 +1,38 @@
 module Reflekt
-class Renderer
+  class Renderer
 
-  def initialize(path, output_path)
-
-    @path = path
-    @output_path = output_path
-
-  end
-
-  ##
-  # Place files in output path.
-  ##
-  def render()
+    def initialize(package_path, output_path)
+      @package_path = package_path
+      @output_path = output_path
+    end
 
-    filenames = [
-      "bundle.js",
-      "index.html",
-      "package-lock.json",
-      "package.json",
-      "README.md",
-      "server.js"
-    ]
+    ##
+    # Place files in output path.
+    ##
+    def render()
+
+      filenames = [
+        "bundle.js",
+        "index.html",
+        "package-lock.json",
+        "package.json",
+        "README.md",
+        "server.js"
+      ]
+
+      filenames.each do |filename|
+        file = File.read(File.join(@package_path, "web", filename))
+        File.open(File.join(@output_path, filename), 'w+') do |f|
+          f.write file
+        end
+      end
 
-    filenames.each do |filename|
-      file = File.read(File.join(@path, "web", filename))
-      File.open(File.join(@output_path, filename), 'w+') do |f|
+      file = File.read(File.join(@package_path, "web", "gitignore.txt"))
+      File.open(File.join(@output_path, ".gitignore"), 'w+') do |f|
         f.write file
       end
-    end
 
-    file = File.read(File.join(@path, "web", "gitignore.txt"))
-    File.open(File.join(@output_path, ".gitignore"), 'w+') do |f|
-      f.write file
     end
 
   end
-
-
-end
 end