rest-client 2.0.0-x86-mingw32 → 2.0.1-x86-mingw32

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1befabed08c74293482e493dc0c2b6af2fb0aa95
-  data.tar.gz: 6cbd00246b48690123c0fe37ddc2aa2d279fce29
+  metadata.gz: 90f816c5864fc8e81f3bc5f06a0e2da8144e241b
+  data.tar.gz: fe72a7b7c83d3edb8952bf1ca4f3b3afc483018c
 SHA512:
-  metadata.gz: 904b6aac75c9083f9757aa8a687971472499c93b27ba9532ddaae435a0aa65e21f4b4af93a5461046618703d7c4a197694d7d9d3b83e5ae62b83ca05ba3cc65d
-  data.tar.gz: 80f8d55c65385636b7381861a9f8dd9df2c35afe0940656e2f391715cd1526bb9d6dc75db51bed0b83ae55d954d7b8e9604c3ce8075a776b92d7e2601d048413
+  metadata.gz: 5cf7e934cf28feca0693463ff753c5dbc34e0d19e6ef7a1200823dce2f4905b3fee8e8a580fc81026ef26acc65108c5a3d1ff4babe369a1ec2e6e106beeb4c76
+  data.tar.gz: dca326f15f34e580a4c0f40e768e06e8cec878b9936b5dc4eb758940f9e0bbd39bf323532b354d701f472da5aeb00dc40edff690145d612392576c30c0167c59

data/.travis.yml

@@ -1,43 +1,53 @@
 # 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"
+
 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
+
+
+# Use Java 8 for jruby to fix some Java 7 bugs.
+addons:
+  apt:
+    packages:
+      - oracle-java8-set-default

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)
@@ -75,30 +75,48 @@ Overview of significant changes:
 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,
   {
@@ -191,21 +209,44 @@ 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
+```
+
+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.
@@ -297,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 !"
@@ -319,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),
@@ -509,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]})
@@ -571,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

data/history.md

@@ -1,3 +1,12 @@
+# 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,67 +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.
-    #
-    # TODO: either remove this code or always use it, since Ruby uses a decent
-    # cipher list in versions >= 2.0.
-    #
-    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}
 
@@ -190,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
@@ -432,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)
+            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/version.rb

@@ -1,5 +1,5 @@
 module RestClient
-  VERSION_INFO = [2, 0, 0] unless defined?(self::VERSION_INFO)
+  VERSION_INFO = [2, 0, 1] 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,7 @@ 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'
+    if ['jruby-19mode', 'jruby-9.0.5.0'].include?(ENV['TRAVIS_RUBY_VERSION'])
       'http://httpbin.org/'
     else
       'https://httpbin.org/'

data/spec/unit/request_spec.rb

@@ -260,6 +260,34 @@ 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 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')
@@ -898,56 +926,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
+  version: 2.0.1
 platform: x86-mingw32
 authors:
 - REST Client Team
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-07-02 00:00:00.000000000 Z
+date: 2017-02-19 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
@@ -258,7 +258,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5.1
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: Simple HTTP and REST client for Ruby, inspired by microframework syntax for
@@ -294,4 +294,3 @@ test_files:
 - spec/unit/restclient_spec.rb
 - spec/unit/utils_spec.rb
 - spec/unit/windows/root_certs_spec.rb
-has_rdoc: