reflekt 0.9.6 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 30e9de1f6073eb71a87871e5790dee7a5da6476b4c787a31c75d772986994295
-  data.tar.gz: 29b671194ac45fe98d596c4aefcd7cb17a5aba511d82109968403889d7d94aef
+  metadata.gz: cfaf70b43c12867f93934b6b1f2e0d672486b3331369c9c85c0646e54bfc18d2
+  data.tar.gz: 437bbcdd66ae77ec202360255386edc10d69bcfb2da5b41816b0aed3c3151285
 SHA512:
-  metadata.gz: b3701e103b4ad81c7f1e0697b5f1dd07075f7fc8f55cc1715a0e9d2b8448218b8f8c6efa3ef6334943ba369172d967879b0e9e7516b1b0e2652981147ca4f107
-  data.tar.gz: 278a84e1cb673170c52779aea32de1e958b1ea2f2b24dcc6cb8c1356603b07d018c4d2ff22d16b9a86f2ea03beee8462f5024be87d94c362ff5163418259234a
+  metadata.gz: 789f134df80a4cb9455274cd36d968f83903f6c474b6974d451ecfea1910799121f815eeecb9162a3b0ea2417f52983f1bb4557a5dd9b729fbdfa3e7325a6b99
+  data.tar.gz: 3bfb838fb97dda4989fba353db654b9498ce2ff8112f880d0bb5c926ae58865e05916701ec81cf393486b0b279af308a349245c970242879774c172bf12e2e7c

data/lib/Accessor.rb

@@ -1,37 +1,36 @@
 ################################################################################
-# ACCESSOR
-#
 # Access variables via one object to avoid polluting the caller class scope.
 #
-# Some variables are not accessed via Accessor:
+# @pattern Singleton
+#
+# @note Some variables are not accessed via Accessor:
 #   - @reflekt_counts on the instance
-#   - @reflekt_enabled on the instance
 #   - @@reflekt_skipped_methods on the instance's singleton class
 ################################################################################
 
 class Accessor
 
+  attr_accessor :config
   attr_accessor :setup
   attr_accessor :db
   attr_accessor :stack
-  attr_accessor :ruler
+  attr_accessor :aggregator
   attr_accessor :renderer
   attr_accessor :path
   attr_accessor :output_path
-  attr_accessor :reflect_amount
-  attr_accessor :reflect_limit
+  attr_accessor :error
 
   def initialize()
 
+    @config = nil
     @setup = nil
     @db = nil
     @stack = nil
-    @ruler = nil
+    @aggregator = nil
     @renderer = nil
     @path = nil
     @output_path = nil
-    @reflect_amount = nil
-    @reflect_limit = nil
+    @error = false
 
   end
 

data/lib/Aggregator.rb

@@ -0,0 +1,238 @@
+################################################################################
+# Aggregate control metadata into rule sets.
+# Validate reflections against aggregated controls.
+#
+# @pattern Singleton
+#
+# @hierachy
+#   1. Aggregator <- YOU ARE HERE
+#   2. RuleSet
+#   3. Rule
+################################################################################
+
+require 'RuleSet'
+
+class Aggregator
+
+  ##
+  # @param meta_map [Hash] The rules that apply to each meta type.
+  ##
+  def initialize(meta_map)
+
+    @meta_map = meta_map
+    # Key rule sets by class and method.
+    @rule_sets = {}
+
+  end
+
+  ##
+  # Create aggregated rule sets from control metadata.
+  #
+  # @stage Called on setup.
+  # @param controls [Array] Controls with metadata.
+  # @TODO Revert string keys to symbols once "Fix Rowdb.get(path)" bug fixed.
+  ##
+  def train(controls)
+
+    # On first use there are no previous controls.
+    return if controls.nil?
+
+    controls.each do |control|
+
+      klass = control["class"].to_sym
+      method = control["method"].to_sym
+
+      ##
+      # INPUT
+      ##
+
+      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
+
+          # 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
+      end
+
+      ##
+      # OUTPUT
+      ##
+
+      # Get rule set.
+      output_rule_set = get_output_rule_set(klass, method)
+      if output_rule_set.nil?
+        output_rule_set = RuleSet.new(@meta_map)
+        set_output_rule_set(klass, method, output_rule_set)
+      end
+
+      # Train on metadata.
+      output_rule_set.train(control["output"])
+
+    end
+
+  end
+
+  ##
+  # Validate inputs.
+  #
+  # @stage Called when validating a reflection.
+  # @param inputs [Array] The method's arguments.
+  # @param input_rule_sets [Array] The RuleSets to validate each input with.
+  ##
+  def test_inputs(inputs, input_rule_sets)
+
+    # Default result to PASS.
+    result = true
+
+    # Validate each argument against each rule set for that argument.
+    inputs.each_with_index do |input, arg_num|
+
+      unless input_rule_sets[arg_num].nil?
+
+        rule_set = input_rule_sets[arg_num]
+
+        unless rule_set.test(input)
+          result = false
+        end
+
+      end
+    end
+
+    return result
+
+  end
+
+  ##
+  # Validate output.
+  #
+  # @stage Called when validating a reflection.
+  # @param output [Dynamic] The method's return value.
+  # @param output_rule_set [RuleSet] The RuleSet to validate the output with.
+  ##
+  def test_output(output, output_rule_set)
+
+    # Default to a PASS result.
+    result = true
+
+    unless output_rule_set.nil?
+
+      # Validate output RuleSet for that argument.
+      unless output_rule_set.test(output)
+        result = false
+      end
+
+    end
+
+    return result
+
+  end
+
+  ##
+  # Get aggregated RuleSets for all inputs.
+  #
+  # @stage Called when building a reflection.
+  # @param klass [Symbol]
+  # @param method [Symbol]
+  # @return [Array]
+  ##
+  def get_input_rule_sets(klass, method)
+    @rule_sets.dig(klass, method, :inputs)
+  end
+
+  ##
+  # Get an aggregated RuleSet for an output.
+  #
+  # @stage Called when building a reflection.
+  # @param klass [Symbol]
+  # @param method [Symbol]
+  # @return [RuleSet]
+  ##
+  def get_output_rule_set(klass, method)
+    @rule_sets.dig(klass, method, :output)
+  end
+
+  ##
+  # Get the base rule type for a data type.
+  ##
+  def self.value_to_rule_type(value)
+
+    data_type = value.class
+
+    rule_types = {
+      Array      => ArrayRule,
+      TrueClass  => BooleanRule,
+      FalseClass => BooleanRule,
+      Float      => FloatRule,
+      Integer    => IntegerRule,
+      String     => StringRule
+    }
+
+    return rule_types[data_type]
+
+  end
+
+  ##############################################################################
+  # HELPERS
+  ##############################################################################
+
+  private
+
+  ##
+  # Get an aggregated RuleSet for an input.
+  #
+  # @param klass [Symbol]
+  # @param method [Symbol]
+  # @return [RuleSet]
+  ##
+  def get_input_rule_set(klass, method, arg_num)
+    @rule_sets.dig(klass, method, :inputs, arg_num)
+  end
+
+  ##
+  # Set an aggregated RuleSet for an input.
+  #
+  # @param klass [Symbol]
+  # @param method [Symbol]
+  ##
+  def set_input_rule_set(klass, method, arg_num, rule_set)
+
+    # Set defaults.
+    @rule_sets[klass] = {} unless @rule_sets.key? klass
+    @rule_sets[klass][method] = {} unless @rule_sets[klass].key? method
+    @rule_sets[klass][method][:inputs] = [] unless @rule_sets[klass][method].key? :inputs
+    # Set value.
+    @rule_sets[klass][method][:inputs][arg_num] = rule_set
+
+  end
+
+  ##
+  # Set an aggregated RuleSet for an output.
+  #
+  # @param klass [Symbol]
+  # @param method [Symbol]
+  # @param rule_set [RuleSet]
+  ##
+  def set_output_rule_set(klass, method, rule_set)
+
+    # Set defaults.
+    @rule_sets[klass] = {} unless @rule_sets.key? klass
+    @rule_sets[klass][method] = {} unless @rule_sets[klass].key? method
+    # Set value.
+    @rule_sets[klass][method][:output] = rule_set
+
+  end
+
+end

data/lib/Clone.rb

@@ -0,0 +1,31 @@
+################################################################################
+# A clone of the instance that a reflection calls methods on,
+# as well as any other instances that those methods may lead to.
+#
+# @note
+#   Not currently in use due to bug where "send" needs to be called directly
+#   on object, not indirectly through clone which results in "undefined method".
+#
+# @hierachy
+#   1. Execution
+#   2. Reflection
+#   3. Clone <- YOU ARE HERE
+################################################################################
+
+class Clone
+
+  def initialize(execution)
+
+    # Clone the execution's calling object.
+    @caller_object_clone = execution.caller_object.clone
+
+    # TODO: Clone any other instances that this clone references.
+    # TODO: Replace clone's references to these new instances.
+
+  end
+
+  def action(method, *new_args)
+    @caller_object_clone.send(method, *new_args)
+  end
+
+end

data/lib/Config.rb

@@ -0,0 +1,41 @@
+class Config
+
+  attr_accessor :enabled
+  attr_accessor :reflect_amount
+  attr_accessor :reflect_limit
+  attr_accessor :meta_map
+  attr_accessor :output_path
+  attr_accessor :output_directory
+
+  def initialize()
+
+    # Reflekt is enabled by default and should be disabled on production.
+    @enabled = 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/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],
+      :string => [StringRule]
+    }
+
+    # An absolute path to the directory that contains the output directory.
+    # Defaults to current execution path.
+    @output_path = nil
+
+    # Name of output directory.
+    @output_directory = "reflections"
+
+  end
+
+end

data/lib/Control.rb

@@ -1,31 +1,70 @@
+################################################################################
+# A shapshot of real data.
+#
+# A control's @number property will always be zero.
+#
+# @hierachy
+#   1. Execution
+#   2. Control <- YOU ARE HERE
+#   3. Meta
+################################################################################
+
 require 'Reflection'
+require 'MetaBuilder'
 
 class Control < Reflection
 
   ##
   # Reflect on a method.
   #
-  # Creates a shadow execution stack.
-  #
-  # @param method - The name of the method.
-  # @param *args - The method arguments.
-  #
-  # @return - A reflection hash.
+  # Creates a shadow execution.
+  # @param *args [Dynamic] The method's arguments.
   ##
   def reflect(*args)
 
-    @inputs = *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)
+
+    # When arguments exist.
+    unless args.size == 0
+
+      # When aggregated rule sets exist.
+      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.
+      @inputs = MetaBuilder.create_many(args)
 
-    # Action method with new arguments.
+    end
+
+    # Action method with new/old arguments.
     begin
-      @output = @clone.send(@method, *@inputs)
-    # When fail.
+
+      # Run reflection.
+      output = @clone.send(@method, *args)
+      @output = MetaBuilder.create(output)
+
+      # Validate output with 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
+
+      @status = :error
       @message = message
-    # When pass.
-    else
-      @status = PASS
+
     end
 
   end