rest-core 3.6.0 → 4.0.0

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

@@ -1,39 +1,40 @@
 
-require 'rest-core/middleware'
 require 'rest-core/util/json'
 
-class RestCore::JsonResponse
-  def self.members; [:json_response]; end
-  include RestCore::Middleware
+module RestCore
+  class JsonResponse
+    def self.members; [:json_response]; end
+    include Middleware
 
-  class ParseError < Json.const_get(:ParseError)
-    attr_reader :cause, :body
-    def initialize cause, body
-      msg = cause.message.force_encoding('utf-8')
-      super("#{msg}\nOriginal text: #{body}")
-      @cause, @body = cause, body
+    class ParseError < Json.const_get(:ParseError)
+      attr_reader :cause, :body
+      def initialize cause, body
+        msg = cause.message.force_encoding('utf-8')
+        super("#{msg}\nOriginal text: #{body}")
+        @cause, @body = cause, body
+      end
     end
-  end
 
-  JSON_RESPONSE_HEADER = {'Accept' => 'application/json'}.freeze
+    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)
+    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
+      app.call(env.merge(REQUEST_HEADERS =>
+        JSON_RESPONSE_HEADER.merge(env[REQUEST_HEADERS]||{}))){ |response|
+          yield(process(response))
+        }
+    end
 
-  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/, '')
-    response.merge(RESPONSE_BODY => Json.decode("[#{body}]").first)
-    # [this].first is not needed for yajl-ruby
-  rescue Json.const_get(:ParseError) => error
-    fail(response, ParseError.new(error, body))
+    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/, '')
+      response.merge(RESPONSE_BODY => Json.decode("[#{body}]").first)
+      # [this].first is not needed for yajl-ruby
+    rescue Json.const_get(:ParseError) => error
+      fail(response, ParseError.new(error, body))
+    end
   end
 end

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

@@ -1,100 +1,101 @@
 
-require 'rest-core/middleware'
+require 'openssl'
+require 'rest-core/event'
 require 'rest-core/util/hmac'
 
-require 'uri'
-require 'openssl'
+module RestCore
+  # http://tools.ietf.org/html/rfc5849
+  class Oauth1Header
+    def self.members
+      [:request_token_path, :access_token_path, :authorize_path,
+       :consumer_key, :consumer_secret,
+       :oauth_callback, :oauth_verifier,
+       :oauth_token, :oauth_token_secret, :data]
+    end
+    include Middleware
 
-# http://tools.ietf.org/html/rfc5849
-class RestCore::Oauth1Header
-  def self.members
-    [:request_token_path, :access_token_path, :authorize_path,
-     :consumer_key, :consumer_secret,
-     :oauth_callback, :oauth_verifier,
-     :oauth_token, :oauth_token_secret, :data]
-  end
-  include RestCore::Middleware
-  def call env, &k
-    start_time = Time.now
-    headers = {'Authorization' => oauth_header(env)}.
-                merge(env[REQUEST_HEADERS])
+    def call env, &k
+      start_time = Time.now
+      headers = {'Authorization' => oauth_header(env)}.
+                  merge(env[REQUEST_HEADERS])
 
-    event = Event::WithHeader.new(Time.now - start_time,
-              "Authorization: #{headers['Authorization']}")
+      event = Event::WithHeader.new(Time.now - start_time,
+                "Authorization: #{headers['Authorization']}")
 
-    app.call(log(env.merge(REQUEST_HEADERS => headers), event), &k)
-  end
+      app.call(log(env.merge(REQUEST_HEADERS => headers), event), &k)
+    end
 
-  def oauth_header env
-    oauth = attach_signature(env,
-      'oauth_consumer_key'     => consumer_key(env),
-      'oauth_signature_method' => 'HMAC-SHA1',
-      'oauth_timestamp'        => Time.now.to_i.to_s,
-      'oauth_nonce'            => nonce,
-      'oauth_version'          => '1.0',
-      'oauth_callback'         => oauth_callback(env),
-      'oauth_verifier'         => oauth_verifier(env),
-      'oauth_token'            => oauth_token(env)).
-      map{ |(k, v)| "#{k}=\"#{escape(v)}\"" }.join(', ')
-
-    "OAuth #{oauth}"
-  end
+    def oauth_header env
+      oauth = attach_signature(env,
+        'oauth_consumer_key'     => consumer_key(env),
+        'oauth_signature_method' => 'HMAC-SHA1',
+        'oauth_timestamp'        => Time.now.to_i.to_s,
+        'oauth_nonce'            => nonce,
+        'oauth_version'          => '1.0',
+        'oauth_callback'         => oauth_callback(env),
+        'oauth_verifier'         => oauth_verifier(env),
+        'oauth_token'            => oauth_token(env)).
+        map{ |(k, v)| "#{k}=\"#{escape(v)}\"" }.join(', ')
+
+      "OAuth #{oauth}"
+    end
 
-  def attach_signature env, oauth_params
-    params = reject_blank(oauth_params)
-    params.merge('oauth_signature' => signature(env, params))
-  end
+    def attach_signature env, oauth_params
+      params = reject_blank(oauth_params)
+      params.merge('oauth_signature' => signature(env, params))
+    end
 
-  def signature env, params
-    [Hmac.sha1("#{consumer_secret(env)}&#{oauth_token_secret(env)}",
-               base_string(env, params))].pack('m0')
-  end
+    def signature env, params
+      [Hmac.sha1("#{consumer_secret(env)}&#{oauth_token_secret(env)}",
+                 base_string(env, params))].pack('m0')
+    end
 
-  def base_string env, oauth_params
-    method   = env[REQUEST_METHOD].to_s.upcase
-    base_uri = env[REQUEST_PATH]
-    payload  = payload_params(env)
-    query    = reject_blank(env[REQUEST_QUERY])
-    params   = reject_blank(oauth_params.merge(query.merge(payload))).
-      to_a.sort.map{ |(k, v)|
-        "#{escape(k.to_s)}=#{escape(v.to_s)}"}.join('&')
+    def base_string env, oauth_params
+      method   = env[REQUEST_METHOD].to_s.upcase
+      base_uri = env[REQUEST_PATH]
+      payload  = payload_params(env)
+      query    = reject_blank(env[REQUEST_QUERY])
+      params   = reject_blank(oauth_params.merge(query.merge(payload))).
+        to_a.sort.map{ |(k, v)|
+          "#{escape(k.to_s)}=#{escape(v.to_s)}"}.join('&')
 
-    "#{method}&#{escape(base_uri)}&#{escape(params)}"
-  end
+      "#{method}&#{escape(base_uri)}&#{escape(params)}"
+    end
 
-  def nonce
-    [OpenSSL::Random.random_bytes(32)].pack('m0').tr("+/=", '')
-  end
+    def nonce
+      [OpenSSL::Random.random_bytes(32)].pack('m0').tr("+/=", '')
+    end
 
-  # according to OAuth 1.0a spec, only:
-  #     Content-Type: application/x-www-form-urlencoded
-  # should take payload as a part of the base_string
-  def payload_params env
-    # if we already specified Content-Type and which is not
-    # application/x-www-form-urlencoded, then we should not
-    # take payload as a part of the base_string
-    if env[REQUEST_HEADERS].kind_of?(Hash)  &&
-       env[REQUEST_HEADERS]['Content-Type'] &&
-       env[REQUEST_HEADERS]['Content-Type'] !=
-         'application/x-www-form-urlencoded'
-      {}
-
-    # if it contains any binary data,
-    # then it shouldn't be application/x-www-form-urlencoded either
-    # the Content-Type header would be handled in our HTTP client
-    elsif contain_binary?(env[REQUEST_PAYLOAD])
-      {}
-
-    # so the Content-Type header must be application/x-www-form-urlencoded
-    else
-      reject_blank(env[REQUEST_PAYLOAD])
+    # according to OAuth 1.0a spec, only:
+    #     Content-Type: application/x-www-form-urlencoded
+    # should take payload as a part of the base_string
+    def payload_params env
+      # if we already specified Content-Type and which is not
+      # application/x-www-form-urlencoded, then we should not
+      # take payload as a part of the base_string
+      if env[REQUEST_HEADERS].kind_of?(Hash)  &&
+         env[REQUEST_HEADERS]['Content-Type'] &&
+         env[REQUEST_HEADERS]['Content-Type'] !=
+           'application/x-www-form-urlencoded'
+        {}
+
+      # if it contains any binary data,
+      # then it shouldn't be application/x-www-form-urlencoded either
+      # the Content-Type header would be handled in our HTTP client
+      elsif contain_binary?(env[REQUEST_PAYLOAD])
+        {}
+
+      # so the Content-Type header must be application/x-www-form-urlencoded
+      else
+        reject_blank(env[REQUEST_PAYLOAD])
+      end
     end
-  end
 
-  def reject_blank params
-    params.reject{ |k, v| v.nil? || v == false ||
-                                    (v.respond_to?(:strip) &&
-                                     v.respond_to?(:empty) &&
-                                     v.strip.empty? == true) }
+    def reject_blank params
+      params.reject{ |k, v| v.nil? || v == false ||
+                                      (v.respond_to?(:strip) &&
+                                       v.respond_to?(:empty) &&
+                                       v.strip.empty? == true) }
+    end
   end
 end

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

@@ -1,33 +1,35 @@
 
-require 'rest-core/middleware'
+require 'rest-core/event'
 
-# http://tools.ietf.org/html/rfc6749
-class RestCore::Oauth2Header
-  def self.members; [:access_token_type, :access_token]; end
-  include RestCore::Middleware
+module RestCore
+  # http://tools.ietf.org/html/rfc6749
+  class Oauth2Header
+    def self.members; [:access_token_type, :access_token]; end
+    include Middleware
 
-  def call env, &k
-    start_time = Time.now
-    headers    = build_headers(env)
-    auth       = headers['Authorization']
-    event      = Event::WithHeader.new(Time.now - start_time,
-                   "Authorization: #{auth}") if auth
+    def call env, &k
+      start_time = Time.now
+      headers    = build_headers(env)
+      auth       = headers['Authorization']
+      event      = Event::WithHeader.new(Time.now - start_time,
+                     "Authorization: #{auth}") if auth
 
-    app.call(log(env.merge(REQUEST_HEADERS => headers), event), &k)
-  end
+      app.call(log(env.merge(REQUEST_HEADERS => headers), event), &k)
+    end
 
-  def build_headers env
-    auth = case token = access_token(env)
-           when String
-             token
-           when Hash
-            token.map{ |(k, v)| "#{k}=\"#{v}\"" }.join(', ')
-           end
+    def build_headers env
+      auth = case token = access_token(env)
+             when String
+               token
+             when Hash
+              token.map{ |(k, v)| "#{k}=\"#{v}\"" }.join(', ')
+             end
 
-    if auth
-      {'Authorization' => "#{access_token_type(env)} #{auth}"}
-    else
-      {}
-    end.merge(env[REQUEST_HEADERS])
+      if auth
+        {'Authorization' => "#{access_token_type(env)} #{auth}"}
+      else
+        {}
+      end.merge(env[REQUEST_HEADERS])
+    end
   end
 end

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

@@ -1,20 +1,20 @@
 
-require 'rest-core/middleware'
+module RestCore
+  # http://tools.ietf.org/html/rfc6749
+  class Oauth2Query
+    def self.members; [:access_token]; end
+    include Middleware
 
-# http://tools.ietf.org/html/rfc6749
-class RestCore::Oauth2Query
-  def self.members; [:access_token]; end
-  include RestCore::Middleware
+    def call env, &k
+      local = if access_token(env)
+                env.merge(REQUEST_QUERY =>
+                            {'access_token' => access_token(env)}.
+                             merge(env[REQUEST_QUERY]))
+              else
+                env
+              end
 
-  def call env, &k
-    local = if access_token(env)
-              env.merge(REQUEST_QUERY =>
-                          {'access_token' => access_token(env)}.
-                           merge(env[REQUEST_QUERY]))
-            else
-              env
-            end
-
-    app.call(local, &k)
+      app.call(local, &k)
+    end
   end
 end

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

@@ -1,23 +1,23 @@
 
-require 'rest-core/middleware'
 require 'rest-core/util/parse_query'
 
-class RestCore::QueryResponse
-  def self.members; [:query_response]; end
-  include RestCore::Middleware
+module RestCore
+  class QueryResponse
+    def self.members; [:query_response]; end
+    include Middleware
 
-  QUERY_RESPONSE_HEADER =
-    {'Accept' => 'application/x-www-form-urlencoded'}.freeze
+    QUERY_RESPONSE_HEADER =
+      {'Accept' => 'application/x-www-form-urlencoded'}.freeze
 
-  def call env, &k
-    return app.call(env, &k) if env[DRY]
-    return app.call(env, &k) unless query_response(env)
+    def call env, &k
+      return app.call(env, &k) if env[DRY]
+      return app.call(env, &k) unless query_response(env)
 
-    headers = QUERY_RESPONSE_HEADER.merge(env[REQUEST_HEADERS]||{})
-    app.call(env.merge(REQUEST_HEADERS => headers)) do |response|
-      body = ParseQuery.parse_query(response[RESPONSE_BODY])
-      yield(response.merge(RESPONSE_BODY => body))
+      headers = QUERY_RESPONSE_HEADER.merge(env[REQUEST_HEADERS]||{})
+      app.call(env.merge(REQUEST_HEADERS => headers)) do |response|
+        body = ParseQuery.parse_query(response[RESPONSE_BODY])
+        yield(response.merge(RESPONSE_BODY => body))
+      end
     end
   end
 end
-

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

@@ -1,33 +1,35 @@
 
-require 'rest-core/middleware'
+require 'rest-core/event'
 
-class RestCore::Retry
-  def self.members; [:max_retries, :retry_exceptions]; end
-  include RestCore::Middleware
+module RestCore
+  class Retry
+    def self.members; [:max_retries, :retry_exceptions]; end
+    include Middleware
 
-  DefaultRetryExceptions = [IOError, SystemCallError]
+    DefaultRetryExceptions = [IOError, SystemCallError]
 
-  def call env, &k
-    if env[DRY]
-      app.call(env, &k)
-    else
-      app.call(env){ |res| process(res, k) }
+    def call env, &k
+      if env[DRY]
+        app.call(env, &k)
+      else
+        app.call(env){ |res| process(res, k) }
+      end
     end
-  end
 
-  def process res, k
-    times = max_retries(res)
-    return k.call(res) if times <= 0
-    errors = retry_exceptions(res) || DefaultRetryExceptions
+    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)
+      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)
+        event = Event::Retrying.new(nil, "(#{times}) for: #{err.inspect}")
+        give_promise(call(log(env, event), &k))
+      else
+        k.call(res)
+      end
     end
   end
 end