webmock 1.18.0 → 1.19.0

data/.gitignore

@@ -13,6 +13,9 @@ tmtags
 ## VIM
 .*.sw[a-z]
 
+## RubyMine and related
+.idea
+
 ## PROJECT::GENERAL
 coverage
 rdoc
@@ -27,4 +30,4 @@ tmp/*
 *.rbc
 *.rbx
 .ruby-gemset
-.ruby-version
+.ruby-version

data/CHANGELOG.md

@@ -1,5 +1,51 @@
 # Changelog
 
+## 1.19.0
+
+  * Fixed issue with Excon adapter giving warning message when redirects middleware was enabled.
+
+      Thanks to [Theo Hultberg](https://github.com/iconara) for reporting that.
+
+  * Fixed issue with `undefined method 'valid_request_keys' for Excon::Utils:Module`
+
+      Thanks to [Pablo Jairala](https://github.com/davidjairala)
+
+  * Fixed query mapper to encode `'one' => ['1','2']` as `'one[]=1&one[]=2'`.
+
+      Thanks to [Insoo Buzz Jung](https://github.com/insoul)
+
+  * Improved cookies support for em-http-request
+
+      Thanks to [Carlos Alonso Pérez](https://github.com/calonso)
+
+  * Fix HTTP Gem adapter to ensure uri attribute is set on response object.
+
+      Thanks to [Aleksey V. Zapparov](https://github.com/ixti)
+
+  * Fixed HTTPClient adapter. The response header now receives `request_method`, `request_uri`, and `request_query` transferred from request header
+
+      Thanks to [trlorenz](https://github.com/trlorenz)
+
+  * Query mapper supports nested data structures i.e. `{"first" => [{"two" => [{"three" => "four"}, "five"]}]}`
+
+      Thanks to [Alexander Simonov](https://github.com/simonoff)
+
+  * Fixed compatibility with latest versions of Excon which don't define `VALID_REQUEST_KEYS` anymore.
+
+      Thanks to [Pablo Jairala](https://github.com/davidjairala)
+
+  * Request method is always a symbol is request signatures. This fixes the issue of WebMock not matching Typhoeus requests with request method defined as string.
+
+      Thanks to [Thorbjørn Hermanse](https://github.com/thhermansen)
+
+  * Stubbing instructions which are displayed when no matching stub is found, can be disabled with `Config.instance.show_stubbing_instructions = false`
+
+      Thanks to [Mark Lorenz](https://github.com/dapplebeforedawn)
+
+  * Notation used for mapping query strings to data structure can be configured i.e. `WebMock::Config.instance.query_values_notation = :subscript`. This allows setting `:flat_array` notation which supports duplicated parameter names in query string.
+
+      Thanks to [tjsousa](https://github.com/tjsousa)
+
 ## 1.18.0
 
 * Updated dependency on Addressable to versions >= 2.3.6

data/README.md

@@ -320,7 +320,7 @@ RestClient.post('www.example.net', 'abc')    # ===> "abc\n"
     `curl -is www.example.com > /tmp/www.example.com.txt`
 ```ruby
 stub_request(:get, "www.example.com").
-  to_return(lambda { |request| File.new("/tmp/#{request.uri.host.to_s}.txt" }))
+  to_return(lambda { |request| File.new("/tmp/#{request.uri.host.to_s}.txt") })
 ```
 
 ### Responses with dynamically evaluated parts
@@ -910,6 +910,16 @@ People who submitted patches and new features or suggested improvements. Many th
 * Oleg Gritsenko
 * Hwan-Joon Choi
 * SHIBATA Hiroshi
+* Caleb Thompson
+* Theo Hultberg
+* Pablo Jairala
+* Insoo Buzz Jung
+* Carlos Alonso Pérez
+* trlorenz
+* Alexander Simonov
+* Thorbjørn Hermanse
+* Mark Lorenz
+* tjsousa
 
 For a full list of contributors you can visit the
 [contributors](https://github.com/bblimke/webmock/contributors) page.

data/lib/webmock/config.rb

@@ -2,9 +2,15 @@ module WebMock
   class Config
     include Singleton
 
+    def initialize
+      @show_stubbing_instructions = true
+    end
+
     attr_accessor :allow_net_connect
     attr_accessor :allow_localhost
     attr_accessor :allow
     attr_accessor :net_http_connect_on_start
+    attr_accessor :show_stubbing_instructions
+    attr_accessor :query_values_notation
   end
 end

data/lib/webmock/errors.rb

@@ -2,19 +2,20 @@ module WebMock
 
   class NetConnectNotAllowedError < Exception
     def initialize(request_signature)
-      text = "Real HTTP connections are disabled. Unregistered request: #{request_signature}"
-      text << "\n\n"
-      text << stubbing_instructions(request_signature)
-      text << request_stubs
-      text << "\n\n" + "="*60
+      text = [
+        "Real HTTP connections are disabled. Unregistered request: #{request_signature}",
+        stubbing_instructions(request_signature),
+        request_stubs,
+        "="*60
+      ].compact.join("\n\n")
       super(text)
     end
 
     private
 
     def request_stubs
-      return "" if WebMock::StubRegistry.instance.request_stubs.empty?
-      text = "\n\nregistered request stubs:\n"
+      return if WebMock::StubRegistry.instance.request_stubs.empty?
+      text = "registered request stubs:\n"
       WebMock::StubRegistry.instance.request_stubs.each do |stub|
         text << "\n#{WebMock::StubRequestSnippet.new(stub).to_s(false)}"
       end
@@ -22,6 +23,7 @@ module WebMock
     end
 
     def stubbing_instructions(request_signature)
+      return unless WebMock.show_stubbing_instructions?
       text = ""
       request_stub = RequestStub.from_request_signature(request_signature)
       text << "You can stub this request with the following snippet:\n\n"

data/lib/webmock/http_lib_adapters/em_http_request/em_http_request_1_x.rb

@@ -133,6 +133,16 @@ if defined?(EventMachine::HttpClient)
         @stubbed_webmock_response
       end
 
+      def get_response_cookie(name)
+        name = name.to_s
+
+        raw_cookie = response_header.cookie
+        raw_cookie = [raw_cookie] if raw_cookie.is_a? String
+
+        cookie = raw_cookie.select { |c| c.start_with? name }.first
+        cookie and cookie.split('=', 2)[1]
+      end
+
       private
 
       def build_webmock_response
@@ -189,15 +199,21 @@ if defined?(EventMachine::HttpClient)
 
         headers["Content-Length"] = body.bytesize unless headers["Content-Length"]
         headers.each do |header, value|
-          value = value.join(", ") if value.is_a?(Array)
+          if header =~ /set-cookie/i
+            [value].flatten.each do |cookie|
+              response_string << "#{header}: #{cookie}"
+            end
+          else
+            value = value.join(", ") if value.is_a?(Array)
 
-          # WebMock's internal processing will not handle the body
-          # correctly if the header indicates that it is chunked, unless
-          # we also create all the chunks.
-          # It's far easier just to remove the header.
-          next if header =~ /transfer-encoding/i && value =~/chunked/i
+            # WebMock's internal processing will not handle the body
+            # correctly if the header indicates that it is chunked, unless
+            # we also create all the chunks.
+            # It's far easier just to remove the header.
+            next if header =~ /transfer-encoding/i && value =~/chunked/i
 
-          response_string << "#{header}: #{value}"
+            response_string << "#{header}: #{value}"
+          end
         end if headers
 
         response_string << "" << body

data/lib/webmock/http_lib_adapters/excon_adapter.rb

@@ -79,9 +79,8 @@ if defined?(Excon)
 
         def self.request_params_from(hash)
           hash = hash.dup
-          if Excon::VERSION >= '0.27.5'
-            request_keys = Excon::Utils.valid_request_keys(hash)
-            hash.reject! {|key,_| !request_keys.include?(key) }
+          if defined?(Excon::VALID_REQUEST_KEYS)
+            hash.reject! {|key,_| !Excon::VALID_REQUEST_KEYS.include?(key) }
           end
           PARAMS_TO_DELETE.each { |key| hash.delete(key) }
           hash
@@ -146,7 +145,8 @@ if defined?(Excon)
 
   Excon::Connection.class_eval do
     def self.new(args)
-      super.tap do |instance|
+      args.delete(:__construction_args)
+      super(args).tap do |instance|
         instance.data[:__construction_args] = args
       end
     end

data/lib/webmock/http_lib_adapters/http_gem/response.rb

@@ -10,12 +10,13 @@ module HTTP
       webmock_response
     end
 
-    def self.from_webmock(webmock_response)
+    def self.from_webmock(webmock_response, request_signature = nil)
       status  = webmock_response.status.first
       headers = webmock_response.headers || {}
       body    = Body.new Streamer.new webmock_response.body
+      uri     = URI request_signature.uri.to_s if request_signature
 
-      new(status, "1.1", headers, body)
+      new(status, "1.1", headers, body, uri)
     end
   end
 end

data/lib/webmock/http_lib_adapters/http_gem/webmock.rb

@@ -37,7 +37,7 @@ module HTTP
       webmock_response.raise_error_if_any
 
       invoke_callbacks(webmock_response, :real_request => false)
-      ::HTTP::Response.from_webmock webmock_response
+      ::HTTP::Response.from_webmock webmock_response, request_signature
     end
 
     def perform

data/lib/webmock/http_lib_adapters/httpclient_adapter.rb

@@ -46,7 +46,7 @@ if defined?(::HTTPClient)
 
       if webmock_responses[request_signature]
         webmock_response = webmock_responses.delete(request_signature)
-        response = build_httpclient_response(webmock_response, stream, &block)
+        response = build_httpclient_response(webmock_response, stream, req.header, &block)
         @request_filter.each do |filter|
           filter.filter_response(req, response)
         end
@@ -89,9 +89,9 @@ if defined?(::HTTPClient)
       end
     end
 
-    def build_httpclient_response(webmock_response, stream = false, &block)
+    def build_httpclient_response(webmock_response, stream = false, req_header = nil, &block)
       body = stream ? StringIO.new(webmock_response.body) : webmock_response.body
-      response = HTTP::Message.new_response(body)
+      response = HTTP::Message.new_response(body, req_header)
       response.header.init_response(webmock_response.status[0])
       response.reason=webmock_response.status[1]
       webmock_response.headers.to_a.each { |name, value| response.header.set(name, value) }
@@ -132,7 +132,7 @@ if defined?(::HTTPClient)
 
   def build_request_signature(req, reuse_existing = false)
     uri = WebMock::Util::URI.heuristic_parse(req.header.request_uri.to_s)
-    uri.query = WebMock::Util::QueryMapper.values_to_query(req.header.request_query) if req.header.request_query
+    uri.query = WebMock::Util::QueryMapper.values_to_query(req.header.request_query, :notation => WebMock::Config.instance.query_values_notation) if req.header.request_query
     uri.port = req.header.request_uri.port
     uri = uri.omit(:userinfo)
 

data/lib/webmock/matchers/hash_including_matcher.rb

@@ -4,7 +4,7 @@ module WebMock
     #https://github.com/rspec/rspec-mocks/blob/master/lib/rspec/mocks/argument_matchers.rb
     class HashIncludingMatcher
       def initialize(expected)
-        @expected = Hash[WebMock::Util::HashKeysStringifier.stringify_keys!(expected).sort]
+        @expected = Hash[WebMock::Util::HashKeysStringifier.stringify_keys!(expected, :deep => true).sort]
       end
 
       def ==(actual)

data/lib/webmock/request_pattern.rb

@@ -48,9 +48,10 @@ module WebMock
 
 
     def assign_options(options)
-      @body_pattern = BodyPattern.new(options[:body]) if options.has_key?(:body)
-      @headers_pattern = HeadersPattern.new(options[:headers]) if options.has_key?(:headers)
-      @uri_pattern.add_query_params(options[:query]) if options.has_key?(:query)
+      options = WebMock::Util::HashKeysStringifier.stringify_keys!(options, :deep => true)
+      @body_pattern = BodyPattern.new(options['body']) if options.has_key?('body')
+      @headers_pattern = HeadersPattern.new(options['headers']) if options.has_key?('headers')
+      @uri_pattern.add_query_params(options['query']) if options.has_key?('query')
     end
 
     def create_uri_pattern(uri)
@@ -102,7 +103,7 @@ module WebMock
       elsif rSpecHashIncludingMatcher?(query_params)
         WebMock::Matchers::HashIncludingMatcher.from_rspec_matcher(query_params)
       else
-        WebMock::Util::QueryMapper.query_to_values(query_params)
+        WebMock::Util::QueryMapper.query_to_values(query_params, :notation => Config.instance.query_values_notation)
       end
     end
 
@@ -116,7 +117,7 @@ module WebMock
   class URIRegexpPattern  < URIPattern
     def matches?(uri)
       WebMock::Util::URI.variations_of_uri_as_strings(uri).any? { |u| u.match(@pattern) } &&
-        (@query_params.nil? || @query_params == WebMock::Util::QueryMapper.query_to_values(uri.query))
+        (@query_params.nil? || @query_params == WebMock::Util::QueryMapper.query_to_values(uri.query, :notation => Config.instance.query_values_notation))
     end
 
     def to_s
@@ -155,7 +156,7 @@ module WebMock
       if @pattern.is_a?(Addressable::URI)
         if @query_params
           uri.omit(:query) === @pattern &&
-          (@query_params.nil? || @query_params == WebMock::Util::QueryMapper.query_to_values(uri.query))
+          (@query_params.nil? || @query_params == WebMock::Util::QueryMapper.query_to_values(uri.query, :notation => Config.instance.query_values_notation))
         else
           uri === @pattern
         end
@@ -167,8 +168,8 @@ module WebMock
     def add_query_params(query_params)
       super
       if @query_params.is_a?(Hash) || @query_params.is_a?(String)
-        query_hash = (WebMock::Util::QueryMapper.query_to_values(@pattern.query) || {}).merge(@query_params)
-        @pattern.query = WebMock::Util::QueryMapper.values_to_query(query_hash)
+        query_hash = (WebMock::Util::QueryMapper.query_to_values(@pattern.query, :notation => Config.instance.query_values_notation) || {}).merge(@query_params)
+        @pattern.query = WebMock::Util::QueryMapper.values_to_query(query_hash, :notation => WebMock::Config.instance.query_values_notation)
         @query_params = nil
       end
     end
@@ -232,7 +233,7 @@ module WebMock
       when :xml then
         Crack::XML.parse(body)
       else
-        WebMock::Util::QueryMapper.query_to_values(body)
+        WebMock::Util::QueryMapper.query_to_values(body, :notation => Config.instance.query_values_notation)
       end
     end
 
@@ -279,7 +280,7 @@ module WebMock
     end
 
     def normalize_hash(hash)
-      Hash[WebMock::Util::HashKeysStringifier.stringify_keys!(hash).sort]
+      Hash[WebMock::Util::HashKeysStringifier.stringify_keys!(hash, :deep => true).sort]
     end
 
   end

data/lib/webmock/request_signature.rb

@@ -6,7 +6,7 @@ module WebMock
     attr_reader :headers
 
     def initialize(method, uri, options = {})
-      self.method = method
+      self.method = method.to_sym
       self.uri = uri.is_a?(Addressable::URI) ? uri : WebMock::Util::URI.normalize_uri(uri)
       assign_options(options)
     end

data/lib/webmock/request_stub.rb

@@ -81,7 +81,7 @@ module WebMock
 
       if signature.body.to_s != ''
         body = if signature.url_encoded?
-          WebMock::Util::QueryMapper.query_to_values(signature.body)
+          WebMock::Util::QueryMapper.query_to_values(signature.body, :notation => Config.instance.query_values_notation)
         else
           signature.body
         end

data/lib/webmock/util/hash_keys_stringifier.rb

@@ -2,15 +2,17 @@ module WebMock
   module Util
     class HashKeysStringifier
 
-      def self.stringify_keys!(arg)
+      def self.stringify_keys!(arg, options = {})
         case arg
         when Array
-          arg.map { |elem| stringify_keys!(elem) }
+          arg.map { |elem|
+            options[:deep] ? stringify_keys!(elem, options) : elem
+          }
         when Hash
           Hash[
             *arg.map { |key, value|
               k = key.is_a?(Symbol) ? key.to_s : key
-              v = stringify_keys!(value)
+              v = (options[:deep] ? stringify_keys!(value, options) : value)
               [k,v]
             }.inject([]) {|r,x| r + x}]
         else

data/lib/webmock/util/query_mapper.rb

@@ -1,142 +1,227 @@
 module WebMock::Util
   class QueryMapper
-    #This class is based on Addressable::URI pre 2.3.0
-
-    ##
-    # Converts the query component to a Hash value.
-    #
-    # @option [Symbol] notation
-    #   May be one of <code>:flat</code>, <code>:dot</code>, or
-    #   <code>:subscript</code>. The <code>:dot</code> notation is not
-    #   supported for assignment. Default value is <code>:subscript</code>.
-    #
-    # @return [Hash, Array] The query string parsed as a Hash or Array object.
-    #
-    # @example
-    #   WebMock::Util::QueryMapper.query_to_values("?one=1&two=2&three=3")
-    #   #=> {"one" => "1", "two" => "2", "three" => "3"}
-    #   WebMock::Util::QueryMapper("?one[two][three]=four").query_values
-    #   #=> {"one" => {"two" => {"three" => "four"}}}
-    #   WebMock::Util::QueryMapper.query_to_values("?one.two.three=four",
-    #     :notation => :dot
-    #   )
-    #   #=> {"one" => {"two" => {"three" => "four"}}}
-    #   WebMock::Util::QueryMapper.query_to_values("?one[two][three]=four",
-    #     :notation => :flat
-    #   )
-    #   #=> {"one[two][three]" => "four"}
-    #   WebMock::Util::QueryMapper.query_to_values("?one.two.three=four",
-    #     :notation => :flat
-    #   )
-    #   #=> {"one.two.three" => "four"}
-    #   WebMock::Util::QueryMapper(
-    #     "?one[two][three][]=four&one[two][three][]=five"
-    #   )
-    #   #=> {"one" => {"two" => {"three" => ["four", "five"]}}}
-    #   WebMock::Util::QueryMapper.query_to_values(
-    #     "?one=two&one=three").query_values(:notation => :flat_array)
-    #   #=> [['one', 'two'], ['one', 'three']]
-    def self.query_to_values(query, options={})
-      query.force_encoding('utf-8') if query.respond_to?(:force_encoding)
-      defaults = {:notation => :subscript}
-      options = defaults.merge(options)
-      if ![:flat, :dot, :subscript, :flat_array].include?(options[:notation])
-        raise ArgumentError,
-          "Invalid notation. Must be one of: " +
-          "[:flat, :dot, :subscript, :flat_array]."
+    class << self
+      #This class is based on Addressable::URI pre 2.3.0
+
+      ##
+      # Converts the query component to a Hash value.
+      #
+      # @option [Symbol] notation
+      #   May be one of <code>:flat</code>, <code>:dot</code>, or
+      #   <code>:subscript</code>. The <code>:dot</code> notation is not
+      #   supported for assignment. Default value is <code>:subscript</code>.
+      #
+      # @return [Hash, Array] The query string parsed as a Hash or Array object.
+      #
+      # @example
+      #   WebMock::Util::QueryMapper.query_to_values("?one=1&two=2&three=3")
+      #   #=> {"one" => "1", "two" => "2", "three" => "3"}
+      #   WebMock::Util::QueryMapper("?one[two][three]=four").query_values
+      #   #=> {"one" => {"two" => {"three" => "four"}}}
+      #   WebMock::Util::QueryMapper.query_to_values("?one.two.three=four",
+      #     :notation => :dot
+      #   )
+      #   #=> {"one" => {"two" => {"three" => "four"}}}
+      #   WebMock::Util::QueryMapper.query_to_values("?one[two][three]=four",
+      #     :notation => :flat
+      #   )
+      #   #=> {"one[two][three]" => "four"}
+      #   WebMock::Util::QueryMapper.query_to_values("?one.two.three=four",
+      #     :notation => :flat
+      #   )
+      #   #=> {"one.two.three" => "four"}
+      #   WebMock::Util::QueryMapper(
+      #     "?one[two][three][]=four&one[two][three][]=five"
+      #   )
+      #   #=> {"one" => {"two" => {"three" => ["four", "five"]}}}
+      #   WebMock::Util::QueryMapper.query_to_values(
+      #     "?one=two&one=three").query_values(:notation => :flat_array)
+      #   #=> [['one', 'two'], ['one', 'three']]
+      def query_to_values(query, options={})
+        return nil if query.nil?
+        query.force_encoding('utf-8') if query.respond_to?(:force_encoding)
+
+        options[:notation] ||= :subscript
+
+        if ![:flat, :dot, :subscript, :flat_array].include?(options[:notation])
+          raise ArgumentError,
+                'Invalid notation. Must be one of: ' +
+                '[:flat, :dot, :subscript, :flat_array].'
+        end
+
+        empty_accumulator = :flat_array == options[:notation] ? [] : {}
+
+        query_array = collect_query_parts(query)
+
+        query_hash = collect_query_hash(query_array, empty_accumulator, options)
+
+        normalize_query_hash(query_hash, empty_accumulator, options)
       end
-      dehash = lambda do |hash|
-        hash.each do |(key, value)|
-          if value.kind_of?(Hash)
-            hash[key] = dehash.call(value)
+
+      def normalize_query_hash(query_hash, empty_accumulator, options)
+        query_hash.inject(empty_accumulator.dup) do |accumulator, (key, value)|
+          if options[:notation] == :flat_array
+            accumulator << [key, value]
+          else
+            accumulator[key] = value.kind_of?(Hash) ? dehash(value) : value
           end
+          accumulator
         end
-        if hash != {} && hash.keys.all? { |key| key =~ /^\d+$/ }
-          hash.sort.inject([]) do |accu, (_, value)|
-            accu << value; accu
-          end
-        else
-          hash
+      end
+
+      def collect_query_parts(query)
+        query_parts = query.split('&').map do |pair|
+          pair.split('=', 2) if pair && !pair.empty?
         end
+        query_parts.compact
       end
-      return nil if query == nil
-      empty_accumulator = :flat_array == options[:notation] ? [] : {}
-      return ((query.split("&").map do |pair|
-                 pair.split("=", 2) if pair && !pair.empty?
-              end).compact.inject(empty_accumulator.dup) do |accumulator, (key, value)|
-                value = true if value.nil?
-                key = Addressable::URI.unencode_component(key)
-                key = key.dup.force_encoding(Encoding::ASCII_8BIT) if key.respond_to?(:force_encoding)
-                if value != true
-                  value = Addressable::URI.unencode_component(value.gsub(/\+/, " "))
-                end
-                if options[:notation] == :flat
-                  if accumulator[key]
-                    raise ArgumentError, "Key was repeated: #{key.inspect}"
-                  end
-                  accumulator[key] = value
-                elsif options[:notation] == :flat_array
-                  accumulator << [key, value]
-                else
-                  if options[:notation] == :dot
-                    array_value = false
-                    subkeys = key.split(".")
-                  elsif options[:notation] == :subscript
-                    array_value = !!(key =~ /\[\]$/)
-                    subkeys = key.split(/[\[\]]+/)
-                  end
-                  current_hash = accumulator
-                  for i in 0...(subkeys.size - 1)
-                    subkey = subkeys[i]
-                    current_hash[subkey] = {} unless current_hash[subkey]
-                    current_hash = current_hash[subkey]
-                  end
-                  if array_value
-                    if current_hash[subkeys.last] && !current_hash[subkeys.last].is_a?(Array)
-                      current_hash[subkeys.last] = [current_hash[subkeys.last]]
-                    end
-                    current_hash[subkeys.last] = [] unless current_hash[subkeys.last]
-                    current_hash[subkeys.last] << value
+
+      def collect_query_hash(query_array, empty_accumulator, options)
+        query_array.compact.inject(empty_accumulator.dup) do |accumulator, (key, value)|
+          value = if value.nil?
+                    true
                   else
-                    current_hash[subkeys.last] = value
+                    ::Addressable::URI.unencode_component(value.gsub(/\+/, ' '))
                   end
-                end
-                accumulator
-      end).inject(empty_accumulator.dup) do |accumulator, (key, value)|
-        if options[:notation] == :flat_array
-          accumulator << [key, value]
+          key = Addressable::URI.unencode_component(key)
+          key = key.dup.force_encoding(Encoding::ASCII_8BIT) if key.respond_to?(:force_encoding)
+          self.__send__("fill_accumulator_for_#{options[:notation]}", accumulator, key, value)
+          accumulator
+        end
+      end
+
+      def fill_accumulator_for_flat(accumulator, key, value)
+        if accumulator[key]
+          raise ArgumentError, "Key was repeated: #{key.inspect}"
+        end
+        accumulator[key] = value
+      end
+
+      def fill_accumulator_for_flat_array(accumulator, key, value)
+        accumulator << [key, value]
+      end
+
+      def fill_accumulator_for_dot(accumulator, key, value)
+        array_value = false
+        subkeys = key.split(".")
+        current_hash = accumulator
+        subkeys[0..-2].each do |subkey|
+          current_hash[subkey] = {} unless current_hash[subkey]
+          current_hash = current_hash[subkey]
+        end
+        if array_value
+          if current_hash[subkeys.last] && !current_hash[subkeys.last].is_a?(Array)
+            current_hash[subkeys.last] = [current_hash[subkeys.last]]
+          end
+          current_hash[subkeys.last] = [] unless current_hash[subkeys.last]
+          current_hash[subkeys.last] << value
         else
-          accumulator[key] = value.kind_of?(Hash) ? dehash.call(value) : value
+          current_hash[subkeys.last] = value
         end
-        accumulator
       end
-    end
 
-    ##
-    # Sets the query component for this URI from a Hash object.
-    # This method produces a query string using the :subscript notation.
-    # An empty Hash will result in a nil query.
-    #
-    # @param [Hash, #to_hash, Array] new_query_values The new query values.
-    def self.values_to_query(new_query_values)
+      def fill_accumulator_for_subscript(accumulator, key, value)
+        current_node = accumulator
+        subkeys = key.split(/(?=\[\w)/)
+        subkeys[0..-2].each do |subkey|
+          node = subkey =~ /\[\]\z/ ? [] : {}
+          subkey = subkey.gsub(/[\[\]]/, '')
+          if current_node.is_a? Array
+            container = current_node.find { |n| n.is_a?(Hash) && n.has_key?(subkey) }
+            if container
+              current_node = container[subkey]
+            else
+              current_node << {subkey => node}
+              current_node = node
+            end
+          else
+            current_node[subkey] = node unless current_node[subkey]
+            current_node = current_node[subkey]
+          end
+        end
+        last_key = subkeys.last
+        array_value = !!(last_key =~ /\[\]$/)
+        last_key = last_key.gsub(/[\[\]]/, '')
+        if current_node.is_a? Array
+          container = current_node.find { |n| n.is_a?(Hash) && n.has_key?(last_key) }
+          if container
+            if array_value
+              container[last_key] << value
+            else
+              container[last_key] = value
+            end
+          else
+            if array_value
+              current_node << {last_key => [value]}
+            else
+              current_node << {last_key => value}
+            end
+          end
+        else
+          if array_value
+            current_node[last_key] = [] unless current_node[last_key]
+            current_node[last_key] << value
+          else
+            current_node[last_key] = value
+          end
+        end
+      end
+
+      ##
+      # Sets the query component for this URI from a Hash object.
+      # This method produces a query string using the :subscript notation.
+      # An empty Hash will result in a nil query.
+      #
+      # @param [Hash, #to_hash, Array] new_query_values The new query values.
+      def values_to_query(new_query_values, options = {})
+        options[:notation] ||= :subscript
+        return if new_query_values.nil?
+
+        unless new_query_values.is_a?(Array)
+          unless new_query_values.respond_to?(:to_hash)
+            raise TypeError,
+                  "Can't convert #{new_query_values.class} into Hash."
+          end
+          new_query_values = new_query_values.to_hash
+          new_query_values = new_query_values.inject([]) do |object, (key, value)|
+            key = key.to_s if key.is_a?(::Symbol) || key.nil?
+            if value.is_a?(Array)
+              value.each { |v| object << [key.to_s + '[]', v] }
+            elsif value.is_a?(Hash)
+              value.each { |k, v| object << ["#{key.to_s}[#{k}]", v]}
+            else
+              object << [key.to_s, value]
+            end
+            object
+          end
+          # Useful default for OAuth and caching.
+          # Only to be used for non-Array inputs. Arrays should preserve order.
+          new_query_values.sort!
+        end
 
-      if new_query_values == nil
-        return nil
+        buffer = ''
+        new_query_values.each do |parent, value|
+          encoded_parent = ::Addressable::URI.encode_component(
+              parent.dup, ::Addressable::URI::CharacterClasses::UNRESERVED
+          )
+          buffer << "#{to_query(encoded_parent, value, options)}&"
+        end
+        buffer.chop
       end
 
-      if !new_query_values.is_a?(Array)
-        if !new_query_values.respond_to?(:to_hash)
-          raise TypeError,
-            "Can't convert #{new_query_values.class} into Hash."
+      def dehash(hash)
+        hash.each do |(key, value)|
+          if value.is_a?(::Hash)
+            hash[key] = self.dehash(value)
+          end
         end
-        new_query_values = new_query_values.to_hash
-        new_query_values = new_query_values.map do |key, value|
-          key = key.to_s if key.kind_of?(Symbol) || key.nil?
-          [key.to_s, value]
+        if hash != {} && hash.keys.all? { |key| key =~ /^\d+$/ }
+          hash.sort.inject([]) do |accu, (_, value)|
+            accu << value; accu
+          end
+        else
+          hash
         end
-        # Useful default for OAuth and caching.
-        # Only to be used for non-Array inputs. Arrays should preserve order.
-        new_query_values.sort!
       end
 
       ##
@@ -148,47 +233,42 @@ module WebMock::Util
       # @param [Array, Hash, Symbol, #to_str] value
       #
       # @return [String] a properly escaped and ordered URL query.
-      to_query = lambda do |parent, value|
-        if value.is_a?(Hash)
+
+      # new_query_values have form [['key1', 'value1'], ['key2', 'value2']]
+      def to_query(parent, value, options = {})
+        options[:notation] ||= :subscript
+        case value
+        when ::Hash
           value = value.map do |key, val|
             [
-              Addressable::URI.encode_component(key.dup, Addressable::URI::CharacterClasses::UNRESERVED),
+              ::Addressable::URI.encode_component(key.dup, ::Addressable::URI::CharacterClasses::UNRESERVED),
               val
             ]
           end
           value.sort!
-          buffer = ""
+          buffer = ''
           value.each do |key, val|
-            new_parent = "#{parent}[#{key}]"
-            buffer << "#{to_query.call(new_parent, val)}&"
+            new_parent = options[:notation] != :flat_array ? "#{parent}[#{key}]" : parent
+            buffer << "#{to_query(new_parent, val, options)}&"
           end
-          return buffer.chop
-        elsif value.is_a?(Array)
-          buffer = ""
+          buffer.chop
+        when ::Array
+          buffer = ''
           value.each_with_index do |val, i|
-            new_parent = "#{parent}[#{i}]"
-            buffer << "#{to_query.call(new_parent, val)}&"
+            new_parent = options[:notation] != :flat_array ? "#{parent}[#{i}]" : parent
+            buffer << "#{to_query(new_parent, val, options)}&"
           end
-          return buffer.chop
-        elsif value == true
-          return parent
+          buffer.chop
+        when TrueClass
+          parent
         else
           encoded_value = Addressable::URI.encode_component(
             value.to_s.dup, Addressable::URI::CharacterClasses::UNRESERVED
           )
-          return "#{parent}=#{encoded_value}"
+          "#{parent}=#{encoded_value}"
         end
       end
-
-      # new_query_values have form [['key1', 'value1'], ['key2', 'value2']]
-      buffer = ""
-      new_query_values.each do |parent, value|
-        encoded_parent = Addressable::URI.encode_component(
-          parent.dup, Addressable::URI::CharacterClasses::UNRESERVED
-        )
-        buffer << "#{to_query.call(encoded_parent, value)}&"
-      end
-      return buffer.chop
     end
+
   end
 end