reflekt 1.0.5 → 1.0.10

data/lib/ActionStack.rb

@@ -1,44 +0,0 @@
-################################################################################
-# Track the actions in a shadow call stack.
-#
-# @pattern Stack
-################################################################################
-
-class ActionStack
-
-  def initialize()
-    @bottom = nil
-    @top = nil
-  end
-
-  def peek()
-    @top
-  end
-
-  def base()
-    @bottom
-  end
-
-  ##
-  # Place Action at the top of stack.
-  #
-  # @param action [Action] The action to place.
-  # @return [Action] The placed action.
-  ##
-  def push(action)
-
-    # Place first action at bottom of stack.
-    if @bottom.nil?
-      @bottom = action
-    # Connect subsequent actions to each other.
-    else
-      @top.parent = action
-      action.child = @top
-    end
-
-    # Place action at top of stack.
-    @top = action
-
-  end
-
-end

data/lib/Aggregator.rb

@@ -1,260 +0,0 @@
-################################################################################
-# Aggregate control metadata into rule sets.
-# Validate reflections against aggregated controls.
-#
-# @pattern Singleton
-#
-# @hierachy
-#   1. Aggregator <- YOU ARE HERE
-#   2. RuleSet
-#   3. Rule
-################################################################################
-
-require 'RuleSet'
-
-class Aggregator
-
-  ##
-  # @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 = {}
-
-  end
-
-  ##
-  # Create aggregated rule sets from control metadata.
-  #
-  # @stage Called on setup.
-  # @param controls [Array] Controls with metadata.
-  # @TODO Revert string keys to symbols once "Fix Rowdb.get(path)" bug fixed.
-  ##
-  def train(controls)
-
-    # On first use there are no previous controls.
-    return if controls.nil?
-
-    controls.each do |control|
-
-      klass = control["class"].to_sym
-      method = control["method"].to_sym
-
-      ##
-      # INPUT
-      ##
-
-      # Singular null input.
-      if control["inputs"].nil?
-        train_input(klass, method, nil, 0)
-      # Multiple inputs.
-      else
-        control["inputs"].each_with_index do |meta, arg_num|
-          train_input(klass, method, meta, arg_num)
-        end
-      end
-
-      ##
-      # OUTPUT
-      ##
-
-      # Get rule set.
-      output_rule_set = get_output_rule_set(klass, method)
-      if output_rule_set.nil?
-        output_rule_set = RuleSet.new(@meta_map)
-        set_output_rule_set(klass, method, output_rule_set)
-      end
-
-      # Train on metadata.
-      output_rule_set.train(Meta.deserialize(control["output"]))
-
-    end
-
-  end
-
-  def train_input(klass, method, meta, arg_num)
-
-    # Get deserialized meta.
-    meta = Meta.deserialize(meta)
-
-    # Get rule set.
-    rule_set = get_input_rule_set(klass, method, arg_num)
-    if rule_set.nil?
-      rule_set = RuleSet.new(@meta_map)
-      set_input_rule_set(klass, method, arg_num, rule_set)
-    end
-
-    # Train on metadata.
-    rule_set.train(meta)
-
-  end
-
-  ##
-  # Validate inputs.
-  #
-  # @stage Called when validating a control reflection.
-  # @param inputs [Array] The method's arguments.
-  # @param input_rule_sets [Array] The RuleSets to validate each input with.
-  ##
-  def test_inputs(inputs, input_rule_sets)
-
-    # Default result to PASS.
-    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.test(input)
-          result = false
-        end
-
-      end
-    end
-
-    return result
-
-  end
-
-  ##
-  # 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 test_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.test(output)
-        result = false
-      end
-
-    end
-
-    return result
-
-  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,
-      NilClass   => NullRule,
-      String     => StringRule
-    }
-
-    return rule_types[data_type]
-
-  end
-
-  def self.testable?(args, input_rule_sets)
-
-    args.each_with_index do |arg, arg_num|
-
-      rule_type = value_to_rule_type(arg)
-      if input_rule_sets[arg_num].rules[rule_type].nil?
-        return false
-      end
-
-    end
-
-    return true
-
-  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/Config.rb

@@ -1,42 +0,0 @@
-class Config
-
-  attr_accessor :enabled
-  attr_accessor :reflect_amount
-  attr_accessor :reflect_limit
-  attr_accessor :meta_map
-  attr_accessor :output_path
-  attr_accessor :output_directory
-
-  def initialize()
-
-    # Reflekt is enabled by default and should be disabled on production.
-    @enabled = true
-
-    # The amount of reflections to create per method call.
-    # 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.
-    @reflect_limit = 10
-
-    # The rules that apply to meta types.
-    @meta_map = {
-      :array  => [ArrayRule],
-      :bool   => [BooleanRule],
-      :int    => [IntegerRule],
-      :float  => [FloatRule],
-      :null   => [NullRule],
-      :string => [StringRule]
-    }
-
-    # An absolute path to the directory that contains the output directory.
-    # Defaults to current action path.
-    @output_path = nil
-
-    # Name of output directory.
-    @output_directory = "reflections"
-
-  end
-
-end

data/lib/Control.rb

@@ -1,83 +0,0 @@
-################################################################################
-# A shapshot of real data.
-#
-# @note
-#   A control's @number will always be 0.
-#
-# @nomenclature
-#   args, inputs/output and meta represent different stages of a value.
-#
-# @hierachy
-#   1. Action
-#   2. Control <- YOU ARE HERE
-#   3. Meta
-#
-# @status
-#   - :pass [Symbol] The reflection passes the rules.
-#   - :fail [Symbol] The reflection fails the rules or produces a system error.
-#   - :error [Symbol] The control reflection produces a system error.
-################################################################################
-
-require 'Reflection'
-require 'MetaBuilder'
-
-class Control < Reflection
-
-  ##
-  # Reflect on a method.
-  #
-  # Creates a shadow action.
-  # @param *args [Dynamic] The method's arguments.
-  ##
-  def reflect(*args)
-
-    # Get trained rule sets.
-    input_rule_sets = @aggregator.get_input_rule_sets(@klass, @method)
-    output_rule_set = @aggregator.get_output_rule_set(@klass, @method)
-
-    # Fail when no trained rule sets.
-    if input_rule_sets.nil?
-      @status = :fail
-    end
-
-    # When arguments exist.
-    unless args.size == 0
-
-      # Validate arguments against trained rule sets.
-      unless input_rule_sets.nil?
-        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 instance variables.
-      @inputs = MetaBuilder.create_many(args)
-
-    end
-
-    # Action method with real arguments.
-    begin
-
-      # Run reflection.
-      output = @clone.send(@method, *args)
-      @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 = :error
-      @message = message
-
-    end
-
-  end
-
-end

data/lib/Meta.rb

@@ -1,71 +0,0 @@
-################################################################################
-# Metadata for input and output.
-#
-# @pattern Abstract class
-# @see lib/meta for each meta.
-#
-# @hierachy
-#   1. Action
-#   2. Reflection
-#   3. Meta <- YOU ARE HERE
-################################################################################
-
-class Meta
-
-  ##
-  # Each meta defines its type.
-  ##
-  def initialize()
-    @type = :null
-  end
-
-  ##
-  # Each meta loads values.
-  #
-  # @param value [Dynamic]
-  ##
-  def load(value)
-  end
-
-  ##
-  # @return [Hash]
-  ##
-  def serialize()
-    {
-      :type => @type
-    }
-  end
-
-  ##############################################################################
-  # CLASS
-  ##############################################################################
-
-  ##
-  # Deserialize metadata.
-  #
-  # @todo Deserialize should create a Meta object.
-  # @todo Require each Meta type to handle its own deserialization.
-  #
-  # @param meta [Hash] The metadata to deserialize.
-  # @param meta [Hash]
-  ##
-  def self.deserialize(meta)
-
-    # Convert nil meta into NullMeta.
-    # Meta is nil when there are no @inputs or @output on the method.
-    if meta.nil?
-      return NullMeta.new().serialize()
-    end
-
-    # Symbolize keys.
-    # TODO: Remove once "Fix Rowdb.get(path)" bug fixed.
-    meta = meta.transform_keys(&:to_sym)
-
-    # Symbolize type value.
-    meta[:type] = meta[:type].to_sym
-
-    return meta
-
-  end
-
-end