reflekt 0.9.8 → 0.9.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c5b9e88d60fea03ebe06c430b489cb1295b8d56ec76f30982721a709a406f0af
-  data.tar.gz: 948f53a8b72f5befda3e175029edfdb017d98b3b8fd41998ab95b5f6b0a6b95e
+  metadata.gz: f04cedc3780f61776191bf7ae72822aae50eba606c76c61c176f5c252462fa22
+  data.tar.gz: 2ca6aa88016bfcab50460048d338a45f3855ee623f1b1bb5edc5e36323418eca
 SHA512:
-  metadata.gz: e70f287d10e70e3ac8ab3e01881ed6d8bb79f881c9af5530f39c7dd29997021ddf246d1129467503cfb3c6efb0589604648876c64bda917e8b970cb278a79fb3
-  data.tar.gz: ef005f855d7c3d1002eb059a73ecf742645841d4d3d0bd416a84b549e2e7d5b63a8bc216e8fe1404bf20c383a8e0a10c54740458e40382fa9591f9c67f3a075c
+  metadata.gz: 88024a7b33ba0ac0fca948b1b0808ad1a7094e958ae3b5d48f378b2c9256fcb29735b4635880322f5c2ee62e0034a265263997c3074d90d6756aef5408e5a2cb
+  data.tar.gz: b2700bb56c2cf3915676c797381ad7913cb3091ffe576e7f276c9e97dcde488be602e01defbd812c3886f26a2cdde4090bd207312bad14f3d1ab20e55e3541e6

data/lib/Accessor.rb

@@ -2,14 +2,15 @@
 # Access variables via one object to avoid polluting the caller class scope.
 #
 # @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
@@ -17,11 +18,10 @@ class Accessor
   attr_accessor :renderer
   attr_accessor :path
   attr_accessor :output_path
-  attr_accessor :reflect_amount
-  attr_accessor :reflect_limit
 
   def initialize()
 
+    @config = nil
     @setup = nil
     @db = nil
     @stack = nil
@@ -29,8 +29,6 @@ class Accessor
     @renderer = nil
     @path = nil
     @output_path = nil
-    @reflect_amount = nil
-    @reflect_limit = nil
 
   end
 

data/lib/Aggregator.rb

@@ -5,7 +5,7 @@
 # @pattern Singleton
 #
 # @hierachy
-#   1. Aggregator
+#   1. Aggregator <- YOU ARE HERE
 #   2. RuleSet
 #   3. Rule
 ################################################################################
@@ -14,8 +14,12 @@ require 'RuleSet'
 
 class Aggregator
 
-  def initialize()
+  ##
+  # @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 = {}
 
@@ -109,7 +113,7 @@ class Aggregator
           # Get rule set.
           rule_set = get_input_rule_set(klass, method, arg_num)
           if rule_set.nil?
-            rule_set = RuleSet.new()
+            rule_set = RuleSet.new(@meta_map)
             set_input_rule_set(klass, method, arg_num, rule_set)
           end
 
@@ -126,7 +130,7 @@ class Aggregator
       # Get rule set.
       output_rule_set = get_output_rule_set(klass, method)
       if output_rule_set.nil?
-        output_rule_set = RuleSet.new()
+        output_rule_set = RuleSet.new(@meta_map)
         set_output_rule_set(klass, method, output_rule_set)
       end
 

data/lib/Config.rb

@@ -0,0 +1,35 @@
+class Config
+
+  attr_accessor :reflect_amount
+  attr_accessor :reflect_limit
+  attr_accessor :meta_map
+  attr_accessor :output_path
+  attr_accessor :output_directory
+
+  def initialize()
+
+    # The amount of reflections to create per method call.
+    @reflect_amount = 2
+
+    # 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],
+      :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/Execution.rb

@@ -17,10 +17,10 @@ class Execution
   ##
   # Create Execution.
   #
-  # @param Object object - The calling object.
-  # @param Symbol method - The calling method.
-  # @param Integer number - The number of reflections to create per execution.
-  # @param ShadowStack stack - The shadow execution call stack.
+  # @param object [Object] The calling object.
+  # @param method [Symbol] The calling method.
+  # @param number [Integer] The number of reflections to create per execution.
+  # @param stack [ShadowStack] The shadow execution call stack.
   ##
   def initialize(caller_object, method, number, stack)
 

data/lib/Meta.rb

@@ -1,7 +1,7 @@
 ################################################################################
-# Meta for input and output. All meta behave the same.
+# Metadata for input and output.
 #
-# @pattern Abstract class.
+# @pattern Abstract class
 # @see lib/meta for each meta.
 ################################################################################
 

data/lib/MetaBuilder.rb

@@ -1,7 +1,7 @@
 ################################################################################
-# Create Meta.
+# Create metadata.
 #
-# @pattern Builder.
+# @pattern Builder
 # @see lib/meta for each meta.
 ################################################################################
 

data/lib/Reflekt.rb

@@ -1,14 +1,15 @@
 ################################################################################
 # Reflective testing.
 #
-# @author
-#   Maedi Prichard
+# @author Maedi Prichard
 #
 # @flow
-#   1. An Execution is created on method call.
-#   2. Many Refections are created per Execution.
-#   3. Each Reflection executes on cloned data.
-#   4. Flow is returned to the original method.
+#   1. Reflekt is prepended to a class and setup.
+#   2. When a class insantiates so does Reflekt.
+#   3. An Execution is created on method call.
+#   4. Many Refections are created per Execution.
+#   5. Each Reflection executes on cloned data.
+#   6. Flow is returned to the original method.
 #
 # @usage
 #   class ExampleClass
@@ -20,11 +21,14 @@ require 'erb'
 require 'rowdb'
 require 'Accessor'
 require 'Aggregator'
+require 'Config'
 require 'Control'
 require 'Execution'
 require 'Reflection'
 require 'Renderer'
 require 'ShadowStack'
+# Require all rules.
+Dir[File.join(__dir__, 'rules', '*.rb')].each { |file| require file }
 
 module Reflekt
 
@@ -32,37 +36,41 @@ module Reflekt
 
     @reflekt_counts = {}
 
-    # Get instance methods.
-    # TODO: Include parent methods like "Array.include?".
-    self.class.instance_methods(false).each do |method|
+    # 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
 
-      # Don't process skipped methods.
-      next if self.class.reflekt_skipped?(method)
+    # TODO: Include core methods like "Array.include?".
+    instance_methods.each do |method|
 
       @reflekt_counts[method] = 0
 
       # When method called in flow.
       self.define_singleton_method(method) do |*args|
 
-        # Don't reflect when limit reached.
-        unless @reflekt_counts[method] >= @@reflekt.reflect_limit
+        # Get current execution.
+        execution = @@reflekt.stack.peek()
 
-          # Get current execution.
-          execution = @@reflekt.stack.peek()
+        # Don't reflect when reflect limit reached or method skipped.
+        unless (@reflekt_counts[method] >= @@reflekt.config.reflect_limit) || self.class.reflekt_skipped?(method)
 
           # When stack empty or past execution done reflecting.
           if execution.nil? || execution.has_finished_reflecting?
 
             # Create execution.
-            execution = Execution.new(self, method, @@reflekt.reflect_amount, @@reflekt.stack)
+            execution = Execution.new(self, method, @@reflekt.config.reflect_amount, @@reflekt.stack)
 
             @@reflekt.stack.push(execution)
 
           end
 
-          # Reflect.
+          ##
+          # Reflect the execution.
+          #
           # 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
 
@@ -103,8 +111,13 @@ module Reflekt
 
         end
 
-        # Continue execution / shadow execution.
-        super *args
+        # Don't execute skipped methods when reflecting.
+        unless execution.is_reflecting? && self.class.reflekt_skipped?(method)
+
+          # Continue execution / shadow execution.
+          super *args
+
+        end
 
       end
 
@@ -115,6 +128,13 @@ module Reflekt
 
   end
 
+  ##
+  # Provide Config instance to block.
+  ##
+  def self.configure
+    yield(@@reflekt.config)
+  end
+
   private
 
   def self.prepended(base)
@@ -132,18 +152,16 @@ module Reflekt
   def self.reflekt_setup_class()
 
     # Receive configuration.
-    $ENV ||= {}
-    $ENV[:reflekt] ||= $ENV[:reflekt] = {}
-    $ENV[:reflekt][:output_directory] = "reflections"
+    @@reflekt.config = Config.new()
 
     # Set configuration.
     @@reflekt.path = File.dirname(File.realpath(__FILE__))
 
     # Get reflections directory path from config or current execution path.
-    if $ENV[:reflekt][:output_path]
-      @@reflekt.output_path = File.join($ENV[:reflekt][:output_path], $ENV[:reflekt][:output_directory])
+    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, $ENV[:reflekt][:output_directory])
+      @@reflekt.output_path = File.join(Dir.pwd, @@reflekt.config.output_directory)
     end
 
     # Create reflections directory.
@@ -161,16 +179,9 @@ module Reflekt
     @@reflekt.stack = ShadowStack.new()
 
     # Create aggregated rule sets.
-    @@reflekt.aggregator = Aggregator.new()
+    @@reflekt.aggregator = Aggregator.new(@@reflekt.config.meta_map)
     @@reflekt.aggregator.train(db[:controls])
 
-    # The amount of reflections to create per method call.
-    @@reflekt.reflect_amount = 2
-
-    # 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.reflect_limit = 10
-
     # Create renderer.
     @@reflekt.renderer = Renderer.new(@@reflekt.path, @@reflekt.output_path)
 
@@ -185,6 +196,10 @@ module Reflekt
     ##
     # Skip a method.
     #
+    # @note
+    #  Class variables cascade to child classes.
+    #  So a reflekt_skip on the parent class will persist to the child class.
+    #
     # @param method [Symbol] The method name.
     ##
     def reflekt_skip(method)
@@ -196,9 +211,9 @@ module Reflekt
       false
     end
 
-    def reflekt_limit(amount)
-      @@reflekt.reflect_limit = amount
-    end
+    #def reflekt_limit(amount)
+    #  @@reflekt.reflect_limit = amount
+    #end
 
   end
 

data/lib/Rule.rb

@@ -1,7 +1,13 @@
 ################################################################################
-# All rules behave the same.
+# A pattern that metadata follows.
+#
+# @pattern Abstract class
+#
+# @hierachy
+#   1. Aggregator
+#   2. RuleSet
+#   3. Rule <- YOU ARE HERE
 #
-# @pattern Abstract class.
 # @see lib/rules for rules.
 ################################################################################
 

data/lib/RuleSet.rb

@@ -1,5 +1,14 @@
 ################################################################################
-# A collection of rules that validate a value.
+# A collection of rules that validate metadata.
+#
+# @patterns
+#   - Dependency Injection
+#   - Builder
+#
+# @hierachy
+#   1. Aggregator
+#   2. RuleSet <- YOU ARE HERE
+#   3. Rule
 ################################################################################
 
 require 'set'
@@ -8,44 +17,17 @@ class RuleSet
 
   attr_accessor :rules
 
-  def initialize()
+  ##
+  # @param meta_map [Hash] The rules to apply to each data type.
+  ##
+  def initialize(meta_map)
 
+    @meta_map = meta_map
     @rules = {}
     @types = Set.new()
 
   end
 
-  def self.create_sets(args)
-
-    rule_sets = []
-
-    args.each do |arg|
-      rule_sets << self.create_set(arg)
-    end
-
-    rule_sets
-  end
-
-  def self.create_set(value)
-
-    rule_set = RuleSet.new()
-    value_type = value.class.to_s
-
-    # Creates values for matching data type.
-    case value_type
-    when "Integer"
-      rule = IntegerRule.new()
-      rule.train(arg)
-      rule_set.rules[IntegerRule] = rule
-    when "String"
-      rule = StringRule.new()
-      rule.train(arg)
-      rule_set.rules[StringRule] = rule
-    end
-
-    rule_set
-  end
-
   ##
   # Train rule set on metadata.
   #
@@ -53,35 +35,29 @@ class RuleSet
   ##
   def train(meta)
 
-    # Track data type.
-    @types << meta.class
-    type = meta.class.to_s
-
-    # 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]
+    unless meta.nil? || meta[:type].nil?
+
+      meta_type = meta[:type]
+      @types << meta_type
+
+      # Get rule types for this meta type.
+      if @meta_map.key? meta_type
+        @meta_map[meta_type].each do |rule_type|
+
+          # Ensure rule exists.
+          if @rules[rule_type].nil?
+            @rules << rule_type.new()
+          end
+
+          # Train rule.
+          @rules[rule_type].train(meta)
+
+        end
       end
-    end
 
-    # Train rule.
-    unless rule.nil?
-      rule.train(meta)
-    end
+      return self
 
-    return self
+    end
 
   end
 

data/lib/ShadowStack.rb

@@ -1,5 +1,7 @@
 ################################################################################
 # Track the executions in a shadow call stack.
+#
+# @pattern Stack
 ################################################################################
 
 class ShadowStack

data/lib/meta/ArrayMeta.rb

@@ -0,0 +1,33 @@
+require 'Meta'
+
+class ArrayMeta < Meta
+
+  def initialize()
+
+    @min = nil
+    @max = nil
+    @length = nil
+
+  end
+
+  ##
+  # @param value [Array]
+  ##
+  def load(value)
+
+    @min = value.min()
+    @max = value.max()
+    @length = value.length()
+
+  end
+
+  def result()
+    {
+      :type => :array,
+      :max => @max,
+      :min => @min,
+      :length => @length
+    }
+  end
+
+end

data/lib/meta/BooleanMeta.rb

@@ -0,0 +1,23 @@
+require 'Meta'
+
+class BooleanMeta < Meta
+
+  def initialize()
+    @value = nil
+  end
+
+  ##
+  # @param value [Boolean]
+  ##
+  def load(value)
+    @value = value
+  end
+
+  def result()
+    {
+      :type => :bool,
+      :value => @value
+    }
+  end
+
+end

data/lib/meta/IntegerMeta.rb

@@ -3,18 +3,14 @@ require 'Meta'
 class IntegerMeta < Meta
 
   def initialize()
-
     @value = nil
-
   end
 
   ##
   # @param value [Integer]
   ##
   def load(value)
-
     @value = value
-
   end
 
   def result()

data/lib/meta/StringMeta.rb

@@ -3,18 +3,14 @@ require 'Meta'
 class StringMeta < Meta
 
   def initialize()
-
     @length = nil
-
   end
 
   ##
-  # @param value [Integer]
+  # @param value [String]
   ##
   def load(value)
-
     @length = value.length
-
   end
 
   def result()

data/lib/rules/ArrayRule.rb

@@ -0,0 +1,75 @@
+require 'Rule'
+
+class ArrayRule < Rule
+
+  def initialize()
+
+    @min = nil
+    @max = nil
+    @min_length = nil
+    @max_length = nil
+
+  end
+
+  ##
+  # @param meta [ArrayMeta]
+  ##
+  def train(meta)
+
+    # Min value.
+    if @min.nil?
+      @min = meta[:min]
+    else
+      @min = meta[:min] if meta[:min] < @min
+    end
+
+    # Max value.
+    if @max.nil?
+      @max = meta[:max]
+    else
+      @max = meta[:max] if meta[:max] > @max
+    end
+
+    # Min length.
+    if @min_length.nil?
+      @min_length = meta[:length]
+    else
+      @min_length = meta[:length] if meta[:length] < @min_length
+    end
+
+    # Max length.
+    if @max_length.nil?
+      @max_length = meta[:length]
+    else
+      @max_length = meta[:length] if meta[:length] > @max_length
+    end
+
+  end
+
+  ##
+  # @param value [Array]
+  ##
+  def test(value)
+
+    # Min/max value.
+    return false if value.min() < @min
+    return false if value.max() > @max
+
+    # Min/max length.
+    return false if value.length < @min_length
+    return false if value.length > @max_length
+
+    true
+  end
+
+  def result()
+    {
+      :type => :array,
+      :min => @min,
+      :max => @max,
+      :min_length => @min_length,
+      :max_length => @max_length
+    }
+  end
+
+end

data/lib/rules/BooleanRule.rb

@@ -0,0 +1,42 @@
+require 'set'
+require 'Rule'
+
+class BooleanRule < Rule
+
+  def initialize()
+
+    @booleans = Set.new()
+
+  end
+
+  ##
+  # @param meta [BooleanMeta]
+  ##
+  def train(meta)
+
+    value = meta[:value]
+
+    unless value.nil?
+      @booleans << value
+    end
+
+  end
+
+  ##
+  # @param value [Boolean]
+  ##
+  def test(value)
+
+    @booleans.include? value
+
+  end
+
+  def result()
+    {
+      :type => :bool,
+      :is_true => @booleans.include?,
+      :is_false => @booleans.include?
+    }
+  end
+
+end

data/lib/rules/IntegerRule.rb

@@ -44,7 +44,8 @@ class IntegerRule < Rule
   def result()
     {
       :type => :int,
-      :value => @min # Min/max are the same.
+      :min => @min,
+      :max => @max
     }
   end
 

data/lib/rules/StringRule.rb

@@ -13,7 +13,7 @@ class StringRule < Rule
   end
 
   ##
-  # @param meta [Meta]
+  # @param meta [StringMeta]
   ##
   def train(meta)
 

data/lib/web/README.md

@@ -1,7 +1,7 @@
 # Reflections
 
-As you use the application reflections will be added to /reflections/db.js.
-They can be viewed by opening reflections/index.html, no server setup required.
+As you use your application, reflections will be added to `/reflections/db.js`.  
+They can be viewed by opening `/reflections/index.html` in your browser, no server setup required.
 
 If you would like to keep or delete reflections then start the server:
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: reflekt
 version: !ruby/object:Gem::Version
-  version: 0.9.8
+  version: 0.9.9
 platform: ruby
 authors:
 - Maedi Prichard
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-11-26 00:00:00.000000000 Z
+date: 2020-11-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rowdb
@@ -32,6 +32,7 @@ extra_rdoc_files: []
 files:
 - lib/Accessor.rb
 - lib/Aggregator.rb
+- lib/Config.rb
 - lib/Control.rb
 - lib/Execution.rb
 - lib/Meta.rb
@@ -42,8 +43,12 @@ files:
 - lib/Rule.rb
 - lib/RuleSet.rb
 - lib/ShadowStack.rb
+- lib/meta/ArrayMeta.rb
+- lib/meta/BooleanMeta.rb
 - lib/meta/IntegerMeta.rb
 - lib/meta/StringMeta.rb
+- lib/rules/ArrayRule.rb
+- lib/rules/BooleanRule.rb
 - lib/rules/IntegerRule.rb
 - lib/rules/StringRule.rb
 - lib/web/README.md