rest-core 3.6.0 → 4.0.0

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

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

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

@@ -1,27 +1,26 @@
 
 require 'timeout'
 
-require 'rest-core/middleware'
-require 'rest-core/timer'
+module RestCore
+  class Timeout
+    def self.members; [:timeout]; end
+    include Middleware
 
-class RestCore::Timeout
-  def self.members; [:timeout]; end
-  include RestCore::Middleware
+    def call env, &k
+      return app.call(env, &k) if env[DRY] || timeout(env) == 0
+      process(env, &k)
+    end
 
-  def call env, &k
-    return app.call(env, &k) if env[DRY] || timeout(env) == 0
-    process(env, &k)
-  end
-
-  def process env, &k
-    timer = Timer.new(timeout(env), timeout_error)
-    app.call(env.merge(TIMER => timer), &k)
-  rescue Exception
-    timer.cancel
-    raise
-  end
+    def process env, &k
+      timer = PromisePool::Timer.new(timeout(env), timeout_error)
+      app.call(env.merge(TIMER => timer), &k)
+    rescue Exception
+      timer.cancel
+      raise
+    end
 
-  def timeout_error
-    ::Timeout::Error.new('execution expired')
+    def timeout_error
+      ::Timeout::Error.new('execution expired')
+    end
   end
 end

data/lib/rest-core/test.rb

@@ -9,21 +9,4 @@ require 'webmock'
 require 'yaml'
 
 WebMock.disable_net_connect!(:allow_localhost => true)
-Pork::Executor.__send__(:include, Muack::API, WebMock::API)
-
-class Pork::Executor
-  def with_img
-    f = Tempfile.new(['img', '.jpg'])
-    n = File.basename(f.path)
-    f.write('a'*10)
-    f.rewind
-    yield(f, n)
-  ensure
-    f.close!
-  end
-
-  def stub_select_for_stringio
-    stub(IO).select(where([is_a(StringIO)]), [], [],
-                    RestCore::EventSource::READ_WAIT){ |rd, *| rd }
-  end
-end
+Pork::Executor.include(Muack::API, WebMock::API)

data/lib/rest-core/util/clash.rb

@@ -1,50 +1,51 @@
 
-module RestCore; end
-class RestCore::Clash
-  Empty = Hash.new(&(l = lambda{|_,_|Hash.new(&l).freeze})).freeze
+module RestCore
+  class Clash
+    Empty = Hash.new(&(l = lambda{|_,_|Hash.new(&l).freeze})).freeze
 
-  attr_accessor :data
-  def initialize data
-    self.data = data
-  end
+    attr_accessor :data
+    def initialize data
+      self.data = data
+    end
 
-  def [] k
-    if data.key?(k)
-      convert(data[k])
-    else
-      Empty
+    def [] k
+      if data.key?(k)
+        convert(data[k])
+      else
+        Empty
+      end
     end
-  end
 
-  def == rhs
-    if rhs.kind_of?(RestCore::Clash)
-      data == rhs.data
-    else
-      data == rhs
+    def == rhs
+      if rhs.kind_of?(Clash)
+        data == rhs.data
+      else
+        data == rhs
+      end
     end
-  end
 
-  private
-  def convert value
-    case value
-    when Hash
-      RestCore::Clash.new(value)
-    when Array
-      value.map{ |ele| convert(ele) }
-    else
-      value
+    private
+    def convert value
+      case value
+      when Hash
+        Clash.new(value)
+      when Array
+        value.map{ |ele| convert(ele) }
+      else
+        value
+      end
     end
-  end
 
-  def respond_to_missing? msg, include_private=false
-    data.respond_to?(msg, include_private)
-  end
+    def respond_to_missing? msg, include_private=false
+      data.respond_to?(msg, include_private)
+    end
 
-  def method_missing msg, *args, &block
-    if data.respond_to?(msg)
-      data.public_send(msg, *args, &block)
-    else
-      super
+    def method_missing msg, *args, &block
+      if data.respond_to?(msg)
+        data.public_send(msg, *args, &block)
+      else
+        super
+      end
     end
   end
 end

data/lib/rest-core/util/config.rb

@@ -2,49 +2,50 @@
 require 'erb'
 require 'yaml'
 
-module RestCore; end
-module RestCore::Config
-  extend self
-  DefaultModuleName = 'DefaultAttributes'
+module RestCore
+  module Config
+    extend self
+    DefaultModuleName = 'DefaultAttributes'
 
-  def load klass, path, env, namespace=nil
-    config   = YAML.load(ERB.new(File.read(path)).result(binding))
-    defaults = config[env]
-    return false unless defaults
-    return false unless defaults[namespace] if namespace
-    data = if namespace
-             defaults[namespace]
-           else
-             defaults
-           end
-    raise ArgumentError.new("#{data} is not a hash") unless
-      data.kind_of?(Hash)
+    def load klass, path, env, namespace=nil
+      config   = YAML.load(ERB.new(File.read(path)).result(binding))
+      defaults = config[env]
+      return false unless defaults
+      return false unless defaults[namespace] if namespace
+      data = if namespace
+               defaults[namespace]
+             else
+               defaults
+             end
+      raise ArgumentError.new("#{data} is not a hash") unless
+        data.kind_of?(Hash)
 
-    default_attributes_module(klass).module_eval(
-      data.inject(["extend self\n"]){ |r, (k, v)|
-        # quote strings, leave others free (e.g. false, numbers, etc)
-        r << <<-RUBY
-          def default_#{k}
-            #{v.inspect}
-          end
-        RUBY
-      }.join, __FILE__, __LINE__)
-  end
+      default_attributes_module(klass).module_eval(
+        data.inject(["extend self\n"]){ |r, (k, v)|
+          # quote strings, leave others free (e.g. false, numbers, etc)
+          r << <<-RUBY
+            def default_#{k}
+              #{v.inspect}
+            end
+          RUBY
+        }.join, __FILE__, __LINE__)
+    end
 
-  def default_attributes_module klass
-    mod = if klass.const_defined?(DefaultModuleName)
-            klass.const_get(DefaultModuleName)
-          else
-            klass.send(:const_set, DefaultModuleName, Module.new)
-          end
+    def default_attributes_module klass
+      mod = if klass.const_defined?(DefaultModuleName)
+              klass.const_get(DefaultModuleName)
+            else
+              klass.send(:const_set, DefaultModuleName, Module.new)
+            end
 
-    singleton_class = if klass.respond_to?(:singleton_class)
-                        klass.singleton_class
-                      else
-                        class << klass; self; end
-                      end
+      singleton_class = if klass.respond_to?(:singleton_class)
+                          klass.singleton_class
+                        else
+                          class << klass; self; end
+                        end
 
-    klass.send(:extend, mod) unless singleton_class < mod
-    mod
+      klass.send(:extend, mod) unless singleton_class < mod
+      mod
+    end
   end
 end

data/lib/rest-core/util/dalli_extension.rb

@@ -1,15 +1,16 @@
 
-module RestCore; end
-module RestCore::DalliExtension
-  def [] *args
-    get(*args)
-  end
+module RestCore
+  module DalliExtension
+    def [] *args
+      get(*args)
+    end
 
-  def []= *args
-    set(*args)
-  end
+    def []= *args
+      set(*args)
+    end
 
-  def store key, value, expires_in: nil
-    set(key, value, expires_in)
+    def store key, value, expires_in: nil
+      set(key, value, expires_in)
+    end
   end
 end

data/lib/rest-core/util/hmac.rb

@@ -1,14 +1,15 @@
 
 require 'openssl'
 
-module RestCore; end
-module RestCore::Hmac
-  module_function
-  def sha256 key, data
-    OpenSSL::HMAC.digest('sha256', key, data)
-  end
+module RestCore
+  module Hmac
+    module_function
+    def sha256 key, data
+      OpenSSL::HMAC.digest('sha256', key, data)
+    end
 
-  def sha1 key, data
-    OpenSSL::HMAC.digest('sha1', key, data)
+    def sha1 key, data
+      OpenSSL::HMAC.digest('sha1', key, data)
+    end
   end
 end

data/lib/rest-core/util/json.rb

@@ -1,64 +1,65 @@
 
-module RestCore; end
-module RestCore::Json
-  module MultiJson
-    def self.extended mod
-      mod.const_set(:ParseError, ::MultiJson::DecodeError)
-    end
-    def encode hash
-      ::MultiJson.dump(hash)
-    end
-    def decode json
-      ::MultiJson.load(json)
+module RestCore
+  module Json
+    module MultiJson
+      def self.extended mod
+        mod.const_set(:ParseError, ::MultiJson::DecodeError)
+      end
+      def encode hash
+        ::MultiJson.dump(hash)
+      end
+      def decode json
+        ::MultiJson.load(json)
+      end
     end
-  end
 
-  module YajlRuby
-    def self.extended mod
-      mod.const_set(:ParseError, Yajl::ParseError)
+    module YajlRuby
+      def self.extended mod
+        mod.const_set(:ParseError, Yajl::ParseError)
+      end
+      def encode hash
+        Yajl::Encoder.encode(hash)
+      end
+      def decode json
+        Yajl::Parser.parse(json)
+      end
     end
-    def encode hash
-      Yajl::Encoder.encode(hash)
-    end
-    def decode json
-      Yajl::Parser.parse(json)
-    end
-  end
 
-  module Json
-    def self.extended mod
-      mod.const_set(:ParseError, JSON::ParserError)
-    end
-    def encode hash
-      JSON.dump(hash)
-    end
-    def decode json
-      JSON.parse(json, :quirks_mode => true)
+    module Json
+      def self.extended mod
+        mod.const_set(:ParseError, JSON::ParserError)
+      end
+      def encode hash
+        JSON.dump(hash)
+      end
+      def decode json
+        JSON.parse(json, :quirks_mode => true)
+      end
     end
-  end
 
-  def self.select_json! mod, picked=false
-    if    Object.const_defined?(:MultiJson)
-      mod.send(:extend, MultiJson)
-    elsif Object.const_defined?(:Yajl)
-      mod.send(:extend, YajlRuby)
-    elsif Object.const_defined?(:JSON)
-      mod.send(:extend, Json)
-    elsif picked
-      raise LoadError.new(
-        'No JSON library found. Tried: multi_json, yajl-ruby, json.')
-    else
-      # pick a json gem if available
-      %w[multi_json yajl json].each{ |json|
-        begin
-          require json
-          break
-        rescue LoadError
-        end
-      }
-      select_json!(mod, true)
+    def self.select_json! mod, picked=false
+      if    Object.const_defined?(:MultiJson)
+        mod.send(:extend, MultiJson)
+      elsif Object.const_defined?(:Yajl)
+        mod.send(:extend, YajlRuby)
+      elsif Object.const_defined?(:JSON)
+        mod.send(:extend, Json)
+      elsif picked
+        raise LoadError.new(
+          'No JSON library found. Tried: multi_json, yajl-ruby, json.')
+      else
+        # pick a json gem if available
+        %w[multi_json yajl json].each{ |json|
+          begin
+            require json
+            break
+          rescue LoadError
+          end
+        }
+        select_json!(mod, true)
+      end
     end
-  end
 
-  select_json!(self)
+    select_json!(self)
+  end
 end