to_robust 1.0.0.pre

data/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2013 Chris Timperley
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,39 @@
+ruby_to_robust
+==============
+
+RubyToRobust allows you to implement soft semantics in your programs so that they
+may automatically recover from a range of supported exceptions in some sensible manner,
+allowing the program to continue running.
+
+The soft semantics provided by this project were originally designed to be exploited by
+Wallace.rb to provide robustness and support for soft grammars when using Grammatical Evolution.
+
+Two different soft semantics solutions are provided by RubyToRobust, both based on the
+Local and Global robustness schemes outlined in Chris Timperley's Masters Thesis.
+
+* **Global:** The Global robustness module implements soft semantics by intercepting
+  all exceptions thrown by a monitored method and using line information and other information
+  provided by the exception to determine the root of the problem in the method source code
+  which it then proceeds to "repair".
+* **Local:** Rather than manipulating the source code of the monitored function, the Local
+  robustness measure operates by implementing a series of monkey patches which ensure that
+  a set of supported exceptions are never (or rarely) thrown within the context of the monitored
+  function.
+
+Please note that the definition of a "repaired method" used by this project is a method which
+no longer produces errors (which would otherwise crash the program). This does not mean that the
+program does what its programmer wanted (although sometimes it might).
+
+The implementation and behaviour of this robustness scheme is very different to the implementation
+used in Chris Timperley's Master Thesis.
+* In the original version Global robustness was either enabled or disabled, and was constantly active
+  except in certain classes and modules. The new implementation allows Global robustness to be constrained
+  to a given block or method, so that the program may operate as it otherwise would outside the "protected"
+  block.
+* Exceptions are treated as soon as they are thrown outside the context of the monitored method.
+  The original Global robustness would allow exceptions to propagate through the program (allowing
+  them to be caught by a parent context) up till the point they would crash Ruby.
+* Performance is hugely improved! By providing the optional file name and line number parameters to
+  dynamically evaluated procedures there is no need to use external files to extract detailed error information.
+  Additionally, since the soft semantics are constrained to a given block or method, very few method calls
+  have to be wrapped (and therefore slowed down).

data/lib/global/fix.rb

@@ -0,0 +1,72 @@
+# Instances of this class are used to represent candidate fixes / solutions to given errors that
+# have occurred during the execution of a method.
+#
+# A fix operates on the source code of a method, adding, removing and replacing specific lines of
+# code (like a Git patch/change) in an attempt to remove the source of the error.
+#
+# As mentioned elsewhere in the Global module, strategies may return an ordered sequence of fixes
+# according to the likelihood that they will solve the problem (or by their performance penalty to
+# the method), but as this ordering is carried out by the strategies and all ordering information is
+# implict, candidate fixes proposed by different solutions cannot be compared and ordered.
+# 
+# The ability to compare arbitrary fixes could be introduced by adding a notion of cost to each fix;
+# a net quantification of both the performance penalty incurred to the method *after* applying the fix
+# and the probability that the fix will be a good one (a good fix would have a lower cost than a worse
+# fix). Candidate fixes could then be processed in ascending order of cost.
+class ToRobust::Global::Fix
+
+  # Creates a new candidate fix.
+  #
+  # *Parameters:*
+  # * changes, an array of changes that the fix should make to the source code.
+  # * validator, a lambda function that verifies a given error is not the same as the original error.
+  def initialize(changes,validator)
+    @changes = changes
+    @validator = validator
+  end
+
+  # Calculates the source code of the fixed method using the atomic fixes described by this object.
+  #
+  # *Parameters:*
+  # * src, the original source code (as lines) of the affected method.
+  #
+  # *Returns:*
+  # The fixed source code for the method.
+  def fixed_source(src)
+    history = []
+    @changes.each do |change|
+      change.apply!(src, history)
+      history << change
+    end
+    return src
+  end
+
+  # Applies the proposed changes to the source code of the affected method.
+  #
+  # *Parameters:*
+  # * method, the affected method.
+  #
+  # *Returns*
+  # A variant of the affected method modified according to the changes given by this fix.
+  def apply(method)
+    ToRobust::Global::RobustProc.new(method.headers, fixed_source(method.source.dup[1...-1]).join('/\n/)'))
+  end
+
+  # In the event that the method resulting from the fix encounters an error, this method *attempts*
+  # to determine whether the fix has been successful in removing the source of the original error.
+  # A "fixed" method in this sense is not necessarily one which removes all errors from a given method,
+  # rather it removes a particular identifiable error.
+  #
+  # *Parameters:*
+  # * method, the affected method.
+  # * original_error, the original error that was encountered by the method.
+  # * new_error, the error encountered after applying this fix and executing the method again.
+  #
+  # *Returns:*
+  # * True if the fix was successful in removing the cause of the original error, false if not.
+  def successful?(method, original_error, new_error)
+    @validator[method, original_error, new_error]
+  end
+  alias_method :validate, :successful?
+
+end

data/lib/global/fix/add_atom.rb

@@ -0,0 +1,28 @@
+# A add atom is used to insert a sequence of lines at a given position in the affected source code.
+class ToRobust::Global::Fix::AddAtom < ToRobust::Global::Fix::Atom
+
+  # Constructs a new add atom.
+  #
+  # *Parameters:*
+  # * line_no, the line in the source code which the atom should operate on.
+  # * additions, the sequence of lines to insert at the given line number (as an ordered array).
+  def initialize(line_no, additions)
+    super(line_no)
+    @additions = additions
+  end
+
+  # Calculates and returns the number of lines added by the atom.
+  def lines_added
+    @additions.length
+  end
+
+  # Inserts a sequence of lines at specific line in the affected source code.
+  #
+  # *Parameters:*
+  # * source, the (partially fixed) affected source.
+  # * changes, an array of the atomic changes already applied to this source (in order of application).
+  def apply!(source, changes)
+    source.insert(adjusted_line_no(changes), *@additions)
+  end
+
+end

data/lib/global/fix/atom.rb

@@ -0,0 +1,51 @@
+# A fix atom is used to store and represent a single "atomic" change made by a candidate fix which
+# may be represented as a collection of such atomic fixes.
+class ToRobust::Global::Fix::Atom
+
+  # The line which this atomic fix changes.
+  attr_reader :line_no
+
+  # Constructs a new fix atom.
+  #
+  # *Parameters:*
+  # * line_no, the line in the source code which the atom should operate on.
+  def initialize(line_no)
+    @line_no = line_no
+  end
+
+  # Calculates the number of lines that will be added by this fix.
+  def lines_added
+    raise NotImplementedError, 'No "lines_added" method was implemented by this Atom.'
+  end
+
+  # Calculate the line number in the adjusted source code that corresponds to the specified
+  # line in the body of the original source code.
+  #
+  # *Parameters:*
+  # * changes, an array of the atomic changes already applied to this source.
+  def adjusted_line_no(changes)
+    
+    adj_n = @line_no
+    changes.each do |c|
+      if c.line_no < @line_no and lines_added < 0
+        adj_n += c.lines_added
+      elsif c.line_no >= line_no and lines_added > 0
+        adj_n += c.lines_added
+      end
+    end
+
+    # Subtract one to return the line number in the body (header takes up the first line).
+    return adj_n - 1
+
+  end
+
+  # Destructively applies the change described by this atomic fix to the given source code.
+  #
+  # *Parameters:*
+  # * source, the source code of the affected method (represented as a sequence of lines).
+  # * changes, an array of the atomic changes already applied to this source (in order of application).
+  def apply!(source, changes)
+    raise NotImplementedError, 'No "apply!" method was implemented by this Atom.'
+  end
+
+end

data/lib/global/fix/init.rb

@@ -0,0 +1,4 @@
+require_relative 'atom.rb'
+require_relative 'remove_atom.rb'
+require_relative 'swap_atom.rb'
+require_relative 'add_atom.rb'

data/lib/global/fix/remove_atom.rb

@@ -0,0 +1,16 @@
+# A remove atom is used to remove a line from the affected source code.
+class ToRobust::Global::Fix::RemoveAtom < ToRobust::Global::Fix::Atom
+
+  # Removes a single line from the source code.
+  def lines_added; -1; end
+
+  # Removes a specific line from the affected source code.
+  #
+  # *Parameters:*
+  # * source, the (partially fixed) affected source.
+  # * changes, an array of the atomic changes already applied to this source (in order of application).
+  def apply!(source, changes)
+    source.delete_at(adjusted_line_no(changes))
+  end
+
+end

data/lib/global/fix/swap_atom.rb

@@ -0,0 +1,26 @@
+# A remove atom is used to swap a line from the affected source code with another.
+class ToRobust::Global::Fix::SwapAtom < ToRobust::Global::Fix::Atom
+
+  # Constructs a new swap atom.
+  #
+  # *Parameters:*
+  # * line_no, the line in the source code which the atom should operate on.
+  # * replacement, the contents of the replacement line.
+  def initialize(line_no, replacement)
+    super(line_no)
+    @replacement = replacement
+  end
+
+  # No lines are added.
+  def lines_added; 0; end
+
+  # Swaps the contents at specific line with an altered form stored by this object.
+  #
+  # *Parameters:*
+  # * source, the (partially fixed) affected source.
+  # * changes, an array of the atomic changes already applied to this source (in order of application).
+  def apply!(source, changes)
+    source[adjusted_line_no(changes)] = @replacement
+  end
+
+end

data/lib/global/global.rb

@@ -0,0 +1,155 @@
+# The Global robustness module implements a simplified (and faster) variant of the global
+# robustness measure outlined in Chris Timperley's Master's Thesis.
+#
+# Methods executed under global robustness protection are executed within an exception
+# catching block which intercept any errors which cause the method to fail 
+#
+# For now this measure only works with simple methods that do not change the state of 
+# objects or interfere with the global state.
+#
+# Author: Chris Timperley
+module ToRobust::Global
+
+  @strategies = []
+  @max_attempts = 10
+  @save_repairs = true
+
+  class << self
+
+    # A flag to control whether repairs to a method should be permanent (true) or if they
+    # should last only for a given call (false).
+    # True by default.
+    attr_accessor :save_repairs
+
+    # The maximum number of (different) errors that will be tolerated before
+    # all attempts to repair the method are ceased.
+    # 10 by default.
+    attr_accessor :max_attempts
+
+    # Allow strategies to be added and removed via:
+    # * Global.strategies << Strategy.new
+    # * Global.strategies.remove(strategy)
+    attr_reader :strategies
+
+  end
+
+  # Executes a given method (or proc) under global robustness protection.
+  #
+  # *Parameters:*
+  # * method, the (robust proc) method to execute using global robustness protection.
+  # * params, the parameters to the method call.
+  #
+  # *Returns:*
+  # The result of the method call.
+  def self.execute(method, params)
+
+    # Attempt to execute the method. If an error occurs then attempt to repair the method
+    # using the error information.
+    attempts = 0
+    begin
+      return method.call(*params.clone)
+    rescue => original_error
+      report = repair(method, params, original_error)
+      attempts += 1
+    end
+
+    # Once repaired attempt to call the method again, repeating the cycle,
+    # until either the method successfully returns a result or a maximum number of errors occur.
+    until attempts >= @max_attempts or report.complete?
+      attempts += 1
+      report = repair(report.fixed_method, params, report.error)
+    end
+
+    # If the repair limit has been hit then return the original error and make no permanent
+    # changes to the supplied method (or should we keep the changes?).
+    raise original_error if report.partial?
+
+    # If the method was completely repaired then swap the original method with the fixed form
+    # (so long as that functionality is enabled) and return the result of the method call.
+    method.become(report.fixed_method) if @save_repairs
+    return report.result
+
+  end
+
+  # Calculates all the possible candidate fixes to a given error within a provided method.
+  # Passes the details of the error along with the method to each associated error handling
+  # strategy and queries all possible candidate solutions.
+  #
+  # *TODO:*
+  # At the moment each strategy may return an ordered set of candidate fixes to the problem,
+  # but this ordering information is implicit (and usually not universally comparable) so there
+  # can be no ordering of candidate fixes from ALL given strategies (i.e. strategy B may produce
+  # a strategy that is more likely to solve the error than the best candidate given by strategy A).
+  #
+  # *Parameters:*
+  # * method, the method to be fixed.
+  # * error, the error to be addressed.
+  #
+  # *Returns:*
+  # An array of candidate fixes to the error.
+  def self.generate_candidates(method, error)
+    @strategies.map { |s| s.generate_candidates(method, error) }.flatten
+  end
+
+  # Repairs a given (statically defined) method using the details of an encountered error.
+  #
+  # Special care must be taken to define repair. In this context, a repaired method
+  # is one which does not suffer from the same error that it did originally. This means
+  # that the repaired form of the provided method may still contain errors.
+  #
+  # This definition of repair is necessary to fix methods which contain more than a single
+  # error.
+  #
+  # *Parameters:*
+  # * method, the broken method to be repaired.
+  # * params, the parameters to the original method call.
+  # * error, the error that occurred when the method was called.
+  #
+  # *Returns:*
+  # A repaired form of the method.
+  def self.repair(method, params, error)
+
+    # Produce a series of candidate fixes to the method.
+    candidates = generate_candidates(method, error)
+
+    # Attempt each of the candidate fixes until the error is prevented or there are no
+    # further candidates to try.
+    until candidates.empty?
+
+      fix = candidates.shift
+      fixed_method = fix.apply(method)
+
+      begin
+        result = fixed_method.call(*params.clone)
+        return Report.new(fixed_method, result: result)
+      rescue => fix_error
+        return Report.new(fixed_method, error: fix_error) if fix.successful?(fixed_method, error, fix_error)
+      end
+
+    end
+
+    # If all attempts to repair the method against the given error fail then re-throw
+    # the exception.
+    raise error
+
+  end
+
+  # Executes a given block whilst preventing a ZeroDivisionError occurring.
+  # If a zero division error does occur during the execution of the block, this safety
+  # wrapper will catch the exception and will return a zero instead, allowing the program
+  # to continue.
+  #
+  # *Parameters:*
+  # * &block, the block to execute under ZeroDivisionError protection.
+  #
+  # *Returns:*
+  # The result of the block execution, or zero if the block execution yields a ZeroDivisionError.
+  def self.prevent_dbz(&block)
+    begin
+      return block.call
+    rescue ZeroDivisionError
+      return 0
+    end
+  end
+
+end

data/lib/global/init.rb

@@ -0,0 +1,10 @@
+module ToRobust; end
+
+require_relative 'kernel/init.rb'
+require_relative 'global.rb'
+require_relative 'robust_proc.rb'
+require_relative 'strategy.rb'
+require_relative 'strategies/init.rb'
+require_relative 'fix.rb'
+require_relative 'fix/init.rb'
+require_relative 'report.rb'

data/lib/global/kernel/argument_error.rb

@@ -0,0 +1,22 @@
+# Augments the functionality of ArgumentError instances so that the affected method and expected number
+# of arguments can be quickly inspected. Also adjusts the line number calculation so that the correct
+# line number is returned for the error.
+class ArgumentError
+
+  # Returns the name of the method which was provided with poorly formed arguments.
+  def affected_method
+    backtrace[0].match(/`(([a-zA-Z]|_)+)'/)[0][1...-1]
+  end
+
+  # Returns the number of arguments that were expected by this method.
+  def args_expected
+    message.match(/\s(\d+)\)/)[0][1...-1].to_i
+  end
+
+  # Returns the line number that the method call was made from.
+  # The line that the method call was made is given by the second line of the backtrace.
+  def line_no
+    backtrace[1][/:(\d+):/][1...-1].to_i
+  end
+
+end