to_robust 1.0.0.pre

data/lib/local/strategies/numeric_division_strategy.rb

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

data/lib/local/strategies/numeric_modulus_strategy.rb

@@ -0,0 +1,12 @@
+# Ensures that the modulus operator returns 0 if a division by zero
+# error occurs.
+class ToRobust::Local::Strategies::NumericModulusStrategy < ToRobust::Local::Strategies::SwapMethodStrategy
+
+  # Constructs a new NumericModulusStrategy.
+  def initialize
+    super(Numeric, :divmod, :__divmod) do |other|
+      other.zero? ? 0 : __divmod(other)
+    end
+  end
+
+end

data/lib/local/strategies/soft_binding_strategy.rb

@@ -0,0 +1,108 @@
+require 'levenshtein'
+
+# Exploits the 'method_missing' hook to implement a custom message passing protocol.
+#
+# All methods for each associated context are hidden by prepending their names with "__" and
+# making them private. These hidden methods can later be accessed using the "hidden_methods"
+# method on an associated context.
+#
+# All method calls will fire the 'method_missing' callback, since the method is no longer
+# attached to the object at the original address. The method missing callback then inspects the
+# method call and attempts to find the nearest method to that which was requested (based
+# on the Levenshtein distance between the requested method and a candidate method).
+#
+# This way method calls like 'ad(3,2)' and 'adda(3,2)' would map to 'add(3,2)', giving methods
+# a soft binding.
+#
+# If the nearest method has an arity which does not match the number of parameters supplied to
+# the method call, then:
+# * If there are too few parameters, pad the list with zeroes (arbitrary choice!).
+# * If there are too many parameters, restrict the length of the list to the arity of the method.
+class ToRobust::Local::Strategies::SoftBindingStrategy < ToRobust::Local::Strategy
+
+  # Allow the maximum acceptable Levenshtein distance to a candidate method to be
+  # adjusted.
+  @max_distance = 5
+  class << self
+    attr_accessor :max_distance
+  end
+
+  # Caches the list of contexts for later use.
+  def prepare!(contexts)
+    @contexts = contexts
+  end
+
+  # Hides all methods attached to each context (by prepending their names with "__" and making
+  # them private) before attaching a method missing handler to each of the contexts.
+  def enable!
+    @contexts.each do |c|
+      c.hide_methods!
+      c.singleton_class.send(:define_method, :method_missing) do |method_name, *args, &block|
+
+        # Convert the method symbol to a string, ready for lookup.
+        method_name = method_name.to_s
+
+        # Maximum levenshtein distance allowed between a candidate and the requested method.
+        max_distance = RubyToRobust::Local::Strategies::SoftBindingStrategy.max_distance
+
+        # Cache the list of candidate methods.
+        candidates = hidden_methods
+
+        # If no method exists with the given name then find the method with the closest
+        # name (measured by levenshtein distance). Only consider candidates whose distance
+        # to the requested method is less or equal to the maximum distance.
+        unless candidates.key? method_name
+
+          best_candidate = nil
+          best_score = nil
+          candidates.each_key do |cname|
+          
+            # Only calculate the distance if the difference in length between the requested
+            # and candidate methods is less or equal to the maximum distance.
+            unless (cname.length - method_name.length).abs > max_distance
+              distance = Levenshtein.distance(cname, method_name)
+              if distance <= max_distance and (best_score.nil? or distance < best_score)
+                best_candidate = cname
+                best_score = distance
+              end
+            end
+          end
+          
+          # Attempt to call the best candidate.
+          # If no appropriate candidate is found, raise a NoMethodError.
+          raise NoMethodError if best_candidate.nil?
+          method_name = best_candidate
+
+        end
+
+        # Retrieve the method object for the selected method.
+        method = candidates[method_name]
+          
+        # If no arguments are provided and the arity of this method is greater than zero,
+        # then return zero.
+        return 0 if method.arity > 0 and args.length == 0
+
+        # If fewer arguments than necessary are provided then pad the arguments with zeros.
+        args = args.fill(0, args.length...method.arity) if method.arity > args.length
+
+        # If more arguments than necessary are provided, restrict them to the function's
+        # arity.
+        args = args.first(method.arity) if method.arity != -1 and args.length > method.arity
+
+        # Call the method with the filtered arguments.
+        return method.call(*args)
+
+      end
+    end
+  end
+
+  # Restores all the hidden methods to their previous state and removes the method missing
+  # handler from each associated context.
+  def disable!
+    @contexts.each do |c|
+      c.unhide_methods!
+      c.singleton_class.send(:remove_method, :method_missing)
+    end
+  end
+
+end

data/lib/local/strategies/swap_method_strategy.rb

@@ -0,0 +1,32 @@
+# The swap method strategy is an abstract base strategy used by
+# other strategies which operate by swapping a given method with
+# an alternative which utilises soft semantics.
+class ToRobust::Local::Strategies::SwapMethodStrategy < ToRobust::Local::Strategy
+
+  # Constructs a new swap method strategy.
+  #
+  # *Parameters:*
+  # * binding, the class or module of the method that should be patched.
+  # * name, the name of the method to be patched.
+  # * backup, the name to store the old method under.
+  # * &replacement, the replacement method itself.
+  def initialize(binding, name, backup, &replacement)
+    @binding = binding
+    @name = name
+    @backup = backup
+    @replacement = replacement
+  end
+
+  # Swaps the target method with its "softer" counterpart.
+  def enable!
+    @binding.send(:alias_method, @backup, @name)
+    @binding.send(:define_method, @name, @replacement)
+  end
+
+  # Restores the target method to its original "hard" semantics.
+  def disable!
+    @binding.send(:define_method, @name, @binding.instance_method(@backup))
+    @binding.send(:remove_method, @backup)
+  end
+
+end

data/lib/local/strategy.rb

@@ -0,0 +1,18 @@
+# Implements a local robustness strategy.
+#
+# These strategies are used to implement "softer" semantics in the program.
+class ToRobust::Local::Strategy
+
+  # Prepares this strategy.
+  #
+  # *Parameters:*
+  # * contexts, a list of contexts that Local robustness is operating under.
+  def prepare!(contexts); end
+
+  # Enables this patch.
+  def enable!; end
+
+  # Disables this patch.
+  def disable!; end
+
+end

data/lib/to_robust.rb

@@ -0,0 +1,4 @@
+module ToRobust; end
+
+require_relative 'global/init.rb'
+require_relative 'local/init.rb'

data/test/local/float_division.rb

@@ -0,0 +1,28 @@
+require 'to_robust'
+require 'test/unit'
+ 
+class TestFloatDivision < Test::Unit::TestCase
+ 
+  def test_standard_behaviour
+    program = lambda { |x, y| x / y }
+    assert_equal(5.0, ToRobust::Local.protected { program[50.0, 10.0] })
+    assert_equal(5.0, program[50.0, 10.0])
+  end
+ 
+  def test_hard_dbz
+    program = lambda { |x, y| x / y }
+    assert_equal(Float::INFINITY, program[1.0, 0.0])
+    assert_equal(Float::INFINITY, program[2.0, 0.0])
+    assert_equal(Float::INFINITY, program[10.0, 0.0])
+    assert_equal(Float::INFINITY, program[255.0, 0.0])
+  end
+
+  def test_soft_dbz
+    program = lambda { |x, y| x / y }
+    assert_equal(0.0, ToRobust::Local.protected { program[1.0, 0.0] })
+    assert_equal(0.0, ToRobust::Local.protected { program[2.0, 0.0] })
+    assert_equal(0.0, ToRobust::Local.protected { program[10.0, 0.0] })
+    assert_equal(0.0, ToRobust::Local.protected { program[255.0, 0.0] })
+  end
+ 
+end

data/test/local/integer_division.rb

@@ -0,0 +1,28 @@
+require 'to_robust'
+require 'test/unit'
+ 
+class TestIntegerDivision < Test::Unit::TestCase
+ 
+  def test_standard_behaviour
+    program = lambda { |x, y| x / y }
+    assert_equal(5, ToRobust::Local.protected { program[50, 10] })
+    assert_equal(5, program[50, 10])
+  end
+ 
+  def test_hard_dbz
+    program = lambda { |x, y| x / y }
+    assert_raise(ZeroDivisionError) { program[1, 0] }
+    assert_raise(ZeroDivisionError) { program[2, 0] }
+    assert_raise(ZeroDivisionError) { program[10, 0] }
+    assert_raise(ZeroDivisionError) { program[255, 0] }
+  end
+
+  def test_soft_dbz
+    program = lambda { |x, y| x / y }
+    assert_equal(0, ToRobust::Local.protected { program[1, 0] })
+    assert_equal(0, ToRobust::Local.protected { program[2, 0] })
+    assert_equal(0, ToRobust::Local.protected { program[10, 0] })
+    assert_equal(0, ToRobust::Local.protected { program[255, 0] })
+  end
+ 
+end

data/test/local/method_binding.rb

@@ -0,0 +1,45 @@
+require 'to_robust'
+require 'test/unit'
+
+module TestMethods
+  def self.add(x,y); x+y; end
+  def self.sub(x,y); x-y; end
+  def self.mul(x,y); x*y; end
+end
+ 
+class TestMethodBinding < Test::Unit::TestCase
+ 
+  def test_standard_bad_method_name
+    assert_raise(NoMethodError) { TestMethods.ad(3,2) }
+    assert_raise(NoMethodError) { TestMethods.addd(3,2) }
+    assert_raise(NoMethodError) { TestMethods.su(3,2) }
+    assert_raise(NoMethodError) { TestMethods.sab(3,2) }
+    assert_raise(NoMethodError) { TestMethods.mula(3,2) }
+    assert_raise(NoMethodError) { TestMethods.mu(3,2) }
+  end
+
+  def test_good_method_call
+    
+    # Without Local robustness.
+    assert_equal(6, TestMethods.add(3,3))
+    assert_equal(9, TestMethods.mul(3,3))
+    assert_equal(0, TestMethods.sub(3,3))
+
+    # Using Local robustness.
+    assert_equal(6, RubyToRobust::Local.protected(TestMethods) { TestMethods.add(3,3) })
+    assert_equal(9, RubyToRobust::Local.protected(TestMethods) { TestMethods.mul(3,3) })
+    assert_equal(0, RubyToRobust::Local.protected(TestMethods) { TestMethods.sub(3,3) })
+
+  end
+
+
+  def test_soft_method_call
+
+    # Enable local robustness.
+    assert_equal(6, RubyToRobust::Local.protected(TestMethods) { TestMethods.ad(3,3) })
+    assert_equal(9, RubyToRobust::Local.protected(TestMethods) { TestMethods.ml(3,3) })
+    assert_equal(0, RubyToRobust::Local.protected(TestMethods) { TestMethods.sab(3,3) })
+
+  end
+
+end

metadata

@@ -0,0 +1,109 @@
+--- !ruby/object:Gem::Specification
+name: to_robust
+version: !ruby/object:Gem::Version
+  version: 1.0.0.pre
+  prerelease: 6
+platform: ruby
+authors:
+- Chris Timperley
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-12-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: levenshtein
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.2.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.2.2
+description: ! "    Soft semantics for Ruby to automatically recover from fatal exceptions
+  and to repair damaged programs.\n    Used to improve robustness, expressiveness
+  and performance in Grammatical Evolution.\n"
+email: christimperley@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/to_robust.rb
+- lib/global/fix.rb
+- lib/global/global.rb
+- lib/global/init.rb
+- lib/global/report.rb
+- lib/global/robust_proc.rb
+- lib/global/strategy.rb
+- lib/global/fix/add_atom.rb
+- lib/global/fix/atom.rb
+- lib/global/fix/init.rb
+- lib/global/fix/remove_atom.rb
+- lib/global/fix/swap_atom.rb
+- lib/global/kernel/argument_error.rb
+- lib/global/kernel/exception.rb
+- lib/global/kernel/init.rb
+- lib/global/kernel/no_method_error.rb
+- lib/global/kernel/zero_division_error.rb
+- lib/global/strategies/divide_by_zero_error_strategy.rb
+- lib/global/strategies/init.rb
+- lib/global/strategies/no_method_error_strategy.rb
+- lib/global/strategies/wrong_arguments_error_strategy.rb
+- lib/local/init.rb
+- lib/local/local.rb
+- lib/local/strategy.rb
+- lib/local/kernel/init.rb
+- lib/local/kernel/module.rb
+- lib/local/strategies/bignum_division_strategy.rb
+- lib/local/strategies/bignum_modulus_strategy.rb
+- lib/local/strategies/fixnum_coerce_strategy.rb
+- lib/local/strategies/fixnum_division_strategy.rb
+- lib/local/strategies/fixnum_modulus_strategy.rb
+- lib/local/strategies/float_division_strategy.rb
+- lib/local/strategies/float_modulus_strategy.rb
+- lib/local/strategies/init.rb
+- lib/local/strategies/numeric_division_strategy.rb
+- lib/local/strategies/numeric_modulus_strategy.rb
+- lib/local/strategies/soft_binding_strategy.rb
+- lib/local/strategies/swap_method_strategy.rb
+- test/local/float_division.rb
+- test/local/integer_division.rb
+- test/local/method_binding.rb
+homepage: https://github.com/ChrisTimperley/ruby_to_robust
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.8.6
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>'
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.28
+signing_key: 
+specification_version: 3
+summary: Adds optional soft semantics and self-repair to methods.
+test_files:
+- test/local/float_division.rb
+- test/local/integer_division.rb
+- test/local/method_binding.rb