Rest-core 1.0.0 released

rest-core https://github.com/cardinalblue/rest-core

by Cardinal Blue http://cardinalblue.com

Lin Jen-Shin (godfat) had given a talk about rest-core on
RubyConf Taiwan 2011. The slide is in English, but the
talk is in Mandarin.

You can also read some other topics at doc

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.

INSTALLATION:

gem install rest-core

Or if you want development version, put this in Gemfile:

gem 'rest-core', :git => 'git://github.com/cardinalblue/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.

CHANGES:

rest-core 1.0.0 – 2012-03-17

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)
for more detail.

  • [Client] Client#inspect is fixed for clients which do not have any
    attributes.

  • [Client] HEAD, OPTIONS, and PATCH requests are added. For example:

    client = Client.new
    client.head('path')
    client.options('path')
    client.patch('path')
    
  • [Client] Now if you passed a block to either get or post or
    other
    requests, the response would be returned to the block instead the
    caller.
    In this case, the return value of get or post would be the
    client
    itself. For example:

    client = Client.new
    client.get('path'){ |response| puts response.insepct }.
           get('math'){ |response| puts response.insepct }
    
  • [RestClient] Now all the response headers names are converted to
    upper
    cases and underscores (_). Also, if a header has only presented
    once, it
    would not be wrapped inside an array. This is more consistent with
    em-http-request, cool.io-http, and http_parser.rb

  • [RestClient] From now on, the default HTTP client, i.e.
    RestClient won’t
    follow any redirect. To follow redirect, please use FollowRedirect
    middleware. Two reasons. One is that the underlying HTTP client
    should
    be minimal. Another one is that a FollowRedirect middleware could be
    used for all HTTP clients. This would make it more consistent across
    all HTTP clients.

  • [RestClient] Added a patch to avoid "123".to_i returning 200,
    please see: https://github.com/archiloque/rest-client/pull/103
    I would remove this once after this patch is merged.

  • [RestClient] Added a patch to properly returning response whenever
    a redirect is happened. Please see:
    https://github.com/archiloque/rest-client/pull/118
    I would remove this once after this patch is merged.

  • [FollowRedirect] This middleware would follow the redirect. Pass
    :max_redirects for the maximum redirect times. For example:

    Client = RestCore::Builder.client do
      use FollowRedirect, 2 # default :max_redirects
    end
    client = Client.new
    client.get('path', {}, :max_redirects => 5)
    
  • [Middleware] Added Middleware#run which can return the
    underlying HTTP
    client, if you need to know the underlying HTTP client can support
    asynchronous requests or not.

  • [Cache] Now it’s asynchrony-aware.

  • [CommonLogger] Now it’s asynchrony-aware.

  • [ErrorDetector] Now it’s asynchrony-aware.

  • [ErrorHandler] Now it’s asynchrony-aware.

  • [JsonDecode] Now it’s asynchrony-aware.

  • [Timeout] Now it’s asynchrony-aware.

  • [Universal] FollowRedirect middleware is added.

  • [Universal] Defaults middleware is removed.

  • Added RestCore::ASYNC which should be the callback function which
    is
    called whenever the response is available. It’s similar to Rack’s
    async.callback.

  • Added RestCore::TIMER which is only used in Timeout middleware. We
    need
    this to disable timer whenever the response is back.

  • [EmHttpRequestAsync] This HTTP client accepts a block to make
    asynchronous
    HTTP requests via em-http-request gem.

  • [EmHttpRequestFiber] This HTTP client would make asynchronous HTTP
    requests with em-http-request but also wrapped inside a fiber, so
    that it
    looks synchronous to the program who calls it.

  • [EmHttpRequest] This HTTP client would would use
    EmHttpRequestAsync if
    a block (RestCore::ASYNC) is passed, otherwise use
    EmHttpRequestFiber.

  • [CoolioAsync] This HTTP client is basically the same as
    EmHttpRequestAsync, but using cool.io-http instead of em-http-
    request.

  • [CoolioFiber] This HTTP client is basically the same as
    EmHttpRequestFiber, but using cool.io-http instead of em-http-
    request.

  • [Coolio] This HTTP client is basically the same as
    EmHttpRequest,
    but using cool.io-http instead of em-http-request.

  • [Auto] This HTTP client would auto-select a suitable client. Under
    eventmachine, it would use EmHttpRequest. Under cool.io, it would
    use
    Coolio. Otherwise, it would use RestClient.

This forum is not affiliated to the Ruby language, Ruby on Rails framework, nor any Ruby applications discussed here.

| Privacy Policy | Terms of Service | Remote Ruby Jobs