rest-core 0.8.2 → 1.0.0

data/lib/rest-core/app/auto.rb

@@ -0,0 +1,22 @@
+
+require 'rest-core/middleware'
+
+class RestCore::Auto
+  include RestCore::Middleware
+  def call env
+    client = http_client
+    client.call(log(env, "Auto picked: #{client.class}"))
+  end
+
+  def http_client
+    if Object.const_defined?(:Coolio) && ::Coolio::Loop.default.
+                                           has_active_watchers?
+      @coolio        ||= RestCore::Coolio.new
+    elsif Object.const_defined?(:EventMachine) && ::EventMachine.
+                                                    reactor_running?
+      @emhttprequest ||= RestCore::EmHttpRequest.new
+    else
+      @restclient    ||= RestCore::RestClient.new
+    end
+  end
+end

data/lib/rest-core/app/coolio-async.rb

@@ -0,0 +1,32 @@
+
+require 'rest-core/middleware'
+
+require 'cool.io-http'
+
+class RestCore::CoolioAsync
+  include RestCore::Middleware
+  def call env
+    client = ::Coolio::Http.request(:method  => env[REQUEST_METHOD] ,
+                                    :url     => request_uri(env)    ,
+                                    :payload => env[REQUEST_PAYLOAD],
+                                    :headers => env[REQUEST_HEADERS]){ |res|
+
+      env[TIMER].detach if env[TIMER]
+      env[ASYNC].call(env.merge(RESPONSE_BODY    => res.body  ,
+                                RESPONSE_STATUS  => res.status,
+                                RESPONSE_HEADERS => res.headers)) if
+        env[ASYNC]
+    }
+
+    env[TIMER].on_timer{
+      detach
+      client.detach
+      env[ASYNC].call(env.merge(RESPONSE_BODY    => env[TIMER].error,
+                                RESPONSE_STATUS  => 0               ,
+                                RESPONSE_HEADERS => {}             )) if
+         env[ASYNC]
+    } if env[TIMER]
+
+    env
+  end
+end

data/lib/rest-core/app/coolio-fiber.rb

@@ -0,0 +1,30 @@
+
+require 'rest-core/middleware'
+
+require 'cool.io-http'
+
+class RestCore::CoolioFiber
+  include RestCore::Middleware
+  def call env
+    process(env,
+            ::Coolio::HttpFiber.request(:method  => env[REQUEST_METHOD] ,
+                                        :url     => request_uri(env)    ,
+                                        :payload => env[REQUEST_PAYLOAD],
+                                        :headers => env[REQUEST_HEADERS]))
+  end
+
+  def process env, response
+    env[TIMER].detach if env[TIMER]
+    Thread.current[:coolio_http_client].detach if
+      Thread.current[:coolio_http_client].kind_of?(::Coolio::HttpFiber)
+
+    raise response if response.kind_of?(::Exception)
+
+    result = env.merge(RESPONSE_BODY    => response.body  ,
+                       RESPONSE_STATUS  => response.status,
+                       RESPONSE_HEADERS => response.headers)
+
+    result[ASYNC].call(result) if result[ASYNC]
+    result
+  end
+end

data/lib/rest-core/app/coolio.rb

@@ -0,0 +1,9 @@
+
+require 'rest-core/app/abstract/async_fiber'
+require 'rest-core/app/coolio-async'
+require 'rest-core/app/coolio-fiber'
+
+class RestCore::Coolio < RestCore::AsyncFiber
+  def async; @async ||= CoolioAsync.new; end
+  def fiber; @fiber ||= CoolioFiber.new; end
+end

data/lib/rest-core/app/dry.rb

@@ -4,6 +4,7 @@ require 'rest-core/middleware'
 class RestCore::Dry
   include RestCore::Middleware
   def call env
+    env[ASYNC].call(env) if env[ASYNC]
     env
   end
 end

data/lib/rest-core/app/em-http-request-async.rb

@@ -0,0 +1,34 @@
+
+require 'rest-core/middleware'
+
+require 'rest-client'
+require 'em-http-request'
+
+class RestCore::EmHttpRequestAsync
+  include RestCore::Middleware
+  def call env
+    payload = ::RestClient::Payload.generate(env[REQUEST_PAYLOAD])
+    client  = ::EventMachine::HttpRequest.new(request_uri(env)).send(
+                 env[REQUEST_METHOD],
+                 :body => payload.read,
+                 :head => payload.headers.merge(env[REQUEST_HEADERS]))
+
+    client.callback{
+      env[TIMER].cancel if env[TIMER]
+      env[ASYNC].call(env.merge(
+        RESPONSE_BODY    => client.response,
+        RESPONSE_STATUS  => client.response_header.status,
+        RESPONSE_HEADERS => client.response_header)) if env[ASYNC]
+    }
+
+    env[TIMER].on_timeout{
+      client.close
+      env[ASYNC].call(env.merge(RESPONSE_BODY    => env[TIMER].error,
+                                RESPONSE_STATUS  => 0               ,
+                                RESPONSE_HEADERS => {}             )) if
+         env[ASYNC]
+    } if env[TIMER]
+
+    env
+  end
+end

data/lib/rest-core/app/em-http-request-fiber.rb

@@ -0,0 +1,39 @@
+
+require 'rest-core/middleware'
+
+require 'rest-client'
+require 'em-http-request'
+require 'fiber'
+
+class RestCore::EmHttpRequestFiber
+  include RestCore::Middleware
+  def call env
+    f = Fiber.current
+
+    payload = ::RestClient::Payload.generate(env[REQUEST_PAYLOAD])
+    client  = ::EventMachine::HttpRequest.new(request_uri(env)).send(
+                 env[REQUEST_METHOD],
+                 :body => payload.read,
+                 :head => payload.headers.merge(env[REQUEST_HEADERS]))
+
+    client.callback{
+      env[TIMER].cancel if env[TIMER]
+      f.resume(process(env, client)) if f.alive?
+    }
+
+    if (response = Fiber.yield).kind_of?(::Exception)
+      client.close
+      raise response
+    else
+      response
+    end
+  end
+
+  def process env, client
+    result = env.merge(RESPONSE_BODY    => client.response,
+                       RESPONSE_STATUS  => client.response_header.status,
+                       RESPONSE_HEADERS => client.response_header)
+    result[ASYNC].call(result) if result[ASYNC]
+    result
+  end
+end

data/lib/rest-core/app/em-http-request.rb

@@ -0,0 +1,9 @@
+
+require 'rest-core/app/abstract/async_fiber'
+require 'rest-core/app/em-http-request-async'
+require 'rest-core/app/em-http-request-fiber'
+
+class RestCore::EmHttpRequest < RestCore::AsyncFiber
+  def async; @async ||= EmHttpRequestAsync.new; end
+  def fiber; @fiber ||= EmHttpRequestFiber.new; end
+end

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

@@ -3,22 +3,39 @@ require 'rest-core/middleware'
 
 require 'restclient'
 
+require 'rest-core/patch/rest-client'
+
 class RestCore::RestClient
   include RestCore::Middleware
   def call env
-    respond(env,
+    process(env,
             ::RestClient::Request.execute(:method  => env[REQUEST_METHOD ],
                                           :url     => request_uri(env)    ,
                                           :payload => env[REQUEST_PAYLOAD],
-                                          :headers => env[REQUEST_HEADERS]))
+                                          :headers => env[REQUEST_HEADERS],
+                                          :max_redirects => 0))
 
   rescue ::RestClient::Exception => e
-    respond(env, e.response)
+    process(env, e.response)
+  end
+
+  def process env, response
+    result = env.merge(RESPONSE_BODY    => response.body,
+                       RESPONSE_STATUS  => response.code,
+                       RESPONSE_HEADERS => normalize_headers(
+                                             response.raw_headers))
+    result[ASYNC].call(result) if result[ASYNC]
+    result
   end
 
-  def respond env, response
-    env.merge(RESPONSE_BODY    => response.body,
-              RESPONSE_STATUS  => response.code,
-              RESPONSE_HEADERS => response.raw_headers)
+  def normalize_headers raw_headers
+    raw_headers.inject({}){ |r, (k, v)|
+      r[k.to_s.upcase.tr('-', '_')] = if v.kind_of?(Array) && v.size == 1
+                                        v.first
+                                      else
+                                        v
+                                      end
+      r
+    }
   end
 end

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

@@ -1,19 +1,18 @@
 
-RestCore::Universal = RestCore::Builder.client(:data) do
+RestCore::Universal = RestCore::Builder.client do
   s = self.class # this is only for ruby 1.8!
   use s::Timeout       , 0
 
   use s::DefaultSite   , nil
   use s::DefaultHeaders, {}
   use s::DefaultQuery  , {}
+  use s::AuthBasic     , nil, nil
 
+  use s::FollowRedirect, 10
   use s::CommonLogger  , method(:puts)
-  use s::AuthBasic     , nil, nil
   use s::Cache         ,  {}, 600 do
     use s::ErrorHandler, nil
     use s::ErrorDetectorHttp
     use s::JsonDecode  , false
   end
-
-  use s::Defaults      , :data => lambda{{}}
 end

data/lib/rest-core/client.rb

@@ -60,8 +60,8 @@ module RestCore::Client
   end
 
   def inspect
-    "#<struct #{self.class.name} #{attributes.map{ |k, v|
-      "#{k}=#{v.inspect}" }.join(', ')}>"
+    fields = attributes.map{ |k, v| "#{k}=#{v.inspect}" }.join(', ')
+    "#<struct #{self.class.name}#{if fields.empty? then '' else fields end}>"
   end
 
   def lighten! o={}
@@ -118,6 +118,20 @@ module RestCore::Client
        REQUEST_QUERY   => query  }.merge(opts), &cb)
   end
 
+  def head path, query={}, opts={}, &cb
+    request(
+      {REQUEST_METHOD  => :head  ,
+       REQUEST_PATH    => path   ,
+       REQUEST_QUERY   => query  }.merge(opts), &cb)
+  end
+
+  def options path, query={}, opts={}, &cb
+    request(
+      {REQUEST_METHOD  => :options,
+       REQUEST_PATH    => path   ,
+       REQUEST_QUERY   => query  }.merge(opts), &cb)
+  end
+
   def post   path, payload={}, query={}, opts={}, &cb
     request(
       {REQUEST_METHOD  => :post  ,
@@ -134,6 +148,14 @@ module RestCore::Client
        REQUEST_PAYLOAD => payload}.merge(opts), &cb)
   end
 
+  def patch  path, payload={}, query={}, opts={}, &cb
+    request(
+      {REQUEST_METHOD  => :patch ,
+       REQUEST_PATH    => path   ,
+       REQUEST_QUERY   => query  ,
+       REQUEST_PAYLOAD => payload}.merge(opts), &cb)
+  end
+
   def request env, app=app
     if block_given?
       request_full(env, app){ |response|
@@ -152,10 +174,15 @@ module RestCore::Client
        REQUEST_PAYLOAD => {}  ,
        REQUEST_HEADERS => {}  ,
        FAIL            => []  ,
-       LOG             => []  }.merge(env)))
+       LOG             => []  ,
+       ASYNC           => if block_given?
+                            lambda{ |response| yield(response) }
+                          else
+                            nil
+                          end}.merge(env)))
 
     if block_given?
-      yield(response)
+      self
     else
       response
     end

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

@@ -25,16 +25,34 @@ class RestCore::Cache
     if cached = cache_get(e)
       wrapped.call(cached)
     else
-      response         = app.call(e)
-      response_wrapped = wrapped.call(response)
-      if (response_wrapped[FAIL] || []).empty?
-        cache_for(e, response).merge(response_wrapped)
+      if e[ASYNC]
+        app.call(e.merge(ASYNC => lambda{ |response|
+          process(e, response)
+        }))
       else
-        response_wrapped
+        process(e, app.call(e))
       end
     end
   end
 
+  def process env, response
+    if env[ASYNC]
+      wrapped.call(response.merge(ASYNC => lambda{ |response_wrapped|
+        env[ASYNC].call(process_wrapped(env, response, response_wrapped))
+      }))
+    else
+      process_wrapped(env, response, wrapped.call(response))
+    end
+  end
+
+  def process_wrapped env, response, response_wrapped
+    if (response_wrapped[FAIL] || []).empty?
+      cache_for(env, response).merge(response_wrapped)
+    else
+      response_wrapped
+    end
+  end
+
   protected
   def cache_key env
     Digest::MD5.hexdigest(env['cache.key'] || request_uri(env))

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

@@ -8,13 +8,23 @@ class RestCore::CommonLogger
 
   def call env
     start_time = Time.now
-    response = app.call(flushed = flush(env))
-    flush(log(response, log_request(start_time, response)))
+    flushed = flush(env)
+    if env[ASYNC]
+      app.call(flushed.merge(ASYNC => lambda{ |response|
+        env[ASYNC].call(process(response, start_time))
+      }))
+    else
+      process(app.call(flushed), start_time)
+    end
   rescue
-    flush(log(flushed, log_request(start_time, flushed)))
+    process(flushed, start_time)
     raise
   end
 
+  def process response, start_time
+    flush(log(response, log_request(start_time, response)))
+  end
+
   def flush env
     return env if !log_method(env) || env[DRY]
     (env[LOG] || []).compact.

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

@@ -6,7 +6,16 @@ class RestCore::ErrorDetector
   include RestCore::Middleware
 
   def call env
-    response = app.call(env)
+    if env[ASYNC]
+      app.call(env.merge(ASYNC => lambda{ |response|
+        env[ASYNC].call(process(env, response))
+      }))
+    else
+      process(env, app.call(env))
+    end
+  end
+
+  def process env, response
     detector = error_detector(env)
     if error = (detector && detector.call(response))
       fail(response, error)

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

@@ -6,7 +6,13 @@ class RestCore::ErrorHandler
   include RestCore::Middleware
 
   def call env
-    handle(app.call(handle(env)))
+    if env[ASYNC]
+      app.call(handle(env).merge(ASYNC => lambda{ |response|
+        env[ASYNC].call(handle(response))
+      }))
+    else
+      handle(app.call(handle(env)))
+    end
   end
 
   def handle env

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

@@ -0,0 +1,42 @@
+
+require 'rest-core/middleware'
+
+class RestCore::FollowRedirect
+  def self.members; [:max_redirects]; end
+  include RestCore::Middleware
+
+  def call env
+    e = env.merge('follow_redirect.max_redirects' =>
+                    env['follow_redirect.max_redirects'] ||
+                    max_redirects(env))
+
+    return app.call(e) if e[DRY]
+    if e[ASYNC]
+      app.call(e.merge(ASYNC => lambda{ |response|
+        e[ASYNC].call(process(response))
+      }))
+    else
+      process(app.call(e))
+    end
+  end
+
+  def process res
+    return res if res['follow_redirect.max_redirects'] <= 0
+    return res if ![301,302,303,307].include?(res[RESPONSE_STATUS])
+    return res if  [301,302    ,307].include?(res[RESPONSE_STATUS]) &&
+                  ![:get, :head    ].include?(res[REQUEST_METHOD])
+
+    location = [res[RESPONSE_HEADERS]['LOCATION']].flatten.first
+    meth     = if res[RESPONSE_STATUS] == 303
+                 :get
+               else
+                 res[REQUEST_METHOD]
+               end
+
+    call(res.merge(REQUEST_PATH    => location,
+                   REQUEST_METHOD  => meth    ,
+                   REQUEST_PAYLOAD => nil     ,
+                   'follow_redirect.max_redirects' =>
+                     res['follow_redirect.max_redirects'] - 1))
+  end
+end

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

@@ -7,8 +7,17 @@ class RestCore::JsonDecode
 
   def call env
     return app.call(env) if env[DRY]
-    response = app.call(env)
-    if json_decode(env)
+    if env[ASYNC]
+      app.call(env.merge(ASYNC => lambda{ |response|
+        env[ASYNC].call(process(response))
+      }))
+    else
+      process(app.call(env))
+    end
+  end
+
+  def process response
+    if json_decode(response)
       response.merge(RESPONSE_BODY =>
         self.class.json_decode("[#{response[RESPONSE_BODY]}]").first)
         # [this].first is not needed for yajl-ruby

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

@@ -0,0 +1,4 @@
+
+class RestCore::Timeout::CoolioTimer < ::Coolio::TimerWatcher
+  attr_accessor :error
+end

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

@@ -0,0 +1,14 @@
+
+class RestCore::Timeout::EventMachineTimer < ::EventMachine::Timer
+  attr_accessor :timeout, :error
+
+  def initialize timeout, error, &block
+    super(timeout, &block) if block_given?
+    self.timeout = timeout
+    self.error   = error
+  end
+
+  def on_timeout &block
+    send(:initialize, timeout, error, &block)
+  end
+end

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

@@ -8,6 +8,78 @@ class RestCore::Timeout
   include RestCore::Middleware
 
   def call env
-    ::Timeout.timeout(timeout(env)){ app.call(env) }
+    return app.call(env) if env[DRY]
+    monitor(env){ |e| app.call(e) }
   end
+
+  def monitor env
+    class_name = case name = run.class.to_s
+                 when /Auto/
+                   run.http_client.class.to_s
+                 else
+                   name
+                 end
+
+    case class_name
+    when /Coolio|EmHttpRequest/
+      if root_fiber? && env[ASYNC]
+        yield(env.merge(TIMER => timeout_with_callback(env, class_name)))
+      else
+        yield(env.merge(TIMER => timeout_with_resume(  env, class_name)))
+      end
+    else
+      ::Timeout.timeout(timeout(env)){ yield(env) }
+    end
+  end
+
+  def root_fiber?
+    if RestCore.const_defined?(:RootFiber)
+      RootFiber == Fiber.current
+    else
+      true
+    end
+  end
+
+  def timeout_with_callback env, class_name
+    case class_name
+    when /Coolio/
+      timer = CoolioTimer.new(timeout(env))
+      timer.error = timeout_error
+      timer.attach(::Coolio::Loop.default)
+      timer
+    when /EmHttpRequest/
+      EventMachineTimer.new(timeout(env), timeout_error)
+    else
+      raise "BUG: #{run} is not supported"
+    end
+  end
+
+  def timeout_with_resume env, class_name
+    case class_name
+    when /Coolio/
+      f = Fiber.current
+      timer = CoolioTimer.new(timeout(env))
+      error = timer.error = timeout_error
+      timer.on_timer{ f.resume(error) if f.alive? }
+      timer.attach(::Coolio::Loop.default)
+      timer
+
+    when /EmHttpRequest/
+      f = Fiber.current
+      EventMachineTimer.new(timeout(env), error = timeout_error){
+        f.resume(error) if f.alive?
+      }
+    else
+      raise "BUG: #{run} is not supported"
+    end
+  end
+
+  def timeout_error
+    ::Timeout::Error.new('execution expired')
+  end
+
+  autoload       :CoolioTimer,
+    'rest-core/middleware/timeout/coolio_timer'
+  autoload :EventMachineTimer,
+    'rest-core/middleware/timeout/eventmachine_timer'
 end

data/lib/rest-core/middleware.rb

@@ -37,6 +37,13 @@ module RestCore::Middleware
   def call env     ; app.call(env)                               ; end
   def fail env, obj; env.merge(FAIL => (env[FAIL] || []) + [obj]); end
   def log  env, obj; env.merge(LOG  => (env[LOG]  || []) + [obj]); end
+  def run app=app
+    if app.respond_to?(:app) && app.app
+      run(app.app)
+    else
+      app
+    end
+  end
 
   module_function
   def request_uri env

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

@@ -0,0 +1,35 @@
+
+module RestClient
+  module AbstractResponse
+    # begin patch
+    # https://github.com/archiloque/rest-client/pull/103
+    remove_method :to_i if method_defined?(:to_i)
+    # end patch
+
+    # Follow a redirection
+    def follow_redirection request = nil, result = nil, & block
+      url = headers[:location]
+      if url !~ /^http/
+        url = URI.parse(args[:url]).merge(url).to_s
+      end
+      args[:url] = url
+      if request
+        if request.max_redirects == 0
+          # begin patch
+          # https://github.com/archiloque/rest-client/pull/118
+          raise MaxRedirectsReached.new(self, code)
+          # end patch
+        end
+        args[:password] = request.password
+        args[:user] = request.user
+        args[:headers] = request.headers
+        args[:max_redirects] = request.max_redirects - 1
+        # pass any cookie set in the result
+        if result && result['set-cookie']
+          args[:headers][:cookies] = (args[:headers][:cookies] || {}).merge(parse_cookie(result['set-cookie']))
+        end
+      end
+      Request.execute args, &block
+    end
+  end
+end

data/lib/rest-core/version.rb

@@ -1,4 +1,4 @@
 
 module RestCore
-  VERSION = '0.8.2'
+  VERSION = '1.0.0'
 end