rest-core 3.6.0 → 4.0.0

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

@@ -1,21 +1,22 @@
 
-require 'rest-core/middleware'
 require 'rest-core/util/clash'
 
-class RestCore::ClashResponse
-  def self.members; [:clash_response]; end
-  include RestCore::Middleware
+module RestCore
+  class ClashResponse
+    def self.members; [:clash_response]; end
+    include Middleware
 
-  def call env, &k
-    return app.call(env, &k) if env[DRY]
-    return app.call(env, &k) unless clash_response(env)
+    def call env, &k
+      return app.call(env, &k) if env[DRY]
+      return app.call(env, &k) unless clash_response(env)
 
-    app.call(env){ |res|
-      if res[RESPONSE_BODY].kind_of?(Hash)
-        yield(res.merge(RESPONSE_BODY => Clash.new(res[RESPONSE_BODY])))
-      else
-        yield(res)
-      end
-    }
+      app.call(env){ |res|
+        if res[RESPONSE_BODY].kind_of?(Hash)
+          yield(res.merge(RESPONSE_BODY => Clash.new(res[RESPONSE_BODY])))
+        else
+          yield(res)
+        end
+      }
+    end
   end
 end

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

@@ -1,35 +1,36 @@
 
 require 'rest-core/event'
-require 'rest-core/middleware'
 
-class RestCore::CommonLogger
-  def self.members; [:log_method]; end
-  include RestCore::Middleware
+module RestCore
+  class CommonLogger
+    def self.members; [:log_method]; end
+    include Middleware
 
-  def call env
-    start_time = Time.now
-    flushed = flush(env)
-    app.call(flushed){ |response|
-      yield(process(response, start_time))
-    }
-  rescue
-    process(flushed, start_time)
-    raise
-  end
+    def call env
+      start_time = Time.now
+      flushed = flush(env)
+      app.call(flushed){ |response|
+        yield(process(response, start_time))
+      }
+    rescue
+      process(flushed, start_time)
+      raise
+    end
 
-  def process response, start_time
-    flush(log(response, log_request(start_time, response)))
-  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.
-      each{ |obj| log_method(env).call("RestCore: #{obj}") }
-    env.merge(LOG => [])
-  end
+    def flush env
+      return env if !log_method(env) || env[DRY]
+      (env[LOG] || []).compact.
+        each{ |obj| log_method(env).call("RestCore: #{obj}") }
+      env.merge(LOG => [])
+    end
 
-  def log_request start_time, response
-    Event::Requested.new(Time.now - start_time,
-      "#{response[RC::REQUEST_METHOD].to_s.upcase} #{request_uri(response)}")
+    def log_request start_time, response
+      Event::Requested.new(Time.now - start_time,
+        "#{response[REQUEST_METHOD].to_s.upcase} #{request_uri(response)}")
+    end
   end
 end

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

@@ -1,11 +1,11 @@
 
-require 'rest-core/middleware'
-
-class RestCore::DefaultHeaders
-  def self.members; [:headers]; end
-  include RestCore::Middleware
-  def call env, &k
-    h = merge_hash(@headers, headers(env), env[REQUEST_HEADERS])
-    app.call(env.merge(REQUEST_HEADERS => h), &k)
+module RestCore
+  class DefaultHeaders
+    def self.members; [:headers]; end
+    include Middleware
+    def call env, &k
+      h = merge_hash(@headers, headers(env), env[REQUEST_HEADERS])
+      app.call(env.merge(REQUEST_HEADERS => h), &k)
+    end
   end
 end

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

@@ -1,11 +1,11 @@
 
-require 'rest-core/middleware'
-
-class RestCore::DefaultPayload
-  def self.members; [:payload]; end
-  include RestCore::Middleware
-  def call env, &k
-    p = merge_hash(@payload, payload(env), env[REQUEST_PAYLOAD])
-    app.call(env.merge(REQUEST_PAYLOAD => p), &k)
+module RestCore
+  class DefaultPayload
+    def self.members; [:payload]; end
+    include Middleware
+    def call env, &k
+      p = merge_hash(@payload, payload(env), env[REQUEST_PAYLOAD])
+      app.call(env.merge(REQUEST_PAYLOAD => p), &k)
+    end
   end
 end

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

@@ -1,11 +1,11 @@
 
-require 'rest-core/middleware'
-
-class RestCore::DefaultQuery
-  def self.members; [:query]; end
-  include RestCore::Middleware
-  def call env, &k
-    q = merge_hash(@query, query(env), env[REQUEST_QUERY])
-    app.call(env.merge(REQUEST_QUERY => q), &k)
+module RestCore
+  class DefaultQuery
+    def self.members; [:query]; end
+    include Middleware
+    def call env, &k
+      q = merge_hash(@query, query(env), env[REQUEST_QUERY])
+      app.call(env.merge(REQUEST_QUERY => q), &k)
+    end
   end
 end

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

@@ -1,17 +1,17 @@
 
-require 'rest-core/middleware'
+module RestCore
+  class DefaultSite
+    def self.members; [:site]; end
+    include Middleware
 
-class RestCore::DefaultSite
-  def self.members; [:site]; end
-  include RestCore::Middleware
+    def call env, &k
+      path = if env[REQUEST_PATH].to_s.include?('://')
+               env[REQUEST_PATH]
+             else
+               File.join(site(env).to_s, env[REQUEST_PATH].to_s)
+             end
 
-  def call env, &k
-    path = if env[REQUEST_PATH].to_s.include?('://')
-             env[REQUEST_PATH]
-           else
-             File.join(site(env).to_s, env[REQUEST_PATH].to_s)
-           end
-
-    app.call(env.merge(REQUEST_PATH => path), &k)
+      app.call(env.merge(REQUEST_PATH => path), &k)
+    end
   end
 end

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

@@ -1,46 +1,46 @@
 
-require 'rest-core/middleware'
+module RestCore
+  class Defaults
+    def self.members; [:defaults]; end
+    include Middleware
 
-class RestCore::Defaults
-  def self.members; [:defaults]; end
-  include RestCore::Middleware
+    # the use of singleton_class is making serialization hard!
+    # def initialize app, defaults
+    #   super
+    #   singleton_class.module_eval do
+    #     defaults.each{ |(key, value)|
+    #       define_method(key) do |env|
+    #         if value.respond_to?(:call)
+    #           value.call
+    #         else
+    #           value
+    #         end
+    #       end
+    #     }
+    #   end
+    # end
 
-  # the use of singleton_class is making serialization hard!
-  # def initialize app, defaults
-  #   super
-  #   singleton_class.module_eval do
-  #     defaults.each{ |(key, value)|
-  #       define_method(key) do |env|
-  #         if value.respond_to?(:call)
-  #           value.call
-  #         else
-  #           value
-  #         end
-  #       end
-  #     }
-  #   end
-  # end
-
-  def method_missing msg, *args, &block
-    env = args.first
-    if env.kind_of?(Hash) && (d = defaults(env)) && d.key?(msg)
-      defaults(env)[msg]
-    else
-      super
+    def method_missing msg, *args, &block
+      env = args.first
+      if env.kind_of?(Hash) && (d = defaults(env)) && d.key?(msg)
+        defaults(env)[msg]
+      else
+        super
+      end
     end
-  end
 
-  def respond_to_missing? msg, include_private=false
-    # since psych would call respond_to? before setting up
-    # instance variables when restoring ruby objects, we might
-    # be accessing undefined ivars in that case even all ivars are
-    # defined in initialize. we can't avoid this because we can't
-    # use singleton_class (otherwise we can't serialize this)
-    return super unless instance_variable_defined?(:@defaults)
-    if (d = defaults({})) && d.key?(msg)
-      true
-    else
-      super
+    def respond_to_missing? msg, include_private=false
+      # since psych would call respond_to? before setting up
+      # instance variables when restoring ruby objects, we might
+      # be accessing undefined ivars in that case even all ivars are
+      # defined in initialize. we can't avoid this because we can't
+      # use singleton_class (otherwise we can't serialize this)
+      return super unless instance_variable_defined?(:@defaults)
+      if (d = defaults({})) && d.key?(msg)
+        true
+      else
+        super
+      end
     end
   end
 end

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

@@ -1,14 +1,14 @@
 
-require 'rest-core/middleware'
+module RestCore
+  class ErrorDetector
+    def self.members; [:error_detector]; end
+    include Middleware
 
-class RestCore::ErrorDetector
-  def self.members; [:error_detector]; end
-  include RestCore::Middleware
-
-  def call env
-    app.call(env){ |response|
-      detector = error_detector(env)
-      yield(fail(response, detector && detector.call(response)))
-    }
+    def call env
+      app.call(env){ |response|
+        detector = error_detector(env)
+        yield(fail(response, detector && detector.call(response)))
+      }
+    end
   end
 end

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

@@ -1,9 +1,11 @@
 
 require 'rest-core/middleware/error_detector'
 
-class RestCore::ErrorDetectorHttp < RestCore::ErrorDetector
-  def initialize app, detector=nil
-    super(app, detector ||
-               lambda{ |env| (env[RESPONSE_STATUS] || 200) / 100 >= 4 })
+module RestCore
+  class ErrorDetectorHttp < RestCore::ErrorDetector
+    def initialize app, detector=nil
+      super(app, detector ||
+                 lambda{ |env| (env[RESPONSE_STATUS] || 200) / 100 >= 4 })
+    end
   end
 end

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

@@ -1,18 +1,18 @@
 
-require 'rest-core/middleware'
+module RestCore
+  class ErrorHandler
+    def self.members; [:error_handler]; end
+    include Middleware
 
-class RestCore::ErrorHandler
-  def self.members; [:error_handler]; end
-  include RestCore::Middleware
-
-  def call env
-    app.call(env){ |res|
-      h = error_handler(res)
-      f = res[FAIL] || []
-      yield(if f.empty? || f.find{ |ff| ff.kind_of?(Exception) } || !h
-              res
-            else
-              fail(res, h.call(res))
-            end)}
+    def call env
+      app.call(env){ |res|
+        h = error_handler(res)
+        f = res[FAIL] || []
+        yield(if f.empty? || f.find{ |ff| ff.kind_of?(Exception) } || !h
+                res
+              else
+                fail(res, h.call(res))
+              end)}
+    end
   end
 end

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

@@ -1,35 +1,36 @@
 
-require 'rest-core/middleware'
+module RestCore
+  class FollowRedirect
+    def self.members; [:max_redirects]; end
+    include Middleware
 
-class RestCore::FollowRedirect
-  def self.members; [:max_redirects]; end
-  include RestCore::Middleware
-
-  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
-    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])
+    def process res, k
+      return k.call(res) if max_redirects(res) <= 0
+      status = res[RESPONSE_STATUS]
+      return k.call(res) if ![301,302,303,307].include?(status)
+      return k.call(res) if  [301,302    ,307].include?(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
+      location = [res[RESPONSE_HEADERS]['LOCATION']].flatten.first
+      meth     = if status == 303
+                   :get
+                 else
+                   res[REQUEST_METHOD]
+                 end
 
-    give_promise(call(res.merge(
-      REQUEST_METHOD => meth    ,
-      REQUEST_PATH   => location,
-      REQUEST_QUERY  => {}      ,
-      'max_redirects' => max_redirects(res) - 1), &k))
+      give_promise(call(res.merge(
+        REQUEST_METHOD => meth    ,
+        REQUEST_PATH   => location,
+        REQUEST_QUERY  => {}      ,
+        'max_redirects' => max_redirects(res) - 1), &k))
+    end
   end
 end

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

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