attempt_this 0.8.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a25ae3dbdf326fbbfd6ac7f4f87576495d4aa2ff
+  data.tar.gz: 570ce5129322b14d1b0c61a463daeb6b3c335962
+SHA512:
+  metadata.gz: e97953cc5b47eedbe6f6398ec1e1ad528aadf2cd36829dc8e5533c80846b0344fd1f5efc95a7bf4fc8481b866175f1a732dd1a4de88d57ddfa66f44f2cc96f68
+  data.tar.gz: 135cd4ad6336d9c63b9a6d58c3858706dd5445d73cd882e9e94ea6ea0dbbbb9db40df5a1dabfd66fea82b480c8ec9ca565fefcfd8bd4b7506601917879851c98

data/lib/attempt_this/attempt_object.rb

@@ -0,0 +1,112 @@
+require_relative 'binary_backoff_policy.rb'
+require_relative 'exception_type_filter.rb'
+
+module AttemptThis
+	# Retry policy implementation.
+	# This class is internal and is not supposed to be used outside of the module.
+	class AttemptObject
+		# Initializes object with enumerator.
+		def initialize(enumerator)
+			@enumerator = enumerator
+		end
+
+		# Executes the code block.
+		def attempt(block)
+			if (block)
+				last_exception = nil
+				first_time = true
+
+				@delay_policy = ->{} unless @delay_policy
+				@reset_method = ->{} unless @reset_method
+				@exception_filter = ExceptionTypeFilter.new([StandardError]) unless @exception_filter 
+
+				@enumerator.each do
+					@delay_policy.call unless first_time
+					last_exception = nil
+					begin
+						block.call
+						break
+					rescue => ex
+						raise unless @exception_filter.include?(ex)
+						last_exception = ex
+						@reset_method.call
+					end
+					first_time = false
+				end
+
+				# Re-raise the last exception
+				if (last_exception)
+					if (@default_method)
+						@default_method.call
+					else
+						raise last_exception
+					end
+				end
+			end
+
+			# Return self to allow chaining calls.
+			self
+		end
+
+		# Specifies delay in seconds between failed attempts. 
+		def with_delay(delay, &block)
+			# Delay should be either an integer or a range of integers.
+			if (delay.is_a?(Numeric))
+				raise(ArgumentError, "Delay should be a non-negative number; got #{delay}!") unless delay >= 0
+				delay = delay..delay
+			elsif delay.is_a?(Range)
+				raise(ArgumentError, "Range members should be numbers; got #{delay}!") unless delay.first.is_a?(Numeric) && delay.last.is_a?(Numeric)
+				raise(ArgumentError, "Range members should be non-negative; got #{delay}!") unless delay.first >= 0 && delay.last >= 0
+				raise(ArgumentError, "Range's end should be greater than or equal to range's start; got #{delay}!") unless delay.first <= delay.last
+			else
+				raise(ArgumentError, "Delay should be either an number or a range of numbers; got #{delay}!")
+			end
+			raise(ArgumentError, 'Delay policy has already been specified!') if @delay_policy
+			@delay_policy = ->{Kernel.sleep(rand(delay))}
+
+			attempt(block)
+		end
+
+		# Specifies reset method that will be called after each failed attempt.
+		def with_reset(reset_method, &block)
+			raise(ArgumentError, 'Reset method is nil!') unless reset_method
+			raise(ArgumentError, 'Reset method has already been speicifed!') if @reset_method
+
+			@reset_method = reset_method
+			attempt(block)
+		end
+
+		# Specifies default method that should be called after all attempts have failed.
+		def and_default_to(default_method, &block)
+			raise(ArgumentError, 'Default method is nil!') unless default_method
+			raise(ArgumentError, 'Default method has already been specified!') if @default_method
+
+			@default_method = default_method
+			attempt(block)
+		end
+
+		# Specifies delay which doubles between failed attempts.
+		def with_binary_backoff(initial_delay, &block)
+			raise(ArgumentError, "Delay should be a number; got ${initial_delay}!") unless initial_delay.is_a?(Numeric)
+			raise(ArgumentError, "Delay should be a positive number; got #{initial_delay}!") unless initial_delay > 0
+			raise(ArgumentError, "Delay policy has already been specified!") if @delay_policy
+
+			@delay_policy = BinaryBackoffPolicy.new(initial_delay)
+			attempt(block)
+		end
+
+		# Specifies exceptions 
+		def with_filter(*exceptions, &block)
+			raise(ArgumentError, "Empty exceptions list!") unless exceptions.size > 0
+			# Everything must be an exception.
+			exceptions.each do |e|
+				raise(ArgumentError, "Not an exception: #{e}!") unless e <= Exception
+			end
+
+			raise(ArgumentError, "Exception filter has already been specified!") if @exception_filter
+
+			@exception_filter = ExceptionTypeFilter.new(exceptions)
+			attempt(block)
+		end
+	end
+end

data/lib/attempt_this/binary_backoff_policy.rb

@@ -0,0 +1,15 @@
+module AttemptThis
+	# Implementation of binary backoff policy. Internal use only.
+	class BinaryBackoffPolicy
+		# Initializer.
+		def initialize(initial_delay)
+			@delay = initial_delay
+		end
+
+		# Calls the policy.
+		def call
+			Kernel.sleep(@delay)
+			@delay *= 2
+		end
+	end
+end

data/lib/attempt_this/exception_type_filter.rb

@@ -0,0 +1,14 @@
+module AttemptThis
+	# Type-based exception filter.
+	class ExceptionTypeFilter
+		# Initializer.
+		def initialize(exception_classes)
+			@exception_classes = Array.new(exception_classes)
+		end
+
+		# Tells whether the given exception satisfies the filter.
+		def include?(exception)
+			@exception_classes.any?{|klass| exception.is_a?(klass)}
+		end
+	end
+end

data/lib/attempt_this.rb

@@ -0,0 +1,11 @@
+require 'attempt_this/attempt_object.rb'
+
+module AttemptThis
+	# Attempts code block until it doesn't throw an exception or the end of enumerator has been reached.
+	def attempt(enumerator, &block)
+		raise(ArgumentError, 'Nil enumerator!') if enumerator.nil?
+
+		impl = AttemptObject.new(enumerator)
+		impl.attempt(block)
+	end
+end

metadata

@@ -0,0 +1,47 @@
+--- !ruby/object:Gem::Specification
+name: attempt_this
+version: !ruby/object:Gem::Version
+  version: 0.8.0
+platform: ruby
+authors:
+- Aliaksei Baturytski
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-05-05 00:00:00.000000000 Z
+dependencies: []
+description: Retry on exception with configurable number of times, delays, exception
+  filters, and fall back strategies
+email: abaturytski@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/attempt_this.rb
+- lib/attempt_this/attempt_object.rb
+- lib/attempt_this/binary_backoff_policy.rb
+- lib/attempt_this/exception_type_filter.rb
+homepage: https://github.com/aliakb/attempt_this
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.0
+signing_key: 
+specification_version: 4
+summary: Retry policy mix-in
+test_files: []