rest-core 2.1.2 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 71b8ab944328b862d8a3524a01da91432fe7fcb4
-  data.tar.gz: 204f46ff9a25281ffdbbe814df50831519a98c88
+  metadata.gz: 58ed90f247d23da6267042bf108e50637e8dba98
+  data.tar.gz: a0d0b5f7dd766fee5426fc0faf5c5d0dd6adb229
 SHA512:
-  metadata.gz: 67d6c4ee4116a562fa5a16a41b6c94b5b4f0c768abc077e78d1b0a416d28146784a9a358208175de212c9ccac3fe3956a00bda5eabfa81ba714beec2aeeaec7e
-  data.tar.gz: 7f723ab6d7e7b295d24b664aa9ef1ce38d56c39e2c2ef75d34aaded046a8aa97d9fb1b16ecf5a3d1867fba596afb46f4203f250b9f729ccad998dfbf887cb72f
+  metadata.gz: a45a9c11e364a08414a7e583feedbe3a289a59fba42aa8d0180e0144e91279b7a77662737c489ec466402a72db4a2833f9e674ad27954d93e325e33713f4766d
+  data.tar.gz: 3f3b2e09cd1131543a677e9a61cf4872c70fb272aad936eccd0f005d6490646b6589e0128ffd33f6107b644c77ef772a34f6433bd6c3d37fffe0aa1a53b72010

data/.gitignore

@@ -1,2 +1 @@
-pkg
-*.rbc
+/pkg/

data/.travis.yml

@@ -1,11 +1,9 @@
 before_install: 'git submodule update --init'
 script: 'ruby -r bundler/setup -S rake test'
 
-env:
-  - 'RBXOPT=-X19'
-
 rvm:
   - 1.9.3
   - 2.0.0
-  - rbx-head
-  - jruby-head
+  - ruby
+  - rbx
+  - jruby

data/CHANGES.md

@@ -1,5 +1,65 @@
 # CHANGES
 
+## rest-core 3.0.0 -- ?
+
+Highlights:
+
+* Hijack for streaming responses
+* EventSource for SSE (server-sent events)
+* Thread pool
+* Keep-alive connections from httpclient
+
+### Incompatible changes
+
+* Since eventmachine is buggy, and fibers without eventmachine doesn't make
+  too much sense, we have removed the support for eventmachine and fibers.
+
+* We also changed the default HTTP client from rest-client to httpclient.
+  If you still want to use rest-client, switch it like this:
+
+      RC::Builder.default_engine = RC::RestClient
+
+  Be warned, we might remove rest-client support in the future.
+
+* `RC::Client#options` would now return the headers instead of response body.
+
+* Removed support for Ruby 1.8.7 without openssl installed.
+
+* `RC::Future` is renamed to `RC::Promise`, and `RC::Future::Proxy` is
+  renamed to `RC::Promise::Future`.
+
+### Enhancement
+
+* HIJACK support, which is similar to Rack's HIJACK feature. If you're
+  passing `{RC::HIJACK => true}` whenever making a request, rest-core would
+  rather set the `RC::RESPONSE_BODY` as an empty string, and set
+  `RC::RESPONSE_SOCKET` as a socket for the response. This is used for
+  `RC::EventSource`, and you could also use this for streaming the response.
+  Note that this only works for default engine, httpclient.
+
+* Introduce `RC::EventSource`. You could obtain the object via
+  `RC::Client#event_source`, and then setup `onopen`, `onmessage`, and
+  `onerror` respectively, and then call `RC::EventSource#start` to begin
+  making the request, and receive the SSE (sever-sent events) from the server.
+  This is used in `RC::Firebase` from rest-more.
+
+* Now we have thread pool support. We could set the pool size with:
+  `RC::YourClient.pool_size = 10` and thread idle time with:
+  `RC::YourClient.pool_idle_time = 60`. By default, `pool_size` is 0
+  which means we don't use a thread pool. Setting it to a negative number
+  would mean do not spawn any threads, just make a blocking request.
+  `pool_idle_time` is default to 60, meaning an idle thread would be shut
+  down after 60 seconds without being used.
+
+* Since we're now using httpclient by default, we should also take the
+  advantage of using keep-alive connections for the same host.
+
+* Now `RC::Middleware#fail` and `RC::Middleware#log` could accept `nil` as
+  an input, which would then do nothing. This could much simplify the code
+  building middleware.
+
+* Now we're using timers gem which should be less buggy from previous timeout.
+
 ## rest-core 2.1.2 -- 2013-05-31
 
 ### Incompatible changes
@@ -160,7 +220,7 @@ It's a bit outdated, but you can also checkout my blog post.
 [rest-core 2.0 roadmap, thunk based response][post]
 (p.s. now thunk is renamed to future)
 
-[use-cases.rb]: https://github.com/cardinalblue/rest-core/blob/master/example/use-cases.rb
+[use-cases.rb]: https://github.com/godfat/rest-core/blob/master/example/use-cases.rb
 [post]: http://blogger.godfat.org/2012/06/rest-core-20-roadmap-thunk-based.html
 
 ### Incompatible changes
@@ -263,8 +323,8 @@ This is a very significant release. The most important change is now we
 support asynchronous requests, by either passing a callback block or using
 fibers in Ruby 1.9 to make the whole program still look synchronous.
 
-Please read [README.md](https://github.com/cardinalblue/rest-core/blob/master/README.md)
-or [example](https://github.com/cardinalblue/rest-core/tree/master/example)
+Please read [README.md](https://github.com/godfat/rest-core/blob/master/README.md)
+or [example](https://github.com/godfat/rest-core/tree/master/example)
 for more detail.
 
 * [`Client`] Client#inspect is fixed for clients which do not have any
@@ -472,7 +532,7 @@ others are moved to [rest-more][]. Since bundler didn't like cyclic
 dependency, so rest-core is not depending on rest-more. Please install
 _rest-more_ if you want to use them.
 
-[rest-more]: https://github.com/cardinalblue/rest-more
+[rest-more]: https://github.com/godfat/rest-more
 
 ## rest-core 0.4.0 -- 2011-09-26
 
@@ -563,7 +623,7 @@ _rest-more_ if you want to use them.
         twitter:
           consumer_key: abc
 
-[rest-graph]: https://github.com/cardinalblue/rest-graph
+[rest-graph]: https://github.com/godfat/rest-graph
 
 ## rest-core 0.2.3 -- 2011-08-27
 

data/Gemfile

@@ -4,11 +4,10 @@ source 'https://rubygems.org/'
 gemspec
 
 gem 'rest-client'
-gem 'em-http-request'
 
 gem 'rake'
 gem 'bacon'
-gem 'rr'
+gem 'muack'
 gem 'webmock'
 
 gem 'json'
@@ -16,12 +15,18 @@ gem 'json_pure'
 gem 'multi_json'
 
 gem 'rack'
-gem 'ruby-hmac'
 
-platforms(:ruby) do
+platforms :ruby do
   gem 'yajl-ruby'
 end
 
-platforms(:jruby) do
+platforms :rbx do
+  gem 'rubysl-weakref'    # used in rest-core
+  gem 'rubysl-singleton'  # used in rake
+  gem 'rubysl-rexml'      # used in crack used in webmock
+  gem 'rubysl-bigdecimal' # used in crack used in webmock
+end
+
+platforms :jruby do
   gem 'jruby-openssl'
 end

data/NOTE.md

@@ -43,6 +43,6 @@ and use that along with pre-built ones to compose a very customized client.
 
 We present you rest-core.
 
-[rest-core]: https://github.com/cardinalblue/rest-core
+[rest-core]: https://github.com/godfat/rest-core
 [Rack]: https://github.com/rack/rack
 [Faraday]: https://github.com/technoweenie/faraday

data/README.md

@@ -1,6 +1,6 @@
 # rest-core [![Build Status](https://secure.travis-ci.org/godfat/rest-core.png?branch=master)](http://travis-ci.org/godfat/rest-core)
 
-by Cardinal Blue <http://cardinalblue.com>
+by Lin Jen-Shin ([godfat](http://godfat.org))
 
 Lin Jen-Shin ([godfat][]) had given a talk about rest-core on
 [RubyConf Taiwan 2011][talk]. The slide is in English, but the
@@ -11,9 +11,9 @@ talk is in Mandarin.
 
 ## LINKS:
 
-* [github](https://github.com/cardinalblue/rest-core)
+* [github](https://github.com/godfat/rest-core)
 * [rubygems](https://rubygems.org/gems/rest-core)
-* [rdoc](http://rdoc.info/projects/cardinalblue/rest-core)
+* [rdoc](http://rdoc.info/projects/godfat/rest-core)
 * [mailing list](http://groups.google.com/group/rest-core/topics)
 
 ## DESCRIPTION:
@@ -27,28 +27,36 @@ 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][].
 
-[rest-more]: https://github.com/cardinalblue/rest-more
+[rest-more]: https://github.com/godfat/rest-more
 
 ## FEATURES:
 
 * Modular interface for REST clients similar to WSGI/Rack for servers.
 * Concurrent requests with synchronous or asynchronous interfaces with
-  fibers or threads are both supported.
+  threads.
+
+## WHY?
+
+Build your own API clients for less dependencies, less codes,
+less memory, less conflicts, and run faster.
 
 ## REQUIREMENTS:
 
 ### Mandatory:
 
-* MRI (official CRuby) 1.9.3, Rubinius 1.9 and JRuby 1.9
-* gem rest-client
+* Tested with MRI (official CRuby), Rubinius and JRuby.
+* gem [httpclient][]
+* gem [mime-types][]
+* gem [timers][]
+
+[httpclient]: https://github.com/nahi/httpclient
+[mime-types]: https://github.com/halostatue/mime-types
+[timers]: https://github.com/celluloid/timers
 
 ### Optional:
 
-* gem [em-http-request][] (if using eventmachine)
 * gem json or yajl-ruby, or multi_json (if `JsonResponse` or
-  `JsonRequest` middlewares are used)
-
-[em-http-request]: https://github.com/igrigorik/em-http-request
+  `JsonRequest` middleware is used)
 
 ## INSTALLATION:
 
@@ -59,14 +67,14 @@ gem install rest-core
 Or if you want development version, put this in Gemfile:
 
 ``` ruby
-gem 'rest-core', :git => 'git://github.com/cardinalblue/rest-core.git',
+gem 'rest-core', :git => 'git://github.com/godfat/rest-core.git',
                  :submodules => true
 ```
 
 If you just want to use Facebook or Twitter clients, please take a look at
 [rest-more][] which has a lot of clients built with rest-core.
 
-[rest-more]: http://github.com/cardinalblue/rest-more
+[rest-more]: http://github.com/godfat/rest-more
 
 ## Build Your Own Clients:
 
@@ -90,12 +98,12 @@ configuration, e.g. different cache time or timeout time):
 
 ``` ruby
 client = YourClient.new(:cache => {})
-client.get('cardinalblue') # cache miss
-client.get('cardinalblue') # cache hit
+client.get('godfat') # cache miss
+client.get('godfat') # cache hit
 
 client.site = 'http://github.com/api/v2/json/user/show/'
-client.get('cardinalblue') # cache miss
-client.get('cardinalblue') # cache hit
+client.get('godfat') # cache miss
+client.get('godfat') # cache hit
 ```
 
 ### Concurrent Requests with Futures:
@@ -104,7 +112,7 @@ You can also make concurrent requests easily:
 (see "Advanced Concurrent HTTP Requests -- Embrace the Future" for detail)
 
 ``` ruby
-a = [client.get('cardinalblue'), client.get('godfat')]
+a = [client.get('godfat'), client.get('cardinalblue')]
 puts "It's not blocking... but doing concurrent requests underneath"
 p a.map{ |r| r['name'] } # here we want the values, so it blocks here
 puts "DONE"
@@ -165,7 +173,7 @@ should work.
 On the other hand, callback mode also available:
 
 ``` ruby
-client.get('cardinalblue'){ |v| p v }
+client.get('godfat'){ |v| p v }
 puts "It's not blocking... but doing concurrent requests underneath"
 client.wait # we block here to wait for the request done
 puts "DONE"
@@ -191,6 +199,108 @@ client.wait # we block here to wait for the request done
 puts "DONE"
 ```
 
+### Thread Pool / Connection Pool
+
+Underneath, rest-core would spawn a thread for each request, freeing you
+from blocking. However, occasionally we would not want this behaviour,
+giving that we might have limited resource and cannot maximize performance.
+
+For example, maybe we could not afford so many threads running concurrently,
+or the target server cannot accept so many concurrent connections. In those
+cases, we would want to have limited concurrent threads or connections.
+
+``` ruby
+YourClient.pool_size = 10
+YourClient.pool_idle_time = 60
+```
+
+This could set the thread pool size to 10, having a maximum of 10 threads
+running together, growing from requests. Each threads idled more than 60
+seconds would be shut down automatically.
+
+Note that `pool_size` should at least be larger than 4, or it might be
+very likely to have _deadlock_ if you're using nested callbacks and having
+a large number of concurrent calls.
+
+Also, setting `pool_size` to `-1` would mean we want to make blocking
+requests, without spawning any threads. This might be useful for debugging.
+
+### Persistent connections (keep-alive connections)
+
+Since we're using [httpclient][] by default now, we would reuse connections,
+making it much faster for hitting the same host repeatedly.
+
+### Streaming Requests
+
+Suppose we want to POST a file, instead of trying to read all the contents
+in memory and send them, we could stream it from the file system directly.
+
+``` ruby
+client.post('path', File.open('README.md'))
+```
+
+Basically, payloads could be any IO object. Check out
+[RC::Payload](lib/rest-core/util/payload.rb) for more information.
+
+### Streaming Responses
+
+This one is much harder then streaming requests, since all built-in
+middleware actually assume the responses should be blocking and buffered.
+Say, some JSON parser could not really parse from streams.
+
+We solve this issue similarly to the way Rack solves it. That is, we hijack
+the socket. This would be how we're doing:
+
+``` ruby
+sock = client.get('path', {}, RC::HIJACK => true)
+p sock.read(10)
+p sock.read(10)
+p sock.read(10)
+```
+
+Of course, if we don't want to block in order to get the socket, we could
+always use the callback form:
+
+``` ruby
+client.get('path', {}, RC::HIJACK => true) do |sock|
+  p sock.read(10)
+  p sock.read(10)
+  p sock.read(10)
+end
+```
+
+Note that since the socket would be put inside `RC::RESPONSE_SOCKET`
+instead of `RC::RESPONSE_BODY`, not all middleware would handle the socket.
+In the case of hijacking, `RC::RESPONSE_BODY` would always be mapped to an
+empty string, as it does not make sense to store the response in this case.
+
+### SSE (Server-Sent Events)
+
+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:
+
+``` ruby
+es = RC::Universal.new.event_source(
+       'https://SampleChat.firebaseIO-demo.com/users/tom/.json')
+
+es.onopen{ |sock| p "Socket: #{sock}" }
+es.onmessage{ |event| p "Event: #{event}" }
+es.onerror{ |error| p "Error: #{error}" }
+
+es.start # Start making the request
+sleep(5) # Sleep awhile to see anything is happening
+es.close # Close the connection when we're done
+```
+
+Those callbacks would be called in a separate background thread,
+so we don't have to worry about blocking it. If we want to wait for
+the connection to be closed, we could call `wait`:
+
+``` ruby
+es.wait # This would block until the connection is closed
+```
+
 ### More Control with `request_full`:
 
 You can also use `request_full` to retrieve everything including response
@@ -202,17 +312,15 @@ including the path.
 ``` ruby
 client.request_full({})[RC::RESPONSE_BODY] # {"message"=>"Not Found"}
 # This would print something like this:
-# RestCore: Auto   picked: RestCore::RestClient
-# RestCore: Future picked: RestCore::Future::FutureThread
-# RestCore: spent 1.135713 Requested GET https://api.github.com/users//
+# RestCore: spent 1.135713 Requested GET https://api.github.com/users/
 
-client.request_full(RC::REQUEST_PATH => 'cardinalblue')[RC::RESPONSE_STATUS]
-client.request_full(RC::REQUEST_PATH => 'cardinalblue')[RC::RESPONSE_HEADERS]
+client.request_full(RC::REQUEST_PATH => 'godfat')[RC::RESPONSE_STATUS]
+client.request_full(RC::REQUEST_PATH => 'godfat')[RC::RESPONSE_HEADERS]
 # Headers are normalized with all upper cases and
 # dashes are replaced by underscores.
 
 # To make POST (or any other request methods) request:
-client.request_full(RC::REQUEST_PATH   => 'cardinalblue',
+client.request_full(RC::REQUEST_PATH   => 'godfat',
                     RC::REQUEST_METHOD => :post)[RC::RESPONSE_STATUS] # 404
 ```
 
@@ -222,15 +330,15 @@ Runnable example is at: [example/simple.rb][]. Please see [rest-more][]
 for more complex examples to build clients, and [slides][] from
 [rubyconf.tw/2011][rubyconf.tw] for concepts.
 
-[example/simple.rb]: https://github.com/cardinalblue/rest-core/blob/master/example/simple.rb
-[rest-more]: https://github.com/cardinalblue/rest-more
+[example/simple.rb]: example/simple.rb
+[rest-more]: https://github.com/godfat/rest-more
 [slides]: http://www.godfat.org/slide/2011-08-27-rest-core.html
 [rubyconf.tw]: http://rubyconf.tw/2011/#6
 
 ## Playing Around:
 
 You can also play around with `RC::Universal` client, which has installed
-_all_ reasonable middlewares built-in rest-core. So the above example could
+_all_ reasonable middleware built-in rest-core. So the above example could
 also be achieved by:
 
 ``` ruby
@@ -238,7 +346,7 @@ require 'rest-core'
 client = RC::Universal.new(:site          => 'https://api.github.com/users/',
                            :json_response => true,
                            :log_method    => method(:puts))
-client.get('cardinalblue')
+client.get('godfat')
 ```
 
 `RC::Universal` is defined as:
@@ -276,7 +384,7 @@ rib rest-core
 And you will be entering a rib shell, which `self` is an instance of
 `RC::Universal` you can play:
 
-    rest-core>> get 'https://api.github.com/users/cardinalblue'
+    rest-core>> get 'https://api.github.com/users/godfat'
 
 will print out the response from Github. You can also do this to make
 calling Github easier:
@@ -286,36 +394,56 @@ calling Github easier:
 
 Then it would do exactly like the original example:
 
-    rest-core>> get 'cardinalblue' # you get a nice parsed hash
+    rest-core>> get 'godfat' # you get a nice parsed hash
 
 This is mostly for fun and experimenting, so it's only included in
 [rest-more][] and [rib][]. Please make sure you have both of them
 installed before trying this.
 
 [rib]: https://github.com/godfat/rib
-[rest-more]: https://github.com/cardinalblue/rest-more
+[rest-more]: https://github.com/godfat/rest-more
 
 ## List of built-in Middleware:
 
-* `RC::AuthBasic`
-* `RC::Bypass`
-* `RC::Cache`
-* `RC::CommonLogger`
-* `RC::DefaultHeaders`
-* `RC::DefaultPayload`
-* `RC::DefaultQuery`
-* `RC::DefaultSite`
-* `RC::Defaults`
-* `RC::ErrorDetector`
-* `RC::ErrorDetectorHttp`
-* `RC::ErrorHandler`
-* `RC::FollowRedirect`
-* `RC::JsonRequest`
-* `RC::JsonResponse`
-* `RC::Oauth1Header`
-* `RC::Oauth2Header`
-* `RC::Oauth2Query`
-* `RC::Timeout`
+* [RC::AuthBasic][]
+* [RC::Bypass][]
+* [RC::Cache][]
+* [RC::CommonLogger][]
+* [RC::DefaultHeaders][]
+* [RC::DefaultPayload][]
+* [RC::DefaultQuery][]
+* [RC::DefaultSite][]
+* [RC::Defaults][]
+* [RC::ErrorDetector][]
+* [RC::ErrorDetectorHttp][]
+* [RC::ErrorHandler][]
+* [RC::FollowRedirect][]
+* [RC::JsonRequest][]
+* [RC::JsonResponse][]
+* [RC::Oauth1Header][]
+* [RC::Oauth2Header][]
+* [RC::Oauth2Query][]
+* [RC::Timeout][]
+
+[RC::AuthBasic]: lib/rest-core/middleware/auth_basic.rb
+[RC::Bypass]: lib/rest-core/middleware/bypass.rb
+[RC::Cache]: lib/rest-core/middleware/cache.rb
+[RC::CommonLogger]: lib/rest-core/middleware/common_logger.rb
+[RC::DefaultHeaders]: lib/rest-core/middleware/default_headers.rb
+[RC::DefaultPayload]: lib/rest-core/middleware/default_payload.rb
+[RC::DefaultQuery]: lib/rest-core/middleware/default_query.rb
+[RC::DefaultSite]: lib/rest-core/middleware/default_site.rb
+[RC::Defaults]: lib/rest-core/middleware/defaults.rb
+[RC::ErrorDetector]: lib/rest-core/middleware/error_detector.rb
+[RC::ErrorDetectorHttp]: lib/rest-core/middleware/error_detector_http.rb
+[RC::ErrorHandler]: lib/rest-core/middleware/error_handler.rb
+[RC::FollowRedirect]: lib/rest-core/middleware/follow_redirect.rb
+[RC::JsonRequest]: lib/rest-core/middleware/json_request.rb
+[RC::JsonResponse]: lib/rest-core/middleware/json_response.rb
+[RC::Oauth1Header]: lib/rest-core/middleware/oauth1_header.rb
+[RC::Oauth2Header]: lib/rest-core/middleware/oauth2_header.rb
+[RC::Oauth2Query]: lib/rest-core/middleware/oauth2_query.rb
+[RC::Timeout]: lib/rest-core/middleware/timeout.rb
 
 ## Build Your Own Middleware:
 
@@ -425,8 +553,8 @@ YourClient = RC::Builder.client do
 end
 
 client = YourClient.new
-puts "rest-client with threads doing concurrent requests"
-a = [client.get('cardinalblue'), client.get('godfat')]
+puts "httpclient with threads doing concurrent requests"
+a = [client.get('godfat'), client.get('cardinalblue')]
 puts "It's not blocking... but doing concurrent requests underneath"
 p a.map{ |r| r['name'] } # here we want the values, so it blocks here
 puts "DONE"
@@ -443,11 +571,11 @@ YourClient = RC::Builder.client do
 end
 
 client = YourClient.new
-puts "rest-client with threads doing concurrent requests"
-client.get('cardinalblue'){ |v|
+puts "httpclient with threads doing concurrent requests"
+client.get('godfat'){ |v|
          p v['name']
        }.
-       get('godfat'){ |v|
+       get('cardinalblue'){ |v|
          p v['name']
        }
 puts "It's not blocking... but doing concurrent requests underneath"
@@ -459,85 +587,21 @@ You can pick whatever works for you.
 
 [future]: http://en.wikipedia.org/wiki/Futures_and_promises
 
-### What Concurrency Model to Choose?
-
-In the above example, we're using rest-client with threads, which works
-for most of cases. But you might also want to use em-http-request with
-EventMachine, which is using a faster HTTP parser. In theory, it should
-be much more efficient than rest-client and threads.
-
-To pick em-http-request, you must run the requests inside the EventMachine's
-event loop, and also wrap your request with either a thread or a fiber,
-because we can't block the event loop and ask em-http-request to finish
-its job making requests.
-
-Here's an example of using em-http-request with threads:
-
-``` ruby
-require 'em-http-request'
-require 'rest-core'
-YourClient = RC::Builder.client do
-  use RC::DefaultSite , 'https://api.github.com/users/'
-  use RC::JsonResponse, true
-  use RC::CommonLogger, method(:puts)
-end
-
-client = YourClient.new
-puts "eventmachine with threads doing concurrent requests"
-EM.run{
-  Thread.new{
-    a = [client.get('cardinalblue'), client.get('godfat')]
-    p a.map{ |r| r['name'] } # here we want the values, so it blocks here
-    puts "DONE"
-    EM.stop
-  }
-  puts "It's not blocking... but doing concurrent requests underneath"
-}
-```
-
-And here's an example of using em-http-request with fibers:
-
-``` ruby
-require 'fiber'           # remember to require fiber first,
-require 'em-http-request' # or rest-core won't pick fibers
-require 'rest-core'
-YourClient = RC::Builder.client do
-  use RC::DefaultSite , 'https://api.github.com/users/'
-  use RC::JsonResponse, true
-  use RC::CommonLogger, method(:puts)
-end
-
-client = YourClient.new
-puts "eventmachine with fibers doing concurrent requests"
-EM.run{
-  Fiber.new{
-    a = [client.get('cardinalblue'), client.get('godfat')]
-    p a.map{ |r| r['name'] } # here we want the values, so it blocks here
-    puts "DONE"
-    EM.stop
-  }
-  puts "It's not blocking... but doing concurrent requests underneath"
-}
-```
-
-As you can see, both of them are quite similar to each other, because the
-idea behind the scene is the same. If you don't know what concurrency model
-to pick, start with rest-client since it's the easiest one to setup.
-
-A full runnable example is at: [example/multi.rb][]. If you want to know
+A full runnable example is at: [example/simple.rb][]. If you want to know
 all the possible use cases, you can also see: [example/use-cases.rb][]. It's
 also served as a test for each possible combinations, so it's quite complex
 and complete.
 
-[example/multi.rb]: https://github.com/cardinalblue/rest-core/blob/master/example/multi.rb
-
-[example/use-cases.rb]: https://github.com/cardinalblue/rest-core/blob/master/example/use-cases.rb
+[example/simple.rb]: example/simple.rb
+[example/use-cases.rb]: example/use-cases.rb
 
 ## rest-core users:
 
-* [topcoder](https://github.com/miaout17/topcoder)
+* [rest-more][]
+* [rest-more-yahoo_buy](https://github.com/GoodLife/rest-more-yahoo_buy)
 * [s2sync](https://github.com/brucehsu/s2sync)
 * [s2sync_web](https://github.com/brucehsu/s2sync_web)
+* [topcoder](https://github.com/miaout17/topcoder)
 
 ## Powered sites:
 
@@ -545,7 +609,7 @@ and complete.
 
 ## CHANGES:
 
-* [CHANGES](https://github.com/cardinalblue/rest-core/blob/master/CHANGES.md)
+* [CHANGES](CHANGES.md)
 
 ## CONTRIBUTORS:
 
@@ -557,7 +621,9 @@ and complete.
 * Florent Vaucelle (@florent)
 * Jaime Cham (@jcham)
 * John Fan (@johnfan)
+* khoa nguyen (@khoan)
 * Lin Jen-Shin (@godfat)
+* lulalala (@lulalala)
 * Mariusz Pruszynski (@snicky)
 * Mr. Big Cat (@miaout17)
 * Nicolas Fouché (@nfo)
@@ -567,7 +633,7 @@ and complete.
 
 Apache License 2.0
 
-Copyright (c) 2011-2012, Cardinal Blue
+Copyright (c) 2011-2014, Lin Jen-Shin (godfat)
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.