to_robust 1.0.0.pre

data/lib/global/strategies/wrong_arguments_error_strategy.rb

@@ -0,0 +1,174 @@
+# Robustness strategy for dealing with ArgumentError's thrown due to incorrect numbers of
+# arguments being supplied to a method. Trims or pads the list of arguments so that the number
+# of arguments is equal to the arity of the method (i.e. the number of provided arguments
+# matches the expected number of arguments).
+class ToRobust::Global::Strategies::WrongArgumentsErrorStrategy < ToRobust::Global::Strategy
+
+  # Fixes all calls to a given method on a provided line such that they all use
+  # an expected number of arguments. Method calls with too few parameters are padded with zeroes,
+  # whilst method calls with too many parameters are trimmed to the correct size.
+  #
+  # *Parameters:*
+  # * method, the method to fix calls to.
+  # * arity, the arity (expected number of parameters) of the method.
+  # * line, the line to fix method calls on.
+  #
+  # *Returns:*
+  # The fixed form of the line, with all calls to the given method meeting the argument length requirements.
+  def self.fix_calls(method, arity, line)
+
+    # Extract all calls to the affected method on the given line.
+    calls = extract_calls(line)
+    calls.reject! do |c|
+      method_full_name = line[c[0]...line.index('(', c[0])].split(/\.|::/)
+      method_full_name.last != method
+    end
+    
+    # Re-order calls so that nested calls are processed first.
+    # First, order the calls by their starting position.
+    # Secondly, create a new list and insert each call at an smaller
+    # index to any calls that enclose it.
+    calls.sort!{|a,b| a[0] <=> b[0]}
+    temp = []
+    calls.each do |x|
+      index = insert_at = temp.length
+      if insert_at > 0
+        temp.reverse_each do |y|
+          index -= 1
+          insert_at = index if y[0] < x[0] and y[1] > x[1]
+        end
+      end
+      temp.insert(insert_at, x)
+    end
+    calls = temp
+    
+    # Process each of the calls (in the safe order that has 
+    # been established). Begin by extracting the current arguments
+    # for the method call, then either padding or shrinking those
+    # arguments to meet the required length.
+    calls.each_index do |call_index|
+    
+      meth_start, meth_end = calls[call_index]
+      params_start = line.index('(', meth_start)+1
+      arg_start = params_start
+      
+      # Process each character in the body of parameters.
+      open_brackets = 0
+      arguments = []
+      for char_index in params_start...meth_end
+        
+        # Extract the character at the given point in the call.
+        char = line[char_index]
+      
+        # Listen for bracket closings.
+        if char == '('
+          open_brackets += 1
+          
+        # Listen for any bracket openings.
+        elsif char == ')'
+          open_brackets -= 1
+          
+        # Check if this character marks the end of the argument.
+        # Only interpret it as the end of the argument if there are
+        # no open brackets.
+        elsif char == ',' and open_brackets == 0
+          arguments << [arg_start, char_index-1]
+          arg_start = char_index + 1
+        end
+        
+      end
+      
+      # Add the last argument.
+      arguments << [arg_start, meth_end-1]
+      
+      # Shrink the arguments to the limit (better to do this before
+      # extracting their text contents, small optimisation), then
+      # retrieve their context contents (stripping any leading and
+      # trailing whitespace) and pad the arguments with zeroes
+      # where necessary.
+      arguments = arguments.first(arity)
+      arguments.map!{|a_start, a_end| line[a_start..a_end].strip}
+      arguments.fill('0', arguments.length...arity)
+      
+      # Apply the transformation, calculate the length difference (delta)
+      # and re-adjust the boundaries of the remaining method calls.
+      transformed = "#{line[meth_start...line.index('(', meth_start)]}(#{arguments.join(',')})"
+      delta = transformed.length - (meth_end - meth_start + 1)
+      line[meth_start..meth_end] = transformed
+      (call_index+1...calls.length).each do |succ_call_index|
+      
+        # Find the start and end points of the call.
+        succ_call_start, succ_call_end = calls[succ_call_index]
+        
+        # Move the end point of any call containing the call that
+        # has been transformed.
+        if succ_call_start < meth_start and succ_call_end > meth_end
+          calls[succ_call_index][1] += delta
+      
+        # Move the start and end points of each call that
+        # starts after the end of this call. (You could embed this
+        # within the if statement above, but this is nicer to read).
+        elsif succ_call_start > meth_end
+          calls[succ_call_index][0] += delta
+          calls[succ_call_index][1] += delta
+        end
+        
+      end
+      
+    end
+    
+    # Return the transformed line.
+    return line
+
+  end
+
+  # Used to fix ArgumentError exceptions by ensuring that all calls to a given method
+  # on the line that the error occurred on use the expected number of arguments.
+  #
+  # When too few arguments are used during a method call, those arguments are padded
+  # with zeroes to reach the correct number of parameters.
+  #
+  # When too many arguments are supplied to a method, those arguments are trimmed to
+  # the number of arguments expected by the method.
+  #
+  # *Parameters:*
+  # * method, the affected method.
+  # * error, the error whose root cause should be fixed.
+  #
+  # *Returns:*
+  # A (possibly empty) array of candidate fixes to the root cause of the error.
+  def generate_candidates(method, error)
+
+    # Ensure that the error is a ArgumentError caused by an incorrect number
+    # of arguments being supplied to a method.
+    return [] unless error.is_a? ArgumentError and error.message.include? 'wrong number of arguments'
+
+    # Extract details of the error.
+    affected_method = error.affected_method
+    args_expected = error.args_expected
+    line_no = error.line_no
+    line_contents = method.source[line_no]
+    
+    # We validate the fix by ensuring that any further errors are not
+    # ArgumentErrors for the incorrect number of arguments on the same
+    # method and on the same line.
+    validator = lambda do |method, old_error, new_error|
+      return true unless new_error.is_a? ArgumentError
+      return true unless new_error.message.include? 'wrong number of arguments'
+      return true unless new_error.line_no == old_error.line_no
+      return true unless new_error.affected_method == old_error.affected_method
+      return false
+    end
+    
+    # Compose the sole candidate fix for this error.
+    line_contents = self.class.fix_calls(affected_method, args_expected, line_contents)
+    return [
+      ToRobust::Global::Fix.new(
+        [ToRobust::Global::Fix::SwapAtom.new(line_no, line_contents)],
+        validator
+      )
+    ]
+
+  end
+
+end

data/lib/global/strategy.rb

@@ -0,0 +1,67 @@
+# Strategies are used by the global robustness layer to suggest candidate fixes to errors that occur
+# within a given function.
+class ToRobust::Global::Strategy
+
+  # Extracts the co-ordinates of all method calls on a given line.
+  #
+  # *Parameters:*
+  # * line, the line to extract method calls from.
+  #
+  # *Returns:*
+  # An array of co-ordinate pairs (each an array - could use a range?).
+  def self.extract_calls(line)
+
+    # Find the co-ordinates of every method call in the string.
+    stack = []
+    calls = []
+    (0..line.length).each do |index|
+
+      # Get the character at this index.
+      char = line[index]
+
+      # If this is the start of a method call,
+      # add the starting index to the stack.
+      if char == '('
+        stack << index
+
+      # If this is the end of a method call,
+      # pop the last index off the stack and combine
+      # it with the current index to give the co-ordinates
+      # of the call.
+      elsif char == ')'
+        calls << [stack.pop, index]
+      end
+
+    end
+
+    # Post-process the co-ordinates so that they start from the label
+    # of the method call rather than the bracket opening. Do this by
+    # moving towards the start of the original string until the method
+    # definition has finished (checked by looking at the character).
+    calls.each_index do |i|
+      start_at = calls[i][0]
+      until start_at == 0 do
+        char = line[start_at-1]
+        break if not (char.match(/^[[:alpha:]]$/) or ['_',':','.'].include? char)
+        start_at -= 1
+      end
+      calls[i][0] = start_at
+    end
+
+    return calls
+    
+  end
+
+  # Generates a list of candidate fixes to a given problem.
+  #
+  # *Parameters:*
+  # * method, the affected method.
+  # * error, the error which occurred within the method.
+  #
+  # *Returns:*
+  # A (possibly empty) array of candidate solutions to fix the root of the error.
+  def generate_candidates(method, error)
+    raise NotImplementedError, 'No "generate_candidates" method was implemented by this Strategy.'
+  end
+
+end

data/lib/local/init.rb

@@ -0,0 +1,6 @@
+module ToRobust; end
+
+require_relative 'kernel/init.rb'
+require_relative 'local.rb'
+require_relative 'strategy.rb'
+require_relative 'strategies/init.rb'

data/lib/local/kernel/init.rb

@@ -0,0 +1 @@
+require_relative 'module.rb'

data/lib/local/kernel/module.rb

@@ -0,0 +1,43 @@
+class Module
+
+  # Hides all public module methods specific to this module by prepending their names
+  # with "__" and making them private.
+  def hide_methods!
+    singleton_class.public_instance_methods(false).each do |original|
+
+      # Ignore method missing.
+      next if original == :method_missing
+
+      # Prepend "__" to the method name and make it private.
+      hidden = ('__' + original.to_s).to_sym
+      singleton_class.send(:alias_method, hidden, original)
+      singleton_class.send(:private, hidden)
+
+    end
+  end
+
+  # Unhides all previously hidden methods, restoring the object/class/module to its
+  # original state.
+  def unhide_methods!
+    hidden_method_symbols.each do |sym|
+      original = sym.to_s[2..-1].to_sym
+      singleton_class.send(:alias_method, original, sym)
+      singleton_class.send(:remove_method, sym)
+      singleton_class.send(:public, original)
+    end
+  end
+
+  # Returns a hash of the hidden methods of this module (indexed by the original name
+  # of the methods, as strings).
+  def hidden_methods
+    Hash[hidden_method_symbols.map { |sym| [sym.to_s[2..-1], method(sym)] }]
+  end
+
+  private
+
+  # Returns an array of the symbols for each of the hidden methods (including their "__").
+  def hidden_method_symbols
+    singleton_class.private_instance_methods(false).select { |m| m.to_s.start_with? '__' }
+  end
+
+end

data/lib/local/local.rb

@@ -0,0 +1,43 @@
+# The Local robustness module is a slightly tailored version of the local robustness layer
+# proposed in Chris Timperley's Master's Thesis.
+#
+# For now patches are enabled and disabled by checking the status of the "enabled" flag in 
+# the Local robustness module for each individual patch.
+# 
+# A far nicer alternative would be to implement patches as instances of a Patch class.
+# This class would then contain details of the target class and method as well as a
+# lambda function implementing the patched form of the method.
+#
+# WARNING: Thread safety is a concern.
+#
+# Author: Chris Timperley
+module ToRobust::Local
+
+  # List of strategies.
+  @strategies = []
+  class << self
+    attr_reader :strategies
+  end
+
+  # Executes a given block under local robustness protection.
+  #
+  # *Parameters:*
+  # * *contexts, depickled list of context objects to protect method calls for.
+  # * &block, the block to execute under local robustness protection.
+  #
+  # *Returns:*
+  # * The result of the block execution.
+  def self.protected(*contexts, &block)
+    @strategies.each { |s| s.prepare!(contexts) }
+    @strategies.each { |s| s.enable! }
+    
+    begin
+      result = block.call
+    ensure
+      @strategies.each { |s| s.disable! }
+    end
+
+    return result
+  end
+
+end

data/lib/local/strategies/bignum_division_strategy.rb

@@ -0,0 +1,11 @@
+#  Ensures that integer division returns 0 if the denominator is zero.
+class ToRobust::Local::Strategies::BignumDivisionStrategy < ToRobust::Local::Strategies::SwapMethodStrategy
+
+  # Constructs a new BignumDivisionStrategy.
+  def initialize
+    super(Bignum, :div, :__div) do |other|
+      other.zero? ? 0 : __div(other)
+    end
+  end
+
+end

data/lib/local/strategies/bignum_modulus_strategy.rb

@@ -0,0 +1,11 @@
+#  Ensures that integer division returns 0 if the denominator is zero.
+class ToRobust::Local::Strategies::BignumModulusStrategy < ToRobust::Local::Strategies::SwapMethodStrategy
+
+  # Constructs a new BignumModulusStrategy.
+  def initialize
+    super(Bignum, :%, :__mod) do |other|
+      other.zero? ? 0 : __mod(other)
+    end
+  end
+
+end

data/lib/local/strategies/fixnum_coerce_strategy.rb

@@ -0,0 +1,11 @@
+# Coerce nil to 0.
+class ToRobust::Local::Strategies::FixnumCoerceStrategy < ToRobust::Local::Strategies::SwapMethodStrategy
+
+  # Constructs a new FixnumCoerceStrategy.
+  def initialize
+    super(Fixnum, :coerce, :__coerce) do |other|
+      other.nil? ? 0 : __coerce(other)
+    end
+  end
+
+end

data/lib/local/strategies/fixnum_division_strategy.rb

@@ -0,0 +1,12 @@
+# Ensures that Fixnum division never encounters zero division errors
+# by returning zero when the denominator is zero.
+class ToRobust::Local::Strategies::FixnumDivisionStrategy < ToRobust::Local::Strategies::SwapMethodStrategy
+
+  # Constructs a new FixnumDivisionStrategy.
+  def initialize
+    super(Fixnum, :/, :__div) do |other|
+      other.zero? ? 0 : __div(other)
+    end
+  end
+
+end

data/lib/local/strategies/fixnum_modulus_strategy.rb

@@ -0,0 +1,12 @@
+# Ensures that the modulus operator returns zero if a divide
+# by zero error would occur.
+class ToRobust::Local::Strategies::FixnumModulusStrategy < ToRobust::Local::Strategies::SwapMethodStrategy
+
+  # Constructs a new FixnumModulusStrategy.
+  def initialize
+    super(Fixnum, :%, :__mod) do |other|
+      other.zero? ? 0 : __mod(other)
+    end
+  end
+
+end

data/lib/local/strategies/float_division_strategy.rb

@@ -0,0 +1,11 @@
+# Ensures that any float divided by zero gives 0.0
+class ToRobust::Local::Strategies::FloatDivisionStrategy < ToRobust::Local::Strategies::SwapMethodStrategy
+
+  # Constructs a new FloatDivisionStrategy.
+  def initialize
+    super(Float, :/, :__fdiv) do |other|
+      other.zero? ? 0.0 : __fdiv(other)
+    end
+  end
+
+end

data/lib/local/strategies/float_modulus_strategy.rb

@@ -0,0 +1,12 @@
+# Ensures that the modulus operator returns zero if a divide
+# by zero error would occur.
+class ToRobust::Local::Strategies::FloatModulusStrategy < ToRobust::Local::Strategies::SwapMethodStrategy
+
+  # Constructs a new FloatModulusStrategy.
+  def initialize
+    super(Float, :%, :__mod) do |other|
+      other.zero? ? 0.0 : __mod(other)
+    end
+  end
+
+end

data/lib/local/strategies/init.rb

@@ -0,0 +1,37 @@
+module ToRobust::Local::Strategies; end
+
+# Load all the strategy definitions.
+require_relative 'swap_method_strategy.rb'
+
+require_relative 'numeric_division_strategy.rb'
+require_relative 'numeric_modulus_strategy.rb'
+
+require_relative 'bignum_division_strategy.rb'
+require_relative 'bignum_modulus_strategy.rb'
+
+require_relative 'fixnum_division_strategy.rb'
+require_relative 'fixnum_modulus_strategy.rb'
+require_relative 'fixnum_coerce_strategy.rb'
+
+require_relative 'float_division_strategy.rb'
+require_relative 'float_modulus_strategy.rb'
+
+require_relative 'soft_binding_strategy.rb'
+
+# Instantiate and attach each of them.
+# This could be done automatically (following class definition) using
+# the "defined" gem, but this may cause some compatibility issues.
+ToRobust::Local.strategies << ToRobust::Local::Strategies::NumericDivisionStrategy.new
+ToRobust::Local.strategies << ToRobust::Local::Strategies::NumericModulusStrategy.new
+
+ToRobust::Local.strategies << ToRobust::Local::Strategies::BignumDivisionStrategy.new
+ToRobust::Local.strategies << ToRobust::Local::Strategies::BignumModulusStrategy.new
+
+ToRobust::Local.strategies << ToRobust::Local::Strategies::FixnumDivisionStrategy.new
+ToRobust::Local.strategies << ToRobust::Local::Strategies::FixnumModulusStrategy.new
+ToRobust::Local.strategies << ToRobust::Local::Strategies::FixnumCoerceStrategy.new
+
+ToRobust::Local.strategies << ToRobust::Local::Strategies::FloatModulusStrategy.new
+ToRobust::Local.strategies << ToRobust::Local::Strategies::FloatDivisionStrategy.new
+
+ToRobust::Local.strategies << ToRobust::Local::Strategies::SoftBindingStrategy.new