esod-client 0.2.1 → 0.3.0

data/lib/{rest-client-1.2.0 → rest-client-1.4.2}/lib/restclient/request.rb

@@ -20,16 +20,17 @@ module RestClient
   # * :timeout and :open_timeout
   # * :ssl_client_cert, :ssl_client_key, :ssl_ca_file
   class Request
-    attr_reader :method, :url, :payload, :headers, :processed_headers,
-                :cookies, :user, :password, :timeout, :open_timeout,
-                :verify_ssl, :ssl_client_cert, :ssl_client_key, :ssl_ca_file,
-                :raw_response
 
-    def self.execute(args)
-      new(args).execute
+    attr_reader :method, :url, :headers, :cookies,
+                :payload, :user, :password, :timeout,
+                :open_timeout, :raw_response, :verify_ssl, :ssl_client_cert,
+                :ssl_client_key, :ssl_ca_file, :processed_headers, :args
+
+    def self.execute(args, &block)
+      new(args).execute &block
     end
 
-    def initialize(args)
+    def initialize args
       @method = args[:method] or raise ArgumentError, "must pass :method"
       @url = args[:url] or raise ArgumentError, "must pass :url"
       @headers = args[:headers] || {}
@@ -46,25 +47,17 @@ module RestClient
       @ssl_ca_file = args[:ssl_ca_file] || nil
       @tf = nil # If you are a raw request, this is your tempfile
       @processed_headers = make_headers headers
+      @args = args
     end
 
-    def execute
-      execute_inner
-    rescue Redirect => e
-      @url = e.url
-      @method = :get
-      @payload = nil
-      execute
-    end
-
-    def execute_inner
+    def execute &block
       uri = parse_url_with_auth(url)
-      transmit uri, net_http_request_class(method).new(uri.request_uri, processed_headers), payload
+      transmit uri, net_http_request_class(method).new(uri.request_uri, processed_headers), payload, &block
     end
 
     def make_headers user_headers
       unless @cookies.empty?
-        user_headers[:cookie] = @cookies.map {|key, val| "#{key.to_s}=#{val}" }.join('; ')
+        user_headers[:cookie] = @cookies.map {|(key, val)| "#{key.to_s}=#{val}" }.sort.join(",")
       end
 
       headers = default_headers.merge(user_headers).inject({}) do |final, (key, value)|
@@ -73,13 +66,13 @@ module RestClient
           target_value = value.to_s
           final[target_key] = MIME::Types.type_for_extension target_value
         elsif 'ACCEPT' == target_key.upcase
-            # Accept can be composed of several comma-separated values
-            if value.is_a? Array
-              target_values = value
-            else
-              target_values = value.to_s.split ','
-            end
-            final[target_key] = target_values.map{ |ext| MIME::Types.type_for_extension(ext.to_s.strip)}.join(', ')
+          # Accept can be composed of several comma-separated values
+          if value.is_a? Array
+            target_values = value
+          else
+            target_values = value.to_s.split ','
+          end
+          final[target_key] = target_values.map{ |ext| MIME::Types.type_for_extension(ext.to_s.strip)}.join(', ')
         else
           final[target_key] = value.to_s
         end
@@ -132,8 +125,8 @@ module RestClient
       end
     end
 
-    def transmit(uri, req, payload)
-      setup_credentials(req)
+    def transmit uri, req, payload, &block
+      setup_credentials req
 
       net = net_http_class.new(uri.host, uri.port)
       net.use_ssl = uri.is_a?(URI::HTTPS)
@@ -148,20 +141,16 @@ module RestClient
       net.read_timeout = @timeout if @timeout
       net.open_timeout = @open_timeout if @open_timeout
 
-      display_log request_log
+      RestClient.before_execution_procs.each do |before_proc|
+        before_proc.call(req, args)
+      end
+
+      log_request
 
       net.start do |http|
         res = http.request(req, payload) { |http_response| fetch_body(http_response) }
-        result = process_result(res)
-        display_log response_log(res)
-
-        if result.kind_of?(String) or @method == :head
-          Response.new(result, res)
-        elsif @raw_response
-          RawResponse.new(@tf, res)
-        else
-          Response.new(nil, res)
-        end
+        log_response res
+        process_result res, &block
       end
     rescue EOFError
       raise RestClient::ServerBrokeConnection
@@ -181,14 +170,16 @@ module RestClient
         @tf = Tempfile.new("rest-client")
         size, total = 0, http_response.header['Content-Length'].to_i
         http_response.read_body do |chunk|
-          @tf.write(chunk)
+          @tf.write chunk
           size += chunk.size
-          if size == 0
-            display_log("#{@method} #{@url} done (0 length file)")
-          elsif total == 0
-            display_log("#{@method} #{@url} (zero content length)")
-          else
-            display_log("#{@method} #{@url} %d%% done (%d of %d)" % [(size * 100) / total, size, total])
+          if RestClient.log
+            if size == 0
+              RestClient.log << "#{@method} #{@url} done (0 length file\n)"
+            elsif total == 0
+              RestClient.log << "#{@method} #{@url} (zero content length)\n"
+            else
+              RestClient.log << "#{@method} #{@url} %d%% done (%d of %d)\n" % [(size * 100) / total, size, total]
+            end
           end
         end
         @tf.close
@@ -199,67 +190,48 @@ module RestClient
       http_response
     end
 
-    def process_result(res)
-      if res.code =~ /\A2\d{2}\z/
+    def process_result res, &block
+      if @raw_response
         # We don't decode raw requests
-        unless @raw_response
-          self.class.decode res['content-encoding'], res.body if res.body
-        end
-      elsif %w(301 302 303).include? res.code
-        url = res.header['Location']
-
-        if url !~ /^http/
-          uri = URI.parse(@url)
-          uri.path = "/#{url}".squeeze('/')
-          url = uri.to_s
-        end
+        response = RawResponse.new(@tf, res, args)
+      else
+        response = Response.new(Request.decode(res['content-encoding'], res.body), res, args)
+      end
 
-        raise Redirect, url
-      elsif res.code == "304"
-        raise NotModified, res
-      elsif res.code == "401"
-        raise Unauthorized, res
-      elsif res.code == "404"
-        raise ResourceNotFound, res
+      if block_given?
+        block.call response, &block
       else
-        raise RequestFailed, res
+        response.return! &block
       end
+
     end
 
-    def self.decode(content_encoding, body)
-      if content_encoding == 'gzip' and not body.empty?
+    def self.decode content_encoding, body
+      if (!body) || body.empty?
+        body
+      elsif content_encoding == 'gzip'
         Zlib::GzipReader.new(StringIO.new(body)).read
       elsif content_encoding == 'deflate'
-        Zlib::Inflate.new.inflate(body)
+        Zlib::Inflate.new.inflate body
       else
         body
       end
     end
 
-    def request_log
+    def log_request
       if RestClient.log
         out = []
         out << "RestClient.#{method} #{url.inspect}"
-        out << "headers: #{processed_headers.inspect}"
-        out << "paylod: #{payload.short_inspect}" if payload
-        out.join(', ')
+        out << payload.short_inspect if payload
+        out << processed_headers.inspect.gsub(/^\{/, '').gsub(/\}$/, '')
+        RestClient.log << out.join(', ') + "\n"
       end
     end
 
-    def response_log(res)
-      size = @raw_response ? File.size(@tf.path) : (res.body.nil? ? 0 : res.body.size)
-      "# => #{res.code} #{res.class.to_s.gsub(/^Net::HTTP/, '')} | #{(res['Content-type'] || '').gsub(/;.*$/, '')} #{size} bytes"
-    end
-
-    def display_log(msg)
-      return unless log_to = RestClient.log
-
-      if log_to == 'stdout'
-        STDOUT.puts msg
-      elsif log_to == 'stderr'
-        STDERR.puts msg
-      else
-        File.open(log_to, 'a') { |f| f.puts msg }
+    def log_response res
+      if RestClient.log
+        size = @raw_response ? File.size(@tf.path) : (res.body.nil? ? 0 : res.body.size)
+        RestClient.log << "# => #{res.code} #{res.class.to_s.gsub(/^Net::HTTP/, '')} | #{(res['Content-type'] || '').gsub(/;.*$/, '')} #{size} bytes\n"
       end
     end
 
@@ -274,7 +246,7 @@ module MIME
 
     # Return the first found content-type for a value considered as an extension or the value itself
     def type_for_extension ext
-      candidates =  @extension_index[ext]
+      candidates = @extension_index[ext]
       candidates.empty? ? ext : candidates[0].content_type
     end
 

data/lib/{rest-client-1.2.0 → rest-client-1.4.2}/lib/restclient/resource.rb

@@ -34,10 +34,11 @@ module RestClient
   #   site['posts/1/comments'].post 'Good article.', :content_type => 'text/plain'
   #
   class Resource
-    attr_reader :url, :options
+    attr_reader :url, :options, :block
 
-    def initialize(url, options={}, backwards_compatibility=nil)
+    def initialize(url, options={}, backwards_compatibility=nil, &block)
       @url = url
+      @block = block
       if options.class == Hash
         @options = options
       else # compatibility with previous versions
@@ -45,38 +46,38 @@ module RestClient
       end
     end
 
-    def get(additional_headers={}, &b)
+    def get(additional_headers={}, &block)
       headers = (options[:headers] || {}).merge(additional_headers)
       Request.execute(options.merge(
               :method => :get,
               :url => url,
-              :headers => headers), &b)
+              :headers => headers), &(block || @block))
     end
 
-    def post(payload, additional_headers={}, &b)
+    def post(payload, additional_headers={}, &block)
       headers = (options[:headers] || {}).merge(additional_headers)
       Request.execute(options.merge(
               :method => :post,
               :url => url,
               :payload => payload,
-              :headers => headers), &b)
+              :headers => headers), &(block || @block))
     end
 
-    def put(payload, additional_headers={}, &b)
+    def put(payload, additional_headers={}, &block)
       headers = (options[:headers] || {}).merge(additional_headers)
       Request.execute(options.merge(
               :method => :put,
               :url => url,
               :payload => payload,
-              :headers => headers), &b)
+              :headers => headers), &(block || @block))
     end
 
-    def delete(additional_headers={}, &b)
+    def delete(additional_headers={}, &block)
       headers = (options[:headers] || {}).merge(additional_headers)
       Request.execute(options.merge(
               :method => :delete,
               :url => url,
-              :headers => headers), &b)
+              :headers => headers), &(block || @block))
     end
 
     def to_s

data/lib/rest-client-1.4.2/lib/restclient/response.rb

@@ -0,0 +1,46 @@
+module RestClient
+
+  # A Response from RestClient, you can access the response body, the code or the headers.
+  #
+  class Response < AbstractResponse
+
+    attr_reader :body
+
+    WARNING_MESSAGE = '[warning] The Response is no more a String and the Response content is now accessed through Response.body, please update your code'
+
+    def initialize body, net_http_res, args
+      super net_http_res, args
+      @body = body || ""
+    end
+
+    def method_missing symbol, *args
+      if body.respond_to? symbol
+        warn WARNING_MESSAGE
+        body.send symbol, *args
+      else
+        super
+      end
+    end
+
+    def == o
+      if super
+        true
+      else
+        equal_body = (body == o)
+        if equal_body
+          warn WARNING_MESSAGE
+        end
+        equal_body
+      end
+    end
+
+    def to_s
+      body.to_s
+    end
+
+    def size
+      body.size
+    end
+
+  end
+end

data/lib/{rest-client-1.2.0/spec/mixin/response_spec.rb → rest-client-1.4.2/spec/abstract_response_spec.rb}

@@ -1,18 +1,9 @@
-require File.dirname(__FILE__) + '/../base'
+require File.dirname(__FILE__) + '/base'
 
-class MockResponse
-  include RestClient::Mixin::Response
-
-  def initialize(body, res)
-    @net_http_res = res
-    @body = @body
-  end
-end
-
-describe RestClient::Mixin::Response do
+describe RestClient::AbstractResponse do
   before do
     @net_http_res = mock('net http response')
-    @response = MockResponse.new('abc', @net_http_res)
+    @response = RestClient::AbstractResponse.new(@net_http_res, {})
   end
 
   it "fetches the numeric response code" do

data/lib/{rest-client-1.2.0 → rest-client-1.4.2}/spec/exceptions_spec.rb

@@ -1,8 +1,11 @@
 require File.dirname(__FILE__) + '/base'
 
+require 'webmock/rspec'
+include WebMock
+
 describe RestClient::Exception do
   it "sets the exception message to ErrorMessage" do
-    RestClient::ResourceNotFound.new.message.should == 'Resource not found'
+    RestClient::ResourceNotFound.new.message.should == 'Resource Not Found'
   end
 
   it "contains exceptions in RestClient" do
@@ -17,10 +20,11 @@ describe RestClient::RequestFailed do
   end
 
   it "stores the http response on the exception" do
+    response = "response"
     begin
-      raise RestClient::RequestFailed, :response
+      raise RestClient::RequestFailed, response
     rescue RestClient::RequestFailed => e
-      e.response.should == :response
+      e.response.should == response
     end
   end
 
@@ -29,10 +33,8 @@ describe RestClient::RequestFailed do
   end
 
   it "http_body convenience method for fetching the body (decoding when necessary)" do
-    @response.stub!(:[]).with('content-encoding').and_return('gzip')
-    @response.stub!(:body).and_return('compressed body')
-    RestClient::Request.should_receive(:decode).with('gzip', 'compressed body').and_return('plain body')
-    RestClient::RequestFailed.new(@response).http_body.should == 'plain body'
+    RestClient::RequestFailed.new(@response).http_code.should == 502
+    RestClient::RequestFailed.new(@response).message.should == 'HTTP status code 502'
   end
 
   it "shows the status code in the message" do
@@ -42,10 +44,11 @@ end
 
 describe RestClient::ResourceNotFound do
   it "also has the http response attached" do
+    response = "response"
     begin
-      raise RestClient::ResourceNotFound, :response
+      raise RestClient::ResourceNotFound, response
     rescue RestClient::ResourceNotFound => e
-      e.response.should == :response
+      e.response.should == response
     end
   end
 end
@@ -62,4 +65,15 @@ describe "backwards compatibility" do
   it "alias RestClient::Request::RequestFailed to RestClient::RequestFailed" do
     RestClient::Request::RequestFailed.should == RestClient::RequestFailed
   end
+
+  it "make the exception's response act like an Net::HTTPResponse" do
+    body = "body"
+    stub_request(:get, "www.example.com").to_return(:body => body, :status => 404)
+    begin
+      RestClient.get "www.example.com"
+      raise
+    rescue RestClient::ResourceNotFound => e
+      e.response.body.should == body
+    end
+  end
 end

data/lib/rest-client-1.4.2/spec/integration_spec.rb

@@ -0,0 +1,38 @@
+require File.dirname(__FILE__) + '/base'
+
+require 'webmock/rspec'
+include WebMock
+
+describe RestClient do
+
+  it "a simple request" do
+    body = 'abc'
+    stub_request(:get, "www.example.com").to_return(:body => body, :status => 200)
+    response = RestClient.get "www.example.com"
+    response.code.should == 200
+    response.body.should == body
+  end
+
+  it "a simple request with gzipped content" do
+    stub_request(:get, "www.example.com").with(:headers => { 'Accept-Encoding' => 'gzip, deflate' }).to_return(:body => "\037\213\b\b\006'\252H\000\003t\000\313T\317UH\257\312,HM\341\002\000G\242(\r\v\000\000\000", :status => 200,  :headers => { 'Content-Encoding' => 'gzip' } )
+    response = RestClient.get "www.example.com"
+    response.code.should == 200
+    response.body.should == "i'm gziped\n"
+  end
+
+  it "a 404" do
+    body = "Ho hai ! I'm not here !"
+    stub_request(:get, "www.example.com").to_return(:body => body, :status => 404)
+    begin
+      RestClient.get "www.example.com"
+      raise
+    rescue RestClient::ResourceNotFound => e
+      e.http_code.should == 404
+      e.response.code.should == 404
+      e.response.body.should == body
+      e.http_body.should == body
+    end
+  end
+
+
+end