reflekt 0.9.9 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f04cedc3780f61776191bf7ae72822aae50eba606c76c61c176f5c252462fa22
-  data.tar.gz: 2ca6aa88016bfcab50460048d338a45f3855ee623f1b1bb5edc5e36323418eca
+  metadata.gz: e94e86e6d558012df59e1aebfdbbb7c2bf70a2e849e9a186795a3e4d5cb648f0
+  data.tar.gz: 9db428f6c518c06fbddb83e0abd9920b9dc30344846827b5c9505c3f2bc111c9
 SHA512:
-  metadata.gz: 88024a7b33ba0ac0fca948b1b0808ad1a7094e958ae3b5d48f378b2c9256fcb29735b4635880322f5c2ee62e0034a265263997c3074d90d6756aef5408e5a2cb
-  data.tar.gz: b2700bb56c2cf3915676c797381ad7913cb3091ffe576e7f276c9e97dcde488be602e01defbd812c3886f26a2cdde4090bd207312bad14f3d1ab20e55e3541e6
+  metadata.gz: e2a7ecf3adb9e06f7f3a09d507265c035bf3c641193711c64fea512b03973696c8ef9278d59eedf43ee83dd03a0f5f552026f0b2f6ba6182c6361bb35a211bf7
+  data.tar.gz: f002c69e490b63dd065e5f0ba0b40e9dcbbe980f71e7df66da01b1bc37b2dfe1081c9e58a3024b388b96628cc98422875a5b90f1e9227327f3241bc5d61450b0

data/lib/Accessor.rb

@@ -18,6 +18,7 @@ class Accessor
   attr_accessor :renderer
   attr_accessor :path
   attr_accessor :output_path
+  attr_accessor :error
 
   def initialize()
 
@@ -29,6 +30,7 @@ class Accessor
     @renderer = nil
     @path = nil
     @output_path = nil
+    @error = false
 
   end
 

data/lib/Aggregator.rb

@@ -1,6 +1,6 @@
 ################################################################################
-# Aggregate reflection metadata into rule sets.
-# Validate reflection arguments against aggregates.
+# Aggregate control metadata into rule sets.
+# Validate reflections against aggregated controls.
 #
 # @pattern Singleton
 #
@@ -26,89 +26,33 @@ class Aggregator
   end
 
   ##
-  # Get aggregated RuleSets for all inputs.
-  #
-  # @param klass [Symbol]
-  # @param method [Symbol]
-  # @return [Array]
-  ##
-  def get_input_rule_sets(klass, method)
-    return @rule_sets.dig(klass, method, :inputs)
-  end
-
-  ##
-  # 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
-
-  ##
-  # Get an aggregated RuleSet for an output.
-  #
-  # @param klass [Symbol]
-  # @param method [Symbol]
-  # @return [RuleSet]
-  ##
-  def get_output_rule_set(klass, method)
-    @rule_sets.dig(klass, method, :output)
-  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.
+  # Create aggregated rule sets from control metadata.
   #
-  # @param klass [Symbol]
-  # @param method [Symbol]
-  # @param rule_set [RuleSet]
+  # @stage Called on setup.
+  # @param controls [Array] Controls with metadata.
+  # @TODO Revert string keys to symbols once "Fix Rowdb.get(path)" bug fixed.
   ##
-  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
-
-  ##
-  # Create aggregated rule sets from reflection metadata.
-  #
-  # @param reflections [Array] Controls with metadata.
-  ##
-  def train(reflections)
+  def train(controls)
 
-    # On first use there are no previous reflections.
-    return if reflections.nil?
+    # On first use there are no previous controls.
+    return if controls.nil?
 
-    reflections.each do |reflection|
+    controls.each do |control|
 
-      klass = reflection[:class]
-      method = reflection[:method]
+      klass = control["class"].to_sym
+      method = control["method"].to_sym
 
       ##
       # INPUT
       ##
 
-      unless reflection[:inputs].nil?
-        reflection[:inputs].each_with_index do |meta, arg_num|
+      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)
@@ -135,7 +79,7 @@ class Aggregator
       end
 
       # Train on metadata.
-      output_rule_set.train(reflection[:output])
+      output_rule_set.train(control["output"])
 
     end
 
@@ -144,22 +88,23 @@ class Aggregator
   ##
   # 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 validate_inputs(inputs, input_rule_sets)
+  def test_inputs(inputs, input_rule_sets)
 
-    # Default to a PASS result.
+    # Default result to PASS.
     result = true
 
-    # Validate each argument against each RuleSet for that argument.
+    # 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.validate_rule(input)
+        unless rule_set.test(input)
           result = false
         end
 
@@ -173,10 +118,11 @@ class Aggregator
   ##
   # 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 validate_output(output, output_rule_set)
+  def test_output(output, output_rule_set)
 
     # Default to a PASS result.
     result = true
@@ -184,7 +130,7 @@ class Aggregator
     unless output_rule_set.nil?
 
       # Validate output RuleSet for that argument.
-      unless output_rule_set.validate_rule(output)
+      unless output_rule_set.test(output)
         result = false
       end
 
@@ -194,4 +140,99 @@ class Aggregator
 
   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

@@ -1,5 +1,6 @@
 class Config
 
+  attr_accessor :enabled
   attr_accessor :reflect_amount
   attr_accessor :reflect_limit
   attr_accessor :meta_map
@@ -8,8 +9,12 @@ class Config
 
   def initialize()
 
+    # Reflekt is enabled by default and should be disabled on production.
+    @enabled = true
+
     # The amount of reflections to create per method call.
-    @reflect_amount = 2
+    # 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.
@@ -20,6 +25,7 @@ class Config
       :array  => [ArrayRule],
       :bool   => [BooleanRule],
       :int    => [IntegerRule],
+      :float  => [FloatRule],
       :string => [StringRule]
     }
 

data/lib/Control.rb

@@ -1,10 +1,12 @@
 ################################################################################
 # A shapshot of real data.
 #
+# A control's @number property will always be zero.
+#
 # @hierachy
 #   1. Execution
-#   2. Control
-#   3. RuleSet
+#   2. Control <- YOU ARE HERE
+#   3. Meta
 ################################################################################
 
 require 'Reflection'
@@ -15,27 +17,54 @@ class Control < Reflection
   ##
   # Reflect on a method.
   #
-  # Creates a shadow execution stack.
-  #
-  # @param method [Symbol] The name of the method.
-  # @param *args [Args] The method arguments.
-  # @return [Hash] A reflection hash.
+  # Creates a shadow execution.
+  # @param *args [Dynamic] The method's arguments.
   ##
   def reflect(*args)
 
-    # Create metadata for each argument.
-    @inputs = MetaBuilder.create_many(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
+
+      # Run reflection.
       output = @clone.send(@method, *args)
-    # When fail.
+      @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

data/lib/Execution.rb

@@ -1,3 +1,12 @@
+################################################################################
+# A shadow execution.
+#
+# @hierachy
+#   1. Execution <- YOU ARE HERE
+#   2. Reflection
+#   3. Meta
+################################################################################
+
 class Execution
 
   attr_accessor :unique_id
@@ -19,10 +28,10 @@ class Execution
   #
   # @param object [Object] The calling object.
   # @param method [Symbol] The calling method.
-  # @param number [Integer] The number of reflections to create per execution.
+  # @param reflect_amount [Integer] The number of reflections to create per execution.
   # @param stack [ShadowStack] The shadow execution call stack.
   ##
-  def initialize(caller_object, method, number, stack)
+  def initialize(caller_object, method, reflect_amount, stack)
 
     @time = Time.now.to_i
     @unique_id = @time + rand(1..99999)
@@ -42,7 +51,7 @@ class Execution
 
     # Reflections.
     @control = nil
-    @reflections = Array.new(number)
+    @reflections = Array.new(reflect_amount)
 
     # State.
     if @stack.peek() == nil