wrest 1.3.0 → 1.4.0

data/CHANGELOG

@@ -2,7 +2,11 @@ Features under the section marked 'Current' are completed but pending release as
 
 Features under a numbered section are complete and available in the Wrest gem.
 
-=== 1.3.0
+== 1.4.0 
+ * GH#96 Naive implementation of asynchronous requests using Eventmachine
+ * GH#93 Since Wrest::Response is immutable, the results of Response#deserialise are cached
+
+== 1.3.0
  * GH#95 Asynchronous requests on Wrest::Uri.
 
 == 1.2.1 

data/README.rdoc

@@ -1,15 +1,17 @@
-= Wrest 1.3.0
+= Wrest 1.4.0
 
 (c) Copyright 2009-2011 {Sidu Ponnappa}[http://blog.sidu.in]. All Rights Reserved.
 
 Wrest is a ruby REST/HTTP client library which
 
+* Allows you to use Net::HTTP or libCurl
+* Allows you to pick your Ruby: use 1.8.7, 1.9.2, JRuby and Rubinius ({Continuous Integration server}[http://ci.c42.in])
+* Supports RFC 2616 based {caching}[https://github.com/kaiwren/wrest/blob/caching/Caching.markdown]
+* [Alpha] Allows you to go async: use Threads or EventMachine
 * Allows you to quickly build object oriented wrappers around any web service 
-* Designed to be used as a library, not just a command line REST client (fewer class/static methods, more object oriented)
+* Is designed to be used as a library, not just a command line REST client (fewer class/static methods, more object oriented)
 * Is spec driven, strongly favours immutable objects and avoids class methods and setters making it better suited for use as a library, especially in multi-threaded environments 
-* Runs on Ruby 1.8, Ruby 1.9.2, JRuby and Rubinius with MacRuby and IronRuby support on the way ({Continuous Integration server}[http://ci.c42.in])
-* Provides convenient HTTP wrappers, redirect handling, serialisation, deserialisation and response {caching}[https://github.com/kaiwren/wrest/blob/caching/Caching.markdown]
-* Supports using either Net::HTTP or libcurl as the underlying HTTP library
+* Provides convenient HTTP wrappers, redirect handling, serialisation, deserialisation and xpath based lookup
 
 To receive notifications whenever new features are added to Wrest, please subscribe to my {twitter feed}[http://twitter.com/ponnappa].
 
@@ -26,9 +28,11 @@ For Facebook, Twitter, Delicious, GitHub and other API examples, see http://gith
     'http://twitter.com/statuses/public_timeline.json'.to_uri.get.deserialise  # works with json and xml out of the box
 
     'http://twitter.com/statuses/public_timeline.xml'.to_uri.get.deserialise   # see lib/wrest/components/translators to add other formats
+    
 * Timeout support
   
     'http://twitter.com/statuses/public_timeline.json'.to_uri.get(:timeout => 5).body
+    
 * Redirect support
   
     'http://google.com'.to_uri(:follow_redirects => false).get
@@ -98,7 +102,7 @@ To delete a resource:
 
 Wrest supports caching with pluggable back-ends.
 
-    Wrest.always_cache_using_hash!     # Hash should NEVER be used in a production environment. It is unbounded and will keep increasing in size.
+    Wrest::Caching.default_to_hash!     # Hash should NEVER be used in a production environment. It is unbounded and will keep increasing in size.
     c42 = "http://c42.in".to_uri.get
 
 A Memcached based caching back-end is available in Wrest. You can get instructions on how to install Memcached on your system {here}[http://code.google.com/p/memcached/wiki/NewInstallFromPackage].
@@ -106,15 +110,12 @@ The Dalli gem is used by Wrest to interface with Memcached. Install dalli using
 
 Use the following method to enable caching for all requests, and set Memcached as the default back-end.
   
-    Wrest.always_cache_using_memcached!
+    Wrest::Caching.default_to_memcached!
 
 For fine-grained control over the cache store (or to use multiple cache stores in the same codebase), you can use this API:
 
-    memcache_store = Wrest::Components::CacheStore::Memcached.new("localhost:11211")
-    hash_store = {}
-    
-    r1 = "http://c42.in".to_uri(:cache_store => memcache_store).get
-    r2 = "http://c42.in".to_uri(:cache_store => hash_store).get
+    r1 = "http://c42.in".to_uri.using_memcached.get
+    r2 = "http://c42.in".to_uri.using_hash.get
 
 A detailed writeup regarding caching as defined by RFC 2616, and how Wrest implements caching is at {Wrest Caching Doc}[https://github.com/kaiwren/wrest/blob/master/Caching.markdown]
 
@@ -122,7 +123,7 @@ You can create your own back-ends for Wrest caching by implementing the interfac
 
 To explicitly disable caching for specific requests:
 
-    "http://c42.in".to_uri(:disable_cache => true).get
+    "http://c42.in".to_uri.disable_cache.get
 
 === Callbacks
 
@@ -161,12 +162,30 @@ Please note that Wrest is a synchronous library. All requests are blocking, and
 Asynchronous requests are non-blocking. They do not return a response and the request is executed on a separate thread. The only way to access the response 
 while using asynchronous request is through callbacks. 
 
-  "http://www.google.com".to_uri.get_async do |callback|
+Asynchronous requests support pluggable backends. The default backend used for asynchronous requests is ruby threads.
+
+  "http://c42.in".to_uri.get_async do |callback|
+    callback.on_ok do |response|
+      Wrest.logger.info "Ok."
+    end
+  end
+
+  sleep 1 # Causes thread created by get_async to execute
+
+You can change the default to eventmachine.
+
+  Wrest::AsyncRequest.default_to_em!
+
+You can also override the default on Uri objects.
+
+  "http://c42.in".to_uri.using_em.get_async do |callback|
     callback.on_ok do |response|
       Wrest.logger.info "Ok."
     end
   end
 
+Note: The current implementation of asynchronous requests is currently in alpha and should not be used in production.
+
 === Other useful stuff
 
 Allows any class to hold an attributes hash, somewhat like ActiveResource. It also supports several extensions to this base fuctionality such as support for typecasting attribute values. See examples/twitter.rb and examples/wow_realm_status.rb for more samples.

data/lib/wrest.rb

@@ -36,6 +36,10 @@ module Wrest
     @logger
   end
 
+  def self.enable_evented_requests!
+    require "#{Wrest::Root}/wrest/event_machine_backend"
+  end
+
   # Switch Wrest to using Net::HTTP.
   def self.use_native!
     silence_warnings{ Wrest.const_set('Http', Wrest::Native) }
@@ -46,37 +50,6 @@ module Wrest
     require "#{Wrest::Root}/wrest/curl"
     silence_warnings{ Wrest.const_set('Http', Wrest::Curl) }
   end
-
-  # Loads the Memcached caching back-end and the Dalli gem 
-  def self.enable_memcached_caching!
-    require "#{Wrest::Root}/wrest/components/cache_store/memcached"
-  end
-
-  # Assign the default cache store to be used. Default is none.
-  def self.default_cachestore=(cachestore)
-    @default_cachestore = cachestore
-  end
-
-  # Returns the default cache store, if any is set.
-  def self.default_cachestore
-    @default_cachestore
-  end
-
-  # Configures Wrest to cache all requests. This will use the Memcached backend.
-  def self.always_cache_using_memcached!
-    self.enable_memcached_caching!
-    self.default_cachestore=Wrest::Components::CacheStore::Memcached.new
-  end
-
-  # Configures Wrest to cache all requests. This will use a Ruby Hash.
-  # WARNING: This should NEVER be used in a real environment. The Hash will keep on growing since Wrest does not limit the size of a cache store.
-  #
-  # Use the Memcached caching back-end for production since the Memcached process uses an LRU based cache removal policy
-  # that keeps the number of entries stored within bounds.
-  def self.always_cache_using_hash!
-    Wrest.logger.warn "Using an in-memory Hash as a cache store. This is dangerous if used in a production environment."
-    self.default_cachestore=Hash.new
-  end
 end
 
 Wrest.logger = ActiveSupport::BufferedLogger.new(STDOUT)
@@ -99,6 +72,11 @@ require "#{Wrest::Root}/wrest/http_codes"
 require "#{Wrest::Root}/wrest/callback"
 require "#{Wrest::Root}/wrest/native"
 
+require "#{Wrest::Root}/wrest/async_request"
+require "#{Wrest::Root}/wrest/async_request/thread_backend"
+Wrest::AsyncRequest.default_to_threads!
+
+require "#{Wrest::Root}/wrest/caching"
 
 # Load Wrest Wrappers
 require "#{Wrest::Root}/wrest/uri"

data/lib/wrest/async_request.rb

@@ -0,0 +1,39 @@
+# Copyright 2009 Sidu Ponnappa
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at native://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software distributed under the License
+# is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and limitations under the License.
+
+
+module Wrest
+  module AsyncRequest
+    # Loads Wrest eventmachine backend alongwith eventmachine gem
+    def self.enable_em
+      require "#{Wrest::Root}/wrest/async_request/event_machine_backend"
+    end
+
+    # Assign default backend to be used for asynchronous request. Default is to use threads
+    def self.default_backend=(backend)
+      @default_backend = backend
+    end
+
+    # Assign default backend for asynchronous request to using eventmachine. 
+    def self.default_to_em!
+      self.enable_em
+      self.default_backend = Wrest::AsyncRequest::EventMachineBackend.new
+    end
+
+    # Assign default backend for asynchronous request to using threads. 
+    def self.default_to_threads!
+      self.default_backend = Wrest::AsyncRequest::ThreadBackend.new
+    end
+
+    # Returns the default backend
+    def self.default_backend
+      @default_backend
+    end
+  end
+end

data/lib/wrest/async_request/event_machine_backend.rb

@@ -0,0 +1,30 @@
+# Copyright 2009 Sidu Ponnappa
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at native://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software distributed under the License
+# is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and limitations under the License.
+
+begin
+  gem 'eventmachine', '~> 0.12.10'
+rescue Gem::LoadError => e
+  Wrest.logger.debug "Eventmachine ~> 0.12.10 not found. Wrest uses Eventmachine to perform evented asynchronous requests"
+  raise e
+end
+
+require 'eventmachine'
+
+module Wrest
+  module AsyncRequest
+    class EventMachineBackend 
+      def execute(block)
+        EventMachine.run do
+          block.invoke
+          EventMachine.stop
+        end
+      end
+    end
+  end
+end

data/lib/wrest/async_request/thread_backend.rb

@@ -0,0 +1,20 @@
+# Copyright 2009 Sidu Ponnappa
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at native://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software distributed under the License
+# is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and limitations under the License.
+
+module Wrest
+  module AsyncRequest
+    class ThreadBackend 
+      def execute(block)
+        Thread.new do
+          block.invoke
+        end
+      end
+    end
+  end
+end

data/lib/wrest/caching.rb

@@ -0,0 +1,42 @@
+# Copyright 2009 Sidu Ponnappa
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at native://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software distributed under the License
+# is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and limitations under the License.
+
+module Wrest
+  module Caching
+    # Loads the Memcached caching back-end and the Dalli gem 
+    def self.enable_memcached
+      require "#{Wrest::Root}/wrest/caching/memcached"
+    end
+
+    # Configures Wrest to cache all requests. This will use a Ruby Hash.
+    # WARNING: This should NEVER be used in a real environment. The Hash will keep on growing since Wrest does not limit the size of a cache store.
+    #
+    # Use the Memcached caching back-end for production since the Memcached process uses an LRU based cache removal policy
+    # that keeps the number of entries stored within bounds.
+    def self.default_to_hash!
+      self.default_store = Hash.new
+    end
+
+    # Default Wrest to using memcached for caching requests. 
+    def self.default_to_memcached!
+      self.enable_memcached
+      self.default_store = Wrest::Caching::Memcached.new 
+    end
+
+    # Assign the default cache store to be used. Default is none.
+    def self.default_store=(store)
+      @default_store = store 
+    end
+
+    # Returns the default store for caching, if any is set.
+    def self.default_store
+      @default_store
+    end
+  end
+end

data/lib/wrest/{components/cache_store → caching}/memcached.rb

@@ -7,7 +7,7 @@ end
 
 require 'dalli'
 
-module Wrest::Components::CacheStore
+module Wrest::Caching
   class Memcached
 
     def initialize(server_urls=nil, options={})

data/lib/wrest/curl/response.rb

@@ -16,6 +16,7 @@ module Wrest #:nodoc:
     # See HttpCodes for a list of all such response checkers.
     class Response              
       attr_reader :http_response
+      attr_accessor :deserialised_body
       include HttpShared::Headers
       include HttpCodes
       
@@ -36,7 +37,7 @@ module Wrest #:nodoc:
       end
 
       def deserialise(options = {})
-        deserialise_using(Wrest::Components::Translators.lookup(content_type),options)
+          @deserialised_body ||= deserialise_using(Wrest::Components::Translators.lookup(content_type),options)
       end
 
       def deserialise_using(translator,options={})

data/lib/wrest/multipart.rb

@@ -46,13 +46,11 @@ module Wrest
     #     'http://localhost:3000/uploads'.to_uri.post_multipart_async('file' => UploadIO.new(file, "image/jpg", '/path/to/image.jpg'))
     #   end
     #
-    # Note: post_multipart_async does not return a response and the response should be accessed through callbacks
-    # This implementation of asynchronous post_multipart is very naive and should not be used in production.
-    # Stable implementation of asynchronous requests involving thread pools would be out soon.
+    # Note: post_multipart_async does not return a response and the response should be accessed through callbacks.
+    # This implementation of asynchronous post_multipart is currently in alpha. Hence, it should not be used in production.
     def post_multipart_async(parameters = {}, headers = {}, &block)
-      Thread.new do
-        post_multipart(parameters, headers, &block)
-      end
+      (@options[:asynchronous_backend] || Wrest::AsyncRequest.default_backend).execute(Http::PostMultipart.new(self, parameters, headers, block ? @options.merge(:callback_block => block) : @options))
+      nil
     end
     
     # Makes a multipart/form-data encoded PUT request to this URI. This is a convenience API
@@ -65,12 +63,10 @@ module Wrest
     # that mimics a multipart form being put. I sincerely hope you never need to use this.
     #
     # Note: put_multipart_async does not return a response and the response should be accessed through callbacks
-    # This implementation of asynchronous put_multipart is very naive and should not be used in production.
-    # Stable implementation of asynchronous requests involving thread pools would be out soon.
+    # This implementation of asynchronous put_multipart is currently in alpha. Hence, it should not be used in production.
     def put_multipart_async(parameters = {}, headers = {}, &block)
-      Thread.new do
-        put_multipart(parameters, headers, &block)
-      end
+      (@options[:asynchronous_backend] || Wrest::AsyncRequest.default_backend).execute(Http::PutMultipart.new(self, parameters, headers, block ? @options.merge(:callback_block => block) : @options))
+      nil
     end
   end
   

data/lib/wrest/native/get.rb

@@ -15,7 +15,7 @@ module Wrest::Native
       follow_redirects = options[:follow_redirects]
       options[:follow_redirects] = (follow_redirects == nil ? true : follow_redirects)
 
-      cache_store = (options[:cache_store] || Wrest.default_cachestore) unless options[:disable_cache]
+      cache_store = (options[:cache_store] || Wrest::Caching.default_store) unless options[:disable_cache]
       @cache_proxy = Wrest::CacheProxy::new(self, cache_store)
       
       super(

data/lib/wrest/native/request.rb

@@ -57,8 +57,8 @@ module Wrest::Native
       @cache_store = options[:cache_store]
       @verify_mode = @options[:verify_mode]
       @detailed_http_logging = options[:detailed_http_logging]
-      @uri_callback = Wrest::Callback.new(@options[:callback] || {})
-      @request_callback = Wrest::Callback.new(@options[:callback_block] || {})
+      @callback = @options[:callback] || Wrest::Callback.new({})
+      @callback = @callback.merge(Wrest::Callback.new(@options[:callback_block] || {}))
     end
 
     # Makes a request, runs the appropriate callback if any and
@@ -115,7 +115,7 @@ module Wrest::Native
 
     #:nodoc:
     def execute_callback_if_any(actual_response)
-      @uri_callback.merge(@request_callback).execute(actual_response)
+      @callback.execute(actual_response)
     end
   end
 end

data/lib/wrest/native/response.rb

@@ -24,6 +24,7 @@ module Wrest #:nodoc:
     # See HttpCodes for a list of all such response checkers.
     class Response
       attr_reader :http_response
+      attr_accessor :deserialised_body
       include HttpCodes
       
       extend Forwardable
@@ -73,7 +74,7 @@ module Wrest #:nodoc:
 
 
       def deserialise(options = {})
-        deserialise_using(Wrest::Components::Translators.lookup(@http_response.content_type),options)
+          @deserialised_body ||= deserialise_using(Wrest::Components::Translators.lookup(@http_response.content_type),options)
       end
 
       def deserialise_using(translator,options = {})

data/lib/wrest/uri.rb

@@ -26,7 +26,7 @@ module Wrest #:nodoc:
         
     # See Wrest::Native::Request for the available options and their default values.
     def initialize(uri_string, options = {})
-        @options = options
+        @options = options.clone
         @uri_string = uri_string.to_s
         @uri = URI.parse(@uri_string)
         uri_scheme = URI.split(@uri_string)
@@ -35,6 +35,7 @@ module Wrest #:nodoc:
         @query = uri_scheme[-2] || ''
         @username = (@options[:username] ||= @uri.user)
         @password = (@options[:password] ||= @uri.password)
+        @options[:callback] = Callback.new(@options[:callback]) if @options[:callback]
     end 
     
     def to_template(pattern)
@@ -95,18 +96,53 @@ module Wrest #:nodoc:
       Http::Get.new(self, parameters, headers, block ? @options.merge(:callback_block => block) : @options).invoke
     end
 
+    # Returns a Uri object that uses threads to perform asynchronous requests.
+    def using_threads
+      options = @options.clone
+      options[:asynchronous_backend] = Wrest::AsyncRequest::ThreadBackend.new
+      Uri.new(uri_string, options)
+    end
+
+    # Returns a Uri object that uses eventmachine to perform asynchronous requests.
+    def using_em
+      options = @options.clone
+      Wrest::AsyncRequest.enable_em
+      options[:asynchronous_backend] = Wrest::AsyncRequest::EventMachineBackend.new
+      Uri.new(uri_string, options)
+    end
+
+    # Returns a Uri object that uses hash for caching responses.
+    def using_hash
+      options = @options.clone
+      options[:cache_store] = Hash.new
+      Uri.new(uri_string, options)
+    end
+
+    # Returns a Uri object that uses memcached for caching responses.
+    def using_memcached
+      options = @options.clone
+      Wrest::Caching.enable_memcached
+      options[:cache_store] = Wrest::Caching::Memcached.new
+      Uri.new(uri_string, options)
+    end
+
+    def disable_cache
+      options = @options.clone
+      Wrest::Caching.enable_memcached
+      options[:disable_cache] = true 
+      Uri.new(uri_string, options)
+    end
+
     # Make a GET request to this URI. This is a convenience API
     # that creates a Wrest::Native::Get.
     # 
     # Remember to escape all parameter strings if necessary, using URI.escape
     #
     # Note: get_async does not return a response and the response should be accessed through callbacks.
-    # This implementation of asynchronous get is very naive and should not be used in production.
-    # Stable implementation of asynchronous requests involving thread pools would be out soon.
+    # This implementation of asynchronous get is currently in alpha. Hence, it should not be used in production.
     def get_async(parameters = {}, headers = {}, &block)
-      Thread.new do
-        get(parameters, headers, &block)
-      end
+      (@options[:asynchronous_backend] || Wrest::AsyncRequest.default_backend).execute(Http::Get.new(self, parameters, headers, block ? @options.merge(:callback_block => block) : @options))
+      nil
     end
 
     # Make a PUT request to this URI. This is a convenience API
@@ -123,12 +159,10 @@ module Wrest #:nodoc:
     # Remember to escape all parameter strings if necessary, using URI.escape
     #
     # Note: put_async does not return a response and the response should be accessed through callbacks.
-    # This implementation of asynchronous put is very naive and should not be used in production.
-    # Stable implementation of asynchronous requests involving thread pools would be out soon.
+    # This implementation of asynchronous put is currently in alpha. Hence, it should not be used in production.
     def put_async(body = '', headers = {}, parameters = {}, &block)
-      Thread.new do
-        put(body, headers, parameters, &block)
-      end
+      (@options[:asynchronous_backend] || Wrest::AsyncRequest.default_backend).execute(Http::Put.new(self, body.to_s, headers, parameters, block ? @options.merge(:callback_block => block) : @options))
+      nil
     end
 
     # Makes a POST request to this URI. This is a convenience API
@@ -147,12 +181,10 @@ module Wrest #:nodoc:
     # Remember to escape all parameter strings if necessary, using URI.escape
     #
     # Note: post_async does not return a response and the response should be accessed through callbacks.
-    # This implementation of asynchronous post is very naive and should not be used in production.
-    # Stable implementation of asynchronous requests involving thread pools would be out soon.
+    # This implementation of asynchronous post is currently in alpha. Hence, it should not be used in production.
     def post_async(body = '', headers = {}, parameters = {}, &block)
-      Thread.new do
-        post(body, headers, parameters, &block)
-      end
+      (@options[:asynchronous_backend] || Wrest::AsyncRequest.default_backend).execute(Http::Post.new(self, body.to_s, headers, parameters, block ? @options.merge(:callback_block => block) : @options))
+      nil
     end
     
     # Makes a POST request to this URI. This is a convenience API
@@ -177,12 +209,12 @@ module Wrest #:nodoc:
     # application/x-www-form-urlencoded
     #
     # Note: post_form_async does not return a response and the response should be accessed through callbacks.
-    # This implementation of asynchronous post_form is very naive and should not be used in production.
-    # Stable implementation of asynchronous requests involving thread pools would be out soon.
+    # This implementation of asynchronous post_form is currently in alpha. Hence, it should not be used in production.
     def post_form_async(parameters = {}, headers = {}, &block)
-      Thread.new do
-        post_form(parameters, headers, &block)
-      end
+      headers = headers.merge(Wrest::H::ContentType => Wrest::T::FormEncoded)
+      body = parameters.to_query
+      (@options[:asynchronous_backend] || Wrest::AsyncRequest.default_backend).execute(Http::Post.new(self, body, headers, {}, block ? @options.merge(:callback_block => block) : @options))
+      nil
     end
 
     # Makes a DELETE request to this URI. This is a convenience API
@@ -199,12 +231,10 @@ module Wrest #:nodoc:
     # Remember to escape all parameter strings if necessary, using URI.escape
     #
     # Note: delete_async does not return a response and the response should be accessed through callbacks.
-    # This implementation of asynchronous delete is very naive and should not be used in production.
-    # Stable implementation of asynchronous requests involving thread pools would be out soon.
+    # This implementation of asynchronous delete is currently in alpha. Hence, it should not be used in production.
     def delete_async(parameters = {}, headers = {}, &block)
-      Thread.new do
-        delete(parameters, headers, &block)
-      end
+      (@options[:asynchronous_backend] || Wrest::AsyncRequest.default_backend).execute(Http::Delete.new(self, parameters, headers, block ? @options.merge(:callback_block => block) : @options))
+      nil
     end
 
     # Makes an OPTIONS request to this URI. This is a convenience API

data/lib/wrest/version.rb

@@ -8,5 +8,5 @@
 # See the License for the specific language governing permissions and limitations under the License. 
 
 module Wrest
-  VERSION = "1.3.0"
+  VERSION = "1.4.0"
 end

metadata

@@ -2,7 +2,7 @@
 name: wrest
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 1.3.0
+  version: 1.4.0
 platform: ruby
 authors: 
 - Sidu Ponnappa
@@ -11,7 +11,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-02-08 00:00:00 +05:30
+date: 2011-02-15 00:00:00 +05:30
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -113,7 +113,7 @@ dependencies:
         version: 1.4.6
   type: :runtime
   version_requirements: *id009
-description: Wrest is a HTTP and REST client library which allows you to quickly build well encapsulated, object oriented wrappers around any web service.
+description: Wrest is a fluent, easy-to-use, object oriented Ruby HTTP/REST client library with support for RFC2616 HTTP caching, multiple HTTP backends and async calls using EventMachine. It runs on CRuby, JRuby and Rubinius.
 email: 
 - sidu@c42.in
 executables: 
@@ -125,9 +125,13 @@ extra_rdoc_files:
 files: 
 - bin/wrest
 - bin/wrest_shell.rb
+- lib/wrest/async_request/event_machine_backend.rb
+- lib/wrest/async_request/thread_backend.rb
+- lib/wrest/async_request.rb
 - lib/wrest/cache_proxy.rb
+- lib/wrest/caching/memcached.rb
+- lib/wrest/caching.rb
 - lib/wrest/callback.rb
-- lib/wrest/components/cache_store/memcached.rb
 - lib/wrest/components/container/alias_accessors.rb
 - lib/wrest/components/container/typecaster.rb
 - lib/wrest/components/container.rb
@@ -221,10 +225,11 @@ requirements:
 - To use Memcached as caching back-end, install the 'dalli' gem.
 - To use multipart post, install the 'multipart-post' gem.
 - To use curl as the http engine, install the 'patron' gem. This feature is not available (and should be unneccessary) on jruby.
+- To use eventmachine as a parallel backend, install the 'eventmachine' gem.
 rubyforge_project: wrest
 rubygems_version: 1.5.0
 signing_key: 
 specification_version: 3
-summary: Wrest is an elegant, object oriented HTTP client library for 1.8, 1.9, JRuby and Rubinius.
+summary: Wrest is a fluent, object oriented HTTP client library for 1.8, 1.9, JRuby and Rubinius.
 test_files: []