rest-client 2.0.0.rc2-x64-mingw32 → 2.0.0.rc3-x64-mingw32

data/lib/restclient/response.rb

@@ -38,17 +38,15 @@ module RestClient
       "<RestClient::Response #{code.inspect} #{body_truncated(10).inspect}>"
     end
 
-    def self.create(body, net_http_res, args, request)
+    def self.create(body, net_http_res, request)
       result = self.new(body || '')
 
-      result.response_set_vars(net_http_res, args, request)
+      result.response_set_vars(net_http_res, request)
       fix_encoding(result)
 
       result
     end
 
-    private
-
     def self.fix_encoding(response)
       charset = RestClient::Utils.get_encoding_from_headers(response.headers)
       encoding = nil
@@ -56,7 +54,9 @@ module RestClient
       begin
         encoding = Encoding.find(charset) if charset
       rescue ArgumentError
-        RestClient.log << "No such encoding: #{charset.inspect}"
+        if RestClient.log
+          RestClient.log << "No such encoding: #{charset.inspect}"
+        end
       end
 
       return unless encoding
@@ -66,11 +66,14 @@ module RestClient
       response
     end
 
+    private
+
     def body_truncated(length)
-      if body.length > length
-        body[0..length] + '...'
+      b = body
+      if b.length > length
+        b[0..length] + '...'
       else
-        body
+        b
       end
     end
   end

data/lib/restclient/utils.rb

@@ -11,11 +11,15 @@ module RestClient
     # Strings will effectively end up using `Encoding.default_external` when
     # this method returns nil.
     #
-    # @param headers [Hash]
+    # @param headers [Hash<Symbol,String>]
     #
     # @return [String, nil] encoding Return the string encoding or nil if no
     #   header is found.
     #
+    # @example
+    #   >> get_encoding_from_headers({:content_type => 'text/plain; charset=UTF-8'})
+    #   => "UTF-8"
+    #
     def self.get_encoding_from_headers(headers)
       type_header = headers[:content_type]
       return nil unless type_header
@@ -54,7 +58,7 @@ module RestClient
       nil
     end
 
-    # Parse a Content-type like header.
+    # Parse a Content-Type like header.
     #
     # Return the main content-type and a hash of options.
     #
@@ -89,5 +93,143 @@ module RestClient
 
       [key, pdict]
     end
+
+    # Serialize a ruby object into HTTP query string parameters.
+    #
+    # There is no standard for doing this, so we choose our own slightly
+    # idiosyncratic format. The output closely matches the format understood by
+    # Rails, Rack, and PHP.
+    #
+    # If you don't want handling of complex objects and only want to handle
+    # simple flat hashes, you may want to use `URI.encode_www_form` instead,
+    # which implements HTML5-compliant URL encoded form data.
+    #
+    # @param [Hash,ParamsArray] object The object to serialize
+    #
+    # @return [String] A string appropriate for use as an HTTP query string
+    #
+    # @see {flatten_params}
+    #
+    # @see URI.encode_www_form
+    #
+    # @see See also Object#to_query in ActiveSupport
+    # @see http://php.net/manual/en/function.http-build-query.php
+    #   http_build_query in PHP
+    # @see See also Rack::Utils.build_nested_query in Rack
+    #
+    # Notable differences from the ActiveSupport implementation:
+    #
+    # - Empty hash and empty array are treated the same as nil instead of being
+    #   omitted entirely from the output. Rather than disappearing, they will
+    #   appear to be nil instead.
+    #
+    # It's most common to pass a Hash as the object to serialize, but you can
+    # also use a ParamsArray if you want to be able to pass the same key with
+    # multiple values and not use the rack/rails array convention.
+    #
+    # @since 2.0.0
+    #
+    # @example Simple hashes
+    #   >> encode_query_string({foo: 123, bar: 456})
+    #   => 'foo=123&bar=456'
+    #
+    # @example Simple arrays
+    #   >> encode_query_string({foo: [1,2,3]})
+    #   => 'foo[]=1&foo[]=2&foo[]=3'
+    #
+    # @example Nested hashes
+    #   >> encode_query_string({outer: {foo: 123, bar: 456}})
+    #   => 'outer[foo]=123&outer[bar]=456'
+    #
+    # @example Deeply nesting
+    #   >> encode_query_string({coords: [{x: 1, y: 0}, {x: 2}, {x: 3}]})
+    #   => 'coords[][x]=1&coords[][y]=0&coords[][x]=2&coords[][x]=3'
+    #
+    # @example Null and empty values
+    #   >> encode_query_string({string: '', empty: nil, list: [], hash: {}})
+    #   => 'string=&empty&list&hash'
+    #
+    # @example Nested nulls
+    #   >> encode_query_string({foo: {string: '', empty: nil}})
+    #   => 'foo[string]=&foo[empty]'
+    #
+    # @example Multiple fields with the same name using ParamsArray
+    #   >> encode_query_string(RestClient::ParamsArray.new([[:foo, 1], [:foo, 2], [:foo, 3]]))
+    #   => 'foo=1&foo=2&foo=3'
+    #
+    # @example Nested ParamsArray
+    #   >> encode_query_string({foo: RestClient::ParamsArray.new([[:a, 1], [:a, 2]])})
+    #   => 'foo[a]=1&foo[a]=2'
+    #
+    #   >> encode_query_string(RestClient::ParamsArray.new([[:foo, {a: 1}], [:foo, {a: 2}]]))
+    #   => 'foo[a]=1&foo[a]=2'
+    #
+    def self.encode_query_string(object)
+      flatten_params(object, true).map {|k, v| v.nil? ? k : "#{k}=#{v}" }.join('&')
+    end
+
+    # Transform deeply nested param containers into a flat array of [key,
+    # value] pairs.
+    #
+    # @example
+    #   >> flatten_params({key1: {key2: 123}})
+    #   => [["key1[key2]", 123]]
+    #
+    # @example
+    #   >> flatten_params({key1: {key2: 123, arr: [1,2,3]}})
+    #   => [["key1[key2]", 123], ["key1[arr][]", 1], ["key1[arr][]", 2], ["key1[arr][]", 3]]
+    #
+    # @param object [Hash, ParamsArray] The container to flatten
+    # @param uri_escape [Boolean] Whether to URI escape keys and values
+    # @param parent_key [String] Should not be passed (used for recursion)
+    #
+    def self.flatten_params(object, uri_escape=false, parent_key=nil)
+      unless object.is_a?(Hash) || object.is_a?(ParamsArray) ||
+             (parent_key && object.is_a?(Array))
+        raise ArgumentError.new('expected Hash or ParamsArray, got: ' + object.inspect)
+      end
+
+      # transform empty collections into nil, where possible
+      if object.empty? && parent_key
+        return [[parent_key, nil]]
+      end
+
+      # This is essentially .map(), but we need to do += for nested containers
+      object.reduce([]) { |result, item|
+        if object.is_a?(Array)
+          # item is already the value
+          k = nil
+          v = item
+        else
+          # item is a key, value pair
+          k, v = item
+          k = escape(k.to_s) if uri_escape
+        end
+
+        processed_key = parent_key ? "#{parent_key}[#{k}]" : k
+
+        case v
+        when Array, Hash, ParamsArray
+          result.concat flatten_params(v, uri_escape, processed_key)
+        else
+          v = escape(v.to_s) if uri_escape && v
+          result << [processed_key, v]
+        end
+      }
+    end
+
+    # Encode string for safe transport by URI or form encoding. This uses a CGI
+    # style escape, which transforms ` ` into `+` and various special
+    # characters into percent encoded forms.
+    #
+    # This calls URI.encode_www_form_component for the implementation. The only
+    # difference between this and CGI.escape is that it does not escape `*`.
+    # http://stackoverflow.com/questions/25085992/
+    #
+    # @see URI.encode_www_form_component
+    #
+    def self.escape(string)
+      URI.encode_www_form_component(string)
+    end
   end
 end

data/lib/restclient/version.rb

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

data/rest-client.gemspec

@@ -10,22 +10,22 @@ Gem::Specification.new do |s|
   s.license = 'MIT'
   s.email = 'rest.client@librelist.com'
   s.executables = ['restclient']
-  s.extra_rdoc_files = ['README.rdoc', 'history.md']
+  s.extra_rdoc_files = ['README.md', 'history.md']
   s.files = `git ls-files -z`.split("\0")
   s.test_files = `git ls-files -z spec/`.split("\0")
   s.homepage = 'https://github.com/rest-client/rest-client'
   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.99')
+  s.add_development_dependency('webmock', '~> 2.0')
+  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('rubocop', '~> 0')
 
   s.add_dependency('http-cookie', '>= 1.0.2', '< 2.0')
-  s.add_dependency('mime-types', '>= 1.16', '< 3.0')
+  s.add_dependency('mime-types', '>= 1.16', '< 4.0')
   s.add_dependency('netrc', '~> 0.8')
 
-  s.required_ruby_version = '>= 1.9.3'
+  s.required_ruby_version = '>= 2.0.0'
 end

data/spec/helpers.rb

@@ -1,3 +1,5 @@
+require 'uri'
+
 module Helpers
   def response_double(opts={})
     double('response', {:to_hash => {}}.merge(opts))
@@ -11,4 +13,10 @@ module Helpers
   ensure
     $stderr = original_stderr
   end
+
+  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})
+  end
 end

data/spec/integration/httpbin_spec.rb

@@ -41,22 +41,22 @@ describe RestClient::Request do
   describe '.execute' do
     it 'sends a user agent' do
       data = execute_httpbin_json('user-agent', method: :get)
-      data['user-agent'].should match(/rest-client/)
+      expect(data['user-agent']).to 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'
+        expect(ex.http_code).to eq 302
+        expect(ex.response.cookies['foo']).to 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'
+      expect(data).to have_key('cookies')
+      expect(data['cookies']['foo']).to eq 'bar'
     end
 
     it 'handles quote wrapped cookies' do
@@ -64,8 +64,8 @@ describe RestClient::Request do
         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"'
+        expect(ex.http_code).to eq 302
+        expect(ex.response.cookies['foo']).to eq '"bar:baz"'
       }
     end
   end

data/spec/integration/integration_spec.rb

@@ -8,15 +8,15 @@ describe RestClient do
     body = 'abc'
     stub_request(:get, "www.example.com").to_return(:body => body, :status => 200)
     response = RestClient.get "www.example.com"
-    response.code.should eq 200
-    response.body.should eq body
+    expect(response.code).to eq 200
+    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"
-    response.code.should eq 200
-    response.body.should eq "i'm gziped\n"
+    expect(response.code).to eq 200
+    expect(response.body).to eq "i'm gziped\n"
   end
 
   it "a 404" do
@@ -26,10 +26,10 @@ describe RestClient do
       RestClient.get "www.example.com"
       raise
     rescue RestClient::ResourceNotFound => e
-      e.http_code.should eq 404
-      e.response.code.should eq 404
-      e.response.body.should eq body
-      e.http_body.should eq body
+      expect(e.http_code).to eq 404
+      expect(e.response.code).to eq 404
+      expect(e.response.body).to eq body
+      expect(e.http_body).to eq body
     end
   end
 
@@ -41,8 +41,8 @@ describe RestClient do
           '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
+      expect(response.encoding).to eq Encoding::UTF_8
+      expect(response.valid_encoding?).to eq true
     end
 
     it 'handles windows-1252' do
@@ -52,9 +52,9 @@ describe RestClient do
           '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
+      expect(response.encoding).to eq Encoding::WINDOWS_1252
+      expect(response.encode('utf-8')).to eq "ÿ"
+      expect(response.valid_encoding?).to eq true
     end
 
     it 'handles binary' do
@@ -64,28 +64,28 @@ describe RestClient do
           'Content-Type' => 'application/octet-stream; charset=binary'
       })
       response = RestClient.get "www.example.com"
-      response.encoding.should eq Encoding::BINARY
-      lambda {
+      expect(response.encoding).to eq Encoding::BINARY
+      expect {
         response.encode('utf-8')
-      }.should raise_error(Encoding::UndefinedConversionError)
-      response.valid_encoding?.should eq true
+      }.to raise_error(Encoding::UndefinedConversionError)
+      expect(response.valid_encoding?).to 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
+      expect(body_utf8.encoding).to 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
+      expect(response.encoding).to eq Encoding::EUC_JP
+      expect(response.valid_encoding?).to eq true
+      expect(response.length).to eq 5
+      expect(response.encode('utf-8')).to eq body_utf8
     end
 
     it 'defaults to Encoding.default_external' do
@@ -95,7 +95,17 @@ describe RestClient do
         })
 
       response = RestClient.get 'www.example.com'
-      response.encoding.should eq Encoding.default_external
+      expect(response.encoding).to eq Encoding.default_external
+    end
+
+    it 'handles invalid encoding' do
+      stub_request(:get, 'www.example.com').to_return(
+        body: 'abc', status: 200, headers: {
+          'Content-Type' => 'text; charset=plain'
+        })
+
+      response = RestClient.get 'www.example.com'
+      expect(response.encoding).to eq Encoding.default_external
     end
 
     it 'leaves images as binary' do
@@ -107,7 +117,7 @@ describe RestClient do
         })
 
       response = RestClient.get 'www.example.com'
-      response.encoding.should eq Encoding::BINARY
+      expect(response.encoding).to eq Encoding::BINARY
     end
   end
 end

data/spec/integration/request_spec.rb

@@ -75,7 +75,7 @@ describe RestClient::Request do
         },
       )
       expect {request.execute }.to_not raise_error
-      ran_callback.should eq(true)
+      expect(ran_callback).to eq(true)
     end
 
     it "fails verification when the callback returns false",

data/spec/spec_helper.rb

@@ -5,7 +5,7 @@ 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
+  config.raise_errors_for_deprecations!
 
   # 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
@@ -13,6 +13,10 @@ RSpec.configure do |config|
   #     --seed 1234
   config.order = 'random'
 
+  # always run with ruby warnings enabled
+  # TODO: figure out why this is so obscenely noisy (rspec bug?)
+  # config.warnings = true
+
   # add helpers
   config.include Helpers, :include_helpers
 
@@ -20,3 +24,6 @@ RSpec.configure do |config|
     mocks.yield_receiver_to_any_instance_implementation_blocks = true
   end
 end
+
+# always run with ruby warnings enabled (see above)
+$VERBOSE = true