rest-core 3.0.0 → 3.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 58ed90f247d23da6267042bf108e50637e8dba98
-  data.tar.gz: a0d0b5f7dd766fee5426fc0faf5c5d0dd6adb229
+  metadata.gz: 070bdd0392158ac265903b7e713245a18933aaa8
+  data.tar.gz: 015edd1a6221a2a0b55dc04958dbed0df1729ecf
 SHA512:
-  metadata.gz: a45a9c11e364a08414a7e583feedbe3a289a59fba42aa8d0180e0144e91279b7a77662737c489ec466402a72db4a2833f9e674ad27954d93e325e33713f4766d
-  data.tar.gz: 3f3b2e09cd1131543a677e9a61cf4872c70fb272aad936eccd0f005d6490646b6589e0128ffd33f6107b644c77ef772a34f6433bd6c3d37fffe0aa1a53b72010
+  metadata.gz: 30bcbb75a17c797b3ebf823d5e46837209bd628df0abc0190f9d67823f4367b1556a1f11461befb176400aba3863ec920561f503da32dd1edc00682e9e2b44a9
+  data.tar.gz: fd18d5ecd9cb318c9b8ce3616c3f7432bd55ea43b6c517ea0bbc21a8d33670b0fca238678b08faf25b6c80b95f3c9d6be449a69a6b74ecb929ea90995b49b4ce

data/.travis.yml

@@ -5,5 +5,5 @@ rvm:
   - 1.9.3
   - 2.0.0
   - ruby
-  - rbx
+  - rbx-2
   - jruby

data/CHANGES.md

@@ -1,6 +1,37 @@
 # CHANGES
 
-## rest-core 3.0.0 -- ?
+## rest-core 3.1.0 -- 2014-05-09
+
+### Incompatible changes
+
+* Now that the second argument `key` in `RC::Client#request` is replaced by
+  `RC::RESPONSE_KEY` passed in env. This would make it easier to use and
+  more consistent internally.
+* Now RC::EventSource#onmessage would receive the event in the first argument,
+  and the data in the second argument instead of a hash in the first argument.
+
+### Enhancement
+
+* Added RC::REQUEST_URI in the env so that we could access the requesting
+  URI easily.
+* Added middleware RC::QueryResponse which could parse query in response.
+* Added RC::Client.event_source_class which we could easily swap the class
+  used for event_source. Used in Firebase client to parse data in JSON.
+* Now methods in RC::EventSource would return itself so that we could chain
+  callbacks.
+* Added RC::EventSource#onreconnect callback to handle if we're going to
+  reconnect automatically or not.
+* RC::Config was extracted from rest-more, which could help us manage config
+  files.
+* RC::Json using JSON would now parse in quirks_mode, so that it could parse
+  not only JSON but also a single value.
+
+### Bugs Fixes
+
+* We should never cache hijacked requests.
+* Now we preserve payload and properly ignore query for RC::FollowRedirect.
+
+## rest-core 3.0.0 -- 2014-05-04
 
 Highlights:
 

data/README.md

@@ -280,17 +280,44 @@ Not only JavaScript could receive server-sent events, any languages could.
 Doing so would establish a keep-alive connection to the server, and receive
 data periodically. We'll take Firebase as an example:
 
+If you are using Firebase, please consider the pre-built client in
+[rest-more][] instead.
+
 ``` ruby
-es = RC::Universal.new.event_source(
-       'https://SampleChat.firebaseIO-demo.com/users/tom/.json')
+require 'rest-core'
+
+# Streaming over 'users/tom.json'
+cl = RC::Universal.new(:site => 'https://SampleChat.firebaseIO-demo.com/')
+es = cl.event_source('users/tom.json', {}, # this is query, none here
+                     :headers => {'Accept' => 'text/event-stream'})
+
+@reconnect = true
+
+es.onopen   { |sock| p sock } # Called when connected
+es.onmessage{ |event, data, sock| p event, data } # Called for each message
+es.onerror  { |error, sock| p error } # Called whenever there's an error
+# Extra: If we return true in onreconnect callback, it would automatically
+#        reconnect the node for us if disconnected.
+es.onreconnect{ |error, sock| p error; @reconnect }
+
+# Start making the request
+es.start
+
+# Try to close the connection and see it reconnects automatically
+es.close
+
+# Update users/tom.json
+p cl.put('users/tom.json', RC::Json.encode(:some => 'data'))
+p cl.post('users/tom.json', RC::Json.encode(:some => 'other'))
+p cl.get('users/tom.json')
+p cl.delete('users/tom.json')
 
-es.onopen{ |sock| p "Socket: #{sock}" }
-es.onmessage{ |event| p "Event: #{event}" }
-es.onerror{ |error| p "Error: #{error}" }
+# Need to tell onreconnect stops reconnecting, or even if we close
+# the connection manually, it would still try to reconnect again.
+@reconnect = false
 
-es.start # Start making the request
-sleep(5) # Sleep awhile to see anything is happening
-es.close # Close the connection when we're done
+# Close the connection to gracefully shut it down.
+es.close
 ```
 
 Those callbacks would be called in a separate background thread,

data/lib/rest-core/builder.rb

@@ -26,7 +26,7 @@ class RestCore::Builder
     client.send(:include, Client)
     class << client
       attr_reader   :builder
-      attr_accessor :pool_size, :pool_idle_time
+      attr_accessor :pool_size, :pool_idle_time, :event_source_class
 
       def thread_pool
         RestCore::ThreadPool[self]
@@ -35,6 +35,7 @@ class RestCore::Builder
     client.instance_variable_set(:@builder, self)
     client.instance_variable_set(:@pool_size, 0) # default to no pool
     client.instance_variable_set(:@pool_idle_time, 60) # default to 60 seconds
+    client.instance_variable_set(:@event_source_class, EventSource)
     client
   end
 

data/lib/rest-core/client/universal.rb

@@ -16,6 +16,7 @@ module RestCore
       use ErrorHandler, nil
       use ErrorDetectorHttp
       use JsonResponse, false
+      use QueryResponse, false
     end
   end
 end

data/lib/rest-core/client.rb

@@ -111,28 +111,30 @@ module RestCore::Client
     request(
       {REQUEST_METHOD  => :get   ,
        REQUEST_PATH    => path   ,
-       REQUEST_QUERY   => query  }.merge(opts), response_key(opts), &cb)
+       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), response_key(opts), &cb)
+       REQUEST_QUERY   => query  }.merge(opts), &cb)
   end
 
   def head path, query={}, opts={}, &cb
     request(
       {REQUEST_METHOD  => :head  ,
        REQUEST_PATH    => path   ,
-       REQUEST_QUERY   => query  }.merge(opts), RESPONSE_HEADERS, &cb)
+       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  }.merge(opts), RESPONSE_HEADERS, &cb)
+       REQUEST_QUERY   => query  ,
+       RESPONSE_KEY    => RESPONSE_HEADERS}.merge(opts), &cb)
   end
 
   def post   path, payload={}, query={}, opts={}, &cb
@@ -140,7 +142,7 @@ module RestCore::Client
       {REQUEST_METHOD  => :post  ,
        REQUEST_PATH    => path   ,
        REQUEST_QUERY   => query  ,
-       REQUEST_PAYLOAD => payload}.merge(opts), response_key(opts), &cb)
+       REQUEST_PAYLOAD => payload}.merge(opts), &cb)
   end
 
   def put    path, payload={}, query={}, opts={}, &cb
@@ -148,7 +150,7 @@ module RestCore::Client
       {REQUEST_METHOD  => :put   ,
        REQUEST_PATH    => path   ,
        REQUEST_QUERY   => query  ,
-       REQUEST_PAYLOAD => payload}.merge(opts), response_key(opts), &cb)
+       REQUEST_PAYLOAD => payload}.merge(opts), &cb)
   end
 
   def patch  path, payload={}, query={}, opts={}, &cb
@@ -156,18 +158,18 @@ module RestCore::Client
       {REQUEST_METHOD  => :patch ,
        REQUEST_PATH    => path   ,
        REQUEST_QUERY   => query  ,
-       REQUEST_PAYLOAD => payload}.merge(opts), response_key(opts), &cb)
+       REQUEST_PAYLOAD => payload}.merge(opts), &cb)
   end
 
   def event_source path, query={}, opts={}
-    EventSource.new(self, path, query, opts)
+    self.class.event_source_class.new(self, path, query, opts)
   end
 
-  def request env, key=RESPONSE_BODY, app=app
+  def request env, app=app
     if block_given?
-      request_full(env, app){ |response| yield(response[key]) }
+      request_full(env, app){ |response| yield(response[response_key(env)]) }
     else
-      request_full(env, app)[key]
+      request_full(env, app)[response_key(env)]
     end
   end
 
@@ -214,7 +216,8 @@ module RestCore::Client
   end
 
   def response_key opts
-    if opts[HIJACK] then RESPONSE_SOCKET else RESPONSE_BODY end
+    opts[RESPONSE_KEY] ||
+      if opts[HIJACK] then RESPONSE_SOCKET else RESPONSE_BODY end
   end
 
   def lighten_hash hash

data/lib/rest-core/engine/http-client.rb

@@ -24,7 +24,7 @@ class RestCore::HttpClient < RestCore::Engine
     client.connect_timeout, client.receive_timeout =
       calculate_timeout(env[TIMER])
 
-    res = client.request(env[REQUEST_METHOD], request_uri(env), nil,
+    res = client.request(env[REQUEST_METHOD], env[REQUEST_URI], nil,
             payload, {'User-Agent' => 'Ruby'}.merge(headers))
 
     promise.fulfill(res.content, res.status,
@@ -32,7 +32,7 @@ class RestCore::HttpClient < RestCore::Engine
   end
 
   def request_async client, payload, headers, promise, env
-    res = client.request_async(env[REQUEST_METHOD], request_uri(env), nil,
+    res = client.request_async(env[REQUEST_METHOD], env[REQUEST_URI], nil,
             payload, {'User-Agent' => 'Ruby'}.merge(headers)).pop
 
     promise.fulfill('', res.status,

data/lib/rest-core/engine/net-http-persistent.rb

@@ -8,7 +8,7 @@ class RestCore::NetHttpPersistent < RestCore::Engine
     http.open_timeout, http.read_timeout = calculate_timeout(env[TIMER])
     payload, headers = payload_and_headers(env)
 
-    uri = ::URI.parse(request_uri(env))
+    uri = ::URI.parse(env[REQUEST_URI])
     req = ::Net::HTTP.const_get(env[REQUEST_METHOD].to_s.capitalize).
             new(uri, headers)
     req.body_stream = payload

data/lib/rest-core/engine/rest-client.rb

@@ -8,7 +8,7 @@ class RestCore::RestClient < RestCore::Engine
     open_timeout, read_timeout = calculate_timeout(env[TIMER])
     payload, headers = payload_and_headers(env)
     res = ::RestClient::Request.execute(:method   => env[REQUEST_METHOD],
-                                        :url      => request_uri(env)   ,
+                                        :url      => env[REQUEST_URI]   ,
                                         :payload  => payload            ,
                                         :headers  => headers            ,
                                         :max_redirects => 0             ,

data/lib/rest-core/engine.rb

@@ -6,9 +6,10 @@ class RestCore::Engine
   include RestCore::Middleware
 
   def call env, &k
-    promise = Promise.new(env, k, env[ASYNC])
-    promise.defer{ request(promise, env) }
-    env.merge(RESPONSE_BODY    => promise.future_body,
+    req     = env.merge(REQUEST_URI => request_uri(env))
+    promise = Promise.new(req, k, req[ASYNC])
+    promise.defer{ request(promise, req) }
+    req.merge(RESPONSE_BODY    => promise.future_body,
               RESPONSE_STATUS  => promise.future_status,
               RESPONSE_HEADERS => promise.future_headers,
               RESPONSE_SOCKET  => promise.future_socket,

data/lib/rest-core/event_source.rb

@@ -8,13 +8,12 @@ class RestCore::EventSource < Struct.new(:client, :path, :query, :opts,
   def start
     self.mutex = Mutex.new
     self.condv = ConditionVariable.new
-    @onopen        ||= nil
-    @onmessage_for ||= nil
-    @onerror       ||= nil
-
-    o = {REQUEST_HEADERS => {'Accept' => 'text/event-stream'},
-         HIJACK          => true}.merge(opts)
-    client.get(path, query, o){ |sock| onopen(sock) }
+    @onopen      ||= nil
+    @onmessage   ||= nil
+    @onerror     ||= nil
+    @onreconnect ||= nil
+    reconnect
+    self
   end
 
   def closed?
@@ -29,15 +28,18 @@ class RestCore::EventSource < Struct.new(:client, :path, :query, :opts,
   def wait
     raise RC::Error.new("Not yet started for: #{self}") unless mutex
     mutex.synchronize{ condv.wait(mutex) until closed? } unless closed?
+    self
   end
 
   def onopen sock=nil, &cb
     if block_given?
       @onopen = cb
     else
+      self.socket = sock # for you to track the socket
       @onopen.call(sock) if @onopen
       onmessage_for(sock)
     end
+    self
   rescue Exception => e
     begin # close the socket since we're going to stop anyway
       sock.close # if we don't close it, client might wait forever
@@ -47,12 +49,13 @@ class RestCore::EventSource < Struct.new(:client, :path, :query, :opts,
     onerror(e, sock)
   end
 
-  def onmessage event=nil, sock=nil, &cb
+  def onmessage event=nil, data=nil, sock=nil, &cb
     if block_given?
       @onmessage = cb
     elsif @onmessage
-      @onmessage.call(event, sock)
+      @onmessage.call(event, data, sock)
     end
+    self
   end
 
   # would also be called upon closing, would always be called at least once
@@ -62,10 +65,26 @@ class RestCore::EventSource < Struct.new(:client, :path, :query, :opts,
     else
       begin
         @onerror.call(error, sock) if @onerror
-      ensure
-        condv.signal # should never deadlock someone
+        onreconnect(error, sock)
+      rescue
+        condv.signal # so we can't be reconnecting, need to try to unblock
+        raise
       end
     end
+    self
+  end
+
+  # would be called upon closing,
+  # and would try to reconnect if a callback is set and return true
+  def onreconnect error=nil, sock=nil, &cb
+    if block_given?
+      @onreconnect = cb
+    elsif closed? && @onreconnect && @onreconnect.call(error, sock)
+      reconnect
+    else
+      condv.signal # we could be closing, let's try to unblock it
+    end
+    self
   end
 
   protected
@@ -74,18 +93,23 @@ class RestCore::EventSource < Struct.new(:client, :path, :query, :opts,
   private
   # called in requesting thread after the request is done
   def onmessage_for sock
-    self.socket = sock # for you to track the socket
     until sock.eof?
       event = sock.readline("\n\n").split("\n").inject({}) do |r, i|
         k, v = i.split(': ', 2)
         r[k] = v
         r
       end
-      onmessage(event, sock)
+      onmessage(event['event'], event['data'], sock)
     end
     sock.close
     onerror(EOFError.new, sock)
   rescue IOError => e
     onerror(e, sock)
   end
+
+  def reconnect
+    o = {REQUEST_HEADERS => {'Accept' => 'text/event-stream'},
+         HIJACK          => true}.merge(opts)
+    client.get(path, query, o){ |sock| onopen(sock) }
+  end
 end

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

@@ -106,7 +106,8 @@ class RestCore::Cache
   end
 
   def cache_for? env
-    [:get, :head, :otpions].include?(env[REQUEST_METHOD]) && !env[DRY]
+    [:get, :head, :otpions].include?(env[REQUEST_METHOD]) &&
+      !env[DRY] && !env[HIJACK]
   end
 
   def header_cache_key env

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

@@ -30,9 +30,9 @@ class RestCore::FollowRedirect
                  res[REQUEST_METHOD]
                end
 
-    call(res.merge(REQUEST_PATH    => location,
-                   REQUEST_METHOD  => meth    ,
-                   REQUEST_PAYLOAD => {}      ,
+    call(res.merge(REQUEST_METHOD => meth    ,
+                   REQUEST_PATH   => location,
+                   REQUEST_QUERY  => {}      ,
                    'follow_redirect.max_redirects' =>
                      res['follow_redirect.max_redirects'] - 1), &k)
   end

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

@@ -0,0 +1,23 @@
+
+require 'rest-core/middleware'
+require 'rest-core/util/parse_query'
+
+class RestCore::QueryResponse
+  def self.members; [:query_response]; end
+  include RestCore::Middleware
+
+  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)
+
+    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
+

data/lib/rest-core/thread_pool.rb

@@ -45,6 +45,7 @@ class RestCore::ThreadPool
     # this should never fail
     def call
       job.call unless cancelled
+      true
     end
 
     # called from the other thread telling us it's timed out

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

@@ -0,0 +1,50 @@
+
+require 'erb'
+require 'yaml'
+
+module RestCore; end
+module RestCore::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)
+
+    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
+
+    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
+  end
+end

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

@@ -34,7 +34,7 @@ module RestCore::Json
       JSON.dump(hash)
     end
     def decode json
-      JSON.parse(json)
+      JSON.parse(json, :quirks_mode => true)
     end
   end
 

data/lib/rest-core/version.rb

@@ -1,4 +1,4 @@
 
 module RestCore
-  VERSION = '3.0.0'
+  VERSION = '3.1.0'
 end

data/lib/rest-core.rb

@@ -5,11 +5,13 @@ module RestCore
   REQUEST_QUERY    = 'REQUEST_QUERY'
   REQUEST_PAYLOAD  = 'REQUEST_PAYLOAD'
   REQUEST_HEADERS  = 'REQUEST_HEADERS'
+  REQUEST_URI      = 'REQUEST_URI'
 
   RESPONSE_BODY    = 'RESPONSE_BODY'
   RESPONSE_STATUS  = 'RESPONSE_STATUS'
   RESPONSE_HEADERS = 'RESPONSE_HEADERS'
   RESPONSE_SOCKET  = 'RESPONSE_SOCKET'
+  RESPONSE_KEY     = 'RESPONSE_KEY'
 
   DRY              = 'core.dry'
   FAIL             = 'core.fail'
@@ -40,6 +42,7 @@ module RestCore
   autoload :Json          , 'rest-core/util/json'
   autoload :ParseQuery    , 'rest-core/util/parse_query'
   autoload :Payload       , 'rest-core/util/payload'
+  autoload :Config        , 'rest-core/util/config'
 
   # middlewares
   autoload :AuthBasic     , 'rest-core/middleware/auth_basic'
@@ -57,6 +60,7 @@ module RestCore
   autoload :FollowRedirect, 'rest-core/middleware/follow_redirect'
   autoload :JsonRequest   , 'rest-core/middleware/json_request'
   autoload :JsonResponse  , 'rest-core/middleware/json_response'
+  autoload :QueryResponse , 'rest-core/middleware/query_response'
   autoload :Oauth1Header  , 'rest-core/middleware/oauth1_header'
   autoload :Oauth2Header  , 'rest-core/middleware/oauth2_header'
   autoload :Oauth2Query   , 'rest-core/middleware/oauth2_query'

data/rest-core.gemspec

@@ -1,14 +1,14 @@
 # -*- encoding: utf-8 -*-
-# stub: rest-core 3.0.0 ruby lib
+# stub: rest-core 3.1.0 ruby lib
 
 Gem::Specification.new do |s|
   s.name = "rest-core"
-  s.version = "3.0.0"
+  s.version = "3.1.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.require_paths = ["lib"]
   s.authors = ["Lin Jen-Shin (godfat)"]
-  s.date = "2014-05-04"
+  s.date = "2014-05-09"
   s.description = "Modular Ruby clients interface for REST APIs.\n\nThere has been an explosion in the number of REST APIs available today.\nTo address the need for a way to access these APIs easily and elegantly,\nwe have developed rest-core, which consists of composable middleware\nthat allows you to build a REST client for any REST API. Or in the case of\ncommon APIs such as Facebook, Github, and Twitter, you can simply use the\ndedicated clients provided by [rest-more][].\n\n[rest-more]: https://github.com/godfat/rest-more"
   s.email = ["godfat (XD) godfat.org"]
   s.files = [
@@ -57,6 +57,7 @@ Gem::Specification.new do |s|
   "lib/rest-core/middleware/oauth1_header.rb",
   "lib/rest-core/middleware/oauth2_header.rb",
   "lib/rest-core/middleware/oauth2_query.rb",
+  "lib/rest-core/middleware/query_response.rb",
   "lib/rest-core/middleware/timeout.rb",
   "lib/rest-core/patch/multi_json.rb",
   "lib/rest-core/patch/rest-client.rb",
@@ -64,6 +65,7 @@ Gem::Specification.new do |s|
   "lib/rest-core/test.rb",
   "lib/rest-core/thread_pool.rb",
   "lib/rest-core/timer.rb",
+  "lib/rest-core/util/config.rb",
   "lib/rest-core/util/hmac.rb",
   "lib/rest-core/util/json.rb",
   "lib/rest-core/util/parse_query.rb",
@@ -73,11 +75,13 @@ Gem::Specification.new do |s|
   "rest-core.gemspec",
   "task/README.md",
   "task/gemgem.rb",
+  "test/config/rest-core.yaml",
   "test/test_auth_basic.rb",
   "test/test_builder.rb",
   "test/test_cache.rb",
   "test/test_client.rb",
   "test/test_client_oauth1.rb",
+  "test/test_config.rb",
   "test/test_default_payload.rb",
   "test/test_default_query.rb",
   "test/test_error_detector.rb",
@@ -92,6 +96,7 @@ Gem::Specification.new do |s|
   "test/test_oauth2_header.rb",
   "test/test_payload.rb",
   "test/test_promise.rb",
+  "test/test_query_response.rb",
   "test/test_rest-client.rb",
   "test/test_simple.rb",
   "test/test_thread_pool.rb",
@@ -108,6 +113,7 @@ Gem::Specification.new do |s|
   "test/test_cache.rb",
   "test/test_client.rb",
   "test/test_client_oauth1.rb",
+  "test/test_config.rb",
   "test/test_default_payload.rb",
   "test/test_default_query.rb",
   "test/test_error_detector.rb",
@@ -122,6 +128,7 @@ Gem::Specification.new do |s|
   "test/test_oauth2_header.rb",
   "test/test_payload.rb",
   "test/test_promise.rb",
+  "test/test_query_response.rb",
   "test/test_rest-client.rb",
   "test/test_simple.rb",
   "test/test_thread_pool.rb",

data/test/config/rest-core.yaml

@@ -0,0 +1,8 @@
+
+test:
+  facebook:
+    app_id: 41829
+    secret: <%= 'r41829'.reverse %>
+    json_response: false
+    lang: zh-tw
+    auto_authorize_scope: 'publish_stream'

data/test/test_cache.rb

@@ -34,7 +34,8 @@ describe RC::Cache do
     c.app.app.tick.should.eq 2
     c.head('/').should.eq('A' => 'B')
     c.get('/').should.eq 'response'
-    c.request({RC::REQUEST_PATH => '/'}, RC::RESPONSE_STATUS).should.eq 200
+    c.request(RC::REQUEST_PATH => '/',
+              RC::RESPONSE_KEY => RC::RESPONSE_STATUS).should.eq 200
   end
 
   should 'basic 1' do
@@ -155,6 +156,17 @@ describe RC::Cache do
     c.cache.should.eq({})
   end
 
+  should 'not cache hijacking' do
+    stub_request(:get, 'http://a').to_return(:body => 'ok')
+    c = RC::Builder.client{use RC::Cache, {}, nil}.new
+    2.times do
+      c.get('http://a', {}, RC::HIJACK => true,
+                            RC::RESPONSE_KEY => RC::RESPONSE_SOCKET).
+        read.should.eq 'ok'
+    end
+    c.cache.should.eq({})
+  end
+
   should 'update cache if there is cache option set to false' do
     url, body = "https://cache", 'ok'
     stub_request(:get, url).to_return(:body => body)

data/test/test_config.rb

@@ -0,0 +1,28 @@
+
+require 'rest-core/test'
+
+describe RC::Config do
+  before do
+    @klass = RC::Builder.client
+  end
+
+  after do
+    Muack.verify
+  end
+
+  def check
+    @klass.default_app_id       .should.eq 41829
+    @klass.default_secret       .should.eq 'r41829'.reverse
+    @klass.default_json_response.should.eq false
+    @klass.default_lang         .should.eq 'zh-tw'
+  end
+
+  should 'honor config' do
+    RC::Config.load(
+      @klass,
+      "#{File.dirname(__FILE__)}/config/rest-core.yaml",
+      'test',
+      'facebook')
+    check
+  end
+end

data/test/test_error_handler.rb

@@ -39,6 +39,6 @@ describe RC::ErrorHandler do
 
   should 'no exception but errors' do
     client.new(:error_handler => lambda{ |res| 1 }).
-      request({RC::FAIL => [0]}, RC::FAIL).should.eq [0, 1]
+      request(RC::FAIL => [0], RC::RESPONSE_KEY => RC::FAIL).should.eq [0, 1]
   end
 end

data/test/test_event_source.rb

@@ -3,7 +3,11 @@ require 'socket'
 require 'rest-core/test'
 
 describe RC::EventSource do
-  client = RC::Builder.client.new
+  after do
+    WebMock.reset!
+  end
+
+  client = RC::Builder.client{use RC::Cache, {}, nil}.new
   server = lambda do |close=true|
     serv = TCPServer.new(0)
     port = serv.addr[1]
@@ -39,25 +43,21 @@ SSE
       sock.should.kind_of IO
       flag.should.eq 0
       flag += 1
-    end
-
-    es.onmessage do |event, sock|
-      event.should.eq(m.shift)
+    end.
+    onmessage do |event, data, sock|
+      {'event' => event, 'data' => data}.should.eq m.shift
       sock.should.kind_of IO
       sock.should.not.closed?
       flag += 1
-    end
-
-    es.onerror do |error, sock|
+    end.
+    onerror do |error, sock|
       error.should.kind_of EOFError
-      m.should.eq []
+      m.should.empty
       sock.should.closed?
       flag.should.eq 3
       flag += 1
-    end
+    end.start.wait
 
-    es.start
-    es.wait
     flag.should.eq 4
     t.join
   end
@@ -68,10 +68,67 @@ SSE
     es.onmessage do
       es.close
       flag += 1
-    end
-    es.start
-    es.wait
+    end.start.wait
+
     flag.should.eq 1
     t.join
   end
+
+  should 'reconnect' do
+    stub_request(:get, 'https://a?b=c').to_return(:body => <<-SSE)
+event: put
+data: 0
+
+event: put
+data: 1
+SSE
+    stub_request(:get, 'https://a?c=d').to_return(:body => <<-SSE)
+event: put
+data: 2
+
+event: put
+data: 3
+SSE
+    es = client.event_source('https://a', :b => 'c')
+    m = ('0'..'3').to_a
+    es.onmessage do |event, data|
+      data.should.eq m.shift
+
+    end.onerror do |error|
+      error.should.kind_of EOFError
+      es.query = {:c => 'd'}
+
+    end.onreconnect do |error, sock|
+      error.should.kind_of EOFError
+      sock.should.respond_to :read
+      !m.empty? # not empty to reconnect
+
+    end.start.wait
+    m.should.empty
+  end
+
+  should 'not cache' do
+    stub_request(:get, 'https://a?b=c').to_return(:body => <<-SSE)
+event: put
+data: 0
+
+event: put
+data: 1
+SSE
+    es = client.event_source('https://a', :b => 'c')
+    m = %w[0 1 0 1]
+    es.onmessage do |event, data|
+      data.should.eq m.shift
+
+    end.onerror do |error|
+      error.should.kind_of EOFError
+
+    end.onreconnect do |error, sock|
+      error.should.kind_of EOFError
+      sock.should.respond_to :read
+      !m.empty? # not empty to reconnect
+
+    end.start.wait
+    m.should.empty
+  end
 end

data/test/test_follow_redirect.rb

@@ -18,25 +18,42 @@ describe RC::FollowRedirect do
   [301, 302, 303, 307].each do |status|
     should "not follow redirect if reached max_redirects: #{status}" do
       dry.status = status
-      app.call(RC::REQUEST_METHOD => :get, 'max_redirects' => 0){ |res|
+      app.call(RC::REQUEST_METHOD => :get, 'max_redirects' => 0) do |res|
         res[RC::RESPONSE_HEADERS]['LOCATION'].should.eq 'location'
-      }
+      end
     end
 
     should "follow once: #{status}" do
       dry.status = status
-      app.call(RC::REQUEST_METHOD => :get){ |res|
+      app.call(RC::REQUEST_METHOD => :get) do |res|
         res[RC::RESPONSE_HEADERS]['LOCATION'].should.eq 'location'
-      }
+      end
     end
+
+    should "not carry query string: #{status}" do
+      dry.status = status
+      app.call(RC::REQUEST_METHOD => :get,
+               RC::REQUEST_QUERY => {:a => 'a'}) do |res|
+        res[RC::REQUEST_PATH] .should.eq 'location'
+        res[RC::REQUEST_QUERY].should.empty
+      end
+    end
+
+    should "carry payload for #{status}" do
+      dry.status = status
+      app.call(RC::REQUEST_METHOD => :put,
+               RC::REQUEST_PAYLOAD => {:a => 'a'}) do |res|
+        res[RC::REQUEST_PAYLOAD].should.eq(:a => 'a')
+      end
+    end if status != 303
   end
 
   [200, 201, 404, 500].each do |status|
     should "not follow redirect if it's not a redirect status: #{status}" do
       dry.status = status
-      app.call(RC::REQUEST_METHOD => :get, 'max_redirects' => 9){ |res|
+      app.call(RC::REQUEST_METHOD => :get, 'max_redirects' => 9) do |res|
         res[RC::RESPONSE_HEADERS]['LOCATION'].should.eq 'location'
-      }
+      end
     end
   end
 end

data/test/test_query_response.rb

@@ -0,0 +1,49 @@
+
+require 'rest-core/test'
+
+describe RC::QueryResponse do
+  describe 'app' do
+    app = RC::QueryResponse.new(RC::Dry.new, true)
+    expected = {RC::RESPONSE_BODY => {},
+                RC::REQUEST_HEADERS =>
+                  {'Accept' => 'application/x-www-form-urlencoded'}}
+
+    should 'give {} for nil' do
+      app.call({}){ |response| response.should.eq(expected) }
+    end
+
+    should 'give {} for ""' do
+      app.call(RC::RESPONSE_BODY => ''){ |r| r.should.eq(expected) }
+    end
+
+    should 'give {"a" => "b"} for "a=b"' do
+      e = expected.merge(RC::RESPONSE_BODY => {'a' => 'b'})
+      app.call(RC::RESPONSE_BODY => 'a=b'){ |r| r.should.eq(e) }
+    end
+  end
+
+  describe 'client' do
+    client = RC::Builder.client do
+      use RC::QueryResponse, true
+      run Class.new{
+        def call env
+          yield(env.merge(RC::RESPONSE_BODY => 'a=b&c=d'))
+        end
+      }
+    end
+
+    should 'do nothing' do
+      expected = 'a=b&c=d'
+      client.new(:query_response => false).get(''){ |response|
+        response.should.eq(expected)
+      }.get('').should.eq(expected)
+    end
+
+    should 'parse' do
+      expected = {'a' => 'b', 'c' => 'd'}
+      client.new.get(''){ |response|
+        response.should.eq(expected)
+      }.get('').should.eq(expected)
+    end
+  end
+end

data/test/test_rest-client.rb

@@ -39,7 +39,7 @@ describe RC::RestClient do
 
     should 'not kill the thread if error was coming from the task' do
       mock(RestClient::Request).execute{ raise 'boom' }.with_any_args
-      c.request({}, RC::FAIL).first.message.should.eq 'boom'
+      c.request(RC::RESPONSE_KEY => RC::FAIL).first.message.should.eq 'boom'
       Muack.verify
     end
 
@@ -54,7 +54,8 @@ describe RC::RestClient do
       stub(c.class.thread_pool).queue{ [] } # don't queue the task
       mock(RC::ThreadPool::Task).new.with_any_args.
         peek_return{ |t| mock(t).cancel; t } # the task should be cancelled
-      c.request({RC::TIMER => timer}, RC::FAIL).first.message.should.eq 'boom'
+      c.request(RC::RESPONSE_KEY => RC::FAIL, RC::TIMER => timer).
+        first.message.should.eq 'boom'
       Muack.verify
     end
   end

data/test/test_simple.rb

@@ -2,13 +2,36 @@
 require 'rest-core/test'
 
 describe RC::Simple do
-  before do
-    @path = 'http://example.com'
-    stub_request(:get, @path).to_return(:body => 'OK')
+  path = 'http://example.com/'
+
+  after do
+    WebMock.reset!
   end
 
-  should 'work with RC' do
-    RC::Simple.new.get(@path).should.eq 'OK'
+  should 'give RESPONSE_BODY' do
+    stub_request(:get, path).to_return(:body => 'OK')
+    RC::Simple.new.get(path).should.eq 'OK'
+  end
+
+  should 'give RESPONSE_HEADERS' do
+    stub_request(:head, path).to_return(:headers => {'A' => 'B'})
+    RC::Simple.new.head(path).should.eq 'A' => 'B'
+  end
+
+  should 'give RESPONSE_HEADERS' do
+    stub_request(:get, path).to_return(:status => 199)
+    RC::Simple.new.get(path, {},
+      RC::RESPONSE_KEY => RC::RESPONSE_STATUS).should.eq 199
+  end
+
+  should 'give RESPONSE_SOCKET' do
+    stub_request(:get, path).to_return(:body => 'OK')
+    RC::Simple.new.get(path, {}, RC::HIJACK => true).read.should.eq 'OK'
   end
-end
 
+  should 'give REQUEST_URI' do
+    stub_request(:get, "#{path}?a=b").to_return(:body => 'OK')
+    RC::Simple.new.get(path, {:a => 'b'},
+      RC::RESPONSE_KEY => RC::REQUEST_URI).should.eq "#{path}?a=b"
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rest-core
 version: !ruby/object:Gem::Version
-  version: 3.0.0
+  version: 3.1.0
 platform: ruby
 authors:
 - Lin Jen-Shin (godfat)
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-05-04 00:00:00.000000000 Z
+date: 2014-05-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: httpclient
@@ -114,6 +114,7 @@ files:
 - lib/rest-core/middleware/oauth1_header.rb
 - lib/rest-core/middleware/oauth2_header.rb
 - lib/rest-core/middleware/oauth2_query.rb
+- lib/rest-core/middleware/query_response.rb
 - lib/rest-core/middleware/timeout.rb
 - lib/rest-core/patch/multi_json.rb
 - lib/rest-core/patch/rest-client.rb
@@ -121,6 +122,7 @@ files:
 - lib/rest-core/test.rb
 - lib/rest-core/thread_pool.rb
 - lib/rest-core/timer.rb
+- lib/rest-core/util/config.rb
 - lib/rest-core/util/hmac.rb
 - lib/rest-core/util/json.rb
 - lib/rest-core/util/parse_query.rb
@@ -130,11 +132,13 @@ files:
 - rest-core.gemspec
 - task/README.md
 - task/gemgem.rb
+- test/config/rest-core.yaml
 - test/test_auth_basic.rb
 - test/test_builder.rb
 - test/test_cache.rb
 - test/test_client.rb
 - test/test_client_oauth1.rb
+- test/test_config.rb
 - test/test_default_payload.rb
 - test/test_default_query.rb
 - test/test_error_detector.rb
@@ -149,6 +153,7 @@ files:
 - test/test_oauth2_header.rb
 - test/test_payload.rb
 - test/test_promise.rb
+- test/test_query_response.rb
 - test/test_rest-client.rb
 - test/test_simple.rb
 - test/test_thread_pool.rb
@@ -185,6 +190,7 @@ test_files:
 - test/test_cache.rb
 - test/test_client.rb
 - test/test_client_oauth1.rb
+- test/test_config.rb
 - test/test_default_payload.rb
 - test/test_default_query.rb
 - test/test_error_detector.rb
@@ -199,6 +205,7 @@ test_files:
 - test/test_oauth2_header.rb
 - test/test_payload.rb
 - test/test_promise.rb
+- test/test_query_response.rb
 - test/test_rest-client.rb
 - test/test_simple.rb
 - test/test_thread_pool.rb