rest-client 2.0.0.rc4 → 2.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 68b80b5b33ba926c8c3a2b4c0aac27b4e7f756f0
-  data.tar.gz: ba56b4b86dc27028889674a840132c6f88671f9f
+  metadata.gz: 10312217af6f5a0312bdce748c8fd82f428fce64
+  data.tar.gz: 67846732a7926b335a7082eb1fba0b7178f0c5c4
 SHA512:
-  metadata.gz: c83b06c417fd471f0c80ad5a7f93c645a5748ebec48785269c8af59e198c8cb9b7b6b52c0c36be48c6c9c0cee61e9faacafe5e4012ca8be655b0edf739d0b799
-  data.tar.gz: cea931e95b38351d4c6236189fbb781a1f2e0067eb95e3d65d94bae1eddeff7217158d1a3ca5875747371d7ceb5cd98fe2cb3fd0e189ed0db322cc913c1428b8
+  metadata.gz: 56d9d3140ee5418e9b4e877e9756bbb1a1858314c4487b5d7e41ca5fc72f70532f764dcf480c8c3098f4297025fa66c7d8db0bd890e9ae46459e7478a34a685a
+  data.tar.gz: 812f11c8a6c2c4ac5ec68852e75f64ae2d7416ae4683f5ff6525055dbf8e472baed3cc01a85eb76e5da2cb39233ff2dc2129cbdab7165dec89637987b346359b

data/.travis.yml

@@ -1,43 +1,48 @@
 # Available ruby versions: http://rubies.travis-ci.org/
 
 language: ruby
+
 os:
   - linux
   - osx
+
 rvm:
   - "2.0.0"
   - "2.1" # latest 2.1.x
-  - "2.2" # latest 2.2.x
-  - "2.3.1" # TODO: switch to "2.3" once travis fixes it
+  - "2.2.5"
+  - "2.3.3"
+  - "2.4.0"
   - "ruby-head"
   - "jruby-9.0.5.0"
+  - "jruby-9.1.5.0"
   - "jruby-head"
+
+cache: bundler
+
 script:
   bundle exec rake test
+
 branches:
   except:
     - "readme-edits"
 
+before_install:
+  - gem update --system
+  # bundler installation needed for jruby-head
+  # https://github.com/travis-ci/travis-ci/issues/5861
+  - gem install bundler
+
 # Travis OS X support is pretty janky. These are some hacks to include tests
 # only on versions that actually work.
-# (last tested: 2016-04)
+# (last tested: 2016-11)
 matrix:
-  exclude:
-    - os: osx
-      rvm: '2.2'
-    - os: osx
-      rvm: '2.3.1' # No 2.3.x at all
-  include:
-    - os: osx
-      rvm: '2.2.2' # Travis OS X doesn't have 2.2 aliases
+  # exclude: {}
+  # include: {}
+
   allow_failures:
     - rvm: 'ruby-head'
-    - os: osx
-      rvm: 'jruby-9.0.5.0'
-    - os: osx
-      rvm: 'jruby-head'
-    - os: linux
-      rvm: 'jruby-head'
+
+  # return results as soon as mandatory versions are done
   fast_finish: true
 
 sudo: false

data/README.md

@@ -1,6 +1,6 @@
 # REST Client -- simple DSL for accessing HTTP and REST resources
 
-[![Gem Downloads](https://img.shields.io/gem/dt/rails.svg)](https://rubygems.org/gems/rest-client)
+[![Gem Downloads](https://img.shields.io/gem/dt/rest-client.svg)](https://rubygems.org/gems/rest-client)
 [![Build Status](https://travis-ci.org/rest-client/rest-client.svg?branch=master)](https://travis-ci.org/rest-client/rest-client)
 [![Code Climate](https://codeclimate.com/github/rest-client/rest-client.svg)](https://codeclimate.com/github/rest-client/rest-client)
 [![Inline docs](http://inch-ci.org/github/rest-client/rest-client.svg?branch=master)](http://www.rubydoc.info/github/rest-client/rest-client/master)
@@ -45,31 +45,78 @@ There are also several development dependencies. It's recommended to use
 [bundler](http://bundler.io/) to manage these dependencies for hacking on
 rest-client.
 
+### Upgrading to rest-client 2.0 from 1.x
+
+Users are encouraged to upgrade to rest-client 2.0, which cleans up a number of
+API warts and wrinkles, making rest-client generally more useful. Usage is
+largely compatible, so many applications will be able to upgrade with no
+changes.
+
+Overview of significant changes:
+
+* requires Ruby >= 2.0
+* `RestClient::Response` objects are a subclass of `String` rather than a
+  Frankenstein monster. And `#body` or `#to_s` return a true `String` object.
+* cleanup of exception classes, including new `RestClient::Exceptions::Timeout`
+* improvements to handling of redirects: responses and history are properly
+  exposed
+* major changes to cookie support: cookie jars are used for browser-like
+  behavior throughout
+* encoding: Content-Type charset response headers are used to automatically set
+  the encoding of the response string
+* HTTP params: handling of GET/POST params is more consistent and sophisticated
+  for deeply nested hash objects, and `ParamsArray` can be used to pass ordered
+  params
+* improved proxy support with per-request proxy configuration, plus the ability
+  to disable proxies set by environment variables
+* default request headers: rest-client sets `Accept: */*` and
+  `User-Agent: rest-client/...`
+
+See [history.md](./history.md) for a more complete description of changes.
+
 ## Usage: Raw URL
+
+Basic usage:
+
+```ruby
+require 'rest-client'
+
+RestClient.get(url, headers={})
+
+RestClient.post(url, payload, headers={})
+```
+
+In the high level helpers, only POST, PATCH, and PUT take a payload argument.
+To pass a payload with other HTTP verbs or to pass more advanced options, use
+`RestClient::Request.execute` instead.
+
+More detailed examples:
+
 ```ruby
 require 'rest-client'
 
 RestClient.get 'http://example.com/resource'
 
-RestClient.get 'http://example.com/resource', {:params => {:id => 50, 'foo' => 'bar'}}
+RestClient.get 'http://example.com/resource', {params: {id: 50, 'foo' => 'bar'}}
 
-RestClient.get 'https://user:password@example.com/private/resource', {:accept => :json}
+RestClient.get 'https://user:password@example.com/private/resource', {accept: :json}
 
-RestClient.post 'http://example.com/resource', :param1 => 'one', :nested => { :param2 => 'two' }
+RestClient.post 'http://example.com/resource', {param1: 'one', nested: {param2: 'two'}}
 
-RestClient.post "http://example.com/resource", { 'x' => 1 }.to_json, :content_type => :json, :accept => :json
+RestClient.post "http://example.com/resource", {'x' => 1}.to_json, {content_type: :json, accept: :json}
 
 RestClient.delete 'http://example.com/resource'
 
-response = RestClient.get 'http://example.com/resource'
-response.code
-➔ 200
-response.cookies
-➔ {"Foo"=>"BAR", "QUUX"=>"QUUUUX"}
-response.headers
-➔ {:content_type=>"text/html; charset=utf-8", :cache_control=>"private" ...
-response.to_str
-➔ \n<!DOCTYPE html PUBLIC \"-//W3C//DTD HTML 4.01//EN\"\n   \"http://www.w3.org/TR/html4/strict.dtd\">\n\n<html ....
+>> response = RestClient.get 'http://example.com/resource'
+=> <RestClient::Response 200 "<!doctype h...">
+>> response.code
+=> 200
+>> response.cookies
+=> {"Foo"=>"BAR", "QUUX"=>"QUUUUX"}
+>> response.headers
+=> {:content_type=>"text/html; charset=utf-8", :cache_control=>"private" ... }
+>> response.body
+=> "<!doctype html>\n<html>\n<head>\n    <title>Example Domain</title>\n\n ..."
 
 RestClient.post( url,
   {
@@ -162,25 +209,76 @@ See `RestClient::Resource` docs for details.
 - for result codes between `200` and `207`, a `RestClient::Response` will be returned
 - for result codes `301`, `302` or `307`, the redirection will be followed if the request is a `GET` or a `HEAD`
 - for result code `303`, the redirection will be followed and the request transformed into a `GET`
-- for other cases, a `RestClient::Exception` holding the Response will be raised; a specific exception class will be thrown for known error codes
+- for other cases, a `RestClient::ExceptionWithResponse` holding the Response will be raised; a specific exception class will be thrown for known error codes
 - call `.response` on the exception to get the server's response
 
 ```ruby
-RestClient.get 'http://example.com/resource'
-➔ RestClient::ResourceNotFound: RestClient::ResourceNotFound
+>> RestClient.get 'http://example.com/nonexistent'
+Exception: RestClient::NotFound: 404 Not Found
 
-begin
-  RestClient.get 'http://example.com/resource'
-rescue => e
-  e.response
-end
-➔ 404 Resource Not Found | text/html 282 bytes
+>> begin
+     RestClient.get 'http://example.com/nonexistent'
+   rescue RestClient::ExceptionWithResponse => e
+     e.response
+   end
+=> <RestClient::Response 404 "<!doctype h...">
+```
+
+### Other exceptions
+
+While most exceptions have been collected under `RestClient::RequestFailed` aka
+`RestClient::ExceptionWithResponse`, there are a few quirky exceptions that
+have been kept for backwards compatibility.
+
+RestClient will propagate up exceptions like socket errors without modification:
+
+```ruby
+>> RestClient.get 'http://localhost:12345'
+Exception: Errno::ECONNREFUSED: Connection refused - connect(2) for "localhost" port 12345
 ```
 
-### Manually following redirection
+RestClient handles a few specific error cases separately in order to give
+better error messages. These will hopefully be cleaned up in a future major
+release.
+
+`RestClient::ServerBrokeConnection` is translated from `EOFError` to give a
+better error message.
+
+`RestClient::SSLCertificateNotVerified` is raised when HTTPS validation fails.
+Other `OpenSSL::SSL::SSLError` errors are raised as is.
+
+### Redirection
+
+By default, rest-client will follow HTTP 30x redirection requests.
+
+__New in 2.0:__ `RestClient::Response` exposes a `#history` method that returns
+a list of each response received in a redirection chain.
+
+```ruby
+>> r = RestClient.get('http://httpbin.org/redirect/2')
+=> <RestClient::Response 200 "{\n  \"args\":...">
+
+# see each response in the redirect chain
+>> r.history
+=> [<RestClient::Response 302 "<!DOCTYPE H...">, <RestClient::Response 302 "">]
+
+# see each requested URL
+>> r.request.url
+=> "http://httpbin.org/get"
+>> r.history.map {|x| x.request.url}
+=> ["http://httpbin.org/redirect/2", "http://httpbin.org/relative-redirect/1"]
+```
+
+#### Manually following redirection
 
 To disable automatic redirection, set `:max_redirects => 0`.
 
+__New in 2.0:__ Prior versions of rest-client would raise
+`RestClient::MaxRedirectsReached`, with no easy way to access the server's
+response. In 2.0, rest-client raises the normal
+`RestClient::ExceptionWithResponse` as it would with any other non-HTTP-20x
+response.
+
 ```ruby
 >> RestClient::Request.execute(method: :get, url: 'http://httpbin.org/redirect/1')
 => RestClient::Response 200 "{\n  "args":..."
@@ -226,7 +324,7 @@ Response objects have several useful methods. (See the class rdoc for more detai
 - `Response#cookies`: A hash of HTTP cookies set by the server
 - `Response#cookie_jar`: <em>New in 1.8</em> An HTTP::CookieJar of cookies
 - `Response#request`: The RestClient::Request object used to make the request
-- `Response#history`: If redirection was followed, a list of prior Response objects
+- `Response#history`: <em>New in 2.0</em> If redirection was followed, a list of prior Response objects
 
 ```ruby
 RestClient.get('http://example.com')
@@ -240,18 +338,20 @@ end
 ➔ <RestClient::Response 404 "<!doctype h...">
 ```
 
-### Response callbacks
+### Response callbacks, error handling
 
 A block can be passed to the RestClient method. This block will then be called with the Response.
 Response.return! can be called to invoke the default response's behavior.
 
 ```ruby
 # Don't raise exceptions but return the response
-RestClient.get('http://example.com/resource'){|response, request, result| response }
-➔ 404 Resource Not Found | text/html 282 bytes
+>> RestClient.get('http://example.com/nonexistent') {|response, request, result| response }
+=> <RestClient::Response 404 "<!doctype h...">
+```
 
+```ruby
 # Manage a specific error code
-RestClient.get('http://my-rest-service.com/resource'){ |response, request, result, &block|
+RestClient.get('http://example.com/resource') { |response, request, result, &block|
   case response.code
   when 200
     p "It worked !"
@@ -262,19 +362,68 @@ RestClient.get('http://my-rest-service.com/resource'){ |response, request, resul
     response.return!(request, result, &block)
   end
 }
+```
+
+But note that it may be more straightforward to use exceptions to handle
+different HTTP error response cases:
+
+```ruby
+begin
+  resp = RestClient.get('http://example.com/resource')
+rescue RestClient::Unauthorized, RestClient::Forbidden => err
+  puts 'Access denied'
+  return err.response
+rescue RestClient::ImATeapot => err
+  puts 'The server is a teapot! # RFC 2324'
+  return err.response
+else
+  puts 'It worked!'
+  return resp
+end
+```
 
+For GET and HEAD requests, rest-client automatically follows redirection. For
+other HTTP verbs, call `.follow_redirection` on the response object (works both
+in block form and in exception form).
+
+```ruby
 # Follow redirections for all request types and not only for get and head
 # RFC : "If the 301, 302 or 307 status code is received in response to a request other than GET or HEAD,
 #        the user agent MUST NOT automatically redirect the request unless it can be confirmed by the user,
 #        since this might change the conditions under which the request was issued."
-RestClient.get('http://my-rest-service.com/resource'){ |response, request, result, &block|
-  if [301, 302, 307].include? response.code
-    response.follow_redirection(request, result, &block)
+
+# block style
+RestClient.post('http://example.com/redirect', 'body') { |response, request, result|
+  case response.code
+  when 301, 302, 307
+    response.follow_redirection
   else
-    response.return!(request, result, &block)
+    response.return!
   end
 }
+
+# exception style by explicit classes
+begin
+  RestClient.post('http://example.com/redirect', 'body')
+rescue RestClient::MovedPermanently,
+       RestClient::Found,
+       RestClient::TemporaryRedirect => err
+  err.response.follow_redirection
+end
+
+# exception style by response code
+begin
+  RestClient.post('http://example.com/redirect', 'body')
+rescue RestClient::ExceptionWithResponse => err
+  case err.http_code
+  when 301, 302, 307
+    err.response.follow_redirection
+  else
+    raise
+  end
+end
 ```
+
 ## Non-normalized URIs
 
 If you need to normalize URIs, e.g. to work with International Resource Identifiers (IRIs),
@@ -452,6 +601,14 @@ Basic `x-www-form-urlencoded` POST params:
     "url"=>"https://httpbin.org/post"}
 ```
 
+JSON payload: rest-client does not speak JSON natively, so serialize your
+payload to a string before passing it to rest-client.
+```ruby
+>> payload = {'name' => 'newrepo', 'description': 'A new repo'}
+>> RestClient.post('https://api.github.com/user/repos', payload.to_json, content_type: :json)
+=> <RestClient::Response 201 "{\"id\":75149...">
+```
+
 Advanced GET params (arrays):
 ```ruby
 >> r = RestClient.get('https://http-params.herokuapp.com/get', params: {foo: [1,2,3]})
@@ -514,6 +671,24 @@ RestClient.post 'http://example.com/resource', {:foo => 'bar', :baz => 'qux'}, {
 RestClient.delete 'http://example.com/resource', {:Authorization => 'Bearer cT0febFoD5lxAlNAXHo6g'}
 ```
 
+## Timeouts
+
+By default the timeout for a request is 60 seconds. Timeouts for your request can
+be adjusted by setting the `timeout:` to the number of seconds that you would like
+the request to wait. Setting `timeout:` will override both `read_timeout:` and `open_timeout:`.
+
+```ruby
+RestClient::Request.execute(method: :get, url: 'http://example.com/resource',
+                            timeout: 120)
+```
+
+Additionally, you can set `read_timeout:` and `open_timeout:` separately.
+
+```ruby
+RestClient::Request.execute(method: :get, url: 'http://example.com/resource',
+                            read_timeout: 120, open_timeout: 240)
+```
+
 ## Cookies
 
 Request and Response objects know about HTTP cookies, and will automatically
@@ -587,13 +762,12 @@ Need caching, more advanced logging or any ability provided by Rack middleware?
 Have a look at rest-client-components: http://github.com/crohr/rest-client-components
 
 ## Credits
-
-|||
-|---------------------|---------------------------------------------------------|
-| REST Client Team    | Andy Brody                                              |
-| Creator             | Adam Wiggins                                            |
-| Maintainers Emeriti | Lawrence Leonard Gilbert, Matthew Manning, Julien Kirch |
-| Major contributions | Blake Mizerany, Julien Kirch                            |
+| | |
+|-------------------------|---------------------------------------------------------|
+| **REST Client Team**    | Andy Brody                                              |
+| **Creator**             | Adam Wiggins                                            |
+| **Maintainers Emeriti** | Lawrence Leonard Gilbert, Matthew Manning, Julien Kirch |
+| **Major contributions** | Blake Mizerany, Julien Kirch                            |
 
 A great many generous folks have contributed features and patches.
 See AUTHORS for the full list.

data/history.md

@@ -1,3 +1,17 @@
+# 2.0.2
+
+- Suppress the header override warning introduced in 2.0.1 if the value is the
+  same. There's no conflict if the value is unchanged. (#578)
+
+# 2.0.1
+
+- Warn if auto-generated headers from the payload, such as Content-Type,
+  override headers set by the user. This is usually not what the user wants to
+  happen, and can be surprising. (#554)
+- Drop the old check for weak default TLS ciphers, and use the built-in Ruby
+  defaults. Ruby versions from Oct. 2014 onward use sane defaults, so this is
+  no longer needed. (#573)
+
 # 2.0.0
 
 This release is largely API compatible, but makes several breaking changes.

data/lib/restclient/request.rb

@@ -52,63 +52,6 @@ module RestClient
       new(args).execute(& block)
     end
 
-    # This is similar to the list now in ruby core, but adds HIGH for better
-    # compatibility (similar to Firefox) and moves AES-GCM cipher suites above
-    # DHE/ECDHE CBC suites (similar to Chromium).
-    # https://github.com/ruby/ruby/commit/699b209cf8cf11809620e12985ad33ae33b119ee
-    #
-    # This list will be used by default if the Ruby global OpenSSL default
-    # ciphers appear to be a weak list.
-    DefaultCiphers = %w{
-      !aNULL
-      !eNULL
-      !EXPORT
-      !SSLV2
-      !LOW
-
-      ECDHE-ECDSA-AES128-GCM-SHA256
-      ECDHE-RSA-AES128-GCM-SHA256
-      ECDHE-ECDSA-AES256-GCM-SHA384
-      ECDHE-RSA-AES256-GCM-SHA384
-      DHE-RSA-AES128-GCM-SHA256
-      DHE-DSS-AES128-GCM-SHA256
-      DHE-RSA-AES256-GCM-SHA384
-      DHE-DSS-AES256-GCM-SHA384
-      AES128-GCM-SHA256
-      AES256-GCM-SHA384
-      ECDHE-ECDSA-AES128-SHA256
-      ECDHE-RSA-AES128-SHA256
-      ECDHE-ECDSA-AES128-SHA
-      ECDHE-RSA-AES128-SHA
-      ECDHE-ECDSA-AES256-SHA384
-      ECDHE-RSA-AES256-SHA384
-      ECDHE-ECDSA-AES256-SHA
-      ECDHE-RSA-AES256-SHA
-      DHE-RSA-AES128-SHA256
-      DHE-RSA-AES256-SHA256
-      DHE-RSA-AES128-SHA
-      DHE-RSA-AES256-SHA
-      DHE-DSS-AES128-SHA256
-      DHE-DSS-AES256-SHA256
-      DHE-DSS-AES128-SHA
-      DHE-DSS-AES256-SHA
-      AES128-SHA256
-      AES256-SHA256
-      AES128-SHA
-      AES256-SHA
-      ECDHE-ECDSA-RC4-SHA
-      ECDHE-RSA-RC4-SHA
-      RC4-SHA
-
-      HIGH
-      +RC4
-    }.join(":")
-
-    # A set of weak default ciphers that we will override by default.
-    WeakDefaultCiphers = Set.new([
-      "ALL:!ADH:!EXPORT:!SSLv2:RC4+RSA:+HIGH:+MEDIUM:+LOW",
-    ])
-
     SSLOptionList = %w{client_cert client_key ca_file ca_path cert_store
                        version ciphers verify_callback verify_callback_warnings}
 
@@ -186,15 +129,6 @@ module RestClient
         if !ssl_ca_file && !ssl_ca_path && !@ssl_opts.include?(:cert_store)
           @ssl_opts[:cert_store] = self.class.default_ssl_cert_store
         end
-
-        unless @ssl_opts.include?(:ciphers)
-          # If we're on a Ruby version that has insecure default ciphers,
-          # override it with our default list.
-          if WeakDefaultCiphers.include?(
-               OpenSSL::SSL::SSLContext::DEFAULT_PARAMS.fetch(:ciphers))
-            @ssl_opts[:ciphers] = DefaultCiphers
-          end
-        end
       end
 
       @tf = nil # If you are a raw request, this is your tempfile
@@ -428,7 +362,26 @@ module RestClient
     #
     def make_headers(user_headers)
       headers = stringify_headers(default_headers).merge(stringify_headers(user_headers))
-      headers.merge!(@payload.headers) if @payload
+
+      # override headers from the payload (e.g. Content-Type, Content-Length)
+      if @payload
+        payload_headers = @payload.headers
+
+        # Warn the user if we override any headers that were previously
+        # present. This usually indicates that rest-client was passed
+        # conflicting information, e.g. if it was asked to render a payload as
+        # x-www-form-urlencoded but a Content-Type application/json was
+        # also supplied by the user.
+        payload_headers.each_pair do |key, val|
+          if headers.include?(key) && headers[key] != val
+            warn("warning: Overriding #{key.inspect} header " +
+                 "#{headers.fetch(key).inspect} with #{val.inspect} " +
+                 "due to payload")
+          end
+        end
+
+        headers.merge!(payload_headers)
+      end
 
       # merge in cookies
       cookies = make_cookie_header

data/lib/restclient/utils.rb

@@ -8,8 +8,8 @@ module RestClient
     # 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.
+    # Strings will use the default encoding when this method returns nil. This
+    # default is likely to be UTF-8 for Ruby >= 2.0
     #
     # @param headers [Hash<Symbol,String>]
     #

data/lib/restclient/version.rb

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

data/rest-client.gemspec

@@ -20,7 +20,7 @@ Gem::Specification.new do |s|
   s.add_development_dependency('rspec', '~> 3.0')
   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('rdoc', '>= 2.4.2', '< 6.0')
   s.add_development_dependency('rubocop', '~> 0')
 
   s.add_dependency('http-cookie', '>= 1.0.2', '< 2.0')

data/spec/integration/httpbin_spec.rb

@@ -13,7 +13,8 @@ describe RestClient::Request do
   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'
+    # Also (2017-04-09) Travis Jruby versions have a broken CA keystore
+    if ENV['TRAVIS_RUBY_VERSION'] =~ /\Ajruby-/
       'http://httpbin.org/'
     else
       'https://httpbin.org/'

data/spec/integration/integration_spec.rb

@@ -88,14 +88,15 @@ describe RestClient do
       expect(response.encode('utf-8')).to eq body_utf8
     end
 
-    it 'defaults to Encoding.default_external' do
+    it 'defaults to the default encoding' do
       stub_request(:get, 'www.example.com').to_return(
         body: 'abc', status: 200, headers: {
           'Content-Type' => 'text/plain'
         })
 
       response = RestClient.get 'www.example.com'
-      expect(response.encoding).to eq Encoding.default_external
+      # expect(response.encoding).to eq Encoding.default_external
+      expect(response.encoding).to eq Encoding::UTF_8
     end
 
     it 'handles invalid encoding' do
@@ -105,7 +106,8 @@ describe RestClient do
         })
 
       response = RestClient.get 'www.example.com'
-      expect(response.encoding).to eq Encoding.default_external
+      # expect(response.encoding).to eq Encoding.default_external
+      expect(response.encoding).to eq Encoding::UTF_8
     end
 
     it 'leaves images as binary' do

data/spec/unit/request_spec.rb

@@ -260,6 +260,41 @@ describe RestClient::Request, :include_helpers do
     end
   end
 
+  it 'warns when overriding existing headers via payload' do
+    expect(fake_stderr {
+      RestClient::Request.new(method: :post, url: 'example.com',
+                              payload: {'foo' => 1}, headers: {content_type: :json})
+    }).to match(/warning: Overriding "Content-Type" header/i)
+    expect(fake_stderr {
+      RestClient::Request.new(method: :post, url: 'example.com',
+                              payload: {'foo' => 1}, headers: {'Content-Type' => 'application/json'})
+    }).to match(/warning: Overriding "Content-Type" header/i)
+
+    expect(fake_stderr {
+      RestClient::Request.new(method: :post, url: 'example.com',
+                              payload: '123456', headers: {content_length: '20'})
+    }).to match(/warning: Overriding "Content-Length" header/i)
+    expect(fake_stderr {
+      RestClient::Request.new(method: :post, url: 'example.com',
+                              payload: '123456', headers: {'Content-Length' => '20'})
+    }).to match(/warning: Overriding "Content-Length" header/i)
+  end
+
+  it "does not warn when overriding user header with header derived from payload if those header values were identical" do
+    expect(fake_stderr {
+      RestClient::Request.new(method: :post, url: 'example.com',
+                              payload: {'foo' => '123456'}, headers: { 'Content-Type' => 'application/x-www-form-urlencoded' })
+    }).not_to match(/warning: Overriding "Content-Type" header/i)
+  end
+
+  it 'does not warn for a normal looking payload' do
+    expect(fake_stderr {
+      RestClient::Request.new(method: :post, url: 'example.com', payload: 'payload')
+      RestClient::Request.new(method: :post, url: 'example.com', payload: 'payload', headers: {content_type: :json})
+      RestClient::Request.new(method: :post, url: 'example.com', payload: {'foo' => 'bar'})
+    }).to eq ''
+  end
+
   it "uses netrc credentials" do
     expect(Netrc).to receive(:read).and_return('example.com' => ['a', 'b'])
     request = RestClient::Request.new(:method => :put, :url => 'http://example.com/', :payload => 'payload')
@@ -567,7 +602,8 @@ describe RestClient::Request, :include_helpers do
       allow(ENV).to receive(:[]).with("http_proxy").and_return("http://127.0.0.1")
       allow(ENV).to receive(:[]).with("no_proxy").and_return(nil)
       allow(ENV).to receive(:[]).with("NO_PROXY").and_return(nil)
-      allow(ENV).to receive(:[]).with("NETRC").and_return(nil)
+      allow(Netrc).to receive(:read).and_return({})
+
       req = RestClient::Request.new(:method => :put, :url => 'http://some/resource', :payload => 'payload')
       obj = req.net_http_object('host', 80)
       expect(obj.proxy?).to be true
@@ -897,56 +933,6 @@ describe RestClient::Request, :include_helpers do
       @request.send(:transmit, @uri, 'req', 'payload')
     end
 
-    it "should override ssl_ciphers with better defaults with weak default ciphers" do
-      stub_const(
-        '::OpenSSL::SSL::SSLContext::DEFAULT_PARAMS',
-        {
-          :ssl_version=>"SSLv23",
-          :verify_mode=>1,
-          :ciphers=>"ALL:!ADH:!EXPORT:!SSLv2:RC4+RSA:+HIGH:+MEDIUM:+LOW",
-          :options=>-2147480577,
-        }
-      )
-
-      @request = RestClient::Request.new(
-        :method => :put,
-        :url => 'https://some/resource',
-        :payload => 'payload',
-      )
-
-      expect(@net).to receive(:ciphers=).with(RestClient::Request::DefaultCiphers)
-
-      allow(@http).to receive(:request)
-      allow(@request).to receive(:process_result)
-      allow(@request).to receive(:response_log)
-      @request.send(:transmit, @uri, 'req', 'payload')
-    end
-
-    it "should not override ssl_ciphers with better defaults with different default ciphers" do
-      stub_const(
-        '::OpenSSL::SSL::SSLContext::DEFAULT_PARAMS',
-        {
-          :ssl_version=>"SSLv23",
-          :verify_mode=>1,
-          :ciphers=>"HIGH:!aNULL:!eNULL:!EXPORT:!LOW:!MEDIUM:!SSLv2",
-          :options=>-2147480577,
-        }
-      )
-
-      @request = RestClient::Request.new(
-        :method => :put,
-        :url => 'https://some/resource',
-        :payload => 'payload',
-      )
-
-      expect(@net).not_to receive(:ciphers=)
-
-      allow(@http).to receive(:request)
-      allow(@request).to receive(:process_result)
-      allow(@request).to receive(:response_log)
-      @request.send(:transmit, @uri, 'req', 'payload')
-    end
-
     it "should set the ssl_client_cert if provided" do
       @request = RestClient::Request.new(
               :method => :put,

data/spec/unit/resource_spec.rb

@@ -94,7 +94,11 @@ describe RestClient::Resource do
     expect(parent.send(:[], 'posts', &block2).block).not_to eq block1
   end
 
-  it "the block should be overrideable in ruby 1.9 syntax" do
+  # Test fails on jruby 9.1.[0-5].* due to
+  # https://github.com/jruby/jruby/issues/4217
+  it "the block should be overrideable in ruby 1.9 syntax",
+      :unless => (RUBY_ENGINE == 'jruby' && JRUBY_VERSION =~ /\A9\.1\.[0-5]\./) \
+  do
     block1 = proc {|r| r}
     block2 = ->(r) {}
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rest-client
 version: !ruby/object:Gem::Version
-  version: 2.0.0.rc4
+  version: 2.0.2
 platform: ruby
 authors:
 - REST Client Team
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-06-19 00:00:00.000000000 Z
+date: 2017-04-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: webmock
@@ -75,7 +75,7 @@ dependencies:
         version: 2.4.2
     - - "<"
       - !ruby/object:Gem::Version
-        version: '5.0'
+        version: '6.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -85,7 +85,7 @@ dependencies:
         version: 2.4.2
     - - "<"
       - !ruby/object:Gem::Version
-        version: '5.0'
+        version: '6.0'
 - !ruby/object:Gem::Dependency
   name: rubocop
   requirement: !ruby/object:Gem::Requirement
@@ -239,12 +239,12 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: 2.0.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5.1
+rubygems_version: 2.6.11
 signing_key: 
 specification_version: 4
 summary: Simple HTTP and REST client for Ruby, inspired by microframework syntax for
@@ -280,4 +280,3 @@ test_files:
 - spec/unit/restclient_spec.rb
 - spec/unit/utils_spec.rb
 - spec/unit/windows/root_certs_spec.rb
-has_rdoc: