rest-client 2.0.2-x64-mingw32 → 2.1.0.rc1-x64-mingw32

data/lib/restclient/resource.rb

@@ -51,7 +51,8 @@ module RestClient
       Request.execute(options.merge(
               :method => :get,
               :url => url,
-              :headers => headers), &(block || @block))
+              :headers => headers,
+              :log => log), &(block || @block))
     end
 
     def head(additional_headers={}, &block)
@@ -59,7 +60,8 @@ module RestClient
       Request.execute(options.merge(
               :method => :head,
               :url => url,
-              :headers => headers), &(block || @block))
+              :headers => headers,
+              :log => log), &(block || @block))
     end
 
     def post(payload, additional_headers={}, &block)
@@ -68,7 +70,8 @@ module RestClient
               :method => :post,
               :url => url,
               :payload => payload,
-              :headers => headers), &(block || @block))
+              :headers => headers,
+              :log => log), &(block || @block))
     end
 
     def put(payload, additional_headers={}, &block)
@@ -77,7 +80,8 @@ module RestClient
               :method => :put,
               :url => url,
               :payload => payload,
-              :headers => headers), &(block || @block))
+              :headers => headers,
+              :log => log), &(block || @block))
     end
 
     def patch(payload, additional_headers={}, &block)
@@ -86,7 +90,8 @@ module RestClient
               :method => :patch,
               :url => url,
               :payload => payload,
-              :headers => headers), &(block || @block))
+              :headers => headers,
+              :log => log), &(block || @block))
     end
 
     def delete(additional_headers={}, &block)
@@ -94,7 +99,8 @@ module RestClient
       Request.execute(options.merge(
               :method => :delete,
               :url => url,
-              :headers => headers), &(block || @block))
+              :headers => headers,
+              :log => log), &(block || @block))
     end
 
     def to_s
@@ -121,6 +127,10 @@ module RestClient
       options[:open_timeout]
     end
 
+    def log
+      options[:log] || RestClient.log
+    end
+
     # Construct a subresource, preserving authentication.
     #
     # Example:

data/lib/restclient/response.rb

@@ -38,15 +38,25 @@ module RestClient
       "<RestClient::Response #{code.inspect} #{body_truncated(10).inspect}>"
     end
 
-    def self.create(body, net_http_res, request)
+    # Initialize a Response object. Because RestClient::Response is
+    # (unfortunately) a subclass of String for historical reasons,
+    # Response.create is the preferred initializer.
+    #
+    # @param [String, nil] body The response body from the Net::HTTPResponse
+    # @param [Net::HTTPResponse] net_http_res
+    # @param [RestClient::Request] request
+    # @param [Time] start_time
+    def self.create(body, net_http_res, request, start_time=nil)
       result = self.new(body || '')
 
-      result.response_set_vars(net_http_res, request)
+      result.response_set_vars(net_http_res, request, start_time)
       fix_encoding(result)
 
       result
     end
 
+    # Set the String encoding according to the 'Content-Type: charset' header,
+    # if possible.
     def self.fix_encoding(response)
       charset = RestClient::Utils.get_encoding_from_headers(response.headers)
       encoding = nil
@@ -54,8 +64,8 @@ module RestClient
       begin
         encoding = Encoding.find(charset) if charset
       rescue ArgumentError
-        if RestClient.log
-          RestClient.log << "No such encoding: #{charset.inspect}"
+        if response.log
+          response.log << "No such encoding: #{charset.inspect}"
         end
       end
 

data/lib/restclient/utils.rb

@@ -1,3 +1,5 @@
+require 'http/accept'
+
 module RestClient
   # Various utility methods
   module Utils
@@ -13,8 +15,8 @@ module RestClient
     #
     # @param headers [Hash<Symbol,String>]
     #
-    # @return [String, nil] encoding Return the string encoding or nil if no
-    #   header is found.
+    # @return [String, nil] Return the string encoding or nil if no header is
+    #   found.
     #
     # @example
     #   >> get_encoding_from_headers({:content_type => 'text/plain; charset=UTF-8'})
@@ -24,19 +26,52 @@ module RestClient
       type_header = headers[:content_type]
       return nil unless type_header
 
-      _content_type, params = cgi_parse_header(type_header)
+      # TODO: remove this hack once we drop support for Ruby 2.0
+      if RUBY_VERSION.start_with?('2.0')
+        _content_type, params = deprecated_cgi_parse_header(type_header)
+
+        if params.include?('charset')
+          return params.fetch('charset').gsub(/(\A["']*)|(["']*\z)/, '')
+        end
+
+      else
 
-      if params.include?('charset')
-        return params.fetch('charset').gsub(/(\A["']*)|(["']*\z)/, '')
+        begin
+          _content_type, params = cgi_parse_header(type_header)
+        rescue HTTP::Accept::ParseError
+          return nil
+        else
+          params['charset']
+        end
       end
+    end
 
-      nil
+    # Parse a Content-Type like header.
+    #
+    # Return the main content-type and a hash of params.
+    #
+    # @param [String] line
+    # @return [Array(String, Hash)]
+    #
+    def self.cgi_parse_header(line)
+      types = HTTP::Accept::MediaTypes.parse(line)
+
+      if types.empty?
+        raise HTTP::Accept::ParseError.new("Found no types in header line")
+      end
+
+      [types.first.mime_type, types.first.parameters]
     end
 
     # Parse semi-colon separated, potentially quoted header string iteratively.
     #
     # @private
     #
+    # @deprecated This method is deprecated and only exists to support Ruby
+    #   2.0, which is not supported by HTTP::Accept.
+    #
+    # @todo remove this method when dropping support for Ruby 2.0
+    #
     def self._cgi_parseparam(s)
       return enum_for(__method__, s) unless block_given?
 
@@ -66,11 +101,15 @@ module RestClient
     # probably doesn't read or perform particularly well in ruby.
     # https://github.com/python/cpython/blob/3.4/Lib/cgi.py#L301-L331
     #
-    #
     # @param [String] line
     # @return [Array(String, Hash)]
     #
-    def self.cgi_parse_header(line)
+    # @deprecated This method is deprecated and only exists to support Ruby
+    #   2.0, which is not supported by HTTP::Accept.
+    #
+    # @todo remove this method when dropping support for Ruby 2.0
+    #
+    def self.deprecated_cgi_parse_header(line)
       parts = _cgi_parseparam(';' + line)
       key = parts.next
       pdict = {}

data/lib/restclient/version.rb

@@ -1,6 +1,6 @@
 module RestClient
-  VERSION_INFO = [2, 0, 2] unless defined?(self::VERSION_INFO)
-  VERSION = VERSION_INFO.map(&:to_s).join('.') unless defined?(self::VERSION)
+  VERSION_INFO = [2, 1, 0, 'rc1'].freeze
+  VERSION = VERSION_INFO.map(&:to_s).join('.').freeze
 
   def self.version
     VERSION

data/rest-client.gemspec

@@ -23,6 +23,7 @@ Gem::Specification.new do |s|
   s.add_development_dependency('rdoc', '>= 2.4.2', '< 6.0')
   s.add_development_dependency('rubocop', '~> 0')
 
+  s.add_dependency('http-accept', '>= 1.7.0', '< 2.0')
   s.add_dependency('http-cookie', '>= 1.0.2', '< 2.0')
   s.add_dependency('mime-types', '>= 1.16', '< 4.0')
   s.add_dependency('netrc', '~> 0.8')

data/spec/helpers.rb

@@ -1,10 +1,36 @@
 require 'uri'
 
 module Helpers
-  def response_double(opts={})
-    double('response', {:to_hash => {}}.merge(opts))
+
+  # @param [Hash] opts A hash of methods, passed directly to the double
+  #   definition. Use this to stub other required methods.
+  #
+  # @return double for Net::HTTPResponse
+  def res_double(opts={})
+    instance_double('Net::HTTPResponse', {to_hash: {}, body: 'response body'}.merge(opts))
+  end
+
+  # Given a Net::HTTPResponse or double and a Request or double, create a
+  # RestClient::Response object.
+  #
+  # @param net_http_res_double an rspec double for Net::HTTPResponse
+  # @param request A RestClient::Request or rspec double
+  #
+  # @return [RestClient::Response]
+  #
+  def response_from_res_double(net_http_res_double, request=nil, duration: 1)
+    request ||= request_double()
+    start_time = Time.now - duration
+
+    response = RestClient::Response.create(net_http_res_double.body, net_http_res_double, request, start_time)
+
+    # mock duration to ensure it gets the value we expect
+    allow(response).to receive(:duration).and_return(duration)
+
+    response
   end
 
+  # Redirect stderr to a string for the duration of the passed block.
   def fake_stderr
     original_stderr = $stderr
     $stderr = StringIO.new
@@ -14,9 +40,15 @@ module Helpers
     $stderr = original_stderr
   end
 
+  # Create a double for RestClient::Request
   def request_double(url: 'http://example.com', method: 'get')
-    double('request', url: url, uri: URI.parse(url), method: method,
-           user: nil, password: nil, cookie_jar: HTTP::CookieJar.new,
-           redirection_history: nil, args: {url: url, method: method})
+    instance_double('RestClient::Request',
+      url: url, uri: URI.parse(url), method: method, user: nil, password: nil,
+      cookie_jar: HTTP::CookieJar.new, redirection_history: nil,
+      args: {url: url, method: method})
+  end
+
+  def test_image_path
+    File.dirname(__FILE__) + "/ISS.jpg"
   end
 end

data/spec/integration/httpbin_spec.rb

@@ -1,6 +1,8 @@
 require_relative '_lib'
 require 'json'
 
+require 'zlib'
+
 describe RestClient::Request do
   before(:all) do
     WebMock.disable!
@@ -83,5 +85,44 @@ describe RestClient::Request do
         expect(ex.http_code).to eq 401
       }
     end
+
+    it 'handles gzipped/deflated responses' do
+      [['gzip', 'gzipped'], ['deflate', 'deflated']].each do |encoding, var|
+        raw = execute_httpbin(encoding, method: :get)
+
+        begin
+          data = JSON.parse(raw)
+        rescue
+          puts "Failed to parse: " + raw.inspect
+          raise
+        end
+
+        expect(data['method']).to eq 'GET'
+        expect(data.fetch(var)).to be true
+      end
+    end
+
+    it 'does not uncompress response when accept-encoding is set' do
+      # == gzip ==
+      raw = execute_httpbin('gzip', method: :get, headers: {accept_encoding: 'gzip, deflate'})
+
+      # check for gzip magic number
+      expect(raw.body).to start_with("\x1F\x8B".b)
+
+      decoded = Zlib::GzipReader.new(StringIO.new(raw.body)).read
+      parsed = JSON.parse(decoded)
+
+      expect(parsed['method']).to eq 'GET'
+      expect(parsed.fetch('gzipped')).to be true
+
+      # == delate ==
+      raw = execute_httpbin('deflate', method: :get, headers: {accept_encoding: 'gzip, deflate'})
+
+      decoded = Zlib::Inflate.new.inflate(raw.body)
+      parsed = JSON.parse(decoded)
+
+      expect(parsed['method']).to eq 'GET'
+      expect(parsed.fetch('deflated')).to be true
+    end
   end
 end

data/spec/integration/integration_spec.rb

@@ -12,13 +12,6 @@ describe RestClient do
     expect(response.body).to eq 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"
-    expect(response.code).to eq 200
-    expect(response.body).to eq "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)

data/spec/unit/abstract_response_spec.rb

@@ -2,21 +2,21 @@ require_relative '_lib'
 
 describe RestClient::AbstractResponse, :include_helpers do
 
+  # Sample class implementing AbstractResponse used for testing.
   class MyAbstractResponse
 
     include RestClient::AbstractResponse
 
     attr_accessor :size
 
-    def initialize net_http_res, request
-      @net_http_res = net_http_res
-      @request = request
+    def initialize(net_http_res, request)
+      response_set_vars(net_http_res, request, Time.now - 1)
     end
 
   end
 
   before do
-    @net_http_res = double('net http response')
+    @net_http_res = res_double()
     @request = request_double(url: 'http://example.com', method: 'get')
     @response = MyAbstractResponse.new(@net_http_res, @request)
   end
@@ -92,8 +92,8 @@ describe RestClient::AbstractResponse, :include_helpers do
     it 'handles cookies when URI scheme is implicit' do
       net_http_res = double('net http response')
       expect(net_http_res).to receive(:to_hash).and_return('set-cookie' => ['session_id=1; path=/'])
-      request = double(url: 'example.com', uri: URI.parse('http://example.com'),
-                       method: 'get', cookie_jar: HTTP::CookieJar.new)
+      request = double('request', url: 'example.com', uri: URI.parse('http://example.com'),
+                       method: 'get', cookie_jar: HTTP::CookieJar.new, redirection_history: nil)
       response = MyAbstractResponse.new(net_http_res, request)
       expect(response.cookie_jar).to be_a HTTP::CookieJar
 
@@ -135,7 +135,7 @@ describe RestClient::AbstractResponse, :include_helpers do
     end
 
     it "should gracefully handle 302 redirect with no location header" do
-      @net_http_res = response_double(code: 302, location: nil)
+      @net_http_res = res_double(code: 302)
       @request = request_double()
       @response = MyAbstractResponse.new(@net_http_res, @request)
       expect(@response).to receive(:check_max_redirects).and_return('fake-check')

data/spec/unit/payload_spec.rb

@@ -2,7 +2,7 @@
 
 require_relative '_lib'
 
-describe RestClient::Payload do
+describe RestClient::Payload, :include_helpers do
   context "Base Payload" do
     it "should reset stream after to_s" do
       payload = RestClient::Payload::Base.new('foobar')
@@ -80,7 +80,7 @@ describe RestClient::Payload do
     end
 
     it 'should not error on close if stream already closed' do
-      m = RestClient::Payload::Multipart.new(:file => File.new(File.join(File.dirname(File.expand_path(__FILE__)), 'master_shake.jpg')))
+      m = RestClient::Payload::Multipart.new(:file => File.new(test_image_path))
       3.times {m.close}
     end
 
@@ -111,11 +111,11 @@ baz\r
     end
 
     it "should form properly separated multipart data" do
-      f = File.new(File.dirname(__FILE__) + "/master_shake.jpg")
+      f = File.new(test_image_path)
       m = RestClient::Payload::Multipart.new({:foo => f})
       expect(m.to_s).to eq <<-EOS
 --#{m.boundary}\r
-Content-Disposition: form-data; name="foo"; filename="master_shake.jpg"\r
+Content-Disposition: form-data; name="foo"; filename="ISS.jpg"\r
 Content-Type: image/jpeg\r
 \r
 #{File.open(f.path, 'rb'){|bin| bin.read}}\r
@@ -124,11 +124,11 @@ Content-Type: image/jpeg\r
     end
 
     it "should ignore the name attribute when it's not set" do
-      f = File.new(File.dirname(__FILE__) + "/master_shake.jpg")
+      f = File.new(test_image_path)
       m = RestClient::Payload::Multipart.new({nil => f})
       expect(m.to_s).to eq <<-EOS
 --#{m.boundary}\r
-Content-Disposition: form-data; filename="master_shake.jpg"\r
+Content-Disposition: form-data; filename="ISS.jpg"\r
 Content-Type: image/jpeg\r
 \r
 #{File.open(f.path, 'rb'){|bin| bin.read}}\r
@@ -137,9 +137,9 @@ Content-Type: image/jpeg\r
     end
 
     it "should detect optional (original) content type and filename" do
-      f = File.new(File.dirname(__FILE__) + "/master_shake.jpg")
-      f.instance_eval "def content_type; 'text/plain'; end"
-      f.instance_eval "def original_filename; 'foo.txt'; end"
+      f = File.new(test_image_path)
+      expect(f).to receive(:content_type).and_return('text/plain')
+      expect(f).to receive(:original_filename).and_return('foo.txt')
       m = RestClient::Payload::Multipart.new({:foo => f})
       expect(m.to_s).to eq <<-EOS
 --#{m.boundary}\r
@@ -161,7 +161,7 @@ foo\r
 --#{m.boundary}--\r
       EOS
 
-      f = File.new(File.dirname(__FILE__) + "/master_shake.jpg")
+      f = File.new(test_image_path)
       f.instance_eval "def content_type; 'text/plain'; end"
       f.instance_eval "def original_filename; 'foo.txt'; end"
       m = RestClient::Payload::Multipart.new({:foo => {:bar => f}})
@@ -177,7 +177,7 @@ Content-Type: text/plain\r
 
     it 'should correctly format hex boundary' do
       allow(SecureRandom).to receive(:base64).with(12).and_return('TGs89+ttw/xna6TV')
-      f = File.new(File.dirname(__FILE__) + '/master_shake.jpg')
+      f = File.new(test_image_path)
       m = RestClient::Payload::Multipart.new({:foo => f})
       expect(m.boundary).to eq('-' * 4 + 'RubyFormBoundary' + 'TGs89AttwBxna6TV')
     end
@@ -186,10 +186,10 @@ Content-Type: text/plain\r
 
   context "streamed payloads" do
     it "should properly determine the size of file payloads" do
-      f = File.new(File.dirname(__FILE__) + "/master_shake.jpg")
+      f = File.new(test_image_path)
       payload = RestClient::Payload.generate(f)
-      expect(payload.size).to eq 76_988
-      expect(payload.length).to eq 76_988
+      expect(payload.size).to eq 72_463
+      expect(payload.length).to eq 72_463
     end
 
     it "should properly determine the size of other kinds of streaming payloads" do
@@ -209,6 +209,14 @@ Content-Type: text/plain\r
         f.close
       end
     end
+
+    it "should have a closed? method" do
+      f = File.new(test_image_path)
+      payload = RestClient::Payload.generate(f)
+      expect(payload.closed?).to be_falsey
+      payload.close
+      expect(payload.closed?).to be_truthy
+    end
   end
 
   context "Payload generation" do
@@ -217,7 +225,7 @@ Content-Type: text/plain\r
     end
 
     it "should recognize multipart params" do
-      f = File.new(File.dirname(__FILE__) + "/master_shake.jpg")
+      f = File.new(test_image_path)
       expect(RestClient::Payload.generate({"foo" => f})).to be_kind_of(RestClient::Payload::Multipart)
     end
 
@@ -226,7 +234,7 @@ Content-Type: text/plain\r
     end
 
     it "should handle deeply nested multipart" do
-      f = File.new(File.dirname(__FILE__) + "/master_shake.jpg")
+      f = File.new(test_image_path)
       params = {foo: RestClient::ParamsArray.new({nested: f})}
       expect(RestClient::Payload.generate(params)).to be_kind_of(RestClient::Payload::Multipart)
     end
@@ -237,17 +245,17 @@ Content-Type: text/plain\r
     end
 
     it "should recognize nested multipart payloads in hashes" do
-      f = File.new(File.dirname(__FILE__) + "/master_shake.jpg")
+      f = File.new(test_image_path)
       expect(RestClient::Payload.generate({"foo" => {"file" => f}})).to be_kind_of(RestClient::Payload::Multipart)
     end
 
     it "should recognize nested multipart payloads in arrays" do
-      f = File.new(File.dirname(__FILE__) + "/master_shake.jpg")
+      f = File.new(test_image_path)
       expect(RestClient::Payload.generate({"foo" => [f]})).to be_kind_of(RestClient::Payload::Multipart)
     end
 
     it "should recognize file payloads that can be streamed" do
-      f = File.new(File.dirname(__FILE__) + "/master_shake.jpg")
+      f = File.new(test_image_path)
       expect(RestClient::Payload.generate(f)).to be_kind_of(RestClient::Payload::Streamed)
     end
 
@@ -259,5 +267,29 @@ Content-Type: text/plain\r
     it "shouldn't treat hashes as streameable" do
       expect(RestClient::Payload.generate({"foo" => 'bar'})).to be_kind_of(RestClient::Payload::UrlEncoded)
     end
+
+    it "should recognize multipart payload wrapped in ParamsArray" do
+      f = File.new(test_image_path)
+      params = RestClient::ParamsArray.new([[:image, f]])
+      expect(RestClient::Payload.generate(params)).to be_kind_of(RestClient::Payload::Multipart)
+    end
+
+    it "should handle non-multipart payload wrapped in ParamsArray" do
+      params = RestClient::ParamsArray.new([[:arg, 'value1'], [:arg, 'value2']])
+      expect(RestClient::Payload.generate(params)).to be_kind_of(RestClient::Payload::UrlEncoded)
+    end
+
+    it "should pass through Payload::Base and subclasses unchanged" do
+      payloads = [
+        RestClient::Payload::Base.new('foobar'),
+        RestClient::Payload::UrlEncoded.new({:foo => 'bar'}),
+        RestClient::Payload::Streamed.new(File.new(test_image_path)),
+        RestClient::Payload::Multipart.new({myfile: File.new(test_image_path)}),
+      ]
+
+      payloads.each do |payload|
+        expect(RestClient::Payload.generate(payload)).to equal(payload)
+      end
+    end
   end
 end