reflekt 0.9.3 → 0.9.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d76793031a1fb34931c9c71500a45249951cc50dcd820be7ac2faf6df2b091d3
-  data.tar.gz: 5263bb832fff7b00d73496cee4f708b1355907f38e496dd96486ca0bbbd0efab
+  metadata.gz: f2048b61fdb7acc0deede9ee5bcae644e6d51fa6e2dab2842f748433ce5ba949
+  data.tar.gz: dce2b1bd92e2eaf90c16e1cad6c27d9b9fc686001c958124f184a5d11a2ebe8d
 SHA512:
-  metadata.gz: 6d0a232b0fbc4cb944a8c19827da8bbe2962e4fc41b178e6b9ae99853c7f96d611d6b08b307313d8f8430af2e118933149e1772f3c3c125bd4f14eb70bf61b82
-  data.tar.gz: c5e439d83d26c7b9938b08ecfa466817e39cdf938a584012a86dd7ec0d2187f8ead6559c085874f8df5e1788567d9b57a847249ae1f20e76c03c67be58fea56d
+  metadata.gz: b4bdebf8083aef0a50806c1970b25f90736dfe68b8373f5a742ef6c7f2e4139e4ca0d273d683d826230069de2039c5fda7428c4ed8147471da00f1e93704f59a
+  data.tar.gz: afbe22e05eb10efe8ead84240c4296546e10570c19e73efea912494e55a85538c8fbed2872c42485ea21ba696a101347e73ec5feee37a568636a154dcae8bcf6

data/lib/Accessor.rb

@@ -12,8 +12,8 @@ class Accessor
 
   attr_accessor :setup
   attr_accessor :db
-  attr_accessor :json
   attr_accessor :stack
+  attr_accessor :renderer
   attr_accessor :rules
   attr_accessor :path
   attr_accessor :output_path
@@ -24,8 +24,8 @@ class Accessor
 
     @setup = nil
     @db = nil
-    @json = nil
     @stack = nil
+    @renderer = nil
     @rules = nil
     @path = nil
     @output_path = nil

data/lib/Control.rb

@@ -14,11 +14,11 @@ class Control < Reflection
   ##
   def reflect(*args)
 
-    @input = *args
+    @inputs = *args
 
     # Action method with new arguments.
     begin
-      @output = @clone.send(@method, *@input)
+      @output = @clone.send(@method, *@inputs)
     # When fail.
     rescue StandardError => message
       @status = FAIL

data/lib/Reflection.rb

@@ -57,31 +57,36 @@ class Reflection
 
     # Action method with new arguments.
     begin
+
       # Validate input with controls.
       unless @ruler.nil?
-        if @ruler.validate_inputs(@execution.caller_class, @method, @inputs)
+        if @ruler.validate_inputs(@inputs)
           @status = PASS
         else
           @status = FAIL
         end
       end
+
       # Run reflection.
       @output = @clone.send(@method, *@inputs)
-    # When fail.
-    rescue StandardError => message
-      @status = FAIL
-      @message = message
-    # When pass.
-    else
+
       # Validate output with controls.
       unless @ruler.nil?
-        if @ruler.validate_output(@execution.caller_class, @method, @output)
+        if @ruler.validate_output(@output)
           @status = PASS
         else
           @status = FAIL
         end
         return
       end
+
+    # When fail.
+    rescue StandardError => message
+      @status = FAIL
+      @message = message
+
+    # When no validation and execution fails.
+    else
       @status = PASS
     end
 

data/lib/{reflekt.rb → Reflekt.rb}

@@ -1,27 +1,27 @@
-require 'set'
-require 'erb'
-require 'rowdb'
-require 'Accessor'
-require 'Control'
-require 'Execution'
-require 'Reflection'
-require 'Ruler'
-require 'ShadowStack'
-
 ################################################################################
-# REFLEKT
+# REFLEKT - By Maedi Prichard.
 #
 # An Execution is created each time a method is called.
-# Multiple Refections are created per Execution.
-# These Reflections execute on a ShadowStack on cloned objects.
+# Many Refections are created per Execution.
+# Each Reflection executes on a ShadowStack on cloned data.
 # Then flow is returned to the original method and normal execution continues.
 #
 # Usage:
-#
 #   class ExampleClass
 #     prepend Reflekt
 ################################################################################
 
+require 'set'
+require 'erb'
+require 'rowdb'
+require 'Accessor'
+require 'Control'
+require 'Execution'
+require 'Reflection'
+require 'Renderer'
+require 'Ruler'
+require 'ShadowStack'
+
 module Reflekt
 
   def initialize(*args)
@@ -102,7 +102,7 @@ module Reflekt
             @@reflekt.db.write()
 
             # Render results.
-            reflekt_render()
+            @@reflekt.renderer.render()
 
             execution.is_reflecting = false
           end
@@ -121,35 +121,6 @@ module Reflekt
 
   end
 
-  ##
-  # Render results.
-  ##
-  def reflekt_render()
-
-    # Get JSON.
-    @@reflekt.json = File.read("#{@@reflekt.output_path}/db.json")
-
-    # Save HTML.
-    template = File.read("#{@@reflekt.path}/web/template.html.erb")
-    rendered = ERB.new(template).result(binding)
-    File.open("#{@@reflekt.output_path}/index.html", 'w+') do |f|
-      f.write rendered
-    end
-
-    # Add JS.
-    javascript = File.read("#{@@reflekt.path}/web/script.js")
-    File.open("#{@@reflekt.output_path}/script.js", 'w+') do |f|
-      f.write javascript
-    end
-
-    # Add CSS.
-    stylesheet = File.read("#{@@reflekt.path}/web/style.css")
-    File.open("#{@@reflekt.output_path}/style.css", 'w+') do |f|
-      f.write stylesheet
-    end
-
-  end
-
   private
 
   def self.prepended(base)
@@ -219,6 +190,9 @@ module Reflekt
     # A method called thousands of times doesn't need that many reflections.
     @@reflekt.reflection_limit = 10
 
+    # Create renderer.
+    @@reflekt.renderer = Renderer.new(@@reflekt.path, @@reflekt.output_path)
+
     return true
   end
 

data/lib/Renderer.rb

@@ -0,0 +1,38 @@
+class Renderer
+
+  def initialize(path, output_path)
+    @path = path
+    @output_path = output_path
+  end
+
+  ##
+  # Render results.
+  ##
+  def render()
+
+    # Get JSON.
+    json = File.read("#{@output_path}/db.json")
+
+    # Save HTML.
+    template = File.read("#{@path}/web/template.html.erb")
+    rendered = ERB.new(template).result(binding)
+    File.open("#{@output_path}/index.html", 'w+') do |f|
+      f.write rendered
+    end
+
+    # Add JS.
+    javascript = File.read("#{@path}/web/script.js")
+    File.open("#{@output_path}/script.js", 'w+') do |f|
+      f.write javascript
+    end
+
+    # Add CSS.
+    stylesheet = File.read("#{@path}/web/style.css")
+    File.open("#{@output_path}/style.css", 'w+') do |f|
+      f.write stylesheet
+    end
+
+  end
+
+
+end

data/lib/Rule.rb

@@ -1,38 +1,32 @@
+################################################################################
+# RULES
+#
+# Abstract class.
+# See lib/rules for rules.
+################################################################################
+
 require 'set'
 
 class Rule
 
-  attr_accessor :type
-  attr_accessor :min
-  attr_accessor :max
-  attr_accessor :length
-  attr_accessor :types
-  attr_accessor :values
-
+  # Each rule intitalises itself.
   def initialize()
-
-    @types = Set.new
-    @values = Set.new
-    @min = nil
-    @max = nil
-    @length = nil
-
+    @values = nil
   end
 
-  ##
-  # A parameter can accept multiple input types.
-  # Duplicates will not be added to the set.
-  ##
-  def add_type(type)
-    @types.add(type)
+  # Each rule loads up an array of values.
+  def load(value)
+    @values << value
   end
 
-  def add_value(value)
-    @values.add(value)
+  # Each rule trains on values to determine its patterns.
+  def train()
+
   end
 
-  def is_number?
-    @types.include? Integer
+  # Each rule compares the data it has with the data it's given.
+  def validate()
+
   end
 
 end

data/lib/RulePool.rb

@@ -0,0 +1,44 @@
+################################################################################
+# 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

data/lib/Ruler.rb

@@ -1,4 +1,10 @@
-require 'Rule'
+################################################################################
+# RULER
+#
+# Aggregate a method's inputs and output into a series of generic rules.
+################################################################################
+
+require 'RulePool'
 
 class Ruler
 
@@ -9,9 +15,9 @@ class Ruler
 
   def initialize()
 
+    # Reflections.
     @controls = nil
-
-    # Rules.
+    # Arguments.
     @inputs = []
     @output = nil
 
@@ -22,90 +28,96 @@ class Ruler
     @controls = controls
     @controls.each_with_index do |control, index|
 
-      # Multiple inputs.
+      # Create rules for each input.
       control[INPUT].each_with_index do |input, index|
         unless input.nil?
-
-          # Create rule.
-          if @inputs[index].nil?
-            rule = Rule.new()
-            @inputs[index] = rule
-          else
-            rule = @inputs[index]
-          end
-
-          # Add rules to rule.
-          unless input[TYPE].nil? || input[TYPE].empty?
-            rule.add_type(input[TYPE].class)
-          end
-          unless input[VALUE].nil? || input[VALUE].empty?
-            rule.add_value(input[VALUE])
-          end
-
-          index = index + 1
+          @inputs[index] = load_rule_pool(@inputs[index], input[TYPE], input[VALUE])
         end
       end
 
-      # Singular output.
+      # Create rules for the output.
       output = control[OUTPUT]
       unless control[OUTPUT].nil?
+        @output = load_rule_pool(@output, output[TYPE], output[VALUE])
+      end
 
-        # Create rule.
-        if @output.nil?
-          rule = Rule.new()
-          @output = rule
-        else
-          rule = @output
-        end
+    end
 
-        ## Add rules to rule.
-        unless output[TYPE].nil? || output[TYPE].empty?
-          rule.add_type(output[TYPE])
-        end
-        unless output[VALUE].nil? || output[VALUE].empty?
-          rule.add_value(output[VALUE])
-        end
+  end
+
+  def load_rule_pool(rule_pool, type, value)
+
+    if rule_pool.nil?
+      rule_pool = RulePool.new()
+    end
+
+    # Track data type.
+    rule_pool.types << type
+
+    # Get rule for this data type.
+    rule = nil
 
+    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
 
+    # Add value to rule.
+    unless rule.nil?
+      rule.load(value)
     end
 
+    return rule_pool
+
   end
 
   def train()
 
-    @inputs.each do |rule|
-      # Get min/max.
-      if rule.is_number?
-        numbers = rule.values.select {|num| num.class == Integer }
-        numbers.sort!
-        rule.min = numbers.first
-        rule.max = numbers.last
+    @inputs.each do |rule_pool|
+      unless rule_pool.nil?
+        rule_pool.train()
       end
+    end
 
+    unless @output.nil?
+      @output.train()
     end
 
   end
 
-  def validate_inputs(klass, method, inputs)
+  def validate_inputs(inputs)
     result = true
+
     inputs.each_with_index do |value, index|
-      rule = @inputs[index]
-      if rule.is_number? && value.class == Integer
-        result = false if value < rule.min
-        result = false if value > rule.max
+      rule_pool = @inputs[index]
+      unless rule_pool.validate(input)
+        result = false
       end
     end
+
     return result
   end
 
-  def validate_output(klass, method, outputs)
+  def validate_output(output)
     result = true
-    rule = @output
-    if rule.is_number? && value.class == Integer
-      result = false if value < rule.min
-      result = false if value > rule.max
+
+    rule_pool = @output
+    unless rule_pool.validate(output)
+      result = false
     end
+
     return result
   end
 

data/lib/rules/FloatRule.rb

@@ -0,0 +1,24 @@
+class FloatRule < Rule
+
+  attr_accessor :min
+  attr_accessor :max
+
+  def initialize()
+    @min = nil
+    @max = nil
+  end
+
+  def load(value)
+    @values << value
+  end
+
+  def train()
+    # TODO.
+  end
+
+  def validate()
+    # TODO.
+    true
+  end
+
+end

data/lib/rules/IntegerRule.rb

@@ -0,0 +1,27 @@
+class IntegerRule < Rule
+
+  attr_accessor :min
+  attr_accessor :max
+
+  def initialize()
+    @min = nil
+    @max = nil
+  end
+
+  def load(value)
+    @values << value
+  end
+
+  def train()
+    numbers = @values.select {|num| num.class == Integer }
+    numbers.sort!
+    @min = numbers.first
+    @max = numbers.last
+  end
+
+  def validate()
+    return false if value < rule.min
+    return false if value > rule.max
+  end
+
+end

data/lib/rules/StringRule.rb

@@ -0,0 +1,24 @@
+class StringRule < Rule
+
+  attr_accessor :min_length
+  attr_accessor :max_length
+
+  def initialize()
+    @min_length = nil
+    @max_length = nil
+  end
+
+  def load(value)
+    @values << value
+  end
+
+  def train()
+    # TODO.
+  end
+
+  def validate()
+    # TODO.
+    true
+  end
+
+end

data/lib/web/template.html.erb

@@ -32,7 +32,7 @@
 
       function getData() {
 
-        var data = JSON.parse(<%= @@reflekt.json %>);
+        var data = JSON.parse(<%= json %>);
         var results = {};
 
         console.log("DATA:");

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: reflekt
 version: !ruby/object:Gem::Version
-  version: 0.9.3
+  version: 0.9.5
 platform: ruby
 authors:
 - Maedi Prichard
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-10-04 00:00:00.000000000 Z
+date: 2020-10-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rowdb
@@ -34,10 +34,15 @@ files:
 - lib/Control.rb
 - lib/Execution.rb
 - lib/Reflection.rb
+- lib/Reflekt.rb
+- lib/Renderer.rb
 - lib/Rule.rb
+- lib/RulePool.rb
 - lib/Ruler.rb
 - lib/ShadowStack.rb
-- lib/reflekt.rb
+- lib/rules/FloatRule.rb
+- lib/rules/IntegerRule.rb
+- lib/rules/StringRule.rb
 - lib/web/script.js
 - lib/web/style.css
 - lib/web/template.html.erb