rest-client-components 0.2.1

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Cyril Rohr
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,79 @@
+= rest-client-components
+
+RestClient on steroids ! 
+
+Want to add transparent HTTP caching to the rest-client[http://github.com/archiloque/rest-client] gem ? It's as simple as:
+  require 'restclient/components'
+  require 'rack/cache'
+  RestClient.enable Rack::Cache
+
+Want to log the requests in the commonlog format ?
+  require 'restclient/components'
+  RestClient.enable Rack::CommonLogger, STDOUT
+
+Want to enable both ?
+  require 'restclient/components'
+  require 'rack/cache'
+  RestClient.enable Rack::CommonLogger, STDOUT
+  RestClient.enable Rack::Cache
+  
+This works with any Rack middleware, thus you can reuse the wide range of existing Rack middleware to add functionalities to RestClient with very little effort.
+The order in which you enable components will be respected.
+
+Note that the rest-client behaviour is also respected: you'll get back a RestClient::Response or RestClient exceptions as a result of your requests. If you prefer a more rackesque approach, just disable the Compatibility component, and you will get back a response conform to the Rack SPEC:
+  require 'restclient/components'
+  RestClient.disable RestClient::Rack::Compatibility
+  status, header, body = RestClient.get('http://some/url')
+In that case, you will only get exceptions for connection or timeout errors (RestClient::ServerBrokeConnection or RestClient::RequestTimeout)
+
+= Installation
+
+  gem install rest-client-components
+  
+= Usage
+Example with Rack::Cache, and Rack::CommonLogger
+
+  require 'restclient/components'
+  require 'rack/cache'
+  
+  RestClient.enable Rack::CommonLogger
+  # Enable the cache Rack middleware, and store both meta and entity data in files:
+  # See http://tomayko.com/src/rack-cache/configuration for the list of available options
+  RestClient.enable Rack::Cache, 
+                    :metastore => 'file:/tmp/cache/meta', 
+                    :entitystore => 'file:/tmp/cache/body'
+
+  
+  # ... done !
+  # Then you can make your requests as usual: 
+  # You'll get a log for each call, and the resources will be automatically and transparently cached for you according to their HTTP headers.
+  # Cache invalidation on requests other than GET is also transparently supported, thanks to Rack::Cache. Enjoy !
+
+  RestClient.get 'http://some/cacheable/resource'
+  # or
+  resource = RestClient::Resource.new('http://some/cacheable/resource')
+  
+  # obviously, caching is only interesting if you request the same resource multiple times, e.g. :
+  resource.get # get from origin server, and cache if possible
+  resource.get # get from cache, if still fresh.
+  resource.put(...) # will automatically invalidate the cache, so that a subsequent GET request on the same resource does not return the cached resource
+  resource.get # get from origin server, and cache if possible
+  # ...
+  resource.get(:cache_control => 'no-cache') # explicitly tells to bypass the cache, requires rack-cache >= 0.5 and :allow_reload => true option
+  # ...
+  resource.delete(...) # will invalidate the cache
+  resource.get # should raise a RestClient::ResourceNotFound exception
+
+
+Now, you just need to make your resources cacheable, so unless you've already taken care of that, do yourself a favor and read: 
+* the HTTP specification related to HTTP caching - http://www.w3.org/Protocols/rfc2616/rfc2616-sec13.html
+* Things Caches Do - http://tomayko.com/writings/things-caches-do
+
+= Dependencies
+
+* rest-client >= 1.2.0
+* rack >= 1.0.1
+
+= COPYRIGHT
+
+Copyright (c) 2009 Cyril Rohr. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,35 @@
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |s|
+    s.name = "rest-client-components"
+    s.summary = %Q{RestClient on steroids ! Easily add one or more Rack middleware around RestClient to add functionalities such as transparent caching (Rack::Cache), transparent logging, etc.}
+    s.email = "cyril.rohr@gmail.com"
+    s.homepage = "http://github.com/crohr/rest-client-components"
+    s.description = "RestClient on steroids ! Easily add one or more Rack middleware around RestClient to add functionalities such as transparent caching (Rack::Cache), transparent logging, etc."
+    s.authors = ["Cyril Rohr"]
+    s.add_dependency "rest-client", ">= 1.2.0"
+    s.add_dependency "rack", ">= 1.0.1"
+  end
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = 'rest-client-components'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+require 'spec/rake/spectask'
+Spec::Rake::SpecTask.new(:spec) do |t|
+  t.libs << 'lib' << 'spec'
+  t.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+
+task :default => :spec

data/VERSION

@@ -0,0 +1 @@
+0.2.1

data/examples/caching.rb

@@ -0,0 +1,53 @@
+# In this example, https://localhost:3443/sid/grid5000/sites/grenoble/jobs is a resource having an Expires header, that makes it cacheable.
+# Note how POSTing a payload to this resource automatically invalidates the previously cached entry.
+require File.dirname(__FILE__) + '/../lib/restclient/components'
+require 'rack/cache'
+require 'json'
+require 'zlib'
+RestClient.log = 'stdout'
+RestClient.enable Rack::Cache, :allow_reload => true, :allow_revalidate => true
+
+api = RestClient::Resource.new('https://localhost:3443')
+def get_jobs(api, headers={})
+  puts "*** GETting jobs..."
+  jobs = JSON.parse api['/sid/grid5000/sites/grenoble/jobs'].get({:accept => :json}.merge(headers))
+end
+
+begin
+  puts "Number of jobs=#{get_jobs(api)['items'].length}" 
+  puts "Number of jobs=#{get_jobs(api)['items'].length}" 
+  puts "*** POSTing new job"
+  job = {
+    :resources => "nodes=1",
+    :command => "sleep 120"
+  }
+  api['/sid/grid5000/sites/grenoble/jobs'].post(job.to_json, :content_type => :json, :accept => :json) 
+  puts "Number of jobs=#{get_jobs(api)['items'].length}"
+rescue RestClient::Exception => e
+  if e.respond_to?(:response)
+    p e.response.to_hash
+    p Zlib::GzipReader.new(StringIO.new(e.response.body)).read
+  else
+    p e.message
+  end
+end
+
+__END__
+This example displays:
+*** GETting jobs...
+RestClient.get "https://localhost:3443/sid/grid5000/sites/grenoble/jobs", headers: {"Accept-encoding"=>"gzip, deflate", "Accept"=>"application/json"}
+# => 200 OK | application/json 295 bytes
+cache: [GET /sid/grid5000/sites/grenoble/jobs] miss
+Number of jobs=1
+*** GETting jobs...
+cache: [GET /sid/grid5000/sites/grenoble/jobs] fresh
+Number of jobs=1
+*** POSTing new job
+RestClient.post "https://localhost:3443/sid/grid5000/sites/grenoble/jobs", headers: {"Accept-encoding"=>"gzip, deflate", "Content-type"=>"application/json", "Content-Length"=>"45", "Accept"=>"application/json"}, paylod: "{\"resources\":\"nodes=1\",\"command\":\"sleep 120\"}"
+# => 201 Created | application/json 181 bytes
+cache: [POST /sid/grid5000/sites/grenoble/jobs] invalidate, pass
+*** GETting jobs...
+RestClient.get "https://localhost:3443/sid/grid5000/sites/grenoble/jobs", headers: {"Accept-encoding"=>"gzip, deflate", "Accept"=>"application/json"}
+# => 200 OK | application/json 323 bytes
+cache: [GET /sid/grid5000/sites/grenoble/jobs] miss
+Number of jobs=2

data/examples/parsing.rb

@@ -0,0 +1,24 @@
+# In this example, we automatically parse the response body if the Content-Type looks like JSON
+require File.dirname(__FILE__) + '/../lib/restclient/components'
+require 'json'
+
+module Rack
+  class JSON
+    def initialize app
+      @app = app
+    end
+    
+    def call(env)
+      status, header, body = @app.call env
+      parsed_body = ::JSON.parse body.join if header['Content-Type'] =~ /^application\/.*json/i
+      [status, header, parsed_body]
+    end
+  end
+end
+
+RestClient.disable RestClient::Rack::Compatibility
+# this breaks the Rack spec, but it should be the last component to be enabled.
+RestClient.enable Rack::JSON
+
+status, header, parsed_body = RestClient.get "http://twitter.com/statuses/user_timeline/20191563.json"
+p parsed_body.map{|tweet| tweet['text']}

data/lib/restclient/components.rb

@@ -0,0 +1,152 @@
+require 'restclient'
+require 'rack'
+
+module RestClient
+  module Rack
+    class Compatibility
+      def initialize(app)
+        @app = app
+      end
+      
+      def call(env)
+        status, header, body = @app.call(env)
+        if e = env['restclient.error']
+          raise e
+        else
+          response = RestClient::MockNetHTTPResponse.new(body, status, header)
+          RestClient::Response.new(response.body.join, response)
+        end
+      end
+    end
+  end
+
+  class <<self
+    attr_reader :components
+  end
+  
+  # Enable a Rack component. You may enable as many components as you want.
+  # e.g.
+  # Transparent HTTP caching:
+  #   RestClient.enable Rack::Cache, 
+  #                       :verbose     => true,
+  #                       :metastore   => 'file:/var/cache/rack/meta'
+  #                       :entitystore => 'file:/var/cache/rack/body'
+  # 
+  # Transparent logging of HTTP requests (commonlog format):
+  #   RestClient.enable Rack::CommonLogger, STDOUT
+  # 
+  # Please refer to the documentation of each rack component for the list of available options.
+  # 
+  def self.enable(component, *args)
+    # remove any existing component of the same class
+    disable(component)
+    @components.unshift [component, args]
+  end
+  
+  # Disable a component
+  #   RestClient.disable Rack::Cache
+  #   => array of remaining components
+  def self.disable(component)
+    @components.delete_if{|(existing_component, options)| component == existing_component}
+  end
+  
+  # Returns true if the given component is enabled, false otherwise
+  #   RestClient.enable Rack::Cache
+  #   RestClient.enabled?(Rack::Cache)
+  #   => true
+  def self.enabled?(component)
+    !@components.detect{|(existing_component, options)| component == existing_component}.nil?
+  end
+  
+  def self.reset
+    # hash of the enabled components 
+    @components = [[RestClient::Rack::Compatibility]]
+  end
+  
+  def self.debeautify_headers(headers = {})   # :nodoc:
+    headers.inject({}) do |out, (key, value)|
+			out[key.to_s.gsub(/_/, '-').split("-").map{|w| w.capitalize}.join("-")] = value.to_s
+			out
+		end
+  end
+  
+  reset
+  
+  # Reopen the RestClient::Request class to add a level of indirection in order to create the stack of Rack middleware.
+  # 
+	class Request
+	  alias_method :original_execute, :execute
+	  def execute
+      uri = URI.parse(@url)
+      uri_path_split = uri.path.split("/")
+      path_info = (last_part = uri_path_split.pop) ? "/"+last_part : ""
+      script_name = uri_path_split.join("/")
+      # minimal rack spec
+      env = { 
+        "restclient.request" => self,
+        "REQUEST_METHOD" => @method.to_s.upcase,
+        "SCRIPT_NAME" => script_name,
+        "PATH_INFO" => path_info,
+        "QUERY_STRING" => uri.query || "",
+        "SERVER_NAME" => uri.host,
+        "SERVER_PORT" => uri.port.to_s,
+        "rack.version" => ::Rack::VERSION,
+        "rack.run_once" => false,
+        "rack.multithread" => true,
+        "rack.multiprocess" => true,
+        "rack.url_scheme" => uri.scheme,
+        "rack.input" => StringIO.new,
+        "rack.errors" => $stderr   # Rack-Cache writes errors into this field
+      }
+      @processed_headers.each do |key, value|
+        env.merge!("HTTP_"+key.to_s.gsub("-", "_").upcase => value)
+      end
+      stack = RestClient::RACK_APP
+      RestClient.components.each do |(component, args)|
+        if (args || []).empty?
+          stack = component.new(stack)
+        else
+          stack = component.new(stack, *args)
+        end
+      end
+      stack.call(env)
+    end
+  end
+	
+  # A class that mocks the behaviour of a Net::HTTPResponse class.
+  # It is required since RestClient::Response must be initialized with a class that responds to :code and :to_hash.
+  class MockNetHTTPResponse
+    attr_reader :body, :header, :status
+    alias_method :code, :status
+    
+    def initialize(body, status, header)
+      @body = body
+      @status = status
+      @header = header
+    end
+
+    def to_hash
+      @header.inject({}) {|out, (key, value)|
+        # In Net::HTTP, header values are arrays
+        out[key] = [value]
+        out
+      }
+    end    
+  end
+  
+  RACK_APP = Proc.new { |env|
+    begin
+      # get the original request and execute it
+      response = env['restclient.request'].original_execute
+      # to satisfy Rack::Lint
+      response.headers.delete(:status)
+      [response.code, RestClient.debeautify_headers( response.headers ), [response.to_s]]
+    rescue RestClient::ExceptionWithResponse => e  
+      env['restclient.error'] = e
+       # e is a Net::HTTPResponse
+      response = RestClient::Response.new(e.response.body, e.response)
+      [response.code, RestClient.debeautify_headers( response.headers ), [response.to_s]]
+    end
+  }
+
+end

data/rest-client-components.gemspec

@@ -0,0 +1,59 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{rest-client-components}
+  s.version = "0.2.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Cyril Rohr"]
+  s.date = %q{2010-01-10}
+  s.description = %q{RestClient on steroids ! Easily add one or more Rack middleware around RestClient to add functionalities such as transparent caching (Rack::Cache), transparent logging, etc.}
+  s.email = %q{cyril.rohr@gmail.com}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.rdoc"
+  ]
+  s.files = [
+    "LICENSE",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION",
+     "examples/caching.rb",
+     "examples/parsing.rb",
+     "lib/restclient/components.rb",
+     "rest-client-components.gemspec",
+     "spec/components_spec.rb",
+     "spec/spec_helper.rb"
+  ]
+  s.homepage = %q{http://github.com/crohr/rest-client-components}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.5}
+  s.summary = %q{RestClient on steroids ! Easily add one or more Rack middleware around RestClient to add functionalities such as transparent caching (Rack::Cache), transparent logging, etc.}
+  s.test_files = [
+    "spec/components_spec.rb",
+     "spec/spec_helper.rb",
+     "examples/caching.rb",
+     "examples/parsing.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<rest-client>, [">= 1.2.0"])
+      s.add_runtime_dependency(%q<rack>, [">= 1.0.1"])
+    else
+      s.add_dependency(%q<rest-client>, [">= 1.2.0"])
+      s.add_dependency(%q<rack>, [">= 1.0.1"])
+    end
+  else
+    s.add_dependency(%q<rest-client>, [">= 1.2.0"])
+    s.add_dependency(%q<rack>, [">= 1.0.1"])
+  end
+end
+

data/spec/components_spec.rb

@@ -0,0 +1,178 @@
+require File.dirname(__FILE__) + '/spec_helper'
+require File.dirname(__FILE__) + '/../lib/restclient/components'
+require 'logger'
+require 'rack/cache'
+describe "Components for RestClient" do
+  before(:each) do
+    RestClient.reset
+    @mock_304_net_http_response = mock('http response', :code => 304, :body => "body", :to_hash => {"Date"=>["Mon, 04 Jan 2010 13:42:43 GMT"], 'header1' => ['value1', 'value2']})
+    @env = {
+      'REQUEST_METHOD' => 'GET',
+      "SCRIPT_NAME" => '/some/cacheable',
+      "PATH_INFO" => '/resource',
+      "QUERY_STRING" => 'q1=a&q2=b',
+      "SERVER_NAME" => 'domain.tld',
+      "SERVER_PORT" => '8888',
+      "rack.version" => Rack::VERSION,
+      "rack.run_once" => false,
+      "rack.multithread" => true,
+      "rack.multiprocess" => true,
+      "rack.url_scheme" => "http",
+      "rack.input" => StringIO.new,
+      "rack.errors" => $stderr
+    }
+  end
+  
+  it "should automatically have the Compatibility component enabled" do
+    RestClient.components.first.should == [RestClient::Rack::Compatibility]
+  end
+  it "should enable components" do
+    RestClient.enable Rack::Cache, :key => "value"
+    RestClient.enabled?(Rack::Cache).should be_true
+    RestClient.components.first.should == [Rack::Cache, [{:key => "value"}]]
+    RestClient.enable Rack::CommonLogger
+    RestClient.components.length.should == 3
+    RestClient.components.first.should == [Rack::CommonLogger, []]
+  end
+  
+  describe "usage" do
+    before do
+
+      @expected_args = {:url=>"http://domain.tld:8888/some/cacheable/resource?q1=a&q2=b", :method=>:get, :headers=>{:additional_header=>"whatever"}}
+      @expected_request = RestClient::Request.new(@expected_args)
+    end
+    
+    describe "internal" do
+      it "should call the backend (bypassing the cache) if the requested resource is not in the cache" do
+        @expected_request.should_receive(:original_execute).and_return(
+          mock('rest-client response', 
+            :headers => {:content_type => "text/plain, */*", :date => "Mon, 04 Jan 2010 13:37:18 GMT"}, 
+            :code => 200, 
+            :to_s => 'body'))
+        status, header, body = Rack::Lint.new(Rack::CommonLogger.new(Rack::Cache.new(RestClient::RACK_APP))).call(@env.merge(
+          'restclient.request' => @expected_request
+        ))
+        status.should == 200
+        header.should == {"Content-Type"=>"text/plain, */*", "X-Rack-Cache"=>"miss", "Date"=>"Mon, 04 Jan 2010 13:37:18 GMT"}
+        content = ""
+        body.each{|part| content << part}
+        content.should == "body"
+      end
+
+      it "should return a 304 not modified response if the call to the backend returned a 304 not modified response" do
+        @expected_request.should_receive(:original_execute).and_raise(RestClient::NotModified.new(@mock_304_net_http_response))
+        status, header, body = Rack::Lint.new(Rack::Cache.new(RestClient::RACK_APP)).call(@env.merge(
+          'restclient.request' => @expected_request
+        ))
+        status.should == 304
+        header.should == {"X-Rack-Cache"=>"miss", "Date"=>"Mon, 04 Jan 2010 13:42:43 GMT", "Header1"=>"value1"} # restclient only returns the first member of each header
+        content = ""
+        body.each{|part| content<<part}
+        content.should == "body"
+      end
+    end
+    
+    describe "external" do
+      before do
+        RestClient.enable Rack::Cache, :key => "value"
+        @rack_app = RestClient::RACK_APP
+        @rack_app_after_cache = Rack::Cache.new(@rack_app)
+        @rack_app_after_composition = RestClient::Rack::Compatibility.new(@rack_app_after_cache)
+        RestClient::Request.should_receive(:new).once.with(@expected_args).and_return(@expected_request)
+        Rack::Cache.should_receive(:new).with(@rack_app, :key => "value").and_return(@rack_app_after_cache)
+      end
+      
+      it "should pass through the components [using RestClient::Resource instance methods]" do
+        RestClient::Rack::Compatibility.should_receive(:new).with(@rack_app_after_cache).and_return(@rack_app_after_composition)
+        resource = RestClient::Resource.new('http://domain.tld:8888/some/cacheable/resource?q1=a&q2=b')
+        @rack_app_after_composition.should_receive(:call).with( 
+          hash_including( {'HTTP_ADDITIONAL_HEADER' => 'whatever', "restclient.request" => @expected_request }) 
+        )
+        resource.get(:additional_header=>"whatever")
+      end
+      
+      it "should pass through the components [using RestClient class methods]" do
+        RestClient::Rack::Compatibility.should_receive(:new).with(@rack_app_after_cache).and_return(@rack_app_after_composition)
+        @rack_app_after_composition.should_receive(:call).with( 
+          hash_including( {'HTTP_ADDITIONAL_HEADER' => 'whatever', "restclient.request" => @expected_request }) 
+        )
+        RestClient.get('http://domain.tld:8888/some/cacheable/resource?q1=a&q2=b', :additional_header => 'whatever')
+      end
+
+      it "should return a RestClient response" do
+        RestClient::Rack::Compatibility.should_receive(:new).with(@rack_app_after_cache).and_return(@rack_app_after_composition)
+        @rack_app.should_receive(:call).and_return(
+          [200, {"Content-Type" => "text/plain", "Content-Length" => "13", "Allow" => "GET, POST", "Date" => "Mon, 04 Jan 2010 13:37:18 GMT"}, ["response body"]]
+        )
+        response = RestClient.get('http://domain.tld:8888/some/cacheable/resource?q1=a&q2=b', :additional_header => 'whatever')
+        response.should be_a(RestClient::Response)
+        response.code.should == 200
+        response.headers.should == {:content_type=>"text/plain", :x_rack_cache=>"miss", :content_length=>"13", :allow => "GET, POST", :date => "Mon, 04 Jan 2010 13:37:18 GMT"}
+        response.to_s.should == "response body"
+      end
+      
+      it "should return a response following the rack spec, if the compatibility component is disabled" do
+        RestClient.disable RestClient::Rack::Compatibility
+        @rack_app.should_receive(:call).and_return(
+          [200, {"Content-Type" => "text/plain", "Content-Length" => "13", "Allow" => "GET, POST", "Date" => "Mon, 04 Jan 2010 13:37:18 GMT"}, ["response body"]]
+        )
+        response = RestClient.get('http://domain.tld:8888/some/cacheable/resource?q1=a&q2=b', :additional_header => 'whatever')
+        response.should be_a(Array)
+        code, header, body = response
+        code.should == 200
+        header.should == {"X-Rack-Cache"=>"miss", "Date"=>"Mon, 04 Jan 2010 13:37:18 GMT", "Content-Type"=>"text/plain", "Content-Length"=>"13", "Allow"=>"GET, POST"}
+        body.should == ["response body"]
+      end
+    end
+    
+    describe "RestClient Exceptions" do
+      before do
+        RestClient::Request.should_receive(:new).once.with(@expected_args).and_return(@expected_request)
+        @mock_resource_not_found_net_http_response = mock("net http response", :code => 404, :to_hash => {'header1' => ['value1']}, :body => "Not Found")
+      end
+      describe "with compatibility component" do
+        it "should still raise the RestClient exceptions" do
+          @expected_request.should_receive(:original_execute).and_raise(RestClient::Exception.new("error"))
+          lambda{ RestClient.get('http://domain.tld:8888/some/cacheable/resource?q1=a&q2=b', :additional_header => 'whatever')}.should raise_error(RestClient::Exception)
+        end
+        it "should still raise the RestClient exceptions with message" do
+          @expected_request.should_receive(:original_execute).and_raise(RestClient::ResourceNotFound.new(@mock_resource_not_found_net_http_response))
+          lambda{ RestClient.get('http://domain.tld:8888/some/cacheable/resource?q1=a&q2=b', :additional_header => 'whatever')}.should raise_error(RestClient::ResourceNotFound)
+        end
+      end
+      describe "without compatibility component" do
+        it "should still raise the RestClient high-level exceptions" do
+          RestClient.components.clear
+          @expected_request.should_receive(:original_execute).and_raise(RestClient::Exception.new("error"))
+          lambda{ RestClient.get('http://domain.tld:8888/some/cacheable/resource?q1=a&q2=b', :additional_header => 'whatever')}.should raise_error(RestClient::Exception)
+        end
+        it "should not raise the RestClient exceptions with response" do
+          RestClient.components.clear
+          @expected_request.should_receive(:original_execute).and_raise(RestClient::ResourceNotFound.new(@mock_resource_not_found_net_http_response))
+          response = RestClient.get('http://domain.tld:8888/some/cacheable/resource?q1=a&q2=b', :additional_header => 'whatever')
+          response.should be_a(Array)
+        end
+      end
+    end
+
+  end
+  
+  describe RestClient::Rack::Compatibility do
+    it "should transform a Rack response into a RestClient Response" do
+      fake_app = Proc.new{|env|
+        [200, {"Content-Type" => "text/plain", "Content-Length" => "13", "Allow" => "GET, POST", "Date" => "Mon, 04 Jan 2010 13:37:18 GMT"}, ["response body"]]
+      }
+      response = RestClient::Rack::Compatibility.new(fake_app).call(@env)
+      response.should be_a(RestClient::Response)
+      response.code.should == 200
+      response.headers.should == {:content_type=>"text/plain", :content_length=>"13", :allow => "GET, POST", :date => "Mon, 04 Jan 2010 13:37:18 GMT"}
+      response.to_s.should == "response body"
+    end
+    it "should raise RestClient Exceptions if restclient.error exists" do
+      fake_app = Proc.new{|env|
+        raise RestClient::Exception, "error"
+      }
+      lambda{RestClient::Rack::Compatibility.new(fake_app).call(@env)}.should raise_error(RestClient::Exception)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,9 @@
+require 'rubygems'
+require 'spec'
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+
+
+Spec::Runner.configure do |config|
+  
+end

metadata

@@ -0,0 +1,87 @@
+--- !ruby/object:Gem::Specification 
+name: rest-client-components
+version: !ruby/object:Gem::Version 
+  version: 0.2.1
+platform: ruby
+authors: 
+- Cyril Rohr
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-01-10 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rest-client
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.2.0
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: rack
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.0.1
+    version: 
+description: RestClient on steroids ! Easily add one or more Rack middleware around RestClient to add functionalities such as transparent caching (Rack::Cache), transparent logging, etc.
+email: cyril.rohr@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- LICENSE
+- README.rdoc
+- Rakefile
+- VERSION
+- examples/caching.rb
+- examples/parsing.rb
+- lib/restclient/components.rb
+- rest-client-components.gemspec
+- spec/components_spec.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/crohr/rest-client-components
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: RestClient on steroids ! Easily add one or more Rack middleware around RestClient to add functionalities such as transparent caching (Rack::Cache), transparent logging, etc.
+test_files: 
+- spec/components_spec.rb
+- spec/spec_helper.rb
+- examples/caching.rb
+- examples/parsing.rb