to_robust 1.0.0.pre

data/lib/global/kernel/exception.rb

@@ -0,0 +1,9 @@
+# Augments the functionality of the Exception class to make error debugging simpler.
+class Exception
+
+  # Returns the line number that this exception was thrown on.
+  def line_no
+    backtrace[0][/:(\d+):/][1...-1].to_i
+  end
+
+end

data/lib/global/kernel/init.rb

@@ -0,0 +1,4 @@
+require_relative 'exception.rb'
+require_relative 'no_method_error.rb'
+require_relative 'argument_error.rb'
+require_relative 'zero_division_error.rb'

data/lib/global/kernel/no_method_error.rb

@@ -0,0 +1,15 @@
+# Augments the functionality of NoMethodError instances so that the name of the missing method
+# and the name of its context (if it has one) can be quickly and easily inspected.
+class NoMethodError
+
+  # Returns the name of the missing method.
+  def method_name
+    message[/\`(.*?)'/, 1]
+  end
+
+  # Returns the details of the method owner (if it has one).
+  def method_owner
+    message.partition('for ')[2]
+  end
+
+end

data/lib/global/kernel/zero_division_error.rb

@@ -0,0 +1,21 @@
+# Augments the ZeroDivisionError class to provide the line number that the ZeroDivisionError was encountered
+# by some given method.
+class ZeroDivisionError
+
+  # Finds the line that the zero division error was first thrown on by
+  # a given method (not the first line that it occurs at, since this may
+  # be within a non-robust method).
+  #
+  # *Parameters:*
+  # * method, the method to extract the line number for.
+  #
+  # *Returns:*
+  # The line that the error occurred on within the provided method.
+  def line_no(method)
+    backtrace.each do |b|
+      return b[/:(\d+):/][1...-1].to_i if b.start_with?(method.code)
+    end
+    return nil
+  end
+
+end

data/lib/global/report.rb

@@ -0,0 +1,42 @@
+# A report is used to hold the details of a successful repair attempt along with
+# the (partially) fixed method.
+# 
+# If a repair was partially successful (i.e. it removed the cause of the original
+# error but not all errors) then the report holds the next error that should
+# be resolved.
+#
+# If a repair was completely succesful (i.e. the method executed without throwing
+# any exceptions) then the report is used to hold the result of the method call.
+#
+# The storage of error and result by the report is exploited by the repair-cycle
+# to prevent redundant method calls.
+class ToRobust::Global::Report
+
+  attr_reader :fixed_method,
+              :result,
+              :error
+
+  # Creates a new report.
+  #
+  # *Parameters:*
+  # * fixed_method, the fixed form of the method.
+  # * opts, a hash of keyword options for this constructor.
+  #   -> result, the result of the method call (if the repair was a complete success).
+  #   -> error, the error encountered when calling the method after repair (if the repair was a partial success).
+  def initialize(fixed_method, opts = {})
+    @fixed_method = fixed_method
+    @result = opts[:result]
+    @error = opts[:error]
+  end
+
+  # Returns true if the repair completely fixed the method (removing all errors).
+  def complete?
+    @error.nil?
+  end
+
+  # Returns true if there were still further (unrelated) errors after fixing the method.
+  def partial?
+    not complete?
+  end
+
+end

data/lib/global/robust_proc.rb

@@ -0,0 +1,48 @@
+# A robust procedure is a type of object which mimics the functionality of a standard lambda
+# function but also adds line-specific error debugging information to exception traces.
+class ToRobust::Global::RobustProc
+
+  attr_reader :headers,
+              :body,
+              :source
+
+  # Constructs a new Robust procedure.
+  #
+  # *Parameters:*
+  # * headers, the arguments to the procedure (as an array of argument names).
+  # * body, the body of the procedure.
+  def initialize(headers, body)
+    
+    @headers = headers.freeze
+    @body = body.freeze
+
+    # Dynamically create the procedure as the "call" method of this object,
+    # and supply file and line debugging information.
+    @source = "def call(#{@headers.join(', ')})
+  #{body}
+end"
+
+    instance_eval(@source, code, 0)
+
+    # Store the lines of the body in the source property as an array (using chomp
+    # to remove /n from the end of each line).
+    @source = @source.lines.map(&:chomp).freeze
+
+  end
+
+  # Every robust procedure has its own unique code that is used as its source
+  # file and is used to identify error information specific to it.
+  def code
+    "ROBUST_PROC_#{object_id}"
+  end
+
+  # Makes this robust procedure object take on the function of another
+  # robust procedure. This allows repairs to be optionally saved.
+  def become(other)
+    @headers = other.headers
+    @body = other.body
+    @source = other.source
+    instance_eval(@source.join("\n"), code, 0)
+  end
+
+end

data/lib/global/strategies/divide_by_zero_error_strategy.rb

@@ -0,0 +1,277 @@
+# Handles zero division errors.
+class ToRobust::Global::Strategies::DivideByZeroStrategy < ToRobust::Global::Strategy
+
+  # Wraps all method calls in a safety barrier, preventing them from raising
+  # a ZeroDivisionError and instead causing them to return zero when a ZeroDivisionError
+  # is thrown.
+  #
+  # *Parameters:*
+  # * line, the line to wrap the method calls for.
+  #
+  # *Returns:*
+  # The provided line with all method calls wrapped.
+  def self.wrap_calls(line)
+    
+    # Extract all the method calls in the line.
+    calls = extract_calls(line)
+    
+    # Wrap each of the method calls in the original string.
+    calls.each_index do |x|
+    
+      # Retrieve the co-ordinates of the call.
+      start_at, end_at = calls[x]
+    
+      # Transform the method call.
+      line.insert start_at, "ToRobust::Global.prevent_dbz{"
+      line.insert end_at+30, "}"
+      
+      # Modify the coordinates of all other method calls.
+      (x...calls.length).each do |y|
+      
+        # If this method ends before another begins, shift
+        # both the start and end of that method.
+        if end_at < calls[y][0]
+          calls[y][0] += 30
+          calls[y][1] += 30
+        
+        # If this X starts after Y but finishes before, then shift
+        # the end of Y by 13.
+        elsif start_at > calls[y][0] and end_at < calls[y][1]
+          calls[y][1] += 30
+        end
+        
+      end
+      
+    end
+    
+    # Return the transformed line.
+    return line
+    
+  end
+
+  # Wraps all inline division operators in a safety barrier, preventing them from raising
+  # a ZeroDivisionError and instead causing them to return zero when a ZeroDivisionError
+  # is thrown.
+  #
+  # *Parameters:*
+  # * line, the line to wrap the inline division operators for.
+  #
+  # *Returns:*
+  # The provided line with all inline division operators wrapped.
+  def self.wrap_ops(line)
+
+    # Find the index of each division operator in the string.
+    last_index = -1
+    operations = []
+    until last_index.nil?
+      last_index = line.index('/', last_index+1)
+      operations << last_index unless last_index.nil?
+    end
+    
+    # Find the start index of the left argument and the end index of
+    # the right argument.
+    operations.map! do |location|
+    
+      # Find the index of the start of the left argument.
+      start_at = index = location
+      started = finished = false
+      bracket_depth = 0
+      until finished or start_at == 0
+        
+        # Move to the next character.
+        index -= 1
+        char = line[index]
+        
+        # Increase the bracket depth if a bracket is closed.
+        if char == ")"
+          started = true
+          bracket_depth += 1
+        
+        # Decrease the bracket depth if a bracket is opened.
+        # If the resulting bracket depth is zero or less then
+        # the argument is finished.
+        elsif char == "("
+          started = true
+          bracket_depth -= 1
+          finished = bracket_depth <= 0
+          end_at = index if bracket_depth == 0
+          
+        # Spaces are only accepted if they are enclosed within brackets
+        # or they trail the argument.
+        elsif char == " "
+          finished = (bracket_depth == 0 and started)
+          
+        # Letters, digits and dots are accepted without question.
+        # Ensure that the argument is marked as "started" when they
+        # are encountered.
+        elsif char.match(/^[[:alnum:]]$/) or char == "."
+          started = true
+        
+        # All other characters are only accepted if they are
+        # enclosed within brackets.
+        else
+          started = true
+          finished = true if bracket_depth <= 0
+        end
+        
+        # Move back the starting point unless it has been found.
+        start_at = index unless finished
+      
+      end
+      
+      # Find the index of the end of the right argument.
+      index = end_at = location
+      started = finished = false
+      bracket_depth = 0
+      until finished or end_at == line.length-1
+      
+        # Look at the character at the next index.
+        index += 1
+        char = line[index]
+        
+        # Increase the bracket depth if a bracket is opened.
+        if char == "("
+          started = true
+          bracket_depth += 1
+        
+        # Decrease the bracket depth if a bracket is closed.
+        # If the bracket closed is the last bracket left,
+        # then this marks the end of the argument.
+        elsif char == ")"
+          started = true
+          bracket_depth -= 1
+          finished = bracket_depth <= 0
+          end_at = index if bracket_depth == 0
+        
+        # Spaces are only accepted if they are enclosed within brackets
+        # or they lead the argument.
+        elsif char == " "
+          finished = (bracket_depth == 0 and started)
+        
+        # Letters, digits and dots are accepted without question.
+        # Ensure that the argument is marked as "started" when they
+        # are encountered.
+        elsif char.match(/^[[:alnum:]]$/) or char == "."
+          started = true
+        
+        # All other characters are only accepted if they are
+        # enclosed within brackets.
+        else
+          started = true
+          finished = true if bracket_depth <= 0
+        end
+        
+        # Move back the end point unless it has been found.
+        end_at = index unless finished
+        
+      end
+      
+      # Convert the index of the division operator to the start and
+      # end indices of the operation.
+      [start_at, end_at]
+      
+    end
+    
+    # Merge any overlapping operations into a single wrapper.
+    temp = []
+    operations.each do |x_start, x_end|
+      merged = false
+      temp.each_index do |y|
+        y_start, y_end = temp[y]
+        if x_start == y_end
+          temp[y][1] = x_end
+          merged = true
+        elsif x_end == y_start
+          temp[y][0] = x_start
+          merged = true
+        end
+        break if merged
+      end
+      temp << [x_start, x_end] unless merged
+    end
+    operations = temp
+    
+    # Wrap each of the operations in the original string.
+    operations.each_index do |x|
+    
+      # Retrieve the co-ordinates of the operation.
+      start_at, end_at = operations[x]
+
+      # Wrap the operation
+      line.insert start_at, "(ToRobust::Global.prevent_dbz{"
+      line.insert end_at+31, "})"
+      
+      # Modify the coordinates of all other method calls.
+      #
+      #
+      #
+      # SURELY THIS SHOULD BE X+1?
+      #
+      #
+      #
+      (x...operations.length).each do |y|
+      
+        # If this operation ends before another begins, shift
+        # both the start and end of that operation.
+        if end_at < operations[y][0]
+          operations[y][0] += 32
+          operations[y][1] += 32
+        
+        # If this X starts after Y but finishes before, then shift
+        # the end of Y.
+        elsif start_at > operations[y][0] and end_at < operations[y][1]
+          operations[y][1] += 32
+        
+        # If this Y is within X, shift the start and end of Y by the
+        # size of the prevention call opening.
+        elsif start_at < operations[y][0] and end_at > operations[y][1]
+          operations[y][0] += 30
+          operations[y][1] += 30
+        end
+        
+      end
+      
+    end
+    
+    # Return the transformed line.
+    return line
+
+  end
+
+  # Finds all method calls and division operators that could yield a ZeroDivisionError
+  # on the line where the error occurred and prevents them from doing so again by
+  # wrapping them in a DbZ exception catcher.
+  #
+  # *Parameters:*
+  # * method, the method which encountered the error.
+  # * error, the error which occurred.
+  #
+  # *Returns:*
+  # A list of candidate solutions to fix the root of the error affecting the method.
+  def generate_candidates(method, error)
+  
+    # Ensure that the error is a ZeroDivisionError.
+    return [] unless error.is_a? ZeroDivisionError
+    
+    # Extract the contents of the line that the exception occured on.
+    line_no = error.line_no(method)
+    line_contents = method.source[line_no]
+    
+    # We validate the fix by ensuring that any further errors are not
+    # ZeroDivisionError exceptions thrown on this line.
+    validator = lambda do |method, old_error, new_error|
+      not (new_error.is_a? ZeroDivisionError and old_error.line_no(method) == new_error.line_no(method))
+    end
+    
+    # Compose the sole candidate fix for this error.
+    line_contents = self.class.wrap_ops(self.class.wrap_calls(line_contents))
+    return [
+      ToRobust::Global::Fix.new(
+        [ToRobust::Global::Fix::SwapAtom.new(line_no, line_contents)],
+        validator
+      )
+    ]
+  
+  end
+
+end

data/lib/global/strategies/init.rb

@@ -0,0 +1,5 @@
+module ToRobust::Global::Strategies; end
+
+require_relative 'divide_by_zero_error_strategy.rb'
+require_relative 'no_method_error_strategy.rb'
+require_relative 'wrong_arguments_error_strategy.rb'

data/lib/global/strategies/no_method_error_strategy.rb

@@ -0,0 +1,92 @@
+require 'levenshtein'
+
+# Handles NoMethodError exceptions by mapping missing method calls to valid replacement methods within
+# the same module/class whose name is within a given Levenshtein distance of the missing method name.
+class ToRobust::Global::Strategies::NoMethodErrorStrategy < ToRobust::Global::Strategy
+
+  attr_accessor :max_distance
+
+  # Constructs a new NoMethodErrorStrategy.
+  #
+  # *Parameters:*
+  # * max_distance, the maximum allowed distance between an attempted and candidate method call.
+  def initialize(max_distance = 5)
+    @max_distance = max_distance
+  end
+
+  # Used to fix NoMethodError exceptions by replacing calls to missing methods with calls to
+  # valid methods whose name is within a given Levenshtein distance of the missing method name.
+  #
+  # *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 NoMethodError.
+    return [] unless error.is_a? NoMethodError
+
+    # Retrieve details of the missing method and the contents of the line that the error
+    # occurred on.
+    line_no = error.line_no
+    line_contents = method.source[line_no]
+    missing_method_name = error.method_name
+    missing_method_owner = error.method_owner
+    
+    # "main" methods aren't dealt with since there are too many dangerous replacement methods
+    # contained within main.
+    return [] if missing_method_owner.empty?
+    
+    # Check if the missing method belongs to a module or a class.
+    missing_method_owner = missing_method_owner.partition(':')
+    missing_method_owner_type = missing_method_owner[2]
+    
+    # Check if the missing method belongs to neither a module nor class (this
+    # shouldn't happen).
+    return [] unless ['Class', 'Module'].include? missing_method_owner_type
+    
+    # Retrieve the object for the class / module.
+    missing_method_owner = Kernel.const_get(missing_method_owner[0])
+    
+    # Extract a list of candidate methods from the class / module and calculate
+    # their levenshtein distance to the missing method. Before calculating the levenshtein
+    # distance to candidates, throw away any candidates whose difference in length with
+    # the requested method is greater than the maximum distance (since it is impossible
+    # that their levenshtein distance can be less or equal to the maximum distance).
+    if missing_method_owner_type == 'Module'
+      candidates = missing_method_owner.singleton_class.public_instance_methods(false)
+    else
+      candidates = missing_method_owner.public_instance_methods(false)
+    end
+
+    candidates.reject!{|c| (c.length - missing_method_name.length).abs > @max_distance}
+    candidates.map!{|c| [c.to_s, Levenshtein.distance(missing_method_name, c.to_s)]}
+    
+    # Only keep candidates whose distance with the missing
+    # method is less or equal to the threshold. Order the remaining candidates
+    # before throwing away the distance information.
+    candidates.reject!{|c| c[1] > @max_distance}
+    candidates.sort {|x,y| x[1] <=> y[1]}
+    candidates.map!{|c| c[0]}
+    
+    # We validate the exception by ensuring that any further exceptions aren't
+    # NoMethodError exceptions for the fixed method on the fixed line.
+    validator = lambda do |method, old_error, new_error|
+      return (not (new_error.is_a? NoMethodError and new_error.method_name == old_error.method_name and new_error.line_no == old_error.line_no))
+    end
+
+    # Compose each candidate into a fix by replacing each occurence of the
+    # missing method name in the string with the name of the candidate method.
+    return candidates.map! do |c|
+      fixed_line = line_contents.gsub(/(\(|^|::|\.|\s|,)#{missing_method_name}\(/) {|s| s[missing_method_name] = c; s}
+      ToRobust::Global::Fix.new(
+        [ToRobust::Global::Fix::SwapAtom.new(line_no, fixed_line)],
+        validator
+      )
+    end
+
+  end
+
+end