reflekt 0.9.5 → 0.9.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f2048b61fdb7acc0deede9ee5bcae644e6d51fa6e2dab2842f748433ce5ba949
-  data.tar.gz: dce2b1bd92e2eaf90c16e1cad6c27d9b9fc686001c958124f184a5d11a2ebe8d
+  metadata.gz: 30e9de1f6073eb71a87871e5790dee7a5da6476b4c787a31c75d772986994295
+  data.tar.gz: 29b671194ac45fe98d596c4aefcd7cb17a5aba511d82109968403889d7d94aef
 SHA512:
-  metadata.gz: b4bdebf8083aef0a50806c1970b25f90736dfe68b8373f5a742ef6c7f2e4139e4ca0d273d683d826230069de2039c5fda7428c4ed8147471da00f1e93704f59a
-  data.tar.gz: afbe22e05eb10efe8ead84240c4296546e10570c19e73efea912494e55a85538c8fbed2872c42485ea21ba696a101347e73ec5feee37a568636a154dcae8bcf6
+  metadata.gz: b3701e103b4ad81c7f1e0697b5f1dd07075f7fc8f55cc1715a0e9d2b8448218b8f8c6efa3ef6334943ba369172d967879b0e9e7516b1b0e2652981147ca4f107
+  data.tar.gz: 278a84e1cb673170c52779aea32de1e958b1ea2f2b24dcc6cb8c1356603b07d018c4d2ff22d16b9a86f2ea03beee8462f5024be87d94c362ff5163418259234a

data/lib/Accessor.rb

@@ -1,10 +1,11 @@
 ################################################################################
 # ACCESSOR
 #
-# Access variables via one object to avoid polluting the caller class.
+# Access variables via one object to avoid polluting the caller class scope.
 #
-# Only 2 variables are not accessed via Accessor:
-#   - @reflection_counts on the instance
+# 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
 ################################################################################
 
@@ -13,24 +14,24 @@ class Accessor
   attr_accessor :setup
   attr_accessor :db
   attr_accessor :stack
+  attr_accessor :ruler
   attr_accessor :renderer
-  attr_accessor :rules
   attr_accessor :path
   attr_accessor :output_path
   attr_accessor :reflect_amount
-  attr_accessor :reflection_limit
+  attr_accessor :reflect_limit
 
   def initialize()
 
     @setup = nil
     @db = nil
     @stack = nil
+    @ruler = nil
     @renderer = nil
-    @rules = nil
     @path = nil
     @output_path = nil
     @reflect_amount = nil
-    @reflection_limit = nil
+    @reflect_limit = nil
 
   end
 

data/lib/Reflection.rb

@@ -15,21 +15,32 @@ class Reflection
 
   attr_accessor :clone
 
-  def initialize(execution, method, ruler)
+  ##
+  # Create a Reflection.
+  #
+  # @param Execution execution - The Execution that created this Reflection.
+  # @param Symbol klass - The class of the method being called.
+  # @param Symbol method - The method that is being called.
+  # @param Ruler ruler - The RuleSets for this class/method.
+  ##
+  def initialize(execution, klass, method, ruler)
 
     @execution = execution
+    @klass = klass
     @method = method
     @ruler = ruler
 
+    # Arguments.
+    @inputs = []
+    @output = nil
+
     # Clone the execution's object.
     @clone = execution.object.clone
     @clone_id = nil
 
     # Result.
-    @status = nil
+    @status = PASS
     @time = Time.now.to_i
-    @inputs = []
-    @output = nil
 
   end
 
@@ -38,13 +49,16 @@ class Reflection
   #
   # Creates a shadow execution stack.
   #
-  # @param method - The name of the method.
-  # @param *args - The method arguments.
+  # @param *args - The method's arguments.
   #
   # @return - A reflection hash.
   ##
   def reflect(*args)
 
+    # Get RuleSets.
+    input_rule_sets = @ruler.get_input_rule_sets(@klass, @method)
+    output_rule_set = @ruler.get_output_rule_set(@klass, @method)
+
     # Create deviated arguments.
     args.each do |arg|
       case arg
@@ -59,10 +73,8 @@ class Reflection
     begin
 
       # Validate input with controls.
-      unless @ruler.nil?
-        if @ruler.validate_inputs(@inputs)
-          @status = PASS
-        else
+      unless input_rule_sets.nil?
+        unless @ruler.validate_inputs(@inputs, input_rule_sets)
           @status = FAIL
         end
       end
@@ -71,23 +83,16 @@ class Reflection
       @output = @clone.send(@method, *@inputs)
 
       # Validate output with controls.
-      unless @ruler.nil?
-        if @ruler.validate_output(@output)
-          @status = PASS
-        else
+      unless output_rule_set.nil?
+        unless @ruler.validate_output(@output, output_rule_set)
           @status = FAIL
         end
-        return
       end
 
     # When fail.
     rescue StandardError => message
       @status = FAIL
       @message = message
-
-    # When no validation and execution fails.
-    else
-      @status = PASS
     end
 
   end

data/lib/Reflekt.rb

@@ -26,7 +26,7 @@ module Reflekt
 
   def initialize(*args)
 
-    @reflection_counts = {}
+    @reflekt_counts = {}
 
     # Get instance methods.
     # TODO: Include parent methods like "Array.include?".
@@ -35,13 +35,13 @@ module Reflekt
       # Don't process skipped methods.
       next if self.class.reflekt_skipped?(method)
 
-      @reflection_counts[method] = 0
+      @reflekt_counts[method] = 0
 
       # When method called in flow.
       self.define_singleton_method(method) do |*args|
 
         # Don't reflect when limit reached.
-        unless @reflection_counts[method] >= @@reflekt.reflection_limit
+        unless @reflekt_counts[method] >= @@reflekt.reflect_limit
 
           # Get current execution.
           execution = @@reflekt.stack.peek()
@@ -55,25 +55,20 @@ module Reflekt
 
           end
 
-          # Get ruler.
-          # The method's ruler will not exist the first time the db generated.
-          if @@reflekt.rules.key? execution.caller_class.to_s.to_sym
-            ruler = @@reflekt.rules[execution.caller_class.to_s.to_sym][method.to_s]
-          else
-            ruler = nil
-          end
-
           # Reflect.
           # The first method call in the Execution creates a Reflection.
           # Subsequent method calls are shadow executions on cloned objects.
           if execution.has_empty_reflections? && !execution.is_reflecting?
             execution.is_reflecting = true
 
+            # Use symbols "klass" and "method" as keys in hashes.
+            # Use strings "class_name" and "method_name" to query the database.
             class_name = execution.caller_class.to_s
             method_name = method.to_s
+            klass = class_name.to_sym
 
             # Create control.
-            control = Control.new(execution, method, ruler)
+            control = Control.new(execution, klass, method, @@reflekt.ruler)
             execution.control = control
 
             # Execute control.
@@ -86,12 +81,12 @@ module Reflekt
             execution.reflections.each_with_index do |value, index|
 
               # Create reflection.
-              reflection = Reflection.new(execution, method, ruler)
+              reflection = Reflection.new(execution, klass, method, @@reflekt.ruler)
               execution.reflections[index] = reflection
 
               # Execute reflection.
               reflection.reflect(*args)
-              @reflection_counts[method] = @reflection_counts[method] + 1
+              @reflekt_counts[method] = @reflekt_counts[method] + 1
 
               # Save reflection.
               @@reflekt.db.get("#{class_name}.#{method_name}.reflections").push(reflection.result())
@@ -163,24 +158,25 @@ module Reflekt
     # Create shadow execution stack.
     @@reflekt.stack = ShadowStack.new()
 
-    # Define rules.
-    # TODO: Fix Rowdb.get(path) not returning data at path after Rowdb.push()?
-    @@reflekt.rules = {}
-    db = @@reflekt.db.value()
-    db.each do |class_name, class_values|
-      @@reflekt.rules[class_name] = {}
-      class_values.each do |method_name, method_values|
-        next if method_values.nil?
-        next unless method_values.class == Hash
-        if method_values.key? "controls"
-
-          ruler = Ruler.new()
-          ruler.load(method_values['controls'])
-          ruler.train()
-
-          @@reflekt.rules[class_name][method_name] = ruler
+    # Create rules.
+    @@reflekt.ruler = Ruler.new()
+    # TODO: Fix Rowdb.get(path) not returning values at path after Rowdb.push()?
+    values = @@reflekt.db.value()
+    values.each do |klass, class_values|
+
+      class_values.each do |method_name, method_items|
+        next if method_items.nil?
+        next unless method_items.class == Hash
+        if method_items.key? "controls"
+
+          method = method_name.to_sym
+
+          @@reflekt.ruler.load(klass, method, method_items['controls'])
+          @@reflekt.ruler.train(klass, method)
+
         end
       end
+
     end
 
     # The amount of reflections to create per method call.
@@ -188,7 +184,7 @@ module Reflekt
 
     # Limit the amount of reflections that can be created per instance method.
     # A method called thousands of times doesn't need that many reflections.
-    @@reflekt.reflection_limit = 10
+    @@reflekt.reflect_limit = 10
 
     # Create renderer.
     @@reflekt.renderer = Renderer.new(@@reflekt.path, @@reflekt.output_path)
@@ -215,7 +211,7 @@ module Reflekt
     end
 
     def reflekt_limit(amount)
-      @@reflekt.reflection_limit = amount
+      @@reflekt.reflect_limit = amount
     end
 
   end

data/lib/Rule.rb

@@ -11,7 +11,7 @@ class Rule
 
   # Each rule intitalises itself.
   def initialize()
-    @values = nil
+    @values = []
   end
 
   # Each rule loads up an array of values.
@@ -19,13 +19,13 @@ class Rule
     @values << value
   end
 
-  # Each rule trains on values to determine its patterns.
+  # Each rule trains on values to determine its boundaries.
   def train()
 
   end
 
-  # Each rule compares the data it has with the data it's given.
-  def validate()
+  # Each rule compares the values it's given with its boundaries.
+  def validate(value)
 
   end
 

data/lib/RuleSet.rb

@@ -0,0 +1,79 @@
+################################################################################
+# RULE POOL
+#
+# A collection of unique rules that validate an argument.
+################################################################################
+
+require 'set'
+require 'rules/FloatRule'
+require 'rules/IntegerRule'
+require 'rules/StringRule'
+
+class RuleSet
+
+  attr_accessor :types
+  attr_accessor :rules
+
+  def initialize()
+
+    @types = Set.new
+    @rules = {}
+
+  end
+
+  def load(type, value)
+
+    # Track data type.
+    @types << type
+
+    # Get rule for this data type.
+    rule = nil
+
+    case type
+    when "Integer"
+      unless @rules.key? IntegerRule
+        rule = IntegerRule.new()
+        @rules[IntegerRule] = rule
+      else
+        rule = @rules[IntegerRule]
+      end
+    when "String"
+      unless @rules.key? StringRule
+        rule = StringRule.new()
+        @rules[StringRule] = rule
+      else
+        rule = @rules[IntegerRule]
+      end
+    end
+
+    # Add value to rule.
+    unless rule.nil?
+      rule.load(value)
+    end
+
+    return self
+
+  end
+
+  def train()
+
+    @rules.each do |klass, rule|
+      rule.train()
+    end
+
+  end
+
+  def validate_rule(value)
+    result = true
+
+    @rules.each do |klass, rule|
+
+      unless rule.validate(value)
+        result = false
+      end
+    end
+
+    return result
+  end
+
+end

data/lib/Ruler.rb

@@ -1,124 +1,197 @@
 ################################################################################
 # RULER
 #
-# Aggregate a method's inputs and output into a series of generic rules.
+# Aggregates input/output from controls.
+# Creates and trains RuleSets from aggregated input/output.
+# Validates reflection input/output against RuleSets.
 ################################################################################
 
-require 'RulePool'
+require 'RuleSet'
 
 class Ruler
 
-  INPUT  = "i"
+  INPUTS = "i"
   OUTPUT = "o"
   TYPE   = "T"
   VALUE  = "V"
 
   def initialize()
+    @rule_sets = {}
+  end
 
-    # Reflections.
-    @controls = nil
-    # Arguments.
-    @inputs = []
-    @output = nil
+  ##
+  # Get input RuleSets.
+  #
+  # @param Symbol klass
+  # @param Symbol method
+  #
+  # @return Array
+  ##
+  def get_input_rule_sets(klass, method)
+    return @rule_sets.dig(klass, method, :inputs)
+  end
 
+  ##
+  # Get input RuleSet.
+  #
+  # @param Symbol klass
+  # @param Symbol method
+  #
+  # @return RuleSet
+  ##
+  def get_input_rule_set(klass, method, arg_num)
+    @rule_sets.dig(klass, method, :inputs, arg_num)
   end
 
-  def load(controls)
+  ##
+  # Get output RuleSet.
+  #
+  # @param Symbol klass
+  # @param Symbol method
+  #
+  # @return RuleSet.
+  ##
+  def get_output_rule_set(klass, method)
+    @rule_sets.dig(klass, method, :output)
+  end
 
-    @controls = controls
-    @controls.each_with_index do |control, index|
+  ##
+  # Set input RuleSet.
+  #
+  # @param Symbol klass
+  # @param Symbol method
+  ##
+  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
 
-      # Create rules for each input.
-      control[INPUT].each_with_index do |input, index|
-        unless input.nil?
-          @inputs[index] = load_rule_pool(@inputs[index], input[TYPE], input[VALUE])
+  ##
+  # Set output RuleSet.
+  #
+  # @param Symbol klass
+  # @param Symbol method
+  # @param RuleSet rule_set
+  ##
+  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
+
+  ##
+  # Load RuleSets.
+  #
+  # @param Symbol klass
+  # @param Symbol method
+  # @param Array controls
+  ##
+  def load(klass, method, controls)
+
+    # Create a RuleSet for each control's inputs/output.
+    controls.each_with_index do |control, index|
+
+      # Process inputs.
+      control[INPUTS].each_with_index do |input, arg_num|
+        rule_set = get_input_rule_set(klass, method, arg_num)
+        if rule_set.nil?
+          rule_set = RuleSet.new()
+          set_input_rule_set(klass, method, arg_num, rule_set)
         end
+        rule_set.load(input[TYPE], input[VALUE])
       end
 
-      # Create rules for the output.
-      output = control[OUTPUT]
-      unless control[OUTPUT].nil?
-        @output = load_rule_pool(@output, output[TYPE], output[VALUE])
+      # Process output.
+      output_rule_set = get_output_rule_set(klass, method)
+      if output_rule_set.nil?
+        output_rule_set = RuleSet.new()
+        set_output_rule_set(klass, method, output_rule_set)
       end
+      output_rule_set.load(control[OUTPUT][TYPE], control[OUTPUT][VALUE])
 
     end
 
   end
 
-  def load_rule_pool(rule_pool, type, value)
+  ##
+  # Train RuleSets from controls.
+  #
+  # @param Symbol klass
+  # @param Symbol method
+  ##
+  def train(klass, method)
+
+    input_rule_sets = get_input_rule_sets(klass, method)
+    unless input_rule_sets.nil?
+      input_rule_sets.each do |input_rule_set|
+        input_rule_set.train()
+      end
+    end
 
-    if rule_pool.nil?
-      rule_pool = RulePool.new()
+    output_rule_set = get_output_rule_set(klass, method)
+    unless output_rule_set.nil?
+      output_rule_set.train()
     end
 
-    # Track data type.
-    rule_pool.types << type
+  end
 
-    # Get rule for this data type.
-    rule = nil
+  ##
+  # Validate inputs.
+  #
+  # @param Array inputs - The method's arguments.
+  # @param Array input_rule_sets - The RuleSets to validate each input with.
+  ##
+  def validate_inputs(inputs, input_rule_sets)
 
-    case type
-    when "Integer"
-      unless rule_pool.rules.key? IntegerRule
-        rule = IntegerRule.new()
-        rule_pool.rules << rule
-      else
-        rule = rule_pool.rules[IntegerRule]
-      end
-    when "String"
-      unless rule_pool.rules.key? StringRule
-        rule = StringRule.new()
-        rule_pool.rules << rule
-      else
-        rule = rule_pool.rules[IntegerRule]
-      end
-    end
+    # Default to a PASS result.
+    result = true
 
-    # Add value to rule.
-    unless rule.nil?
-      rule.load(value)
-    end
+    # Validate each argument against each rule set for that argument.
+    inputs.each_with_index do |input, arg_num|
 
-    return rule_pool
+      unless input_rule_sets[arg_num].nil?
 
-  end
+        rule_set = input_rule_sets[arg_num]
 
-  def train()
+        unless rule_set.validate_rule(input)
+          result = false
+        end
 
-    @inputs.each do |rule_pool|
-      unless rule_pool.nil?
-        rule_pool.train()
       end
     end
 
-    unless @output.nil?
-      @output.train()
-    end
+    return result
 
   end
 
-  def validate_inputs(inputs)
+  ##
+  # Validate output.
+  #
+  # @param dynamic output - The method's return value.
+  # @param RuleSet output_rule_set - The RuleSet to validate the output with.
+  ##
+  def validate_output(output, output_rule_set)
+
+    # Default to a PASS result.
     result = true
 
-    inputs.each_with_index do |value, index|
-      rule_pool = @inputs[index]
-      unless rule_pool.validate(input)
+    unless output_rule_set.nil?
+
+      # Validate output RuleSet for that argument.
+      unless output_rule_set.validate_rule(output)
         result = false
       end
-    end
 
-    return result
-  end
-
-  def validate_output(output)
-    result = true
-
-    rule_pool = @output
-    unless rule_pool.validate(output)
-      result = false
     end
 
     return result
+
   end
 
 end

data/lib/rules/FloatRule.rb

@@ -1,9 +1,13 @@
+require 'Rule'
+
 class FloatRule < Rule
 
   attr_accessor :min
   attr_accessor :max
 
   def initialize()
+    super
+
     @min = nil
     @max = nil
   end
@@ -16,7 +20,7 @@ class FloatRule < Rule
     # TODO.
   end
 
-  def validate()
+  def validate(value)
     # TODO.
     true
   end

data/lib/rules/IntegerRule.rb

@@ -1,15 +1,16 @@
-class IntegerRule < Rule
+require 'Rule'
 
-  attr_accessor :min
-  attr_accessor :max
+class IntegerRule < Rule
 
   def initialize()
     @min = nil
     @max = nil
+
+    super
   end
 
   def load(value)
-    @values << value
+    @values << value.to_i
   end
 
   def train()
@@ -19,9 +20,12 @@ class IntegerRule < Rule
     @max = numbers.last
   end
 
-  def validate()
-    return false if value < rule.min
-    return false if value > rule.max
+  def validate(value)
+
+    return false if value < @min
+    return false if value > @max
+
+    true
   end
 
 end

data/lib/rules/StringRule.rb

@@ -1,11 +1,16 @@
+require 'Rule'
+
 class StringRule < Rule
 
   attr_accessor :min_length
   attr_accessor :max_length
 
   def initialize()
+    super
+
     @min_length = nil
     @max_length = nil
+
   end
 
   def load(value)
@@ -16,7 +21,7 @@ class StringRule < Rule
     # TODO.
   end
 
-  def validate()
+  def validate(value)
     # TODO.
     true
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: reflekt
 version: !ruby/object:Gem::Version
-  version: 0.9.5
+  version: 0.9.6
 platform: ruby
 authors:
 - Maedi Prichard
@@ -37,7 +37,7 @@ files:
 - lib/Reflekt.rb
 - lib/Renderer.rb
 - lib/Rule.rb
-- lib/RulePool.rb
+- lib/RuleSet.rb
 - lib/Ruler.rb
 - lib/ShadowStack.rb
 - lib/rules/FloatRule.rb

data/lib/RulePool.rb

@@ -1,44 +0,0 @@
-################################################################################
-# RULE POOL
-#
-# A collection of rules generated for an argument.
-# Duplicates will not be added to the sets.
-################################################################################
-
-require 'set'
-require 'Rule'
-
-class RulePool
-
-  attr_accessor :types
-  attr_accessor :rules
-
-  def initialize()
-
-    @types = Set.new
-    @rules = {}
-
-  end
-
-  def train()
-
-    rules.each do |rule|
-      rule.train()
-    end
-
-  end
-
-  def validate(value)
-    result = true
-
-    rules.each do |rule|
-      result = rule.validate(value)
-      if result == false
-        result = false
-      end
-    end
-
-    return result
-  end
-
-end