wait 0.4.1 → 0.5

data/lib/counters/base.rb

@@ -1,9 +1,9 @@
 class Wait
   class BaseCounter
-    attr_reader :attempt
+    attr_accessor :logger
+    attr_reader   :attempt
 
-    def initialize(logger, total)
-      @logger = logger
+    def initialize(total)
       # Attempt to prevent causing an infinite loop by being very strict about
       # the value passed.
       unless total.is_a?(Fixnum) and total > 0
@@ -11,7 +11,6 @@ class Wait
       end
 
       @total = total
-      reset
     end
 
     # Called before all attempts to reset the counter.
@@ -32,7 +31,9 @@ class Wait
 
     # Logs the current attempt count.
     def log
-      @logger.debug "[Counter] attempt #{self}"
+      return if @logger.nil?
+
+      @logger.debug("Counter") { "attempt #{self}" }
     end
 
     # Returns a string representation of the current count.

data/lib/delayers/base.rb

@@ -1,19 +1,22 @@
 class Wait
   class BaseDelayer
-    def initialize(logger, initial_delay)
-      @logger = logger
-      @delay  = initial_delay
+    attr_accessor :logger
+
+    def initialize(delay)
+      @delay = delay
     end
 
     # Called before a reattempt to sleep a certain about of time.
     def sleep
-      log_delay
+      log
       Kernel.sleep(@delay)
     end
 
     # Logs how long the delay is.
-    def log_delay
-      @logger.debug "[Delayer] delaying for #{self}"
+    def log
+      return if @logger.nil?
+
+      @logger.debug("Delayer") { "delaying for #{self}" }
     end
 
     # Returns a string representation of the delay.

data/lib/initialize.rb

@@ -2,15 +2,21 @@ require "timeout"
 require "logger"
 require "forwardable"
 
-require File.expand_path("../loggers/base",         __FILE__)
-require File.expand_path("../loggers/debug",        __FILE__)
-require File.expand_path("../counters/base",        __FILE__)
-require File.expand_path("../delayers/base",        __FILE__)
-require File.expand_path("../delayers/regular",     __FILE__)
-require File.expand_path("../delayers/exponential", __FILE__)
-require File.expand_path("../testers/base",         __FILE__)
-require File.expand_path("../testers/passive",      __FILE__)
-require File.expand_path("../testers/truthy",       __FILE__)
-require File.expand_path("../rescuers/base",        __FILE__)
-require File.expand_path("../raisers/base",         __FILE__)
-require File.expand_path("../raisers/passive",      __FILE__)
+paths = %w(
+  version
+  loggers/base
+  loggers/debug
+  counters/base
+  delayers/base
+  delayers/regular
+  delayers/exponential
+  testers/base
+  testers/passive
+  testers/truthy
+  rescuers/base
+  raisers/base
+  raisers/passive
+  raisers/signal
+)
+
+paths.each { |path| require File.expand_path("../#{path}", __FILE__) }

data/lib/loggers/base.rb

@@ -2,12 +2,12 @@ class Wait
   class BaseLogger
     extend Forwardable
 
-    attr_reader :logger
+    attr_reader    :logger
     def_delegators :logger, :fatal,
-                           :error,
-                           :warn,
-                           :info,
-                           :debug
+                            :error,
+                            :warn,
+                            :info,
+                            :debug
 
     def initialize
       @logger           = ::Logger.new(STDOUT)
@@ -20,13 +20,13 @@ class Wait
     end
 
     def formatter
-      proc do |severity, datetime, program_name, message|
-        [severity.ljust(5), message].join(" ") + "\n"
+      proc do |severity, datetime, caller, message|
+        "#{severity.ljust(5)} #{"[#{caller}]".ljust(9)} #{message}\n"
       end
     end
 
-    def backtrace(backtrace)
-      backtrace.map { |line| (" " * 25) + line }.join("\n")
+    def indent(lines, spaces = 25)
+      lines.map { |line| (" " * spaces) + line }.join("\n")
     end
   end # Logger
 end # Wait

data/lib/raisers/base.rb

@@ -1,18 +1,18 @@
 class Wait
   class BaseRaiser
-    def initialize(logger, exception)
-      @logger    = logger
-      @exception = exception
-      log
-    end
+    attr_accessor :logger
 
     # Returns +true+ if an exception ought to be raised.
-    def raise?
-      false
+    def raise?(exception)
+      false.tap do |raising|
+        log(exception, raising)
+      end
     end
 
-    def log
-      @logger.debug "[Raiser] raise? #{@exception.class.name}: #{raise?}"
+    def log(exception, raising)
+      return if @logger.nil?
+
+      @logger.debug("Raiser") { "#{"not " unless raising}raising: #{exception.class.name}" }
     end
   end # BaseRaiser
 end # Wait

data/lib/raisers/signal.rb

@@ -0,0 +1,14 @@
+class Wait
+  class SignalRaiser < BaseRaiser
+    def raise?(exception)
+      signal_exception?(exception.class).tap do |raising|
+        log(exception, raising)
+      end
+    end
+
+    # Returns +true+ if an exception raised is a signal exception.
+    def signal_exception?(klass)
+      [SignalException, Interrupt, NoMemoryError, SystemExit].include?(klass)
+    end
+  end # SignalRaiser
+end # Wait

data/lib/rescuers/base.rb

@@ -1,15 +1,23 @@
 class Wait
   class BaseRescuer
-    attr_reader :exceptions
+    attr_accessor :logger
+    attr_reader   :exceptions
 
-    def initialize(logger, *exceptions)
-      @logger     = logger
+    def initialize(exceptions)
       @exceptions = Array(exceptions).flatten
     end
 
     # Logs an exception.
     def log(exception)
-      @logger.debug "[Rescuer] rescued: #{exception.class.name}: #{exception.message}\n#{@logger.backtrace(exception.backtrace)}"
+      return if @logger.nil?
+
+      klass = exception.class.name
+      # We can omit the message if it's identical to the class name.
+      message = exception.message unless exception.message == klass
+      # Indent the exception so it stands apart from the rest of the messages.
+      backtrace = @logger.indent(exception.backtrace)
+
+      @logger.debug("Rescuer") { "rescued: #{klass}#{": #{message}" if message}\n#{backtrace}" }
     end
   end # BaseRescuer
 end # Wait

data/lib/testers/base.rb

@@ -1,18 +1,18 @@
 class Wait
   class BaseTester
-    def initialize(logger, result)
-      @logger = logger
-      @result = result
-      log
-    end
+    attr_accessor :logger
 
     # Returns +true+ if a result if valid.
-    def valid?
+    def valid?(result)
+      log(result)
+
       true
     end
 
-    def log
-      @logger.debug "[Tester] result: #{@result.inspect}"
+    def log(result)
+      return if @logger.nil?
+
+      @logger.debug("Tester") { "result: #{result.inspect}" }
     end
   end # BaseTester
 end # Wait

data/lib/testers/truthy.rb

@@ -1,7 +1,9 @@
 class Wait
   class TruthyTester < BaseTester
-    def valid?
-      not (@result.nil? or @result == false)
+    def valid?(result)
+      log(result)
+
+      not (result.nil? or result == false)
     end
   end # TruthyTester
 end # Wait

data/lib/version.rb

@@ -0,0 +1,3 @@
+class Wait
+  VERSION = "0.5"
+end # Wait

data/lib/wait.rb

@@ -9,7 +9,7 @@ class Wait
     :delayer  => RegularDelayer,
     :rescuer  => BaseRescuer,
     :tester   => TruthyTester,
-    :raiser   => PassiveRaiser,
+    :raiser   => SignalRaiser,
     :logger   => BaseLogger
   }
 
@@ -43,20 +43,26 @@ class Wait
   #   Strategy used to test the result. Default is Wait::TruthyTester.
   # [:raiser]
   #   Strategy used to raise specific exceptions. Default is
-  #   Wait::PassiveRaiser.
+  #   Wait::SignalRaiser.
   #
   def initialize(options = {})
-    debug       = options[:debug]    || false
-    @logger     = (options[:logger]  || (debug ? DebugLogger : DEFAULT[:logger])).new
-    attempts    = options[:attempts] || DEFAULT[:attempts]
-    @counter    = (options[:counter] || DEFAULT[:counter]).new(@logger, attempts)
-    @timeout    = options[:timeout]  || DEFAULT[:timeout]
-    delay       = options[:delay]    || DEFAULT[:delay]
-    @delayer    = (options[:delayer] || DEFAULT[:delayer]).new(@logger, delay)
-    exceptions  = options[:rescue]
-    @rescuer    = (options[:rescuer] || DEFAULT[:rescuer]).new(@logger, exceptions)
-    @tester     = options[:tester]   || DEFAULT[:tester]
-    @raiser     = options[:raiser]   || DEFAULT[:raiser]
+    # Assign defaults.
+    debug      = options[:debug]    || false
+    @logger    = options[:logger]   || (debug ? DebugLogger : DEFAULT[:logger]).new
+    attempts   = options[:attempts] || DEFAULT[:attempts]
+    @counter   = options[:counter]  || DEFAULT[:counter].new(attempts)
+    @timeout   = options[:timeout]  || DEFAULT[:timeout]
+    delay      = options[:delay]    || DEFAULT[:delay]
+    @delayer   = options[:delayer]  || DEFAULT[:delayer].new(delay)
+    exceptions = options[:rescue]
+    @rescuer   = options[:rescuer]  || DEFAULT[:rescuer].new(exceptions)
+    @tester    = options[:tester]   || DEFAULT[:tester].new
+    @raiser    = options[:raiser]   || DEFAULT[:raiser].new
+
+    # Assign the logger to each of the strategies.
+    [@counter, @delayer, @rescuer, @tester, @raiser].each do |strategy|
+      strategy.logger = @logger if strategy.respond_to?(:logger=)
+    end
   end
 
   # == Description
@@ -74,12 +80,12 @@ class Wait
   #   # => #<Wait>
   #   wait.until { Time.now.sec.even? }
   #   # [Counter] attempt 1/5
-  #   # [Tester] result: false
-  #   # [Rescuer] rescued: Wait::InvalidResult: Wait::InvalidResult
-  #   # [Raiser] raise? Wait::InvalidResult: false
+  #   # [Tester]  result: false
+  #   # [Rescuer] rescued: Wait::ResultInvalid
+  #   # [Raiser]  not raising: Wait::ResultInvalid
   #   # [Delayer] delaying for 1s
   #   # [Counter] attempt 2/5
-  #   # [Tester] result: true
+  #   # [Tester]  result: true
   #   # => true
   #
   # If you wish to handle an exception by attempting the block again, pass one
@@ -95,16 +101,16 @@ class Wait
   #     end
   #   end
   #   # [Counter] attempt 1/5
-  #   # [Tester] result: nil
-  #   # [Rescuer] rescued: Wait::InvalidResult: Wait::InvalidResult
-  #   # [Raiser] raise? Wait::InvalidResult: false
+  #   # [Tester]  result: nil
+  #   # [Rescuer] rescued: Wait::ResultInvalid
+  #   # [Raiser]  not raising: Wait::ResultInvalid
   #   # [Delayer] delaying for 1s
   #   # [Counter] attempt 2/5
-  #   # [Rescuer] rescued: RuntimeError: RuntimeError
-  #   # [Raiser] raise? RuntimeError: false
+  #   # [Rescuer] rescued: RuntimeError
+  #   # [Raiser]  not raising: RuntimeError
   #   # [Delayer] delaying for 1s
   #   # [Counter] attempt 3/5
-  #   # [Tester] result: "foo"
+  #   # [Tester]  result: "foo"
   #   # => "foo"
   #
   # == Returns
@@ -127,14 +133,12 @@ class Wait
         yield(@counter.attempt)
       end
       # Raise an exception unless the result is valid.
-      tester = @tester.new(@logger, result)
-      tester.valid? ? result : raise(InvalidResult)
-    rescue TimeoutError, InvalidResult, *@rescuer.exceptions => exception
+      @tester.valid?(result) ? result : raise(ResultInvalid)
+    rescue TimeoutError, ResultInvalid, *@rescuer.exceptions => exception
       # Log the exception.
       @rescuer.log(exception)
       # Raise the exception if it ought to be.
-      raiser = @raiser.new(@logger, exception)
-      raise(exception) if raiser.raise?
+      raise(exception) if @raiser.raise?(exception)
       # Raise the exception if this was the last attempt.
       raise(exception) if @counter.last_attempt?
       # Sleep before the next attempt.
@@ -148,5 +152,5 @@ class Wait
   class TimeoutError < Timeout::Error; end
 
   # Raised when a block returns an invalid result.
-  class InvalidResult < RuntimeError; end
+  class ResultInvalid < RuntimeError; end
 end #Wait

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: wait
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: '0.5'
   prerelease: 
 platform: ruby
 authors:
@@ -26,10 +26,12 @@ files:
 - lib/loggers/debug.rb
 - lib/raisers/base.rb
 - lib/raisers/passive.rb
+- lib/raisers/signal.rb
 - lib/rescuers/base.rb
 - lib/testers/base.rb
 - lib/testers/passive.rb
 - lib/testers/truthy.rb
+- lib/version.rb
 - lib/wait.rb
 homepage: http://github.com/paperlesspost/wait
 licenses: []