rest-core 3.6.0 → 4.0.0

data/lib/rest-core/client_oauth1.rb

@@ -1,75 +1,80 @@
 
-require 'rest-core'
+require 'digest/md5'
 
-module RestCore::ClientOauth1
-  include RestCore
+require 'rest-core/util/parse_query'
+require 'rest-core/util/json'
 
-  def authorize_url! opts={}
-    self.data = ParseQuery.parse_query(
-      post(request_token_path, {}, {}, {:json_response => false}.merge(opts)))
+module RestCore
+  module ClientOauth1
+    def authorize_url! opts={}
+      self.data = ParseQuery.parse_query(
+        post(request_token_path, {}, {},
+             {:json_response => false}.merge(opts)))
 
-    authorize_url
-  end
+      authorize_url
+    end
 
-  def authorize_url
-    url(authorize_path, :oauth_token => oauth_token)
-  end
+    def authorize_url
+      url(authorize_path, :oauth_token => oauth_token)
+    end
 
-  def authorize! opts={}
-    self.data = ParseQuery.parse_query(
-      post(access_token_path, {}, {}, {:json_response => false}.merge(opts)))
+    def authorize! opts={}
+      self.data = ParseQuery.parse_query(
+        post(access_token_path, {}, {},
+             {:json_response => false}.merge(opts)))
 
-    data['authorized'] = 'true'
-    data
-  end
+      data['authorized'] = 'true'
+      data
+    end
 
-  def authorized?
-    !!(oauth_token && oauth_token_secret && data['authorized'])
-  end
+    def authorized?
+      !!(oauth_token && oauth_token_secret && data['authorized'])
+    end
 
-  def data_json
-    Json.encode(data.merge('sig' => calculate_sig))
-  end
+    def data_json
+      Json.encode(data.merge('sig' => calculate_sig))
+    end
 
-  def data_json= json
-    self.data = check_sig_and_return_data(Json.decode(json))
-  rescue Json.const_get(:ParseError)
-    self.data = nil
-  end
+    def data_json= json
+      self.data = check_sig_and_return_data(Json.decode(json))
+    rescue Json.const_get(:ParseError)
+      self.data = nil
+    end
 
-  def oauth_token
-    data['oauth_token'] if data.kind_of?(Hash)
-  end
-  def oauth_token= token
-    data['oauth_token'] = token if data.kind_of?(Hash)
-  end
-  def oauth_token_secret
-    data['oauth_token_secret'] if data.kind_of?(Hash)
-  end
-  def oauth_token_secret= secret
-    data['oauth_token_secret'] = secret if data.kind_of?(Hash)
-  end
-  def oauth_callback
-    data['oauth_callback'] if data.kind_of?(Hash)
-  end
-  def oauth_callback= uri
-    data['oauth_callback'] = uri if data.kind_of?(Hash)
-  end
+    def oauth_token
+      data['oauth_token'] if data.kind_of?(Hash)
+    end
+    def oauth_token= token
+      data['oauth_token'] = token if data.kind_of?(Hash)
+    end
+    def oauth_token_secret
+      data['oauth_token_secret'] if data.kind_of?(Hash)
+    end
+    def oauth_token_secret= secret
+      data['oauth_token_secret'] = secret if data.kind_of?(Hash)
+    end
+    def oauth_callback
+      data['oauth_callback'] if data.kind_of?(Hash)
+    end
+    def oauth_callback= uri
+      data['oauth_callback'] = uri if data.kind_of?(Hash)
+    end
 
-  private
-  def default_data
-    {}
-  end
+    private
+    def default_data
+      {}
+    end
 
-  def check_sig_and_return_data hash
-    hash if consumer_secret && hash.kind_of?(Hash) &&
-            calculate_sig(hash) == hash['sig']
-  end
+    def check_sig_and_return_data hash
+      hash if consumer_secret && hash.kind_of?(Hash) &&
+              calculate_sig(hash) == hash['sig']
+    end
 
-  def calculate_sig hash=data
-    base = hash.reject{ |(k, _)| k == 'sig' }.sort.map{ |(k, v)|
-      "#{Middleware.escape(k.to_s)}=#{Middleware.escape(v.to_s)}"
-    }.join('&')
-    Digest::MD5.hexdigest("#{Middleware.escape(consumer_secret)}&#{base}")
+    def calculate_sig hash=data
+      base = hash.reject{ |(k, _)| k == 'sig' }.sort.map{ |(k, v)|
+        "#{Middleware.escape(k.to_s)}=#{Middleware.escape(v.to_s)}"
+      }.join('&')
+      Digest::MD5.hexdigest("#{Middleware.escape(consumer_secret)}&#{base}")
+    end
   end
 end

data/lib/rest-core/event.rb

@@ -1,9 +1,6 @@
 
 module RestCore
-  EventStruct = Struct.new(:duration, :message) unless
-    RestCore.const_defined?(:EventStruct)
-
-  class Event < EventStruct
+  class Event < Struct.new(:duration, :message)
     def name; self.class.name[/(?<=::)\w+$/]; end
     def to_s
       if duration
@@ -13,11 +10,12 @@ module RestCore
       end
     end
   end
-  class Event::MultiDone    < Event; end
-  class Event::Requested    < Event; end
-  class Event::CacheHit     < Event; end
-  class Event::CacheCleared < Event; end
-  class Event::Failed       < Event; end
-  class Event::WithHeader   < Event; end
-  class Event::Retrying     < Event; end
+
+  Event::MultiDone    = Class.new(Event)
+  Event::Requested    = Class.new(Event)
+  Event::CacheHit     = Class.new(Event)
+  Event::CacheCleared = Class.new(Event)
+  Event::Failed       = Class.new(Event)
+  Event::WithHeader   = Class.new(Event)
+  Event::Retrying     = Class.new(Event)
 end

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

@@ -1,29 +1,29 @@
 
-require 'rest-core/middleware'
+module RestCore
+  class AuthBasic
+    def self.members; [:username, :password]; end
+    include Middleware
 
-class RestCore::AuthBasic
-  def self.members; [:username, :password]; end
-  include RestCore::Middleware
-
-  def call env, &k
-    if username(env)
-      if password(env)
-        app.call(env.merge(REQUEST_HEADERS =>
-          auth_basic_header(env).merge(env[REQUEST_HEADERS])), &k)
+    def call env, &k
+      if username(env)
+        if password(env)
+          app.call(env.merge(REQUEST_HEADERS =>
+            auth_basic_header(env).merge(env[REQUEST_HEADERS])), &k)
+        else
+          app.call(log(env, "AuthBasic: username provided: #{username(env)},"\
+                            " but password is missing."), &k)
+        end
+      elsif password(env)
+        app.call(log(env, "AuthBasic: password provided: #{password(env)}," \
+                          " but username is missing."), &k)
       else
-        app.call(log(env, "AuthBasic: username provided: #{username(env)}," \
-                          " but password is missing."), &k)
+        app.call(env, &k)
       end
-    elsif password(env)
-      app.call(log(env, "AuthBasic: password provided: #{password(env)}," \
-                        " but username is missing."), &k)
-    else
-      app.call(env, &k)
     end
-  end
 
-  def auth_basic_header env
-    {'Authorization' =>
-       "Basic #{["#{username(env)}:#{password(env)}"].pack('m0')}"}
+    def auth_basic_header env
+      {'Authorization' =>
+         "Basic #{["#{username(env)}:#{password(env)}"].pack('m0')}"}
+    end
   end
 end

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

@@ -1,13 +1,13 @@
 
-module RestCore; end
-
 # the simplest middleware
-class RestCore::Bypass
-  def initialize app
-    @app = app
-  end
+module RestCore
+  class Bypass
+    def initialize app
+      @app = app
+    end
 
-  def call env, &k
-    @app.call(env, &k)
+    def call env, &k
+      @app.call(env, &k)
+    end
   end
 end

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

@@ -1,117 +1,121 @@
 
-require 'rest-core/event'
-require 'rest-core/middleware'
-
 require 'digest/md5'
+require 'rest-core/event'
 
-class RestCore::Cache
-  def self.members; [:cache, :expires_in]; end
-  include RestCore::Middleware
+module RestCore
+  class Cache
+    def self.members; [:cache, :expires_in]; end
+    include Middleware
 
-  def initialize app, cache, expires_in, &block
-    super(&block)
-    @app, @cache, @expires_in = app, cache, expires_in
-  end
+    def initialize app, cache, expires_in, &block
+      super(&block)
+      @app, @cache, @expires_in = app, cache, expires_in
+    end
 
-  def call env, &k
-    e = if env['cache.update']
-          cache_clear(env)
-        else
-          env
-        end
-
-    cache_get(e){ |cached|
-      e[TIMER].cancel if e[TIMER]
-      k.call(cached)
-    } || app_call(e, &k)
-  end
+    def call env, &k
+      e = if env['cache.update']
+            cache_clear(env)
+          else
+            env
+          end
+
+      cache_get(e){ |cached|
+        e[TIMER].cancel if e[TIMER]
+        k.call(cached)
+      } || app_call(e, &k)
+    end
 
-  def app_call env
-    app.call(env) do |res|
-      yield(if (res[FAIL] || []).empty?
-              cache_for(res)
-            else
-              res
-            end)
+    def app_call env
+      app.call(env) do |res|
+        yield(if (res[FAIL] || []).empty?
+                cache_for(res)
+              else
+                res
+              end)
+      end
     end
-  end
 
-  def cache_key env
-    "rest-core:cache:#{Digest::MD5.hexdigest(env['cache.key'] ||
-                                             cache_key_raw(env))}"
-  end
+    def cache_key env
+      "rest-core:cache:#{Digest::MD5.hexdigest(env['cache.key'] ||
+                                               cache_key_raw(env))}"
+    end
 
-  def cache_get env, &k
-    return unless cache(env)
-    return unless cache_for?(env)
+    def cache_get env, &k
+      return unless cache(env)
+      return unless cache_for?(env)
 
-    uri = request_uri(env)
-    start_time = Time.now
-    return unless data = cache(env)[cache_key(env)]
-    res = log(env.merge(REQUEST_URI => uri),
-              Event::CacheHit.new(Time.now - start_time, uri))
-    data_extract(data, res, k)
-  end
+      uri = request_uri(env)
+      start_time = Time.now
+      return unless data = cache(env)[cache_key(env)]
+      res = log(env.merge(REQUEST_URI => uri),
+                Event::CacheHit.new(Time.now - start_time, uri))
+      data_extract(data, res, k)
+    end
 
-  private
-  def cache_key_raw env
-    "#{env[REQUEST_METHOD]}:#{request_uri(env)}:#{header_cache_key(env)}"
-  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)
+    def cache_clear env
+      return env unless cache(env)
+      return env unless cache_for?(env)
 
-    cache_store(env, :[]=, nil)
-  end
+      cache_store(env, :[]=, nil)
+    end
 
-  def cache_for res
-    return res unless cache(res)
-    return res unless cache_for?(res)
+    def cache_for res
+      return res unless cache(res)
+      return res unless cache_for?(res)
 
-    if expires_in(res).kind_of?(Fixnum) &&
-       cache(res).respond_to?(:store)   &&
-       cache(res).method(:store).arity == -3
+      if expires_in(res).kind_of?(Fixnum) &&
+         cache(res).respond_to?(:store)   &&
+         cache(res).method(:store).arity == -3
 
-      cache_store(res, :store, data_construct(res),
-                                 :expires_in => expires_in(res))
-    else
-      cache_store(res, :[]=  , data_construct(res))
+        cache_store(res, :store, data_construct(res),
+                                   :expires_in => expires_in(res))
+      else
+        cache_store(res, :[]=  , data_construct(res))
+      end
     end
-  end
 
-  def cache_store res, msg, value, *args
-    start_time = Time.now
-    cache(res).send(msg, cache_key(res), value, *args)
+    def cache_store res, msg, value, *args
+      start_time = Time.now
+      cache(res).send(msg, cache_key(res), value, *args)
 
-    if value
-      res
-    else
-      log(res,
-        Event::CacheCleared.new(Time.now - start_time, request_uri(res)))
+      if value
+        res
+      else
+        log(res,
+          Event::CacheCleared.new(Time.now - start_time, request_uri(res)))
+      end
     end
-  end
 
-  def data_construct res
-    "#{ res[RESPONSE_STATUS]}\n" \
-    "#{(res[RESPONSE_HEADERS]||{}).map{|k,v|"#{k}: #{v}\n"}.join}\n\n" \
-    "#{ res[RESPONSE_BODY]}"
-  end
+    def data_construct res
+      "#{ res[RESPONSE_STATUS]}\n" \
+      "#{(res[RESPONSE_HEADERS]||{}).map{|k,v|"#{k}: #{v}\n"}.join}\n\n" \
+      "#{ res[RESPONSE_BODY]}"
+    end
 
-  def data_extract data, res, k
-    _, status, headers, body =
-      data.match(/\A(\d*)\n((?:[^\n]+\n)*)\n\n(.*)\Z/m).to_a
+    def data_extract data, res, k
+      _, status, headers, body =
+        data.match(/\A(\d*)\n((?:[^\n]+\n)*)\n\n(.*)\Z/m).to_a
 
-    Promise.claim(res, k, body, status.to_i,
-      Hash[(headers||'').scan(/([^:]+): ([^\n]+)\n/)]).future_response
-  end
+      result = res.merge(RESPONSE_STATUS => status.to_i,
+                         RESPONSE_HEADERS =>
+                           Hash[(headers||'').scan(/([^:]+): ([^\n]+)\n/)],
+                         RESPONSE_BODY => body)
 
-  def cache_for? env
-    [:get, :head, :otpions].include?(env[REQUEST_METHOD]) &&
-      !env[DRY] && !env[HIJACK]
-  end
+      result.merge(Promise.claim(result, &k).future_response)
+    end
 
-  def header_cache_key env
-    env[REQUEST_HEADERS].sort.map{|(k,v)|"#{k}=#{v}"}.join('&')
+    def cache_for? env
+      [:get, :head, :otpions].include?(env[REQUEST_METHOD]) &&
+        !env[DRY] && !env[HIJACK]
+    end
+
+    def header_cache_key env
+      env[REQUEST_HEADERS].sort.map{|(k,v)|"#{k}=#{v}"}.join('&')
+    end
   end
 end