rest-core 3.6.0 → 4.0.0

data/test/test_universal.rb

@@ -8,6 +8,7 @@ describe RC::Universal do
     WebMock.reset!
   end
 
+  # TODO: RuntimeError: The request GET http://localhost:1/ with body nil was expected to execute 1 time but it executed 2 times
   would 'only send payload for post, put, patch' do
     c = RC::Universal.new(:log_method => false, :payload => '$payload')
     [:get, :delete, :head, :options].each do |method|
@@ -69,4 +70,11 @@ describe RC::Universal do
     errors.map(&:class).should.eq [Errno::ECONNREFUSED]*2
     called.map(&:class).should.eq [Errno::ECONNREFUSED]
   end
+
+  would 'not deadlock with ErrorHandler' do
+    c = RC::Universal.new(:log_method => false).
+               event_source('http://localhost:1')
+    c.onerror{ |e| e.should.kind_of?(Errno::ECONNREFUSED) }
+    c.start.wait
+  end
 end

metadata

@@ -1,17 +1,17 @@
 --- !ruby/object:Gem::Specification
 name: rest-core
 version: !ruby/object:Gem::Version
-  version: 3.6.0
+  version: 4.0.0
 platform: ruby
 authors:
 - Lin Jen-Shin (godfat)
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-01-27 00:00:00.000000000 Z
+date: 2016-02-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: httpclient
+  name: rest-builder
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -24,45 +24,12 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: mime-types
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: timers
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 4.0.1
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 4.0.1
 description: |-
-  Modular Ruby clients interface for REST APIs.
-
-  There has been an explosion in the number of REST APIs available today.
-  To address the need for a way to access these APIs easily and elegantly,
-  we have developed rest-core, which consists of composable middleware
-  that allows you to build a REST client for any REST API. Or in the case of
-  common APIs such as Facebook, Github, and Twitter, you can simply use the
-  dedicated clients provided by [rest-more][].
+  Various [rest-builder](https://github.com/godfat/rest-builder) middleware
+  for building REST clients.
 
-  [rest-more]: https://github.com/godfat/rest-more
+  Checkout [rest-more](https://github.com/godfat/rest-more) for pre-built
+  clients.
 email:
 - godfat (XD) godfat.org
 executables: []
@@ -82,18 +49,9 @@ files:
 - example/simple.rb
 - example/use-cases.rb
 - lib/rest-core.rb
-- lib/rest-core/builder.rb
-- lib/rest-core/client.rb
-- lib/rest-core/client/simple.rb
 - lib/rest-core/client/universal.rb
 - lib/rest-core/client_oauth1.rb
-- lib/rest-core/engine.rb
-- lib/rest-core/engine/dry.rb
-- lib/rest-core/engine/http-client.rb
-- lib/rest-core/error.rb
 - lib/rest-core/event.rb
-- lib/rest-core/event_source.rb
-- lib/rest-core/middleware.rb
 - lib/rest-core/middleware/auth_basic.rb
 - lib/rest-core/middleware/bypass.rb
 - lib/rest-core/middleware/cache.rb
@@ -117,10 +75,7 @@ files:
 - lib/rest-core/middleware/retry.rb
 - lib/rest-core/middleware/smash_response.rb
 - lib/rest-core/middleware/timeout.rb
-- lib/rest-core/promise.rb
 - lib/rest-core/test.rb
-- lib/rest-core/thread_pool.rb
-- lib/rest-core/timer.rb
 - lib/rest-core/util/clash.rb
 - lib/rest-core/util/config.rb
 - lib/rest-core/util/dalli_extension.rb
@@ -128,7 +83,6 @@ files:
 - lib/rest-core/util/json.rb
 - lib/rest-core/util/parse_link.rb
 - lib/rest-core/util/parse_query.rb
-- lib/rest-core/util/payload.rb
 - lib/rest-core/util/smash.rb
 - lib/rest-core/version.rb
 - rest-core.gemspec
@@ -136,11 +90,9 @@ files:
 - task/gemgem.rb
 - test/config/rest-core.yaml
 - test/test_auth_basic.rb
-- test/test_builder.rb
 - test/test_cache.rb
 - test/test_clash.rb
 - test/test_clash_response.rb
-- test/test_client.rb
 - test/test_client_oauth1.rb
 - test/test_config.rb
 - test/test_dalli_extension.rb
@@ -151,23 +103,16 @@ files:
 - test/test_error_detector.rb
 - test/test_error_detector_http.rb
 - test/test_error_handler.rb
-- test/test_event_source.rb
 - test/test_follow_redirect.rb
-- test/test_future.rb
-- test/test_httpclient.rb
 - test/test_json_request.rb
 - test/test_json_response.rb
 - test/test_oauth1_header.rb
 - test/test_oauth2_header.rb
 - test/test_parse_link.rb
-- test/test_payload.rb
-- test/test_promise.rb
 - test/test_query_response.rb
 - test/test_retry.rb
-- test/test_simple.rb
 - test/test_smash.rb
 - test/test_smash_response.rb
-- test/test_thread_pool.rb
 - test/test_timeout.rb
 - test/test_universal.rb
 homepage: https://github.com/godfat/rest-core
@@ -190,17 +135,15 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 2.5.2
 signing_key: 
 specification_version: 4
-summary: Modular Ruby clients interface for REST APIs.
+summary: Various [rest-builder](https://github.com/godfat/rest-builder) middleware
 test_files:
 - test/test_auth_basic.rb
-- test/test_builder.rb
 - test/test_cache.rb
 - test/test_clash.rb
 - test/test_clash_response.rb
-- test/test_client.rb
 - test/test_client_oauth1.rb
 - test/test_config.rb
 - test/test_dalli_extension.rb
@@ -211,22 +154,15 @@ test_files:
 - test/test_error_detector.rb
 - test/test_error_detector_http.rb
 - test/test_error_handler.rb
-- test/test_event_source.rb
 - test/test_follow_redirect.rb
-- test/test_future.rb
-- test/test_httpclient.rb
 - test/test_json_request.rb
 - test/test_json_response.rb
 - test/test_oauth1_header.rb
 - test/test_oauth2_header.rb
 - test/test_parse_link.rb
-- test/test_payload.rb
-- test/test_promise.rb
 - test/test_query_response.rb
 - test/test_retry.rb
-- test/test_simple.rb
 - test/test_smash.rb
 - test/test_smash_response.rb
-- test/test_thread_pool.rb
 - test/test_timeout.rb
 - test/test_universal.rb

data/lib/rest-core/builder.rb

@@ -1,162 +0,0 @@
-
-require 'thread'
-require 'weakref'
-require 'rest-core/client'
-
-class RestCore::Builder
-  include RestCore
-
-  singleton_class.module_eval do
-    attr_writer :default_engine
-    def default_engine
-      @default_engine ||= RestCore::HttpClient
-    end
-
-    def client *attrs, &block
-      new(&block).to_client(*attrs)
-    end
-  end
-
-  def initialize &block
-    @engine    = nil
-    @middles ||= []
-    instance_eval(&block) if block_given?
-  end
-
-  attr_reader :middles
-  attr_writer :default_engine
-  def default_engine
-    @default_engine ||= self.class.default_engine
-  end
-
-  def use middle, *args, &block
-    middles << [middle, args, block]
-  end
-
-  def run engine
-    @engine = engine
-  end
-
-  def members
-    middles.map{ |(middle, _, _)|
-      middle.members if middle.respond_to?(:members)
-    }.flatten.compact
-  end
-
-  def to_app engine=@engine || default_engine
-    # === foldr m.new app middles
-    middles.reverse.inject(engine.new){ |app, (middle, args, block)|
-      begin
-        middle.new(app, *partial_deep_copy(args), &block)
-      rescue ArgumentError => e
-        raise ArgumentError.new("#{middle}: #{e}")
-      end
-    }
-  end
-
-  def to_client *attrs
-    fields = (members + attrs + [:config_engine]).uniq
-    struct = build_struct(fields)
-    client = Class.new(struct)
-    client.const_set('Struct', struct)
-    class_methods = build_class_methods
-    client.const_set('ClassMethods', class_methods)
-    client.singleton_class.send(:include, class_methods)
-    client.send(:include, Client)
-    client.builder            = self
-    client.pool_size          =  0 # default to no pool
-    client.pool_idle_time     = 60 # default to 60 seconds
-    client.event_source_class = EventSource
-    client.promises           = []
-    client.mutex              = Mutex.new
-    client
-  end
-
-  private
-  def partial_deep_copy obj
-    case obj
-      when Array; obj.map{ |o| partial_deep_copy(o) }
-      when Hash ; obj.inject({}){ |r, (k, v)| r[k] = partial_deep_copy(v); r }
-      else      ; obj
-    end
-  end
-
-  def build_struct fields
-    if fields.empty?
-      Struct.new(nil)
-    else
-      Struct.new(*fields.uniq)
-    end
-  end
-
-  def build_class_methods
-    Module.new do
-      attr_accessor :builder, :pool_size, :pool_idle_time,
-                    :event_source_class, :promises, :mutex
-
-      def inherited sub
-        sub.builder            = builder
-        sub.pool_size          = pool_size
-        sub.pool_idle_time     = pool_idle_time
-        sub.event_source_class = event_source_class
-        sub.promises           = []
-        sub.mutex              = Mutex.new
-      end
-
-      def thread_pool; RestCore::ThreadPool[self]; end
-
-      def defer returns=:future_body
-        raise ArgumentError.new('no block given') unless block_given?
-        promise = RestCore::Promise.new({RestCore::CLIENT => self},
-          lambda{ |res|
-            if err = res[FAIL].find{ |f| f.kind_of?(Exception) }
-              Promise.set_backtrace(err) unless err.backtrace
-              raise err
-            else
-              res
-            end
-          })
-        give_promise(WeakRef.new(promise))
-        promise.defer do
-          begin
-            promise.done(yield)
-          rescue => e
-            promise.reject(e)
-          end
-        end
-        promise.send(returns)
-      end
-
-      def give_promise weak_promise, ps=promises, m=mutex
-        m.synchronize do
-          ps << weak_promise
-          ps.keep_if(&:weakref_alive?)
-        end
-      end
-
-      # Shutdown the thread pool for this client and wait for all requests
-      def shutdown
-        thread_pool.shutdown
-        wait
-      end
-
-      # Wait for all the requests to be done for this client
-      def wait ps=promises, m=mutex
-        return self if ps.empty?
-        current_promises = nil
-        m.synchronize do
-          current_promises = ps.dup
-          ps.clear
-        end
-        current_promises.each do |p|
-          next unless p.weakref_alive?
-          begin
-            p.wait
-          rescue WeakRef::RefError # it's gc'ed after we think it's alive
-          end
-        end
-        wait(ps, m)
-      end
-    end
-  end
-end

data/lib/rest-core/client.rb

@@ -1,277 +0,0 @@
-
-require 'thread'
-require 'weakref'
-require 'rest-core'
-
-module RestCore::Client
-  include RestCore
-
-  Unserializable = [Proc, Method, IO]
-
-  def self.included mod
-    # honor default attributes
-    src = mod.members.map{ |name|
-      <<-RUBY
-        def #{name}
-          if (r = super).nil?
-            self.#{name} = default_#{name}
-          else
-            r
-          end
-        end
-
-        def default_#{name} a=app
-          if self.class.respond_to?("default_#{name}")
-            self.class.default_#{name}      # old class default style
-          elsif a.respond_to?(:#{name})
-            a.#{name}({})                 # middleware instance value
-          elsif a.respond_to?(:app)
-            default_#{name}(a.app)        # walk into next app
-          else
-            nil
-          end
-        end
-        private :default_#{name}
-      RUBY
-    }
-    accessor = Module.new
-    accessor.module_eval(src.join("\n"), __FILE__, __LINE__)
-    mod.const_set('Accessor', accessor)
-    mod.send(:include, accessor)
-  end
-
-  attr_reader :app, :dry, :promises
-  attr_accessor :error_callback
-  def initialize o={}
-    @app ||= self.class.builder.to_app # lighten! would reinitialize anyway
-    @dry ||= self.class.builder.to_app(Dry)
-    @promises = []  # don't record any promises in lighten!
-    @mutex    = nil # for locking promises, lazily initialized
-                    # for serialization
-    @error_callback = nil
-    o.each{ |key, value| send("#{key}=", value) if respond_to?("#{key}=") }
-  end
-
-  def attributes
-    Hash[each_pair.map{ |k, v| [k, send(k)] }]
-  end
-
-  def inspect
-    fields = if size > 0
-               ' ' + attributes.map{ |k, v|
-                 "#{k}=#{v.inspect.sub(/(?<=.{12}).{4,}/, '...')}"
-               }.join(', ')
-             else
-               ''
-             end
-    "#<struct #{self.class.name}#{fields}>"
-  end
-
-  def lighten! o={}
-    attributes.each{ |k, v| vv = case v;
-                                   when  Hash; lighten_hash(v)
-                                   when Array; lighten_array(v)
-                                   when *Unserializable; nil
-                                   else v
-                                 end
-                            send("#{k}=", vv)}
-    initialize(o)
-    @app, @dry = lighten_app(app), lighten_app(dry)
-    self
-  end
-
-  def lighten o={}
-    dup.lighten!(o)
-  end
-
-  def wait
-    self.class.wait(promises, mutex)
-    self
-  end
-
-  def url path, query={}, opts={}
-    dry.call(build_env({
-      REQUEST_PATH  => path,
-      REQUEST_QUERY => query,
-      DRY           => true}.merge(opts)), &Middleware.method(:request_uri))
-  end
-
-  def get    path, query={}, opts={}, &cb
-    request(
-      {REQUEST_METHOD  => :get   ,
-       REQUEST_PATH    => path   ,
-       REQUEST_QUERY   => query  }.merge(opts), &cb)
-  end
-
-  def delete path, query={}, opts={}, &cb
-    request(
-      {REQUEST_METHOD  => :delete,
-       REQUEST_PATH    => path   ,
-       REQUEST_QUERY   => query  }.merge(opts), &cb)
-  end
-
-  def head path, query={}, opts={}, &cb
-    request(
-      {REQUEST_METHOD  => :head  ,
-       REQUEST_PATH    => path   ,
-       REQUEST_QUERY   => query  ,
-       RESPONSE_KEY    => RESPONSE_HEADERS}.merge(opts), &cb)
-  end
-
-  def options path, query={}, opts={}, &cb
-    request(
-      {REQUEST_METHOD  => :options,
-       REQUEST_PATH    => path   ,
-       REQUEST_QUERY   => query  ,
-       RESPONSE_KEY    => RESPONSE_HEADERS}.merge(opts), &cb)
-  end
-
-  def post   path, payload={}, query={}, opts={}, &cb
-    request(
-      {REQUEST_METHOD  => :post  ,
-       REQUEST_PATH    => path   ,
-       REQUEST_QUERY   => query  ,
-       REQUEST_PAYLOAD => payload}.merge(opts), &cb)
-  end
-
-  def put    path, payload={}, query={}, opts={}, &cb
-    request(
-      {REQUEST_METHOD  => :put   ,
-       REQUEST_PATH    => path   ,
-       REQUEST_QUERY   => query  ,
-       REQUEST_PAYLOAD => payload}.merge(opts), &cb)
-  end
-
-  def patch  path, payload={}, query={}, opts={}, &cb
-    request(
-      {REQUEST_METHOD  => :patch ,
-       REQUEST_PATH    => path   ,
-       REQUEST_QUERY   => query  ,
-       REQUEST_PAYLOAD => payload}.merge(opts), &cb)
-  end
-
-  def event_source path, query={}, opts={}
-    self.class.event_source_class.new(self, path, query, opts)
-  end
-
-  def request env, a=app
-    if block_given?
-      request_full(env, a){ |response| yield(response[response_key(env)]) }
-    else
-      request_full(env, a)[response_key(env)]
-    end
-  end
-
-  def request_full env, a=app, &k
-    response = a.call(build_env({ASYNC => !!k}.merge(env))) do |res|
-      (k || RC.id).call(request_complete(res))
-    end
-
-    give_promise(response)
-
-    if block_given?
-      self
-    else
-      response
-    end
-  end
-
-  def give_promise response
-    # under ASYNC callback, response might not be a response hash
-    # in that case (maybe in a user created engine), Client#wait
-    # won't work because we have no way to track the promise.
-    if response.kind_of?(Hash) && response[PROMISE].kind_of?(Promise)
-      weak_promise = WeakRef.new(response[PROMISE])
-      self.class.give_promise(weak_promise)
-      self.class.give_promise(weak_promise, promises, mutex)
-    end
-
-    response
-  end
-
-  def build_env env={}
-    default_env.merge(
-      Middleware.string_keys(attributes).merge(Middleware.string_keys(env)))
-  end
-
-  def default_env
-    {REQUEST_METHOD  => :get,
-     REQUEST_PATH    => '/' ,
-     REQUEST_QUERY   => {}  ,
-     REQUEST_PAYLOAD => {}  ,
-     REQUEST_HEADERS => {}  ,
-     FAIL            => []  ,
-     LOG             => []  ,
-     CLIENT          => self}
-  end
-  # ------------------------ instance ---------------------
-
-
-
-  private
-  def request_complete res
-    if err = res[FAIL].find{ |f| f.kind_of?(Exception) }
-      Promise.set_backtrace(err) unless err.backtrace
-      error_callback.call(err) if error_callback
-      if res[ASYNC]
-        res.merge(response_key(res) => err)
-      else
-        raise err
-      end
-    else
-      res
-    end
-  end
-
-  def mutex
-    @mutex ||= Mutex.new
-  end
-
-  def response_key opts
-    opts[RESPONSE_KEY] ||
-      if opts[HIJACK] then RESPONSE_SOCKET else RESPONSE_BODY end
-  end
-
-  def lighten_hash hash
-    Hash[hash.map{ |(key, value)|
-      case value
-        when  Hash; lighten_hash(value)
-        when Array; lighten_array(value)
-        when *Unserializable; [key, nil]
-        else [key, value]
-      end
-    }]
-  end
-
-  def lighten_array array
-    array.map{ |value|
-      case value
-        when  Hash; lighten_hash(value)
-        when Array; lighten_array(value)
-        when *Unserializable; nil
-        else value
-      end
-    }.compact
-  end
-
-  def lighten_app app
-    members = if app.class.respond_to?(:members)
-                app.class.members.map{ |key|
-                  case value = app.send(key, {})
-                    when  Hash; lighten_hash(value)
-                    when Array; lighten_array(value)
-                    when *Unserializable; nil
-                    else value
-                  end
-                }
-              else
-                []
-              end
-
-    if app.respond_to?(:app) && app.app
-      app.class.new(lighten_app(app.app), *members)
-    else
-      app.class.new(*members)
-    end
-  end
-end