rest-core 1.0.3 → 2.0.0

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

@@ -7,7 +7,7 @@ class RestCore::Bypass
     @app = app
   end
 
-  def call env
-    @app.call(env)
+  def call env, &k
+    @app.call(env, &k)
   end
 end

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

@@ -15,86 +15,99 @@ class RestCore::Cache
     @app, @cache, @expires_in = app, cache, expires_in
   end
 
-  def call env
-    e = if env['cache.update'] && env[REQUEST_METHOD] == :get
-          cache_assign(env, nil)
+  def call env, &k
+    e = if env['cache.update']
+          cache_clear(env)
         else
           env
         end
 
     if cached = cache_get(e)
-      env[TIMER].cancel if env[TIMER] && !env[TIMER].canceled?
-      wrapped.call(cached)
+      e[TIMER].cancel if e[TIMER]
+      wrapped.call(cached, &k)
     else
-      if e[ASYNC]
-        app.call(e.merge(ASYNC => lambda{ |response|
-          process(e, response)
-        }))
-      else
-        process(e, app.call(e))
-      end
+      app.call(e){ |res|
+        wrapped.call(res){ |res_wrapped|
+          k.call(if (res_wrapped[FAIL] || []).empty?
+                   cache_for(res).merge(res_wrapped)
+                 else
+                   res_wrapped
+                 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))
+    "rest-core:cache:#{Digest::MD5.hexdigest(env['cache.key'] ||
+                                             cache_key_raw(env))}"
   end
 
   def cache_get env
     return unless cache(env)
+    return unless cache_for?(env)
+
     start_time = Time.now
-    return unless value = cache(env)[cache_key(env)]
+    return unless data = cache(env)[cache_key(env)]
     log(env, Event::CacheHit.new(Time.now - start_time, request_uri(env))).
-      merge(RESPONSE_BODY => value)
+      merge(data_extract(data))
+  end
+
+  private
+  def cache_key_raw env
+    "#{env[REQUEST_METHOD]}:#{request_uri(env)}:#{header_cache_key(env)}"
+  end
+
+  def cache_clear env
+    return env unless cache(env)
+    return env unless cache_for?(env)
+
+    cache_store(env, :[]=, nil)
   end
 
-  def cache_for env, response
-    return response unless cache(env)
-    # fake post (env['cache.post'] => true) is considered get and need cache
-    return response if env[REQUEST_METHOD] != :get unless env['cache.post']
+  def cache_for res
+    return res unless cache(res)
+    return res unless cache_for?(res)
 
-    value = response[RESPONSE_BODY]
+    if expires_in(res).kind_of?(Fixnum) &&
+       cache(res).respond_to?(:store)   &&
+       cache(res).method(:store).arity == -3
 
-    if expires_in(env).kind_of?(Fixnum) &&
-       cache(env).respond_to?(:store)   &&
-       cache(env).method(:store).arity == -3
-      cache(env).store(cache_key(env), value,
-                       :expires_in => expires_in(env))
-      response
+      cache_store(res, :store, data_construct(res),
+                                 :expires_in => expires_in(res))
     else
-      cache_assign(response, value)
+      cache_store(res, :[]=  , data_construct(res))
     end
   end
 
-  def cache_assign env, value
-    return env unless cache(env)
-
+  def cache_store res, msg, value, *args
     start_time = Time.now
-    cache(env)[cache_key(env)] = value
-    if value.nil?
-      log(env,
-        Event::CacheCleared.new(Time.now - start_time, request_uri(env)))
+    cache(res).send(msg, cache_key(res), value, *args)
+
+    if value
+      res
     else
-      env
+      log(res,
+        Event::CacheCleared.new(Time.now - start_time, request_uri(res)))
     end
   end
+
+  def data_construct res
+    "#{ res[RESPONSE_STATUS]}\n" \
+    "#{(res[RESPONSE_HEADERS]||{}).map{|k,v|"#{k}: #{v}"}.join("\n")}\n\n" \
+    "#{ res[RESPONSE_BODY]}"
+  end
+
+  def data_extract data
+    _, status, headers, body = data.match(/\A(\d+)\n(.*)\n\n(.*)\Z/m).to_a
+    {RESPONSE_BODY    => body,
+     RESPONSE_HEADERS => Hash[(headers||'').scan(/([^:]+): ([^\n]+)\n?/)],
+     RESPONSE_STATUS  => status.to_i}
+  end
+
+  def cache_for? env
+    [:get, :head, :otpions].include?(env[REQUEST_METHOD])
+  end
+
+  def header_cache_key env
+    (env[REQUEST_HEADERS]||{}).sort.map{|(k,v)|"#{k}=#{v}"}.join('&')
+  end
 end

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

@@ -9,13 +9,9 @@ class RestCore::CommonLogger
   def call env
     start_time = Time.now
     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
+    app.call(flushed){ |response|
+      yield(process(response, start_time))
+    }
   rescue
     process(flushed, start_time)
     raise
@@ -33,6 +29,7 @@ class RestCore::CommonLogger
   end
 
   def log_request start_time, response
-    Event::Requested.new(Time.now - start_time, request_uri(response))
+    Event::Requested.new(Time.now - start_time,
+      "#{response[RC::REQUEST_METHOD].to_s.upcase} #{request_uri(response)}")
   end
 end

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

@@ -4,8 +4,8 @@ require 'rest-core/middleware'
 class RestCore::DefaultHeaders
   def self.members; [:headers]; end
   include RestCore::Middleware
-  def call env
+  def call env, &k
     app.call(env.merge(REQUEST_HEADERS =>
-      @headers.merge(headers(env)).merge(env[REQUEST_HEADERS] || {})))
+      @headers.merge(headers(env)).merge(env[REQUEST_HEADERS] || {})), &k)
   end
 end

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

@@ -4,8 +4,32 @@ require 'rest-core/middleware'
 class RestCore::DefaultPayload
   def self.members; [:payload]; end
   include RestCore::Middleware
-  def call env
+
+  def initialize *args
+    super
+    @payload ||= {}
+  end
+
+  def call env, &k
+    defaults = merge(@payload, payload(env))
+
     app.call(env.merge(REQUEST_PAYLOAD =>
-      @payload.merge(payload(env)).merge(env[REQUEST_PAYLOAD] || {})))
+      merge(defaults, env[REQUEST_PAYLOAD] || {})), &k)
+  end
+
+  # this method is intended to merge payloads if they are non-empty hashes,
+  # but prefer the right most one if they are not hashes.
+  def merge lhs, rhs
+    if rhs.respond_to?(:empty?) && rhs.empty?
+      lhs
+    elsif lhs.respond_to?(:merge)
+      if rhs.respond_to?(:merge)
+        string_keys(lhs).merge(string_keys(rhs))
+      else
+        rhs
+      end
+    else
+      rhs
+    end
   end
 end

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

@@ -10,8 +10,10 @@ class RestCore::DefaultQuery
     @query ||= {}
   end
 
-  def call env
+  def call env, &k
+    defaults = string_keys(@query).merge(string_keys(query(env)))
+
     app.call(env.merge(REQUEST_QUERY =>
-      @query.merge(query(env)).merge(env[REQUEST_QUERY] || {})))
+      defaults.merge(env[REQUEST_QUERY] || {})), &k)
   end
 end

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

@@ -5,11 +5,13 @@ class RestCore::DefaultSite
   def self.members; [:site]; end
   include RestCore::Middleware
 
-  def call env
-    if env[REQUEST_PATH].to_s.start_with?('http')
-      app.call(env)
-    else
-      app.call(env.merge(REQUEST_PATH => "#{site(env)}#{env[REQUEST_PATH]}"))
-    end
+  def call env, &k
+    path = if env[REQUEST_PATH].to_s.start_with?('http')
+             env[REQUEST_PATH]
+           else
+             "#{site(env)}#{env[REQUEST_PATH]}"
+           end
+
+    app.call(env.merge(REQUEST_PATH => path), &k)
   end
 end

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

@@ -6,21 +6,14 @@ class RestCore::ErrorDetector
   include RestCore::Middleware
 
   def 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)
-    else
-      response
-    end
+    app.call(env){ |response|
+      detector = error_detector(env)
+      yield(
+        if error = (detector && detector.call(response))
+          fail(response, error)
+        else
+          response
+        end)
+    }
   end
 end

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

@@ -6,20 +6,34 @@ class RestCore::ErrorHandler
   include RestCore::Middleware
 
   def call env
-    if env[ASYNC]
-      app.call(handle(env).merge(ASYNC => lambda{ |response|
-        env[ASYNC].call(handle(response))
-      }))
-    else
-      handle(app.call(handle(env)))
-    end
+    app.call(env){ |res|
+      yield(if (res[FAIL] || []).empty? # no errors at all
+              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
+            end)}
   end
 
-  def handle env
-    if error_handler(env) && !(env[FAIL] || []).empty?
-      error_handler(env).call(env)
+  def process res, err
+    if res[ASYNC]
+      res.merge(RESPONSE_BODY => err)
     else
-      env
+      raise err
     end
   end
 end

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

@@ -5,26 +5,23 @@ class RestCore::FollowRedirect
   def self.members; [:max_redirects]; end
   include RestCore::Middleware
 
-  def call env
+  def call env, &k
     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))
-      }))
+    if e[DRY]
+      app.call(e, &k)
     else
-      process(app.call(e))
+      app.call(e){ |res| process(res, k) }
     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])
+  def process res, k
+    return k.call(res) if res['follow_redirect.max_redirects'] <= 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])
 
     location = [res[RESPONSE_HEADERS]['LOCATION']].flatten.first
     meth     = if res[RESPONSE_STATUS] == 303
@@ -35,8 +32,8 @@ class RestCore::FollowRedirect
 
     call(res.merge(REQUEST_PATH    => location,
                    REQUEST_METHOD  => meth    ,
-                   REQUEST_PAYLOAD => nil     ,
+                   REQUEST_PAYLOAD => {}      ,
                    'follow_redirect.max_redirects' =>
-                     res['follow_redirect.max_redirects'] - 1))
+                     res['follow_redirect.max_redirects'] - 1), &k)
   end
 end

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

@@ -0,0 +1,19 @@
+
+require 'rest-core/middleware'
+require 'rest-core/util/json'
+
+class RestCore::JsonRequest
+  def self.members; [:json_request]; end
+  include RestCore::Middleware
+
+  JSON_REQUEST_HEADER = {'Content-Type' => 'application/json'}.freeze
+
+  def call env, &k
+    return app.call(env, &k) unless json_request(env)
+    return app.call(env, &k) unless env[REQUEST_PAYLOAD]
+
+    app.call(env.merge(
+      REQUEST_HEADERS => JSON_REQUEST_HEADER.merge(env[REQUEST_HEADERS]||{}),
+      REQUEST_PAYLOAD => Json.encode(env[REQUEST_PAYLOAD])              ), &k)
+  end
+end

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

@@ -0,0 +1,28 @@
+
+require 'rest-core/middleware'
+require 'rest-core/util/json'
+
+class RestCore::JsonResponse
+  def self.members; [:json_response]; end
+  include RestCore::Middleware
+
+  JSON_RESPONSE_HEADER = {'Accept' => 'application/json'}.freeze
+
+  def call env, &k
+    return app.call(env, &k) if env[DRY]
+    return app.call(env, &k) unless json_response(env)
+
+    app.call(env.merge(REQUEST_HEADERS =>
+      JSON_RESPONSE_HEADER.merge(env[REQUEST_HEADERS]||{}))){ |response|
+        yield(process(response))
+      }
+  end
+
+  def process response
+    response.merge(RESPONSE_BODY =>
+      Json.decode("[#{response[RESPONSE_BODY]}]").first)
+      # [this].first is not needed for yajl-ruby
+  rescue Json.const_get(:ParseError) => error
+    fail(response, error)
+  end
+end

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

@@ -15,7 +15,7 @@ class RestCore::Oauth1Header
      :oauth_token, :oauth_token_secret, :data]
   end
   include RestCore::Middleware
-  def call env
+  def call env, &k
     start_time = Time.now
     headers = {'Authorization' => oauth_header(env)}.
                 merge(env[REQUEST_HEADERS] || {})
@@ -23,12 +23,7 @@ class RestCore::Oauth1Header
     event = Event::WithHeader.new(Time.now - start_time,
               "Authorization: #{headers['Authorization']}")
 
-    app.call(log(cache_key(env.merge(REQUEST_HEADERS => headers)), event))
-  end
-
-  def cache_key env
-    env.merge('cache.key' =>
-      "#{request_uri(env)}&#{oauth_token(env)}&#{oauth_token_secret(env)}")
+    app.call(log(env.merge(REQUEST_HEADERS => headers), event), &k)
   end
 
   def oauth_header env