rest-core 3.4.1 → 3.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 85f12b68843aae98a2ceaa7d85346e0c99627f21
-  data.tar.gz: d8ba6d00b676443be83d939f7b676ad75f96ec0a
+  metadata.gz: b4cd61e7344e03258e5ef9482bf9270e29115ee2
+  data.tar.gz: fbc1f00dcb47c15daec112ea4cf6a7397331bc74
 SHA512:
-  metadata.gz: 56f4c5e7e9b54d700947e99598fa889d1bea1d2a9e07a954fcf795109bf5935263b26db50e881ad71458671213d60961b367738b400d1abe5046ade10c05d6b5
-  data.tar.gz: bb5712b4ac86364fcbe05ca8ad938ef6635764e73695a02a982dfb3b6028f0752539063f80ecad5ff630f75c2b185e399e60780eeeeade4938e45066b7743aa1
+  metadata.gz: ffc882cb23b1e1b9017d910c4fb34c77258f4c4afd93eceb6cfb96ef1068fb8afd356c330fdb36ea5bfc8345d985cacfedb72eb374422368d8b573c85220b93c
+  data.tar.gz: aeb92a57d45711993ed90d561b9f4d39e780d5715c3d97acf5310d8089445a071ec0593958ecb7d024c147b3cb8e326153bbc64885e2b0fa89de10ff3c67b736

data/CHANGES.md

@@ -1,5 +1,36 @@
 # CHANGES
 
+## rest-core 3.5.0 -- 2014-12-09
+
+### Incompatible changes
+
+* `RC::Builder` would now only deep copy arrays and hashes.
+* `RC::ErrorHandler`'s only responsibility is now creating the exception.
+  Raising the exceptions or passing it to the callback is now handled by
+  `RC::Client` instead. (Thanks Andrew Clunis, #6)
+* Since exceptions are raised by `RC::Client` now, `RC::Timeout` would not
+  raise any exception, but just hand over to `RC::Client`.
+* Support for Ruby version < 1.9.2 is dropped.
+
+### Bugs fixed
+
+* Reverted #10 because it caused the other encoding issue. (#12)
+* `RC::Client#wait` and `RC::Client.wait` would now properly wait for
+  `RC::FollowRedirect`
+* `RC::Event::CacheHit` is properly logged again.
+
+### Enhancements
+
+* Introduced `RC::Client#error_callback` which would get called for each
+  exceptions raised. This is useful for monitoring and logging errors.
+
+* Introduced `RC::Retry` which could retry the request upon certain errors.
+  Specify `max_retries` for maximum times for retrying, and `retry_exceptions`
+  for which exceptions should be trying.
+  Default is `[IOError, SystemCallError]`
+
+* Eliminated a few warnings when `-w` is used.
+
 ## rest-core 3.4.1 -- 2014-11-29
 
 ### Bugs fixed

data/README.md

@@ -531,6 +531,7 @@ simply ignore `:expires_in`.
 [RC::Oauth2Header]: lib/rest-core/middleware/oauth2_header.rb
 [RC::Oauth2Query]: lib/rest-core/middleware/oauth2_query.rb
 [RC::SmashResponse]: lib/rest-core/middleware/smash_response.rb
+[RC::Retry]: lib/rest-core/middleware/retry.rb
 [RC::Timeout]: lib/rest-core/middleware/timeout.rb
 [moneta]: https://github.com/minad/moneta#expiration
 

data/lib/rest-core.rb

@@ -68,6 +68,7 @@ module RestCore
   autoload :Oauth1Header  , 'rest-core/middleware/oauth1_header'
   autoload :Oauth2Header  , 'rest-core/middleware/oauth2_header'
   autoload :Oauth2Query   , 'rest-core/middleware/oauth2_query'
+  autoload :Retry         , 'rest-core/middleware/retry'
   autoload :Timeout       , 'rest-core/middleware/timeout'
 
   # engines
@@ -88,7 +89,7 @@ module RestCore
         c = const.const_get(n)
       rescue LoadError, NameError => e
         warn "RestCore: WARN: #{e} for #{const}\n" \
-             "  from #{e.backtrace.grep(/top.+required/u).first}"
+             "  from #{e.backtrace.grep(/top.+required/).first}"
       end
       eagerload(c, loaded) if c.respond_to?(:constants) && !loaded[n]
     }

data/lib/rest-core/builder.rb

@@ -76,8 +76,7 @@ class RestCore::Builder
     case obj
       when Array; obj.map{ |o| partial_deep_copy(o) }
       when Hash ; obj.inject({}){ |r, (k, v)| r[k] = partial_deep_copy(v); r }
-      when Numeric, Symbol, TrueClass, FalseClass, NilClass; obj
-      else begin obj.dup; rescue TypeError; obj; end
+      else      ; obj
     end
   end
 

data/lib/rest-core/client.rb

@@ -41,12 +41,14 @@ module RestCore::Client
   end
 
   attr_reader :app, :dry, :promises
+  attr_accessor :error_callback
   def initialize o={}
     @app ||= self.class.builder.to_app # lighten! would reinitialize anyway
     @dry ||= self.class.builder.to_app(Dry)
     @promises = []  # don't record any promises in lighten!
     @mutex    = nil # for locking promises, lazily initialized
                     # for serialization
+    @error_callback = nil
     o.each{ |key, value| send("#{key}=", value) if respond_to?("#{key}=") }
   end
 
@@ -57,7 +59,7 @@ module RestCore::Client
   def inspect
     fields = if size > 0
                ' ' + attributes.map{ |k, v|
-                 "#{k}=#{v.inspect.sub(/(?<=.{12}).{4,}/u, '...')}"
+                 "#{k}=#{v.inspect.sub(/(?<=.{12}).{4,}/, '...')}"
                }.join(', ')
              else
                ''
@@ -161,9 +163,20 @@ module RestCore::Client
   end
 
   def request_full env, app=app, &k
-    response = app.call(build_env({ASYNC => !!k}.merge(env)),
-                        &(k || RC.id))
+    response = app.call(build_env({ASYNC => !!k}.merge(env))) do |res|
+      (k || RC.id).call(request_complete(res))
+    end
+
+    give_promise(response)
+
+    if block_given?
+      self
+    else
+      response
+    end
+  end
 
+  def give_promise response
     # under ASYNC callback, response might not be a response hash
     # in that case (maybe in a user created engine), Client#wait
     # won't work because we have no way to track the promise.
@@ -173,11 +186,7 @@ module RestCore::Client
       self.class.give_promise(weak_promise, promises, mutex)
     end
 
-    if block_given?
-      self
-    else
-      response
-    end
+    response
   end
 
   def build_env env={}
@@ -200,6 +209,24 @@ module RestCore::Client
 
 
   private
+  def request_complete res
+    if err = res[FAIL].find{ |f| f.kind_of?(Exception) }
+      RC::Promise.set_backtrace(err) unless err.backtrace
+      error_callback.call(err) if error_callback
+      if res[ASYNC]
+        if res[HIJACK]
+          res.merge(RESPONSE_SOCKET => err)
+        else
+          res.merge(RESPONSE_BODY => err)
+        end
+      else
+        raise err
+      end
+    else
+      res
+    end
+  end
+
   def mutex
     @mutex ||= Mutex.new
   end

data/lib/rest-core/client/universal.rb

@@ -1,15 +1,14 @@
 
 module RestCore
   Universal = Builder.client do
-    use Timeout       , 0
-
     use DefaultSite   , nil
     use DefaultHeaders, {}
     use DefaultQuery  , {}
     use DefaultPayload, {}
     use JsonRequest   , false
     use AuthBasic     , nil, nil
-    use CommonLogger  , method(:puts)
+    use Retry         , 0, Retry::DefaultRetryExceptions
+    use Timeout       , 0
     use ErrorHandler  , nil
     use ErrorDetectorHttp
 
@@ -17,10 +16,9 @@ module RestCore
     use ClashResponse , false
     use  JsonResponse , false
     use QueryResponse , false
-
+    use FollowRedirect, 10
+    use CommonLogger  , method(:puts)
     use Cache         , {}, 600 # default :expires_in 600 but the default
                                 # cache {} didn't support it
-
-    use FollowRedirect, 10
   end
 end

data/lib/rest-core/event.rb

@@ -4,9 +4,14 @@ module RestCore
     RestCore.const_defined?(:EventStruct)
 
   class Event < EventStruct
-    # self.class.name[/(?<=::)\w+$/] if RUBY_VERSION >= '1.9.2'
-    def name; self.class.name[/::(\w+)$/u, 1]        ; end
-    def to_s; "spent #{duration} #{name} #{message}"; end
+    def name; self.class.name[/(?<=::)\w+$/]; end
+    def to_s
+      if duration
+        "spent #{duration} #{name} #{message}"
+      else
+        "#{name} #{message}"
+      end
+    end
   end
   class Event::MultiDone    < Event; end
   class Event::Requested    < Event; end
@@ -14,4 +19,5 @@ module RestCore
   class Event::CacheCleared < Event; end
   class Event::Failed       < Event; end
   class Event::WithHeader   < Event; end
+  class Event::Retrying     < Event; end
 end

data/lib/rest-core/event_source.rb

@@ -67,7 +67,7 @@ class RestCore::EventSource < Struct.new(:client, :path, :query, :opts,
       begin
         @onerror.call(error, sock) if @onerror
         onreconnect(error, sock)
-      rescue Exception => e
+      rescue Exception
         mutex.synchronize do
           @closed = true
           condv.signal # so we can't be reconnecting, need to try to unblock

data/lib/rest-core/middleware.rb

@@ -57,6 +57,13 @@ module RestCore::Middleware
       app
     end
   end
+  def error_callback res, err
+    res[CLIENT].error_callback.call(err) if
+      res[CLIENT] && res[CLIENT].error_callback
+  end
+  def give_promise res
+    res[CLIENT].give_promise(res) if res[CLIENT]
+  end
 
   module_function
   def request_uri env
@@ -64,7 +71,7 @@ module RestCore::Middleware
     if (query = (env[REQUEST_QUERY] || {}).select{ |k, v| v }).empty?
       env[REQUEST_PATH].to_s
     else
-      q = if env[REQUEST_PATH] =~ /\?/u then '&' else '?' end
+      q = if env[REQUEST_PATH] =~ /\?/ then '&' else '?' end
       "#{env[REQUEST_PATH]}#{q}#{percent_encode(query)}"
     end
   end
@@ -81,7 +88,7 @@ module RestCore::Middleware
   end
   public :percent_encode
 
-  UNRESERVED = /[^a-zA-Z0-9\-\.\_\~]+/u
+  UNRESERVED = /[^a-zA-Z0-9\-\.\_\~]+/
   def escape string
     string.gsub(UNRESERVED) do |s|
       "%#{s.unpack('H2' * s.bytesize).join('%')}".upcase

data/lib/rest-core/middleware/cache.rb

@@ -48,8 +48,9 @@ class RestCore::Cache
     uri = request_uri(env)
     start_time = Time.now
     return unless data = cache(env)[cache_key(env)]
-    log(env, Event::CacheHit.new(Time.now - start_time, uri)).
-      merge(data_extract(data, env.merge(REQUEST_URI => uri), k))
+    res = log(env.merge(REQUEST_URI => uri),
+              Event::CacheHit.new(Time.now - start_time, uri))
+    data_extract(data, res, k)
   end
 
   private
@@ -97,12 +98,12 @@ class RestCore::Cache
     "#{ res[RESPONSE_BODY]}"
   end
 
-  def data_extract data, env, k
+  def data_extract data, res, k
     _, status, headers, body =
-      data.match(/\A(\d+)\n((?:[^\n]+\n)*)\n\n(.*)\Z/um).to_a
+      data.match(/\A(\d+)\n((?:[^\n]+\n)*)\n\n(.*)\Z/m).to_a
 
-    Promise.claim(env, k, body,status.to_i,
-      Hash[(headers||'').scan(/([^:]+): ([^\n]+)\n/u)]).future_response
+    Promise.claim(res, k, body, status.to_i,
+      Hash[(headers||'').scan(/([^:]+): ([^\n]+)\n/)]).future_response
   end
 
   def cache_for? env

data/lib/rest-core/middleware/error_handler.rb

@@ -7,38 +7,12 @@ class RestCore::ErrorHandler
 
   def call env
     app.call(env){ |res|
-      yield(if (res[FAIL] || []).empty? # no errors at all
+      h = error_handler(res)
+      f = res[FAIL] || []
+      yield(if f.empty? || f.find{ |ff| ff.kind_of?(Exception) } || !h
               res
             else
-              # if there's an exception, hand it over
-              if err = res[FAIL].find{ |e| e.kind_of?(Exception) }
-                process(res, err)
-
-              elsif h = error_handler(res)
-                # if the user provides an exception, hand it over
-                if (err = h.call(res)).kind_of?(Exception)
-                  process(res, err)
-
-                else # otherwise we report all of them
-                  res.merge(FAIL => [res[FAIL], err].flatten.compact)
-
-                end
-              else # no exceptions at all, then do nothing
-                res
-              end
+              fail(res, h.call(res))
             end)}
   end
-
-  def process res, err
-    RC::Promise.set_backtrace(err)
-    if res[ASYNC]
-      if res[HIJACK]
-        res.merge(RESPONSE_SOCKET => err)
-      else
-        res.merge(RESPONSE_BODY => err)
-      end
-    else
-      raise err
-    end
-  end
 end

data/lib/rest-core/middleware/follow_redirect.rb

@@ -6,19 +6,15 @@ class RestCore::FollowRedirect
   include RestCore::Middleware
 
   def call env, &k
-    e = env.merge('follow_redirect.max_redirects' =>
-                    env['follow_redirect.max_redirects'] ||
-                    max_redirects(env))
-
-    if e[DRY]
-      app.call(e, &k)
+    if env[DRY]
+      app.call(env, &k)
     else
-      app.call(e){ |res| process(res, k) }
+      app.call(env){ |res| process(res, k) }
     end
   end
 
   def process res, k
-    return k.call(res) if res['follow_redirect.max_redirects'] <= 0
+    return k.call(res) if max_redirects(res) <= 0
     return k.call(res) if ![301,302,303,307].include?(res[RESPONSE_STATUS])
     return k.call(res) if  [301,302    ,307].include?(res[RESPONSE_STATUS]) &&
                           ![:get, :head    ].include?(res[REQUEST_METHOD])
@@ -30,10 +26,10 @@ class RestCore::FollowRedirect
                  res[REQUEST_METHOD]
                end
 
-    call(res.merge(REQUEST_METHOD => meth    ,
-                   REQUEST_PATH   => location,
-                   REQUEST_QUERY  => {}      ,
-                   'follow_redirect.max_redirects' =>
-                     res['follow_redirect.max_redirects'] - 1), &k)
+    give_promise(call(res.merge(
+      REQUEST_METHOD => meth    ,
+      REQUEST_PATH   => location,
+      REQUEST_QUERY  => {}      ,
+      'max_redirects' => max_redirects(res) - 1), &k))
   end
 end

data/lib/rest-core/middleware/json_response.rb

@@ -30,7 +30,7 @@ class RestCore::JsonResponse
   def process response
     # StackExchange returns the problematic BOM! in UTF-8, so we need to
     # strip it or it would break JSON parsers (i.e. yajl-ruby and json)
-    body = response[RESPONSE_BODY].to_s.sub(/\A\xEF\xBB\xBF/u, '')
+    body = response[RESPONSE_BODY].to_s.sub(/\A\xEF\xBB\xBF/, '')
     response.merge(RESPONSE_BODY => Json.decode("[#{body}]").first)
     # [this].first is not needed for yajl-ruby
   rescue Json.const_get(:ParseError) => error

data/lib/rest-core/middleware/retry.rb

@@ -0,0 +1,33 @@
+
+require 'rest-core/middleware'
+
+class RestCore::Retry
+  def self.members; [:max_retries, :retry_exceptions]; end
+  include RestCore::Middleware
+
+  DefaultRetryExceptions = [IOError, SystemCallError]
+
+  def call env, &k
+    if env[DRY]
+      app.call(env, &k)
+    else
+      app.call(env){ |res| process(res, k) }
+    end
+  end
+
+  def process res, k
+    times = max_retries(res)
+    return k.call(res) if times <= 0
+    errors = retry_exceptions(res) || DefaultRetryExceptions
+
+    if idx = res[FAIL].index{ |f| errors.find{ |e| f.kind_of?(e) } }
+      err = res[FAIL].delete_at(idx)
+      error_callback(res, err)
+      env = res.merge('max_retries' => times - 1)
+      give_promise(call(log(
+        env, Event::Retrying.new(nil, "(#{times}) for: #{err.inspect}")), &k))
+    else
+      k.call(res)
+    end
+  end
+end

data/lib/rest-core/middleware/timeout.rb

@@ -1,4 +1,6 @@
 
+require 'timeout'
+
 require 'rest-core/middleware'
 require 'rest-core/timer'
 
@@ -8,21 +10,12 @@ class RestCore::Timeout
 
   def call env, &k
     return app.call(env, &k) if env[DRY] || timeout(env) == 0
-    monitor(env){ |e|
-      app.call(e){ |r|
-        if r[ASYNC] ||
-           !(exp = (r[FAIL]||[]).find{ |f| f.kind_of?(::Timeout::Error) })
-          # we do nothing special for callback and rest-client
-          k.call(r)
-        else
-          # it would go to this branch only under response future
-          raise exp
-        end}}
+    process(env, &k)
   end
 
-  def monitor env
+  def process env, &k
     timer = Timer.new(timeout(env), timeout_error)
-    yield(env.merge(TIMER => timer))
+    app.call(env.merge(TIMER => timer), &k)
   rescue Exception
     timer.cancel
     raise

data/lib/rest-core/promise.rb

@@ -159,15 +159,15 @@ class RestCore::Promise
       never_raise_yield do
         env[TIMER].cancel if env[TIMER]
         self.class.set_backtrace(e)
-        # TODO: add error_log_method
-        warn "RestCore: ERROR: #{e}\n  from #{e.backtrace.inspect}"
       end
 
-      begin
-        rejecting(e) unless done? # not done: i/o error; done: callback error
-      rescue Exception => e
-        never_raise_yield do
-          warn "RestCore: ERROR: #{e}\n  from #{e.backtrace.inspect}"
+      if done?
+        callback_error(e)
+      else
+        begin
+          rejecting(e) # i/o error
+        rescue Exception => e
+          callback_error(e)
         end
       end
     end
@@ -195,6 +195,16 @@ class RestCore::Promise
     self.called = true
   end
 
+  def callback_error e
+    never_raise_yield do
+      if env[CLIENT].error_callback
+        env[CLIENT].error_callback.call(e)
+      else
+        warn "RestCore: ERROR: #{e}\n  from #{e.backtrace.inspect}"
+      end
+    end
+  end
+
   def cancel_task
     mutex.synchronize do
       next if done?

data/lib/rest-core/test.rb

@@ -11,7 +11,7 @@ require 'yaml'
 WebMock.disable_net_connect!(:allow_localhost => true)
 Pork::Executor.__send__(:include, Muack::API, WebMock::API)
 
-module Kernel
+class Pork::Executor
   def with_img
     f = Tempfile.new(['img', '.jpg'])
     n = File.basename(f.path)

data/lib/rest-core/timer.rb

@@ -10,7 +10,7 @@ class RestCore::Timer
     attr_accessor :interval
 
     def group
-      @group ||= @mutex.synchronize{ @group || group_new }
+      @group ||= @mutex.synchronize{ @group ||= group_new }
     end
 
     private

data/lib/rest-core/util/parse_link.rb

@@ -4,12 +4,12 @@ module RestCore::ParseLink
   module_function
   # http://tools.ietf.org/html/rfc5988
   parname = '"?([^"]+)"?'
-  LINKPARAM = /#{parname}=#{parname}/u
+  LINKPARAM = /#{parname}=#{parname}/
   def parse_link link
     link.split(',').inject({}) do |r, value|
       uri, *pairs = value.split(';')
       params = Hash[pairs.map{ |p| p.strip.match(LINKPARAM)[1..2] }]
-      r[params['rel']] = params.merge('uri' => uri[/<([^>]+)>/u, 1])
+      r[params['rel']] = params.merge('uri' => uri[/<([^>]+)>/, 1])
       r
     end
   end

data/lib/rest-core/util/parse_query.rb

@@ -12,7 +12,7 @@ module RestCore::ParseQuery
     def parse_query(qs, d = nil)
       params = {}
 
-      (qs || '').split(d ? /[#{d}] */un : /[&;] */un).each do |p|
+      (qs || '').split(d ? /[#{d}] */n : /[&;] */n).each do |p|
         k, v = p.split('=', 2).map { |x| URI.decode_www_form_component(x) }
         if cur = params[k]
           if cur.class == Array

data/lib/rest-core/version.rb

@@ -1,4 +1,4 @@
 
 module RestCore
-  VERSION = '3.4.1'
+  VERSION = '3.5.0'
 end

data/rest-core.gemspec

@@ -1,14 +1,14 @@
 # -*- encoding: utf-8 -*-
-# stub: rest-core 3.4.1 ruby lib
+# stub: rest-core 3.5.0 ruby lib
 
 Gem::Specification.new do |s|
   s.name = "rest-core"
-  s.version = "3.4.1"
+  s.version = "3.5.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.require_paths = ["lib"]
   s.authors = ["Lin Jen-Shin (godfat)"]
-  s.date = "2014-11-29"
+  s.date = "2014-12-09"
   s.description = "Modular Ruby clients interface for REST APIs.\n\nThere has been an explosion in the number of REST APIs available today.\nTo address the need for a way to access these APIs easily and elegantly,\nwe have developed rest-core, which consists of composable middleware\nthat allows you to build a REST client for any REST API. Or in the case of\ncommon APIs such as Facebook, Github, and Twitter, you can simply use the\ndedicated clients provided by [rest-more][].\n\n[rest-more]: https://github.com/godfat/rest-more"
   s.email = ["godfat (XD) godfat.org"]
   s.files = [
@@ -57,6 +57,7 @@ Gem::Specification.new do |s|
   "lib/rest-core/middleware/oauth2_header.rb",
   "lib/rest-core/middleware/oauth2_query.rb",
   "lib/rest-core/middleware/query_response.rb",
+  "lib/rest-core/middleware/retry.rb",
   "lib/rest-core/middleware/smash_response.rb",
   "lib/rest-core/middleware/timeout.rb",
   "lib/rest-core/promise.rb",
@@ -103,6 +104,7 @@ Gem::Specification.new do |s|
   "test/test_payload.rb",
   "test/test_promise.rb",
   "test/test_query_response.rb",
+  "test/test_retry.rb",
   "test/test_simple.rb",
   "test/test_smash.rb",
   "test/test_smash_response.rb",
@@ -111,7 +113,7 @@ Gem::Specification.new do |s|
   "test/test_universal.rb"]
   s.homepage = "https://github.com/godfat/rest-core"
   s.licenses = ["Apache License 2.0"]
-  s.rubygems_version = "2.4.4"
+  s.rubygems_version = "2.4.5"
   s.summary = "Modular Ruby clients interface for REST APIs."
   s.test_files = [
   "test/test_auth_basic.rb",
@@ -141,6 +143,7 @@ Gem::Specification.new do |s|
   "test/test_payload.rb",
   "test/test_promise.rb",
   "test/test_query_response.rb",
+  "test/test_retry.rb",
   "test/test_simple.rb",
   "test/test_smash.rb",
   "test/test_smash_response.rb",

data/test/test_client.rb

@@ -7,7 +7,7 @@ describe RC::Simple do
     Muack.verify
   end
 
-  url = 'http://localhost/'
+  url = 'http://example.com/'
 
   would 'do simple request' do
     c = RC::Simple.new
@@ -80,7 +80,7 @@ describe RC::Simple do
   end
 
   would 'cleanup promises' do
-    stub_request(:get, url)
+    stub_request(:get, url).to_return(:body => 'nnf')
     client = RC::Builder.client
     5.times{ client.new.get(url) }
     Thread.pass
@@ -164,4 +164,14 @@ describe RC::Simple do
     client.wait
     client.should.nil? # to make sure the inner most block did run
   end
+
+  would 'call error_callback' do
+    error = nil
+    error_callback = lambda{ |e| error = e }
+    should.raise(Errno::ECONNREFUSED) do
+      RC::Simple.new(:error_callback => error_callback).
+        get('http://localhost/').tap{}
+    end
+    error.should.kind_of?(Errno::ECONNREFUSED)
+  end
 end

data/test/test_error_handler.rb

@@ -12,7 +12,7 @@ describe RC::ErrorHandler do
   describe 'there is an exception' do
     would 'raise an error with future' do
       lambda{
-      client.new.get('/', {}, RC::FAIL => [exp.new('fail')])
+        client.new.get('/', {}, RC::FAIL => [exp.new('fail')])
       }.should.raise(exp)
     end
 
@@ -56,4 +56,14 @@ describe RC::ErrorHandler do
     end
     client.wait
   end
+
+  would 'not call error_handler if there is already an exception' do
+    called = false
+    RC::Builder.client do
+      use RC::ErrorHandler, lambda{ |_| called = true }
+    end.new.get('http://localhost') do |error|
+      error.should.kind_of?(SystemCallError)
+    end.wait
+    called.should.eq false
+  end
 end

data/test/test_event_source.rb

@@ -133,21 +133,13 @@ SSE
     m.should.empty?
   end
 
-  def mock_warning
-    mock(any_instance_of(RC::Promise)).warn(is_a(String)) do |msg|
-      msg.should.include?(Errno::ECONNREFUSED.new.message)
-    end
-  end
-
   would 'not deadlock without ErrorHandler' do
-    mock_warning
     c = RC::Simple.new.event_source('http://localhost:1')
-    c.onerror{ |e| e.should.eq nil }
+    c.onerror{ |e| e.should.kind_of?(Errno::ECONNREFUSED) }
     c.start.wait
   end
 
   would 'not deadlock with ErrorHandler' do
-    mock_warning
     c = RC::Universal.new(:log_method => false).
                event_source('http://localhost:1')
     c.onerror{ |e| e.should.kind_of?(Errno::ECONNREFUSED) }
@@ -156,7 +148,7 @@ SSE
 
   would 'not deadlock if errors in onmessage' do
     err = nil
-    es, m, t = server.call
+    es, _, _ = server.call
     es.onmessage do |event, data|
       raise err = "error"
     end.start.wait

data/test/test_follow_redirect.rb

@@ -7,6 +7,7 @@ describe RC::FollowRedirect do
     def call env
       yield(env.merge(RC::RESPONSE_STATUS  => status,
                       RC::RESPONSE_HEADERS => {'LOCATION' => 'location'}))
+      env
     end
   end.new
   app = RC::FollowRedirect.new(dry, 1)

data/test/test_httpclient.rb

@@ -39,11 +39,9 @@ describe RC::HttpClient do
     end
 
     would 'not kill the thread if error was coming from the task' do
-      mock(any_instance_of(RC::Promise)).warn(is_a(String)) do |msg|
-        msg.should.include?('boom')
-      end
       mock(HTTPClient).new{ raise 'boom' }.with_any_args
-      c.request(RC::RESPONSE_KEY => RC::FAIL).first.message.should.eq 'boom'
+      c.request(RC::RESPONSE_KEY => RC::FAIL,
+                RC::ASYNC => true).first.message.should.eq 'boom'
       Muack.verify
     end
   end

data/test/test_promise.rb

@@ -45,6 +45,27 @@ describe RC::Promise do
     @promise.send(:headers).should.eq('K' => 'V')
   end
 
+  would 'warn on callback error' do
+    mock(any_instance_of(RC::Promise)).warn(is_a(String)) do |msg|
+      msg.should.eq 'boom'
+    end
+
+    @client.new.get('http://localhost/') do |err|
+      err.should.kind_of?(Errno::ECONNREFUSED)
+      raise 'boom'
+    end.wait
+  end
+
+  would 'call error_callback on errors' do
+    errors = []
+    @client.new(:error_callback => lambda{ |e| errors << e }).
+      get('http://localhost/') do |err|
+        err.should.kind_of?(Errno::ECONNREFUSED)
+        raise 'boom'
+      end.wait
+    errors.map(&:class).should.eq [Errno::ECONNREFUSED, RuntimeError]
+  end
+
   would 'then then then' do
     plusone = lambda do |r|
       r.merge(RC::RESPONSE_BODY => r[RC::RESPONSE_BODY] + 1)
@@ -65,10 +86,13 @@ describe RC::Promise do
   would 'call in a new thread if pool_size == 0' do
     @client.pool_size = 0
     thread = nil
+    rd, wr = IO.pipe
     mock(Thread).new.with_any_args.peek_return do |t|
       thread = t
+      wr.puts
     end
     @promise.defer do
+      rd.gets
       Thread.current.should.eq thread
       @promise.reject(nil)
     end

data/test/test_retry.rb

@@ -0,0 +1,63 @@
+
+require 'rest-core/test'
+
+describe RC::Retry do
+  before do
+    @called = called = []
+    @errors = errors = []
+    engine = Class.new do
+      define_method :call do |env, &block|
+        called << true
+        env[RC::FAIL].should.eq [true]
+        block.call(env.merge(RC::FAIL => [true, errors.shift]))
+        {}
+      end
+    end.new
+    @app = RC::Retry.new(engine, 5)
+  end
+
+  after do
+    @errors.size.should.eq 0
+  end
+
+  def call env={}
+    @app.call({RC::FAIL => [true]}.merge(env)){}
+  end
+
+  def max_retries
+    @app.max_retries({})
+  end
+
+  would 'retry max_retries times' do
+    @errors.replace([IOError.new] * max_retries)
+    call
+    @called.size.should.eq max_retries + 1
+  end
+
+  would 'retry several times' do
+    @errors.replace([IOError.new] * 2)
+    call
+    @called.size.should.eq 3
+  end
+
+  would 'not retry RuntimeError by default' do
+    @errors.replace([RuntimeError.new])
+    call
+    @called.size.should.eq 1
+  end
+
+  would 'retry RuntimeError when setup' do
+    @errors.replace([RuntimeError.new] * max_retries)
+    @app.retry_exceptions = [RuntimeError]
+    call
+    @called.size.should.eq max_retries + 1
+  end
+
+  would 'call error_callback upon retrying' do
+    @errors.replace([IOError.new] * 2)
+    errors = []
+    call(RC::CLIENT => stub.error_callback{errors.method(:<<)}.object)
+    @called.size.should.eq 3
+    errors.size.should.eq 2
+  end
+end

data/test/test_timeout.rb

@@ -11,13 +11,13 @@ describe RC::Timeout do
   end
 
   would 'bypass timeout if timeout is 0' do
-    mock(app).monitor.times(0)
+    mock(app).process.times(0)
     app.call({}){ |e| e.should.eq({}) }
   end
 
-  would 'run the monitor to setup timeout' do
+  would 'run the process to setup timeout' do
     env = {'timeout' => 2}
-    mock(app).monitor(env)
+    mock(app).process(env)
     app.call(env){|e| e[RC::TIMER].should.kind_of?(RC::Timer)}
   end
 
@@ -43,9 +43,9 @@ describe RC::Timeout do
       }
     end
     app.pool_size = 1
-    app.new.request(RC::RESPONSE_KEY => RC::FAIL, RC::TIMER => timer).
+    app.new.request(RC::RESPONSE_KEY => RC::FAIL, RC::TIMER => timer,
+                    RC::ASYNC => true).
       first.message.should.eq 'boom'
-    Muack.verify
   end
 
   would 'interrupt the task if timing out' do
@@ -70,14 +70,10 @@ describe RC::Timeout do
       }
     end
     (-1..1).each do |size|
-      mock(any_instance_of(RC::Promise)).warn(is_a(String)) do |msg|
-        msg.should.include?('boom')
-      end
       app.pool_size = size
       app.new.request(RC::RESPONSE_KEY => RC::FAIL, RC::TIMER => timer,
-                      'pipe' => wr).
+                      RC::ASYNC => true, 'pipe' => wr).
         first.message.should.eq 'boom'
-      Muack.verify
     end
   end
 end

data/test/test_universal.rb

@@ -2,6 +2,12 @@
 require 'rest-core/test'
 
 describe RC::Universal do
+  url = 'http://localhost/'
+
+  after do
+    WebMock.reset!
+  end
+
   would 'send Authorization header' do
     u = RC::Universal.new(:log_method => false)
     u.username = 'Aladdin'
@@ -18,7 +24,6 @@ describe RC::Universal do
   end
 
   would 'clash' do
-    url = 'http://localhost/'
     stub_request(:get, url).to_return(:body => '{"a":{"b":"c"}}')
     res = RC::Universal.new(:json_response => true,
                             :clash_response => true,
@@ -27,12 +32,25 @@ describe RC::Universal do
   end
 
   would 'follow redirect regardless response body' do
-    url = 'http://localhost/'
+    called = []
     stub_request(:get, url).to_return(:body => 'bad json!',
       :status => 302, :headers => {'Location' => "#{url}a"})
-    stub_request(:get, "#{url}a").to_return(:body => '{"good":"json!"}')
-    RC::Universal.new(:json_response => true,
-                      :log_method => false).
-      get(url).should.eq 'good' => 'json!'
+    stub_request(:get, "#{url}a").to_return do
+      Thread.pass
+      {:body => '{"good":"json!"}'}
+    end
+    RC::Universal.new(:json_response => true, :log_method => false).
+      get(url, &called.method(:<<)).wait
+    called.should.eq([{'good' => 'json!'}])
+  end
+
+  would 'retry and call error_callback' do
+    errors = []
+    called = []
+    RC::Universal.new(:error_callback => errors.method(:<<),
+                      :max_retries => 1, :log_method => false).
+      get(url, &called.method(:<<)).wait
+    errors.map(&:class).should.eq [Errno::ECONNREFUSED]*2
+    called.map(&:class).should.eq [Errno::ECONNREFUSED]
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rest-core
 version: !ruby/object:Gem::Version
-  version: 3.4.1
+  version: 3.5.0
 platform: ruby
 authors:
 - Lin Jen-Shin (godfat)
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-11-29 00:00:00.000000000 Z
+date: 2014-12-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: httpclient
@@ -114,6 +114,7 @@ files:
 - lib/rest-core/middleware/oauth2_header.rb
 - lib/rest-core/middleware/oauth2_query.rb
 - lib/rest-core/middleware/query_response.rb
+- lib/rest-core/middleware/retry.rb
 - lib/rest-core/middleware/smash_response.rb
 - lib/rest-core/middleware/timeout.rb
 - lib/rest-core/promise.rb
@@ -160,6 +161,7 @@ files:
 - test/test_payload.rb
 - test/test_promise.rb
 - test/test_query_response.rb
+- test/test_retry.rb
 - test/test_simple.rb
 - test/test_smash.rb
 - test/test_smash_response.rb
@@ -186,7 +188,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.4
+rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
 summary: Modular Ruby clients interface for REST APIs.
@@ -218,6 +220,7 @@ test_files:
 - test/test_payload.rb
 - test/test_promise.rb
 - test/test_query_response.rb
+- test/test_retry.rb
 - test/test_simple.rb
 - test/test_smash.rb
 - test/test_smash_response.rb