reflekt 1.0.5 → 1.0.10

data/lib/MetaBuilder.rb

@@ -1,84 +0,0 @@
-################################################################################
-# Create metadata.
-#
-# @pattern Builder
-# @see lib/meta for each meta.
-################################################################################
-
-require 'Meta'
-# Require all meta.
-Dir[File.join(__dir__, 'meta', '*.rb')].each { |file| require file }
-
-class MetaBuilder
-
-  ##
-  # Create meta.
-  #
-  # @param value
-  ##
-  def self.create(value)
-
-    meta = nil
-    data_type = value.class.to_s
-
-    # Create meta type for matching data type.
-    case data_type
-    when "Array"
-      meta = ArrayMeta.new()
-    when "TrueClass", "FalseClass"
-      meta = BooleanMeta.new()
-    when "Float"
-      meta = FloatMeta.new()
-    when "Integer"
-      meta = IntegerMeta.new()
-    when "String"
-      meta = StringMeta.new()
-    end
-
-    unless meta.nil?
-      meta.load(value)
-    end
-
-    return meta
-
-  end
-
-  ##
-  # Create meta for multiple values.
-  #
-  # @param values
-  ##
-  def self.create_many(values)
-
-    meta = []
-
-    values.each do |value|
-      meta << self.create(value)
-    end
-
-    return meta
-
-  end
-
-  ##
-  # @param data_type [Type]
-  ##
-  def self.data_type_to_meta_type(value)
-
-    data_type = value.class
-
-    meta_types = {
-      Array      => :array,
-      TrueClass  => :bool,
-      FalseClass => :bool,
-      Float      => :float,
-      Integer    => :int,
-      NilClass   => :null,
-      String     => :string
-    }
-
-    return meta_types[data_type]
-
-  end
-
-end

data/lib/Reflection.rb

@@ -1,195 +0,0 @@
-################################################################################
-# A snapshot of random data.
-#
-# @note
-#   A reflection's random value is within the bounds of aggregated control rule sets
-#   as well as as the arg type being inputted into the current control reflection.
-#
-# @nomenclature
-#   args, inputs/output and meta represent different stages of a value.
-#
-# @hierachy
-#   1. Action
-#   2. Reflection <- 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 'Clone'
-require 'MetaBuilder'
-
-class Reflection
-
-  attr_reader :status
-
-  ##
-  # Create a Reflection.
-  #
-  # @param action [Action] The Action that created this Reflection.
-  # @param number [Integer] Multiple Reflections can be created per Action.
-  # @param aggregator [Aggregator] The aggregated RuleSet for this class/method.
-  ##
-  def initialize(action, number, aggregator)
-
-    @action = action
-    @unique_id = action.unique_id + number
-    @number = number
-
-    # Dependency.
-    @aggregator = aggregator
-
-    # Caller.
-    @klass = action.klass
-    @method = action.method
-
-    # Metadata.
-    @inputs = nil
-    @output = nil
-
-    # Clone the action's calling object.
-    # TODO: Abstract away into Clone class.
-    @clone = action.caller_object.clone
-
-    # Result.
-    @status = :pass
-    @time = Time.now.to_i
-    @message = nil
-
-  end
-
-  ##
-  # Reflect on a method.
-  #
-  # Creates a shadow action.
-  # @param *args [Dynamic] The method's arguments.
-  ##
-  def reflect(*args)
-
-    # Get aggregated 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
-
-      # Create random arguments from aggregated rule sets.
-      unless input_rule_sets.nil?
-        args = randomize(args, input_rule_sets)
-      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 random arguments.
-    begin
-
-      # Run reflection.
-      output = @clone.send(@method, *args)
-      @output = MetaBuilder.create(output)
-
-      # Validate output against 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 = :fail
-      @message = message
-
-    end
-
-  end
-
-  ##
-  # Create random values for each argument from control reflections.
-  #
-  # @param args [Dynamic] The arguments to mirror random values for.
-  # @param input_rule_sets [Array] Aggregated rule sets for each argument.
-  #
-  # @return [Dynamic] Random arguments.
-  ##
-  def randomize(args, input_rule_sets)
-
-    random_args = []
-
-    args.each_with_index do |arg, arg_num|
-
-      # Get a random rule in the rule set.
-      rules = input_rule_sets[arg_num].rules
-      agg_rule = rules[rules.keys.sample]
-
-      # Create a random value that follows that rule.
-      random_args << agg_rule.random()
-
-    end
-
-    return random_args
-
-  end
-
-  ##
-  # Get the results of the reflection.
-  #
-  # @keys
-  #   - eid [Integer] Execution ID
-  #   - aid [Integer] Action ID
-  #   - rid [Integer] Reflection ID
-  #   - num [Integer] Reflection number
-  #
-  # @return [Hash] Reflection metadata.
-  ##
-  def serialize()
-
-    # Create execution ID from the ID of the first action in   the ActionStack.
-    execution_id = @action.unique_id
-    unless @action.base.nil?
-      execution_id = @action.base.unique_id
-    end
-
-    # Build reflection.
-    reflection = {
-      :eid => execution_id,
-      :aid => @action.unique_id,
-      :rid => @unique_id,
-      :num => @number,
-      :time => @time,
-      :class => @klass,
-      :method => @method,
-      :status => @status,
-      :message => @message,
-      :inputs => nil,
-      :output => nil,
-    }
-
-    unless @inputs.nil?
-      reflection[:inputs] = []
-      @inputs.each do |meta|
-        reflection[:inputs] << meta.serialize()
-      end
-    end
-
-    unless @output.nil?
-      reflection[:output] = @output.serialize()
-    end
-
-    return reflection
-
-  end
-
-end

data/lib/Reflekt.rb

@@ -1,243 +0,0 @@
-################################################################################
-# Reflective testing.
-#
-# @author Maedi Prichard
-#
-# @flow
-#   1. Reflekt is prepended to a class and setup.
-#   2. When a class insantiates so does Reflekt.
-#   3. An Action is created on method call.
-#   4. Many Refections are created per Action.
-#   5. Each Reflection executes on cloned data.
-#   6. Flow is returned to the original method.
-#
-# @usage
-#   class ExampleClass
-#     prepend Reflekt
-################################################################################
-
-require 'set'
-require 'erb'
-require 'rowdb'
-require 'Accessor'
-require 'Action'
-require 'ActionStack'
-require 'Aggregator'
-require 'Config'
-require 'Control'
-require 'Reflection'
-require 'Renderer'
-# Require all rules.
-Dir[File.join(__dir__, 'rules', '*.rb')].each { |file| require file }
-
-module Reflekt
-
-  def initialize(*args)
-
-    # TODO: Store counts on @@reflekt and key by instance ID.
-    @reflekt_counts = {}
-
-    # 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
-
-    # 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|
-
-        # When Reflekt enabled and control reflection has executed without error.
-        if @@reflekt.config.enabled && !@@reflekt.error
-
-          # Get current action.
-          action = @@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 action done reflecting.
-            if action.nil? || action.has_finished_reflecting?
-
-              # Create action.
-              action = Action.new(self, method, @@reflekt.config.reflect_amount, @@reflekt.stack)
-
-              @@reflekt.stack.push(action)
-
-            end
-
-            ##
-            # Reflect the action.
-            #
-            # The first method call in the action creates a reflection.
-            # Then method calls are shadow actions which return to the reflection.
-            ##
-            if action.has_empty_reflections? && !action.is_reflecting?
-              action.is_reflecting = true
-
-              # Create control.
-              control = Control.new(action, 0, @@reflekt.aggregator)
-              action.control = control
-
-              # Execute control.
-              control.reflect(*args)
-
-              # Stop reflecting when control fails to execute.
-              if control.status == :error
-                @@reflekt.error = true
-              # Continue reflecting when control executes succesfully.
-              else
-
-                # Save control as a reflection.
-                @@reflekt.db.get("reflections").push(control.serialize())
-
-                # Multiple reflections per action.
-                action.reflections.each_with_index do |value, index|
-
-                  # Create reflection.
-                  reflection = Reflection.new(action, index + 1, @@reflekt.aggregator)
-                  action.reflections[index] = reflection
-
-                  # Execute reflection.
-                  reflection.reflect(*args)
-                  @reflekt_counts[method] = @reflekt_counts[method] + 1
-
-                  # Save reflection.
-                  @@reflekt.db.get("reflections").push(reflection.serialize())
-
-                end
-
-                # Save control.
-                @@reflekt.db.get("controls").push(control.serialize())
-
-                # Save results.
-                @@reflekt.db.write()
-
-                # Render results.
-                @@reflekt.renderer.render()
-
-              end
-
-              action.is_reflecting = false
-            end
-
-          end
-
-          # Don't execute skipped methods when reflecting.
-          unless action.is_reflecting? && self.class.reflekt_skipped?(method)
-
-            # Continue action / shadow action.
-            super *args
-
-          end
-
-        # When Reflekt disabled or control reflection failed.
-        else
-
-          # Continue action.
-          super *args
-
-        end
-
-      end
-
-    end
-
-    # Continue initialization.
-    super
-
-  end
-
-  ##
-  # Provide Config instance to block.
-  ##
-  def self.configure
-    yield(@@reflekt.config)
-  end
-
-  private
-
-  def self.prepended(base)
-
-    # Prepend class methods to the instance's singleton class.
-    base.singleton_class.prepend(SingletonClassMethods)
-
-    # Setup class.
-    @@reflekt = Accessor.new()
-    @@reflekt.setup ||= reflekt_setup_class
-
-  end
-
-  # Setup class.
-  def self.reflekt_setup_class()
-
-    # Receive configuration.
-    @@reflekt.config = Config.new()
-
-    # Set configuration.
-    @@reflekt.path = File.dirname(File.realpath(__FILE__))
-
-    # Get reflections directory path from config or current action path.
-    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, @@reflekt.config.output_directory)
-    end
-
-    # Create reflections directory.
-    unless Dir.exist? @@reflekt.output_path
-      Dir.mkdir(@@reflekt.output_path)
-    end
-
-    # Create database.
-    @@reflekt.db = Rowdb.new(@@reflekt.output_path + '/db.js')
-    @@reflekt.db.defaults({ :reflekt => { :api_version => 1 }})
-    # @TODO Fix Rowdb.get(path) not returning values at path after Rowdb.push()
-    db = @@reflekt.db.value()
-
-    # Create shadow stack.
-    @@reflekt.stack = ActionStack.new()
-
-    # Create aggregated rule sets.
-    @@reflekt.aggregator = Aggregator.new(@@reflekt.config.meta_map)
-    @@reflekt.aggregator.train(db[:controls])
-
-    # Create renderer.
-    @@reflekt.renderer = Renderer.new(@@reflekt.path, @@reflekt.output_path)
-
-    return true
-
-  end
-
-  module SingletonClassMethods
-
-    @@reflekt_skipped_methods = Set.new()
-
-    ##
-    # 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)
-      @@reflekt_skipped_methods.add(method)
-    end
-
-    def reflekt_skipped?(method)
-      return true if @@reflekt_skipped_methods.include?(method)
-      false
-    end
-
-    #def reflekt_limit(amount)
-    #  @@reflekt.reflect_limit = amount
-    #end
-
-  end
-
-end