rest-client-components 0.2.2 → 1.0.0

data/README.rdoc

@@ -23,7 +23,7 @@ Want to enable both ?
 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:
+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 rack-esque 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')
@@ -76,9 +76,9 @@ Now, you just need to make your resources cacheable, so unless you've already ta
 
 = Dependencies
 
-* rest-client >= 1.2.0
+* rest-client >= 1.3.1
 * rack >= 1.0.1
 
 = COPYRIGHT
 
-Copyright (c) 2009 Cyril Rohr. See LICENSE for details.
+Copyright (c) 2009-2010 Cyril Rohr. See LICENSE for details.

data/Rakefile

@@ -9,8 +9,9 @@ begin
     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 "rest-client", ">= 1.3.1"
     s.add_dependency "rack", ">= 1.0.1"
+    s.add_development_dependency "webmock"
   end
 rescue LoadError
   puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"

data/VERSION

@@ -1 +1 @@
-0.2.2
+1.0.0

data/examples/beautify_html.rb

@@ -0,0 +1,14 @@
+# this examples uses Rack::Tidy to automatically tidy the HTML responses returned
+require File.dirname(__FILE__) + '/../lib/restclient/components'
+require 'rack/tidy' # gem install rack-tidy
+
+URL = "http://coderack.org/users/webficient/entries/38-racktidy"
+puts "Without rack-tidy"
+response = RestClient.get URL
+puts response
+
+puts "With rack-tidy"
+RestClient.enable Rack::Tidy
+
+response = RestClient.get URL
+puts response

data/examples/caching.rb

@@ -1,53 +1,103 @@
-# 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
+require 'logger'
+require 'time'
+require 'digest/sha1'
+require 'sinatra/base'
 
-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))
+
+def server(base=Sinatra::Base, &block)
+  app = Sinatra.new(base, &block)
+  pid = fork do
+    app.run!(:port => 7890, :host => "localhost")
+  end  
+  pid
 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"
+pid = server do
+  RESOURCE = {
+    :updated_at => Time.at(Time.now-2),
+    :content => "hello"
   }
-  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
+  get '/cacheable/resource' do
+    response['Cache-Control'] = "public, max-age=4"
+    last_modified RESOURCE[:updated_at].httpdate
+    etag Digest::SHA1.hexdigest(RESOURCE[:content])
+    RESOURCE[:content]
+  end
+  
+  put '/cacheable/resource' do
+    RESOURCE[:content] = params[:content]
+    RESOURCE[:updated_at] = Time.now
+    response['Location'] = '/cacheable/resource'
+    "ok"
   end
 end
 
+RestClient.enable Rack::CommonLogger
+RestClient.enable Rack::Cache, :verbose => true, :allow_reload => true, :allow_revalidate => true
+RestClient.enable Rack::Lint
+
+begin
+  puts "Manipulating cacheable resource..."
+  6.times do
+    sleep 1
+    RestClient.get "http://localhost:7890/cacheable/resource" do |response|
+      p [response.code, response.headers[:etag], response.headers[:last_modified], response.to_s]
+    end
+  end
+  sleep 1
+  RestClient.put "http://localhost:7890/cacheable/resource", {:content => "world"} do |response|
+    p [response.code, response.headers[:etag], response.headers[:last_modified], response.to_s]
+  end
+  # note how the cache is automatically invalidated on non-GET requests
+  2.times do
+    sleep 1
+    RestClient.get "http://localhost:7890/cacheable/resource" do |response|
+      p [response.code, response.headers[:etag], response.headers[:last_modified], response.to_s]
+    end
+  end
+rescue RestClient::Exception => e
+  p [:error, e.message]
+ensure
+  Process.kill("INT", pid)
+  Process.wait
+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
+Manipulating cacheable resource...
+== Sinatra/0.9.4 has taken the stage on 7890 for development with backup from Thin
+>> Thin web server (v1.2.5 codename This Is Not A Web Server)
+>> Maximum connections set to 1024
+>> Listening on localhost:7890, CTRL+C to stop
+cache: [GET /cacheable/resource] miss, store
+- - - [15/Feb/2010 22:37:27] "GET /cacheable/resource " 200 5 0.0117
+[200, "\"aaf4c61ddcc5e8a2dabede0f3b482cd9aea9434d\"", "Mon, 15 Feb 2010 21:37:24 GMT", "hello"]
+cache: [GET /cacheable/resource] fresh
+- - - [15/Feb/2010 22:37:28] "GET /cacheable/resource " 200 5 0.0022
+[200, "\"aaf4c61ddcc5e8a2dabede0f3b482cd9aea9434d\"", "Mon, 15 Feb 2010 21:37:24 GMT", "hello"]
+cache: [GET /cacheable/resource] fresh
+- - - [15/Feb/2010 22:37:29] "GET /cacheable/resource " 200 5 0.0017
+[200, "\"aaf4c61ddcc5e8a2dabede0f3b482cd9aea9434d\"", "Mon, 15 Feb 2010 21:37:24 GMT", "hello"]
+cache: [GET /cacheable/resource] fresh
+- - - [15/Feb/2010 22:37:30] "GET /cacheable/resource " 200 5 0.0019
+[200, "\"aaf4c61ddcc5e8a2dabede0f3b482cd9aea9434d\"", "Mon, 15 Feb 2010 21:37:24 GMT", "hello"]
+cache: [GET /cacheable/resource] stale, valid, store
+- - - [15/Feb/2010 22:37:31] "GET /cacheable/resource " 200 5 0.0074
+[200, "\"aaf4c61ddcc5e8a2dabede0f3b482cd9aea9434d\"", "Mon, 15 Feb 2010 21:37:24 GMT", "hello"]
+cache: [GET /cacheable/resource] fresh
+- - - [15/Feb/2010 22:37:32] "GET /cacheable/resource " 200 5 0.0017
+[200, "\"aaf4c61ddcc5e8a2dabede0f3b482cd9aea9434d\"", "Mon, 15 Feb 2010 21:37:24 GMT", "hello"]
+cache: [PUT /cacheable/resource] invalidate, pass
+- - - [15/Feb/2010 22:37:33] "PUT /cacheable/resource " 200 2 0.0068
+[200, nil, nil, "ok"]
+cache: [GET /cacheable/resource] stale, invalid, store
+- - - [15/Feb/2010 22:37:34] "GET /cacheable/resource " 200 5 0.0083
+[200, "\"7c211433f02071597741e6ff5a8ea34789abbf43\"", "Mon, 15 Feb 2010 21:37:33 GMT", "world"]
+cache: [GET /cacheable/resource] fresh
+- - - [15/Feb/2010 22:37:35] "GET /cacheable/resource " 200 5 0.0017
+[200, "\"7c211433f02071597741e6ff5a8ea34789abbf43\"", "Mon, 15 Feb 2010 21:37:33 GMT", "world"]
+>> Stopping ...
+
+== Sinatra has ended his set (crowd applauds)

data/lib/restclient/components.rb

@@ -10,13 +10,17 @@ module RestClient
       
       def call(env)
         status, header, body = @app.call(env)
-        if e = env['restclient.error']
+        net_http_response = RestClient::MockNetHTTPResponse.new(body, status, header)
+        content = ""
+        net_http_response.body.each{|line| content << line}
+        response = RestClient::Response.new(content, net_http_response)
+        if block = env['restclient.hash'][:block]
+          block.call(response)
+        # only raise error if response is not successful
+        elsif !(200...300).include?(response.code) && e = env['restclient.hash'][:error]
           raise e
         else
-          response = RestClient::MockNetHTTPResponse.new(body, status, header)
-          content = ""
-          response.body.each{|line| content << line}
-          RestClient::Response.new(content, response)
+          response
         end
       end
     end
@@ -42,7 +46,11 @@ module RestClient
   def self.enable(component, *args)
     # remove any existing component of the same class
     disable(component)
-    @components.unshift [component, args]
+    if component == RestClient::Rack::Compatibility
+      @components.push [component, args]
+    else
+      @components.unshift [component, args]
+    end
   end
   
   # Disable a component
@@ -78,17 +86,14 @@ module RestClient
   # 
 	class Request
 	  alias_method :original_execute, :execute
-	  def execute
+	  def execute(&block)
       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,
+        "restclient.hash" => {:request => self, :error => nil, :block => block},
         "REQUEST_METHOD" => @method.to_s.upcase,
-        "SCRIPT_NAME" => script_name,
-        "PATH_INFO" => path_info,
+        "SCRIPT_NAME" => "",
+        "PATH_INFO" => uri.path || "/",
         "QUERY_STRING" => uri.query || "",
         "SERVER_NAME" => uri.host,
         "SERVER_PORT" => uri.port.to_s,
@@ -97,12 +102,13 @@ module RestClient
         "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
+        "rack.input" => payload || StringIO.new,
+        "rack.errors" => $stderr
       }
       @processed_headers.each do |key, value|
         env.merge!("HTTP_"+key.to_s.gsub("-", "_").upcase => value)
       end
+      env.delete('HTTP_CONTENT_TYPE'); env.delete('HTTP_CONTENT_LENGTH')
       stack = RestClient::RACK_APP
       RestClient.components.each do |(component, args)|
         if (args || []).empty?
@@ -111,10 +117,33 @@ module RestClient
           stack = component.new(stack, *args)
         end
       end
-      stack.call(env)
+      response = stack.call(env)
+      # allow to use the response block, even if not using the Compatibility component
+      unless RestClient.enabled?(RestClient::Rack::Compatibility)
+        if block = env['restclient.hash'][:block]
+          block.call(response)
+        end
+      end
+      response
     end
   end
 	
+	module Payload
+	  class Base
+	    def rewind(*args)
+	      @stream.rewind(*args)
+      end
+      
+      def gets(*args)
+        @stream.gets(*args)
+      end
+      
+      def each(&block)
+        @stream.each(&block)
+      end
+    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
@@ -139,17 +168,27 @@ module RestClient
   RACK_APP = Proc.new { |env|
     begin
       # get the original request, replace headers with those of env, and execute it
-      request = env['restclient.request']
-      additional_headers = env.keys.select{|k| k=~/^HTTP_/}.inject({}){|accu, k|
+      request = env['restclient.hash'][:request]
+      additional_headers = (env.keys.select{|k| k=~/^HTTP_/}).inject({}){|accu, k|
         accu[k.gsub("HTTP_", "")] = env[k]
         accu
       }
-      request.processed_headers.replace(request.make_headers(additional_headers))
+      # hack, should probably avoid to call #read on rack.input..
+      payload = if (env['rack.input'].size > 0)
+        env['rack.input'].rewind
+        Payload.generate(env['rack.input'].read)
+      else
+        nil
+      end
+      request.instance_variable_set "@payload", payload
+      headers = request.make_headers(additional_headers)
+      headers.delete('Content-Type')
+      headers['Content-type'] = env['CONTENT_TYPE'] if env['CONTENT_TYPE']
+      request.processed_headers.update(headers)
       response = request.original_execute
     rescue RestClient::ExceptionWithResponse => e  
-      env['restclient.error'] = e
-       # e is a Net::HTTPResponse
-      response = RestClient::Response.new(e.response.body, e.response)
+      env['restclient.hash'][:error] = e
+      response = e.response
     end
     # to satisfy Rack::Lint
     response.headers.delete(:status)

data/rest-client-components.gemspec

@@ -1,15 +1,15 @@
 # Generated by jeweler
 # DO NOT EDIT THIS FILE DIRECTLY
-# Instead, edit Jeweler::Tasks in rakefile, and run the gemspec command
+# 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.2"
+  s.version = "1.0.0"
 
   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.date = %q{2010-03-05}
   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 = [
@@ -21,6 +21,7 @@ Gem::Specification.new do |s|
      "README.rdoc",
      "Rakefile",
      "VERSION",
+     "examples/beautify_html.rb",
      "examples/caching.rb",
      "examples/parsing.rb",
      "lib/restclient/components.rb",
@@ -36,9 +37,9 @@ Gem::Specification.new do |s|
   s.test_files = [
     "spec/components_spec.rb",
      "spec/spec_helper.rb",
+     "examples/beautify_html.rb",
      "examples/caching.rb",
-     "examples/parsing.rb",
-     "examples/twitter_caching.rb"
+     "examples/parsing.rb"
   ]
 
   if s.respond_to? :specification_version then
@@ -46,15 +47,18 @@ Gem::Specification.new do |s|
     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<rest-client>, [">= 1.3.1"])
       s.add_runtime_dependency(%q<rack>, [">= 1.0.1"])
+      s.add_development_dependency(%q<webmock>, [">= 0"])
     else
-      s.add_dependency(%q<rest-client>, [">= 1.2.0"])
+      s.add_dependency(%q<rest-client>, [">= 1.3.1"])
       s.add_dependency(%q<rack>, [">= 1.0.1"])
+      s.add_dependency(%q<webmock>, [">= 0"])
     end
   else
-    s.add_dependency(%q<rest-client>, [">= 1.2.0"])
+    s.add_dependency(%q<rest-client>, [">= 1.3.1"])
     s.add_dependency(%q<rack>, [">= 1.0.1"])
+    s.add_dependency(%q<webmock>, [">= 0"])
   end
 end
 

data/spec/components_spec.rb

@@ -2,29 +2,14 @@ require File.dirname(__FILE__) + '/spec_helper'
 require File.dirname(__FILE__) + '/../lib/restclient/components'
 require 'logger'
 require 'rack/cache'
+require 'time'
 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]
+    RestClient.components.last.should == [RestClient::Rack::Compatibility]
   end
   it "should enable components" do
     RestClient.enable Rack::Cache, :key => "value"
@@ -33,186 +18,202 @@ describe "Components for RestClient" do
     RestClient.enable Rack::CommonLogger
     RestClient.components.length.should == 3
     RestClient.components.first.should == [Rack::CommonLogger, []]
+    RestClient.components.last.should == [RestClient::Rack::Compatibility]
   end
   
-  describe "usage" do
+  it "should allow to disable components" do
+    RestClient.enable Rack::Cache, :key => "value"
+    RestClient.disable RestClient::Rack::Compatibility
+    RestClient.components.length.should == 1
+    RestClient.components.first.should == [Rack::Cache, [{:key => "value"}]]
+  end
+  
+  it "should always put the RestClient::Rack::Compatibility component last on the stack" do
+    RestClient.enable Rack::Cache, :key => "value"
+    RestClient.disable RestClient::Rack::Compatibility
+    RestClient.enable RestClient::Rack::Compatibility
+    RestClient.components.last.should == [RestClient::Rack::Compatibility, []]
+  end
+  
+  describe "with Compatibility component" 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)
+      RestClient.enable RestClient::Rack::Compatibility
+      RestClient.enable Rack::Lint
     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 cif 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"
+    it "should work with blocks" do
+      stub_request(:get, "http://server.ltd/resource").to_return(:status => 200, :body => "body", :headers => {'Content-Length' => 4, 'Content-Type' => 'text/plain'})
+      lambda{ RestClient.get "http://server.ltd/resource" do |response|
+        raise Exception.new(response.code)
+      end}.should raise_error(Exception, 200)
+    end
+    it "should correctly use the response.return! helper" do
+      stub_request(:get, "http://server.ltd/resource").to_return(:status => 404, :body => "body", :headers => {'Content-Length' => 4, 'Content-Type' => 'text/plain'})      
+      lambda{ RestClient.get "http://server.ltd/resource" do |response|
+        response.return!
+      end}.should raise_error(RestClient::ResourceNotFound)
+    end
+    it "should raise ExceptionWithResponse errors" do
+      stub_request(:get, "http://server.ltd/resource").to_return(:status => 404, :body => "body", :headers => {'Content-Length' => 4, 'Content-Type' => 'text/plain'})
+      lambda{ RestClient.get "http://server.ltd/resource" }.should raise_error(RestClient::ResourceNotFound)
+    end
+    it "should raise Exception errors" do
+      stub_request(:get, "http://server.ltd/resource").to_raise(EOFError)
+      lambda{ RestClient.get "http://server.ltd/resource" }.should raise_error(RestClient::ServerBrokeConnection)
+    end
+    it "should correctly pass the payload in rack.input" do
+      class RackAppThatProcessesPayload
+        def initialize(app); @app = app; end
+        def call(env)
+          env['rack.input'].rewind
+          env['rack.input'] = StringIO.new(env['rack.input'].read.gsub(/rest-client/, "<b>rest-client-components</b>"))
+          env['CONTENT_TYPE'] = "text/html"
+          @app.call(env)
+        end
       end
-
-      
-      it "should add HTTP headers set by Rack middleware to the list of request headers" do
-        module Rack
-          class AddRequestHeader
-            def initialize(app)
-              @app = app
-            end
-            def call(env)
-              env['HTTP_X_HEADER'] = "hello"
-              @app.call(env)
-            end
+      RestClient.enable RackAppThatProcessesPayload
+      stub_request(:post, "http://server.ltd/resource").with(:body => "<b>rest-client-components</b> is cool", :headers => {'Content-Type'=>'text/html', 'Accept-Encoding'=>'gzip, deflate', 'Content-Length'=>'37', 'Accept'=>'*/*; q=0.5, application/xml'}).to_return(:status => 201, :body => "ok", :headers => {'Content-Length' => 2, 'Content-Type' => "text/plain"})
+      RestClient.post "http://server.ltd/resource", 'rest-client is cool', :content_type => "text/plain"
+    end
+    
+    describe "and another component" do
+      before do
+        class AnotherRackMiddleware
+          def initialize(app); @app=app; end
+          def call(env)
+            env['HTTP_X_SPECIFIC_HEADER'] = 'value'
+            @app.call(env)
           end
         end
-        @expected_request.should_receive(:processed_headers).and_return(processed_headers=mock("hash processed headers"))
-        processed_headers.should_receive(:replace).with(hash_including("X-header" => "hello"))
-        @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::AddRequestHeader.new(RestClient::RACK_APP)).call(@env.merge(
-          'restclient.request' => @expected_request
-        ))
+        RestClient.enable AnotherRackMiddleware
       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"
+      it "should correctly pass the headers set by other components" do
+        stub_request(:get, "http://server.ltd/resource").with(:headers => {'X-Specific-Header' => 'value'}).to_return(:status => 200, :body => "body", :headers => {'Content-Type' => 'text/plain', 'Content-Length' => 4})
+        RestClient.get "http://server.ltd/resource"
       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)
+    describe "with Rack::Cache enabled" do
+      before(:each) do
+        RestClient.enable Rack::Cache,
+          :metastore   => 'heap:/1/',
+          :entitystore => 'heap:/1/'
       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")
+      it "should raise ExceptionWithResponse errors" do
+        stub_request(:get, "http://server.ltd/resource").to_return(:status => 404, :body => "body", :headers => {'Content-Length' => 4, 'Content-Type' => 'text/plain'})
+        lambda{ RestClient.get "http://server.ltd/resource" }.should raise_error(RestClient::ResourceNotFound)
       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')
+      it "should raise Exception errors" do
+        stub_request(:get, "http://server.ltd/resource").to_raise(EOFError)
+        lambda{ RestClient.get "http://server.ltd/resource" }.should raise_error(RestClient::ServerBrokeConnection)
       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"
+      it "should return a RestClient::Response" do
+        stub_request(:get, "http://server.ltd/resource").to_return(:status => 200, :body => "body", :headers => {'Content-Type' => 'text/plain', 'Content-Length' => 4})
+        RestClient.get "http://server.ltd/resource" do |response|
+          response.code.should == 200
+          response.headers[:x_rack_cache].should == 'miss'
+          response.to_s.should == "body"
+        end
       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"]
+      it "should get cached" do
+        now = Time.now
+        last_modified = Time.at(now-3600)
+        stub_request(:get, "http://server.ltd/resource").to_return(:status => 200, :body => "body", :headers => {'Content-Type' => 'text/plain', 'Cache-Control' => 'public', 'Content-Length' => 4, 'Date' => now.httpdate, 'Last-Modified' => last_modified.httpdate}).times(1).then.
+            to_return(:status => 304, :headers => {'Content-Type' => 'text/plain', 'Cache-Control' => 'public', 'Content-Length' => 0, 'Date' => now.httpdate, 'Last-Modified' => last_modified.httpdate})
+        RestClient.get "http://server.ltd/resource" do |response|
+          response.headers[:x_rack_cache].should == 'miss, store'
+          response.headers[:age].should == "0"
+          response.to_s.should == "body"
+        end
+        sleep 1
+        RestClient.get "http://server.ltd/resource" do |response|
+          response.headers[:x_rack_cache].should == 'stale, valid, store'
+          response.headers[:age].should == "1"
+          response.to_s.should == "body"
+        end
       end
     end
+  end
+  
+  describe "without Compatibility component" do
+    before do
+      RestClient.disable RestClient::Rack::Compatibility
+      RestClient.enable Rack::Lint
+    end
+    it "should return response as an array of status, headers, body" do
+      stub_request(:get, "http://server.ltd/resource").to_return(:status => 200, :body => "body", :headers => {'Content-Type' => 'text/plain', 'Content-Length' => 4})
+      lambda{RestClient.get "http://server.ltd/resource" do |response|
+        raise Exception.new(response.class)
+      end}.should raise_error(Exception, Array)
+    end
+    it "should return response as an array of status, headers, body if response block is used" do
+      stub_request(:get, "http://server.ltd/resource").to_return(:status => 200, :body => "body", :headers => {'Content-Type' => 'text/plain', 'Content-Length' => 4})
+      status, headers, body = RestClient.get "http://server.ltd/resource"
+      status.should == 200
+      headers.should == {"Content-Type"=>"text/plain", "Content-Length"=>"4"}
+      content = ""
+      body.each{|block| content << block}
+      content.should == "body"
+    end
+    it "should not raise ExceptionWithResponse exceptions" do
+      stub_request(:get, "http://server.ltd/resource").to_return(:status => 404, :body => "body", :headers => {'Content-Type' => 'text/plain', 'Content-Length' => 4})
+      status, headers, body = RestClient.get "http://server.ltd/resource"
+      status.should == 404
+      headers.should == {"Content-Type"=>"text/plain", "Content-Length"=>"4"}
+      content = ""
+      body.each{|block| content << block}
+      content.should == "body"
+    end
+    it "should still raise Exception errors" do
+      stub_request(:get, "http://server.ltd/resource").to_raise(EOFError)
+      lambda{ RestClient.get "http://server.ltd/resource" }.should raise_error(RestClient::ServerBrokeConnection)
+    end
     
-    describe "RestClient Exceptions" do
+    describe "with Rack::Cache" 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")
+        RestClient.enable Rack::Cache,
+          :metastore   => 'heap:/2/',
+          :entitystore => 'heap:/2/'
       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)
+      it "should not raise ExceptionWithResponse errors" do
+        stub_request(:get, "http://server.ltd/resource").to_return(:status => 404, :body => "body", :headers => {'Content-Length' => 4, 'Content-Type' => 'text/plain'})
+        status, headers, body = RestClient.get "http://server.ltd/resource"
+        status.should == 404
+        headers['X-Rack-Cache'].should == 'miss'
+        content = ""
+        body.each{|block| content << block}
+        content.should == "body"
+      end
+      it "should raise Exception errors" do
+        stub_request(:get, "http://server.ltd/resource").to_raise(EOFError)
+        lambda{ RestClient.get "http://server.ltd/resource" }.should raise_error(RestClient::ServerBrokeConnection)
+      end
+      it "should return an array" do
+        stub_request(:get, "http://server.ltd/resource").to_return(:status => 200, :body => "body", :headers => {'Content-Type' => 'text/plain', 'Content-Length' => 4})
+        RestClient.get "http://server.ltd/resource" do |response|
+          status, headers, body = response
+          status.should == 200
+          headers['X-Rack-Cache'].should == 'miss'
+          content = ""
+          body.each{|block| content << block}
+          content.should == "body"
         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)
+      it "should get cached" do
+        now = Time.now
+        last_modified = Time.at(now-3600)
+        stub_request(:get, "http://server.ltd/resource").to_return(:status => 200, :body => "body", :headers => {'Content-Type' => 'text/plain', 'Cache-Control' => 'public', 'Content-Length' => 4, 'Date' => now.httpdate, 'Last-Modified' => last_modified.httpdate}).times(1).then.
+            to_return(:status => 304, :headers => {'Content-Type' => 'text/plain', 'Cache-Control' => 'public', 'Content-Length' => 0, 'Date' => now.httpdate, 'Last-Modified' => last_modified.httpdate})
+        RestClient.get "http://server.ltd/resource" do |status, headers, body|
+          headers['X-Rack-Cache'] == 'miss, store'
+          headers['Age'].should == "0"
         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)
+        sleep 1
+        RestClient.get "http://server.ltd/resource" do |status, headers, body|
+          headers['X-Rack-Cache'].should == 'stale, valid, store'
+          headers['Age'].should == "1"
         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

@@ -1,6 +1,8 @@
 require 'rubygems'
 require 'spec'
+require 'webmock/rspec'
 
+include WebMock
 $LOAD_PATH.unshift(File.dirname(__FILE__))
 
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: rest-client-components
 version: !ruby/object:Gem::Version 
-  version: 0.2.2
+  version: 1.0.0
 platform: ruby
 authors: 
 - Cyril Rohr
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-01-10 00:00:00 +01:00
+date: 2010-03-05 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -20,7 +20,7 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 1.2.0
+        version: 1.3.1
     version: 
 - !ruby/object:Gem::Dependency 
   name: rack
@@ -32,6 +32,16 @@ dependencies:
       - !ruby/object:Gem::Version 
         version: 1.0.1
     version: 
+- !ruby/object:Gem::Dependency 
+  name: webmock
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    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: []
@@ -46,6 +56,7 @@ files:
 - README.rdoc
 - Rakefile
 - VERSION
+- examples/beautify_html.rb
 - examples/caching.rb
 - examples/parsing.rb
 - lib/restclient/components.rb
@@ -83,6 +94,6 @@ summary: RestClient on steroids ! Easily add one or more Rack middleware around
 test_files: 
 - spec/components_spec.rb
 - spec/spec_helper.rb
+- examples/beautify_html.rb
 - examples/caching.rb
 - examples/parsing.rb
-- examples/twitter_caching.rb

data/examples/twitter_caching.rb

@@ -1,21 +0,0 @@
-require File.dirname(__FILE__) + '/../lib/restclient/components'
-require 'rack/cache'
-require 'json'
-
-
-RestClient.log = 'stdout'
-RestClient.enable Rack::Cache, :allow_reload => true, :allow_revalidate => true
-
-2.times do 
-  resp = RestClient::Resource.new("https://localhost:3443/sid/grid5000").get(:accept => "application/json")
-  p ["Cache-Control", resp.headers[:cache_control]]
-end
-
-__END__
-RestClient.get "https://localhost:3443/sid/grid5000", headers: {"Accept-encoding"=>"gzip, deflate", "Accept"=>"application/json"}
-# => 200 OK | application/vnd.fr.grid5000.api.grid+json 998 bytes
-cache: [GET /sid/grid5000] miss, store
-["Cache-Control", "public, must-revalidate"]
-RestClient.get "https://localhost:3443/sid/grid5000", headers: {"If-none-match"=>"\"ef6d9ea6d7d00299dd59a025fa84c19b4e69fafe\"", "Accept-encoding"=>"gzip, deflate", "Accept"=>"application/json", "If-modified-since"=>"Wed, 09 Dec 2009 13:58:54 GMT"}
-cache: [GET /sid/grid5000] stale, valid, store
-["Cache-Control", "public, must-revalidate"]