rest-client 1.8.0-x64-mingw32 → 2.0.0.rc1-x64-mingw32

data/lib/restclient/resource.rb

@@ -14,7 +14,7 @@ module RestClient
   #
   # With a timeout (seconds):
   #
-  #   RestClient::Resource.new('http://slow', :timeout => 10)
+  #   RestClient::Resource.new('http://slow', :read_timeout => 10)
   #
   # With an open timeout (seconds):
   #
@@ -113,8 +113,8 @@ module RestClient
       options[:headers] || {}
     end
 
-    def timeout
-      options[:timeout]
+    def read_timeout
+      options[:read_timeout]
     end
 
     def open_timeout

data/lib/restclient/response.rb

@@ -2,20 +2,76 @@ module RestClient
 
   # A Response from RestClient, you can access the response body, the code or the headers.
   #
-  module Response
+  class Response < String
 
     include AbstractResponse
 
+    # Return the HTTP response body.
+    #
+    # Future versions of RestClient will deprecate treating response objects
+    # directly as strings, so it will be necessary to call `.body`.
+    #
+    # @return [String]
+    #
     def body
-      self
+      # Benchmarking suggests that "#{self}" is fastest, and that caching the
+      # body string in an instance variable doesn't make it enough faster to be
+      # worth the extra memory storage.
+      String.new(self)
     end
 
-    def self.create body, net_http_res, args, request
-      result = body || ''
-      result.extend Response
+    # Convert the HTTP response body to a pure String object.
+    #
+    # @return [String]
+    def to_s
+      body
+    end
+
+    # Convert the HTTP response body to a pure String object.
+    #
+    # @return [String]
+    def to_str
+      body
+    end
+
+    def inspect
+      "<RestClient::Response #{code.inspect} #{body_truncated(10).inspect}>"
+    end
+
+    def self.create(body, net_http_res, args, request)
+      result = self.new(body || '')
+
       result.response_set_vars(net_http_res, args, request)
+      fix_encoding(result)
+
       result
     end
 
+    private
+
+    def self.fix_encoding(response)
+      charset = RestClient::Utils.get_encoding_from_headers(response.headers)
+      encoding = nil
+
+      begin
+        encoding = Encoding.find(charset) if charset
+      rescue ArgumentError
+        RestClient.log << "No such encoding: #{charset.inspect}"
+      end
+
+      return unless encoding
+
+      response.force_encoding(encoding)
+
+      response
+    end
+
+    def body_truncated(length)
+      if body.length > length
+        body[0..length] + '...'
+      else
+        body
+      end
+    end
   end
 end

data/lib/restclient/utils.rb

@@ -0,0 +1,93 @@
+module RestClient
+  # Various utility methods
+  module Utils
+
+    # Return encoding from an HTTP header hash.
+    #
+    # We use the RFC 7231 specification and do not impose a default encoding on
+    # text. This differs from the older RFC 2616 behavior, which specifies
+    # using ISO-8859-1 for text/* content types without a charset.
+    #
+    # Strings will effectively end up using `Encoding.default_external` when
+    # this method returns nil.
+    #
+    # @param headers [Hash]
+    #
+    # @return [String, nil] encoding Return the string encoding or nil if no
+    #   header is found.
+    #
+    def self.get_encoding_from_headers(headers)
+      type_header = headers[:content_type]
+      return nil unless type_header
+
+      _content_type, params = cgi_parse_header(type_header)
+
+      if params.include?('charset')
+        return params.fetch('charset').gsub(/(\A["']*)|(["']*\z)/, '')
+      end
+
+      nil
+    end
+
+    # Parse semi-colon separated, potentially quoted header string iteratively.
+    #
+    # @private
+    #
+    def self._cgi_parseparam(s)
+      return enum_for(__method__, s) unless block_given?
+
+      while s[0] == ';'
+        s = s[1..-1]
+        ends = s.index(';')
+        while ends && ends > 0 \
+              && (s[0...ends].count('"') -
+                  s[0...ends].scan('\"').count) % 2 != 0
+          ends = s.index(';', ends + 1)
+        end
+        if ends.nil?
+          ends = s.length
+        end
+        f = s[0...ends]
+        yield f.strip
+        s = s[ends..-1]
+      end
+      nil
+    end
+
+    # Parse a Content-type like header.
+    #
+    # Return the main content-type and a hash of options.
+    #
+    # This method was ported directly from Python's cgi.parse_header(). It
+    # 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)
+      parts = _cgi_parseparam(';' + line)
+      key = parts.next
+      pdict = {}
+
+      begin
+        while (p = parts.next)
+          i = p.index('=')
+          if i
+            name = p[0...i].strip.downcase
+            value = p[i+1..-1].strip
+            if value.length >= 2 && value[0] == '"' && value[-1] == '"'
+              value = value[1...-1]
+              value = value.gsub('\\\\', '\\').gsub('\\"', '"')
+            end
+            pdict[name] = value
+          end
+        end
+      rescue StopIteration
+      end
+
+      [key, pdict]
+    end
+  end
+end

data/lib/restclient/version.rb

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

data/rest-client.gemspec

@@ -17,14 +17,15 @@ Gem::Specification.new do |s|
   s.summary = 'Simple HTTP and REST client for Ruby, inspired by microframework syntax for specifying actions.'
 
   s.add_development_dependency('webmock', '~> 1.4')
-  s.add_development_dependency('rspec', '~> 2.4')
-  s.add_development_dependency('pry')
-  s.add_development_dependency('pry-doc')
+  s.add_development_dependency('rspec', '~> 2.99')
+  s.add_development_dependency('pry', '~> 0')
+  s.add_development_dependency('pry-doc', '~> 0')
   s.add_development_dependency('rdoc', '>= 2.4.2', '< 5.0')
+  s.add_development_dependency('rubocop', '~> 0')
 
   s.add_dependency('http-cookie', '>= 1.0.2', '< 2.0')
   s.add_dependency('mime-types', '>= 1.16', '< 3.0')
-  s.add_dependency('netrc', '~> 0.7')
+  s.add_dependency('netrc', '~> 0.8')
 
-  s.required_ruby_version = '>= 1.9.2'
+  s.required_ruby_version = '>= 1.9.3'
 end

data/spec/helpers.rb

@@ -0,0 +1,14 @@
+module Helpers
+  def response_double(opts={})
+    double('response', {:to_hash => {}}.merge(opts))
+  end
+
+  def fake_stderr
+    original_stderr = $stderr
+    $stderr = StringIO.new
+    yield
+    $stderr.string
+  ensure
+    $stderr = original_stderr
+  end
+end

data/spec/integration/_lib.rb

@@ -0,0 +1 @@
+require_relative '../spec_helper'

data/spec/integration/httpbin_spec.rb

@@ -0,0 +1,72 @@
+require_relative '_lib'
+require 'json'
+
+describe RestClient::Request do
+  before(:all) do
+    WebMock.disable!
+  end
+
+  after(:all) do
+    WebMock.enable!
+  end
+
+  def default_httpbin_url
+    # add a hack to work around java/jruby bug
+    # java.lang.RuntimeException: Could not generate DH keypair with backtrace
+    if ENV['TRAVIS_RUBY_VERSION'] == 'jruby-19mode'
+      'http://httpbin.org/'
+    else
+      'https://httpbin.org/'
+    end
+  end
+
+  def httpbin(suffix='')
+    url = ENV.fetch('HTTPBIN_URL', default_httpbin_url)
+    unless url.end_with?('/')
+      url += '/'
+    end
+
+    url + suffix
+  end
+
+  def execute_httpbin(suffix, opts={})
+    opts = {url: httpbin(suffix)}.merge(opts)
+    RestClient::Request.execute(opts)
+  end
+
+  def execute_httpbin_json(suffix, opts={})
+    JSON.parse(execute_httpbin(suffix, opts))
+  end
+
+  describe '.execute' do
+    it 'sends a user agent' do
+      data = execute_httpbin_json('user-agent', method: :get)
+      data['user-agent'].should match(/rest-client/)
+    end
+
+    it 'receives cookies on 302' do
+      expect {
+        execute_httpbin('cookies/set?foo=bar', method: :get, max_redirects: 0)
+      }.to raise_error(RestClient::Found) { |ex|
+        ex.http_code.should eq 302
+        ex.response.cookies['foo'].should eq 'bar'
+      }
+    end
+
+    it 'passes along cookies through 302' do
+      data = execute_httpbin_json('cookies/set?foo=bar', method: :get)
+      data.should have_key('cookies')
+      data['cookies']['foo'].should eq 'bar'
+    end
+
+    it 'handles quote wrapped cookies' do
+      expect {
+        execute_httpbin('cookies/set?foo=' + CGI.escape('"bar:baz"'),
+                        method: :get, max_redirects: 0)
+      }.to raise_error(RestClient::Found) { |ex|
+        ex.http_code.should eq 302
+        ex.response.cookies['foo'].should eq '"bar:baz"'
+      }
+    end
+  end
+end

data/spec/integration/integration_spec.rb

@@ -1,4 +1,6 @@
-require 'spec_helper'
+# -*- coding: utf-8 -*-
+require_relative '_lib'
+require 'base64'
 
 describe RestClient do
 
@@ -31,5 +33,81 @@ describe RestClient do
     end
   end
 
+  describe 'charset parsing' do
+    it 'handles utf-8' do
+      body = "λ".force_encoding('ASCII-8BIT')
+      stub_request(:get, "www.example.com").to_return(
+        :body => body, :status => 200, :headers => {
+          'Content-Type' => 'text/plain; charset=UTF-8'
+      })
+      response = RestClient.get "www.example.com"
+      response.encoding.should eq Encoding::UTF_8
+      response.valid_encoding?.should eq true
+    end
+
+    it 'handles windows-1252' do
+      body = "\xff".force_encoding('ASCII-8BIT')
+      stub_request(:get, "www.example.com").to_return(
+        :body => body, :status => 200, :headers => {
+          'Content-Type' => 'text/plain; charset=windows-1252'
+      })
+      response = RestClient.get "www.example.com"
+      response.encoding.should eq Encoding::WINDOWS_1252
+      response.encode('utf-8').should eq "ÿ"
+      response.valid_encoding?.should eq true
+    end
+
+    it 'handles binary' do
+      body = "\xfe".force_encoding('ASCII-8BIT')
+      stub_request(:get, "www.example.com").to_return(
+        :body => body, :status => 200, :headers => {
+          'Content-Type' => 'application/octet-stream; charset=binary'
+      })
+      response = RestClient.get "www.example.com"
+      response.encoding.should eq Encoding::BINARY
+      lambda {
+        response.encode('utf-8')
+      }.should raise_error(Encoding::UndefinedConversionError)
+      response.valid_encoding?.should eq true
+    end
+
+    it 'handles euc-jp' do
+      body = "\xA4\xA2\xA4\xA4\xA4\xA6\xA4\xA8\xA4\xAA".
+        force_encoding(Encoding::BINARY)
+      body_utf8 = 'あいうえお'
+      body_utf8.encoding.should eq Encoding::UTF_8
+
+      stub_request(:get, 'www.example.com').to_return(
+        :body => body, :status => 200, :headers => {
+          'Content-Type' => 'text/plain; charset=EUC-JP'
+      })
+      response = RestClient.get 'www.example.com'
+      response.encoding.should eq Encoding::EUC_JP
+      response.valid_encoding?.should eq true
+      response.length.should eq 5
+      response.encode('utf-8').should eq body_utf8
+    end
 
+    it 'defaults to Encoding.default_external' do
+      stub_request(:get, 'www.example.com').to_return(
+        body: 'abc', status: 200, headers: {
+          'Content-Type' => 'text/plain'
+        })
+
+      response = RestClient.get 'www.example.com'
+      response.encoding.should eq Encoding.default_external
+    end
+
+    it 'leaves images as binary' do
+      gif = Base64.strict_decode64('R0lGODlhAQABAAAAADs=')
+
+      stub_request(:get, 'www.example.com').to_return(
+        body: gif, status: 200, headers: {
+          'Content-Type' => 'image/gif'
+        })
+
+      response = RestClient.get 'www.example.com'
+      response.encoding.should eq Encoding::BINARY
+    end
+  end
 end

data/spec/integration/request_spec.rb

@@ -1,4 +1,4 @@
-require 'spec_helper'
+require_relative '_lib'
 
 describe RestClient::Request do
   before(:all) do
@@ -101,4 +101,27 @@ describe RestClient::Request do
       expect { request.execute }.to_not raise_error
     end
   end
+
+  describe "timeouts" do
+    it "raises OpenTimeout when it hits an open timeout" do
+      request = RestClient::Request.new(
+        :method => :get,
+        :url => 'http://www.mozilla.org',
+        :open_timeout => 1e-10,
+      )
+      expect { request.execute }.to(
+        raise_error(RestClient::Exceptions::OpenTimeout))
+    end
+
+    it "raises ReadTimeout when it hits a read timeout via :read_timeout" do
+      request = RestClient::Request.new(
+        :method => :get,
+        :url => 'https://www.mozilla.org',
+        :read_timeout => 1e-10,
+      )
+      expect { request.execute }.to(
+        raise_error(RestClient::Exceptions::ReadTimeout))
+    end
+  end
+
 end

data/spec/spec_helper.rb

@@ -1,2 +1,22 @@
 require 'webmock/rspec'
-require 'restclient'
+require 'rest-client'
+
+require_relative './helpers'
+
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = 'random'
+
+  # add helpers
+  config.include Helpers, :include_helpers
+
+  config.mock_with :rspec do |mocks|
+    mocks.yield_receiver_to_any_instance_implementation_blocks = true
+  end
+end