reflekt 0.9.1 → 0.9.7

data/lib/Renderer.rb

@@ -0,0 +1,34 @@
+class Renderer
+
+  def initialize(path, output_path)
+
+    @path = path
+    @output_path = output_path
+
+  end
+
+  ##
+  # Place files in output path.
+  ##
+  def render()
+
+    filenames = [
+      "bundle.js",
+      "index.html",
+      "package-lock.json",
+      "package.json",
+      "README.md",
+      "server.js"
+    ]
+
+    filenames.each do |filename|
+      file = File.read(File.join(@path, "web", filename))
+      File.open(File.join(@output_path, filename), 'w+') do |f|
+        f.write file
+      end
+    end
+
+  end
+
+
+end

data/lib/Rule.rb

@@ -0,0 +1,32 @@
+################################################################################
+# RULES
+#
+# Abstract class.
+# See lib/rules for rules.
+################################################################################
+
+require 'set'
+
+class Rule
+
+  # Each rule intitalises itself.
+  def initialize()
+    @values = []
+  end
+
+  # Each rule loads up an array of values.
+  def load(value)
+    @values << value
+  end
+
+  # Each rule trains on values to determine its boundaries.
+  def train()
+
+  end
+
+  # Each rule compares the values it's given with its boundaries.
+  def validate(value)
+
+  end
+
+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

@@ -0,0 +1,192 @@
+################################################################################
+# RULER
+#
+# Aggregates input/output from controls.
+# Creates and trains RuleSets from aggregated input/output.
+# Validates reflection input/output against RuleSets.
+################################################################################
+
+require 'RuleSet'
+
+class Ruler
+
+  def initialize()
+    @rule_sets = {}
+  end
+
+  ##
+  # 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
+
+  ##
+  # 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
+
+  ##
+  # 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
+
+  ##
+  # 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
+
+      # 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
+
+  ##
+  # 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
+
+    output_rule_set = get_output_rule_set(klass, method)
+    unless output_rule_set.nil?
+      output_rule_set.train()
+    end
+
+  end
+
+  ##
+  # 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)
+
+    # Default to a PASS result.
+    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.validate_rule(input)
+          result = false
+        end
+
+      end
+    end
+
+    return result
+
+  end
+
+  ##
+  # 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
+
+    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
+
+end

data/lib/ShadowStack.rb

@@ -42,15 +42,4 @@ class ShadowStack
 
   end
 
-  def display
-    display_execution_tree(@bottom)
-  end
-
-  def display_execution_tree(execution)
-    p execution
-    unless execution.parent == nil
-      display_execution_tree(execution.parent)
-    end
-  end
-
 end

data/lib/rules/FloatRule.rb

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

data/lib/rules/IntegerRule.rb

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

data/lib/rules/StringRule.rb

@@ -0,0 +1,29 @@
+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)
+    @values << value
+  end
+
+  def train()
+    # TODO.
+  end
+
+  def validate(value)
+    # TODO.
+    true
+  end
+
+end