retrying_proxy 0.1.2

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,21 @@
+## MAC OS
+.DS_Store
+
+## TEXTMATE
+*.tmproj
+tmtags
+
+## EMACS
+*~
+\#*
+.\#*
+
+## VIM
+*.swp
+
+## PROJECT::GENERAL
+coverage
+rdoc
+pkg
+
+## PROJECT::SPECIFIC

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Christopher J. Bottaro
+
+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.rdoc

@@ -0,0 +1,54 @@
+= retrying_proxy
+
+A simple gem to help you retry methods and deal with transient failures.
+
+== Quickstart
+
+Given a class that has methods that intermittently fail...
+
+  class Failer
+    
+    def initialize(failure_rate = 0.5)
+      @failure_rate = failure_rate
+    end
+    
+    def foo
+      if rand > @failure_rate
+        raise RuntimeError, "failure"
+      else
+        "foo"
+      end
+    end
+    
+  end
+
+You can use retrying_proxy in a few ways to deal with it...
+
+Create a retrying_proxy instance.
+
+  failer = Failer.new
+  proxy = RetryingProxy::Proxy.new(failer)
+  proxy.retry_method :foo
+  proxy.foo # Will retry once with no delay if an Exception is raised.
+
+Create a retrying_proxy class.
+
+  class FailerProxy < RetryingProxy::Base
+    proxy_target{ |failure_rate| Failer.new(failure_rate) }
+    retry_method :foo, :exceptions => RuntimeError # :exceptions can be an array.
+  end
+  proxy = FailerProxy.new(0.33)
+  proxy.foo # Will retry once with no delay if a RuntimeError is raised.
+  
+Modify the class directly.
+
+  class Failer
+    include RetryingProxy
+    retry_method :foo, :times => 2, :delay => 0.25
+  end
+  failer = Failer.new(0.75)
+  failer.foo # Will retry up to 2 times with a delay of 0.25 seconds between retries on any Exception.
+  
+== Author
+
+Christopher J. Bottaro - {cjbottaro}[http://github.com/cjbottaro]

data/Rakefile

@@ -0,0 +1,53 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "retrying_proxy"
+    gem.summary = %Q{A simple gem to help you retry methods and deal with transient failures.}
+    gem.description = %Q{A simple gem to help you retry methods and deal with transient failures.}
+    gem.email = "cjbottaro@alumni.cs.utexas.edu"
+    gem.homepage = "http://github.com/cjbottaro/retrying_proxy"
+    gem.authors = ["Christopher J. Bottaro"]
+    #gem.add_development_dependency "thoughtbot-shoulda", ">= 0"
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'test/**/test_*.rb'
+    test.verbose = true
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+  end
+end
+
+task :test => :check_dependencies
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "retrying_proxy #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.2

data/lib/retrying_proxy.rb

@@ -0,0 +1,42 @@
+require "retrying_proxy/active_support"
+require "retrying_proxy/base"
+require "retrying_proxy/proxy"
+
+module RetryingProxy
+  
+  VERSION = File.read(File.dirname(__FILE__)+"/../VERSION").freeze
+  
+  def self.included(mod)
+    mod.send(:extend, ClassMethods)
+    mod.send(:include, InstanceMethods)
+  end
+  
+  module ClassMethods
+    
+    def retrying_proxy
+      @retrying_proxy ||= Proxy.new
+    end
+    
+    def retry_methods(*args)
+      retrying_proxy.retry_methods(*args).each do |method_name|
+        alias_method_chain(method_name, :retrying_proxy) do |base_method_name, punc|
+          define_method("#{base_method_name}_with_retrying_proxy#{punc}") do |*args, &block|
+            retrying_proxy.call("#{base_method_name}_without_retrying_proxy#{punc}", args, :method_name => method_name, &block)
+          end
+        end
+      end
+    end
+    
+    alias_method :retry_method, :retry_methods
+    
+  end
+  
+  module InstanceMethods
+    
+    def retrying_proxy
+      self.class.retrying_proxy.tap{ |proxy| proxy.target = self }
+    end
+    
+  end
+  
+end

data/lib/retrying_proxy/active_support.rb

@@ -0,0 +1,34 @@
+class Object #:nodoc:
+  
+  def singleton_class
+    class << self
+      self
+    end
+  end unless method_defined?(:singleton_class)
+  
+end
+
+class Module #:nodoc:
+  
+  def alias_method_chain(target, feature)
+    # Strip out punctuation on predicates or bang methods since
+    # e.g. target?_without_feature is not a valid method name.
+    aliased_target, punctuation = target.to_s.sub(/([?!=])$/, ''), $1
+    yield(aliased_target, punctuation) if block_given?
+
+    with_method, without_method = "#{aliased_target}_with_#{feature}#{punctuation}", "#{aliased_target}_without_#{feature}#{punctuation}"
+
+    alias_method without_method, target
+    alias_method target, with_method
+
+    case
+      when public_method_defined?(without_method)
+        public target
+      when protected_method_defined?(without_method)
+        protected target
+      when private_method_defined?(without_method)
+        private target
+    end
+  end unless method_defined?(:alias_method_chain)
+  
+end

data/lib/retrying_proxy/base.rb

@@ -0,0 +1,55 @@
+require "retrying_proxy/proxy"
+
+module RetryingProxy
+  class Base
+    
+    class << self
+      
+      def proxy
+        @proxy ||= Proxy.new
+      end
+      
+      def proxy_target(&block)
+        if block_given?
+          @target = block
+        else
+          @target
+        end
+      end
+      
+      def retry_methods(*args)
+        proxy.retry_methods(*args).each do |method_name|
+          define_method(method_name) do |*args, &block|
+            call(method_name, *args, &block)
+          end
+        end
+      end
+      
+      alias_method :retry_method, :retry_methods
+      
+      def proxy_methods(*args)
+        retry_methods(*(args + [:times => 0])) # It has to be this way for Ruby 1.8
+      end
+      
+      alias_method :proxy_method, :proxy_methods
+      
+    end
+    
+    def initialize(*args, &block)
+      proxy.target = self.class.proxy_target.call(*args, &block)
+    end
+    
+    def target
+      proxy.target
+    end
+    
+    def proxy
+      self.class.proxy
+    end
+    
+    def call(method_name, *args, &block)
+      proxy.send(method_name, *args, &block)
+    end
+    
+  end
+end

data/lib/retrying_proxy/proxy.rb

@@ -0,0 +1,98 @@
+module RetryingProxy
+  class Proxy
+    attr_accessor :target
+    attr_reader :settings
+    
+    DEFAULTS = { :times       => 1,
+                 :exceptions  => StandardError,
+                 :delay       => nil,
+                 :predicate   => nil }
+    
+    def initialize(target = nil)
+      @target = target
+      @settings = {}
+    end
+    
+    def retry_methods(*args)
+      # Handle options.
+      options = args.last.kind_of?(Hash) ? args.pop : {}
+      options = DEFAULTS.merge(options)
+      
+      # Normalize some options.
+      options[:exceptions] = [options[:exceptions]].flatten
+      
+      # Normalize the method names.
+      method_names = args.collect{ |arg| arg.to_sym }
+      
+      # Store the settings
+      method_names.each{ |method_name| settings[method_name] = options }
+      
+      method_names.each do |method_name|
+        singleton_class.class_eval do
+          define_method(method_name) do |*args, &block|
+            call(method_name, args, &block)
+          end
+        end
+      end
+      
+      method_names
+    end
+    
+    alias_method :retry_method, :retry_methods
+    
+    # List of methods to pass through unaltered.
+    #   proxy_methods :foo, :bar, :baz
+    def proxy_methods(*args)
+      retry_methods(*(args + [:times => 0])) # It has to be this way for Ruby 1.8
+    end
+    
+    alias_method :proxy_method, :proxy_methods
+    
+    # Direcly call a method on the target without any wrapping or anything.
+    def raw_call(method_name, *args, &block)
+      if target.respond_to?(method_name) or \
+         target.class.private_method_defined?(method_name) or \
+         target.class.protected_method_defined?(method_name)
+        target.send(method_name, *args, &block)
+      else
+        target.send(:method_missing, method_name, *args, &block)
+      end
+    end
+    
+    # Call a method on the target wrapped with the retry logic.
+    def call(method_name, args, options = {}, &block)
+      
+      # This is tricky.  In the case of including RetryingProxy, we have to do all that alias
+      # method chain stuff, so the method_name argument will have _without_retrying_proxy
+      # appended to it.  options[:method_name] will provide the unmangled name in that case
+      # so we can look up the settings properly.
+      settings = self.settings[options[:method_name] || method_name]
+      
+      # Don't increment our retries counter if we're in recursion or we'll do infinite retries.
+      @retries = 0 unless options[:in_recursion]
+      
+      begin
+        value = raw_call(method_name, *args, &block)
+      rescue *settings[:exceptions] => e
+        should_retry?(settings) ? retry : raise
+      end
+      
+      if settings[:predicate] and should_retry?(settings){ settings[:predicate].call(value) }
+        value = call(method_name, args, options.merge(:in_recursion => true), &block)
+      end
+      
+      value
+    end
+    
+    # Returns true if we should retry calling the method.  +settings+ should be for the method
+    # being called.  If a block an optional predicate to determine if we should retry.
+    def should_retry?(settings, &block)
+      return false unless @retries < settings[:times]
+      return false if block_given? and not block.call
+      sleep(settings[:delay]) if settings[:delay]
+      @retries += 1
+      true
+    end
+    
+  end
+end

data/retrying_proxy.gemspec

@@ -0,0 +1,60 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{retrying_proxy}
+  s.version = "0.1.2"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Christopher J. Bottaro"]
+  s.date = %q{2011-01-07}
+  s.description = %q{A simple gem to help you retry methods and deal with transient failures.}
+  s.email = %q{cjbottaro@alumni.cs.utexas.edu}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+     ".gitignore",
+     "LICENSE",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION",
+     "lib/retrying_proxy.rb",
+     "lib/retrying_proxy/active_support.rb",
+     "lib/retrying_proxy/base.rb",
+     "lib/retrying_proxy/proxy.rb",
+     "retrying_proxy.gemspec",
+     "test/helper.rb",
+     "test/test_base.rb",
+     "test/test_coverage.rb",
+     "test/test_proxy.rb",
+     "test/test_retrying_proxy.rb"
+  ]
+  s.homepage = %q{http://github.com/cjbottaro/retrying_proxy}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.7}
+  s.summary = %q{A simple gem to help you retry methods and deal with transient failures.}
+  s.test_files = [
+    "test/helper.rb",
+     "test/test_base.rb",
+     "test/test_coverage.rb",
+     "test/test_proxy.rb",
+     "test/test_retrying_proxy.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end
+

data/test/helper.rb

@@ -0,0 +1,53 @@
+require 'rubygems'
+require 'test/unit'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'retrying_proxy'
+require "rr"
+
+class Test::Unit::TestCase
+  include RR::Adapters::TestUnit
+end
+
+class Foo
+  
+  module InstanceMethods
+    
+    # Foo must be called +times+ times before not raising an exception.
+    def initialize(times = nil, exception = RuntimeError)
+      @times = times
+      @exception = exception
+      @count = 0
+    end
+    
+    def foo
+      if @times.nil? or @count < @times
+        @count += 1
+        raise @exception, "oops"
+      end
+      @count = 0
+      "foo"
+    end
+  
+    def bar
+      "bar"
+    end
+  
+    def baz
+      "baz"
+    end
+    
+    def method_missing(method_name, *args, &block)
+      if method_name == :fu
+        foo
+      else
+        super
+      end
+    end
+    
+  end
+  
+  include InstanceMethods
+  
+end

data/test/test_base.rb

@@ -0,0 +1,25 @@
+require 'helper'
+
+class TestBase < Test::Unit::TestCase
+  
+  def test_retry
+    klass = Class.new(RetryingProxy::Base) do
+      proxy_target{ |times| Foo.new(times) }
+      retry_methods :foo, :times => 2
+    end
+    proxy = klass.new(2)
+    proxy(proxy.target).foo.times(3)
+    assert_equal "foo", proxy.foo
+  end
+  
+  def test_proxy
+    klass = Class.new(RetryingProxy::Base) do
+      proxy_target{ |times| Foo.new(times) }
+      proxy_method :foo
+    end
+    proxy = klass.new(1)
+    proxy(proxy.target).foo.times(1)
+    assert_raise(RuntimeError){ proxy.foo }
+  end
+  
+end

data/test/test_coverage.rb

@@ -0,0 +1,21 @@
+require 'helper'
+
+# This is just to reach 100% coverage.
+class TestCoverage < Test::Unit::TestCase
+  
+  def test_alias_method_chain
+    klass = Class.new do
+      def foo; end
+      def bar; end
+      def foo_with_nothing; end
+      def bar_with_nothing; end
+      protected :foo
+      private :bar
+      alias_method_chain :foo, :nothing
+      alias_method_chain :bar, :nothing
+    end
+    assert klass.protected_method_defined?(:foo)
+    assert klass.private_method_defined?(:bar)
+  end
+  
+end

data/test/test_proxy.rb

@@ -0,0 +1,90 @@
+require 'helper'
+
+class TestProxy < Test::Unit::TestCase
+  
+  def test_proxy
+    proxy = RetryingProxy::Proxy.new(Foo.new(1))
+    proxy.proxy_method :foo
+    proxy(proxy.target).foo.times(1)
+    assert_raise(RuntimeError){ proxy.foo }
+    proxy(proxy.target).foo.times(1)
+    assert_equal "foo", proxy.foo
+  end
+  
+  def test_retry
+    proxy = RetryingProxy::Proxy.new(Foo.new(1))
+    proxy.retry_method :foo
+    proxy(proxy.target).foo.times(2)
+    assert_equal "foo", proxy.foo
+  end
+  
+  def test_retry_with_times
+    proxy = RetryingProxy::Proxy.new(Foo.new(2))
+    proxy.retry_method :foo, :times => 2
+    proxy(proxy.target).foo.times(3)
+    assert_equal "foo", proxy.foo
+  end
+  
+  def test_retry_with_exceptions
+    proxy = RetryingProxy::Proxy.new(Foo.new(1, ArgumentError))
+    proxy.retry_method :foo, :exceptions => RuntimeError
+    proxy(proxy.target).foo.times(1)
+    assert_raise(ArgumentError){ proxy.foo }
+    
+    proxy = RetryingProxy::Proxy.new(Foo.new(1, ArgumentError))
+    proxy.retry_method :foo, :exceptions => ArgumentError
+    proxy(proxy.target).foo.times(2)
+    assert_equal "foo", proxy.foo
+  end
+  
+  def test_retry_with_delay
+    proxy = RetryingProxy::Proxy.new(Foo.new(1))
+    proxy.retry_method :foo, :delay => 0.23
+    proxy(proxy.target).foo.times(2)
+    mock(proxy).sleep(0.23)
+    assert_equal "foo", proxy.foo
+  end
+  
+  def test_retry_with_predicate
+    proxy = RetryingProxy::Proxy.new(Foo.new)
+    proxy.retry_method :bar, :baz, :predicate => Proc.new{ |value| value =~ /r$/ }
+    proxy(proxy.target).bar.times(2)
+    assert_equal "bar", proxy.bar
+    proxy(proxy.target).baz.times(1)
+    assert_equal "baz", proxy.baz
+  end
+  
+  def test_retries_resets_between_method_calls
+    proxy = RetryingProxy::Proxy.new(Foo.new(1))
+    proxy.retry_method :bar, :predicate => Proc.new{ |value| value =~ /^b/ }
+    proxy(proxy.target).bar.times(2)
+    assert_equal "bar", proxy.bar
+    proxy(proxy.target).bar.times(2)
+    assert_equal "bar", proxy.bar
+  end
+  
+  def test_method_missing
+    proxy = RetryingProxy::Proxy.new(Foo.new(2))
+    proxy.retry_method :fu, :times => 2
+    proxy(proxy.target).fu.times(3)
+    assert_equal "foo", proxy.fu
+  end
+  
+  def test_private_and_protected_methods
+    klass = Class.new do
+    private
+      def foo; "foo"; end
+    protected
+      def bar; "bar"; end
+    end
+    object = klass.new
+    proxy = RetryingProxy::Proxy.new(object)
+    proxy.retry_method :foo
+    proxy(proxy.target).foo.times(1)
+    assert_equal "foo", proxy.foo
+    proxy.proxy_method :bar
+    proxy(proxy.target).bar.times(1)
+    assert_equal "bar", proxy.bar
+  end
+  
+end

data/test/test_retrying_proxy.rb

@@ -0,0 +1,31 @@
+require 'helper'
+
+class TestRetryingProxy < Test::Unit::TestCase
+  
+  def test_retry
+    klass = Class.new do
+      include Foo::InstanceMethods
+      include RetryingProxy
+      retry_method :foo, :times => 2
+    end
+    object = klass.new(2)
+    proxy(object).foo_without_retrying_proxy.times(3)
+    assert_equal "foo", object.foo
+  end
+  
+  def test_punctuation
+    klass = Class.new do
+      include Foo::InstanceMethods
+      include RetryingProxy
+      alias_method :foo!, :foo
+      retry_method :foo!, :times => 3
+    end
+    assert klass.method_defined?(:foo!)
+    assert klass.method_defined?(:foo_with_retrying_proxy!)
+    assert klass.method_defined?(:foo_without_retrying_proxy!)
+    object = klass.new(3)
+    proxy(object).foo_without_retrying_proxy!.times(4)
+    assert_equal "foo", object.foo!
+  end
+  
+end

metadata

@@ -0,0 +1,87 @@
+--- !ruby/object:Gem::Specification 
+name: retrying_proxy
+version: !ruby/object:Gem::Version 
+  hash: 31
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 2
+  version: 0.1.2
+platform: ruby
+authors: 
+- Christopher J. Bottaro
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-01-07 00:00:00 -06:00
+default_executable: 
+dependencies: []
+
+description: A simple gem to help you retry methods and deal with transient failures.
+email: cjbottaro@alumni.cs.utexas.edu
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- .document
+- .gitignore
+- LICENSE
+- README.rdoc
+- Rakefile
+- VERSION
+- lib/retrying_proxy.rb
+- lib/retrying_proxy/active_support.rb
+- lib/retrying_proxy/base.rb
+- lib/retrying_proxy/proxy.rb
+- retrying_proxy.gemspec
+- test/helper.rb
+- test/test_base.rb
+- test/test_coverage.rb
+- test/test_proxy.rb
+- test/test_retrying_proxy.rb
+has_rdoc: true
+homepage: http://github.com/cjbottaro/retrying_proxy
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: A simple gem to help you retry methods and deal with transient failures.
+test_files: 
+- test/helper.rb
+- test/test_base.rb
+- test/test_coverage.rb
+- test/test_proxy.rb
+- test/test_retrying_proxy.rb