rack-test 0.6.3 → 2.1.0

data/lib/rack/test/utils.rb

@@ -1,22 +1,28 @@
+# frozen_string_literal: true
+
 module Rack
   module Test
-
     module Utils # :nodoc:
       include Rack::Utils
+      extend self
 
+      # Build a query string for the given value and prefix. The value
+      # can be an array or hash of parameters.
       def build_nested_query(value, prefix = nil)
         case value
         when Array
-          value.map do |v|
-            unless unescape(prefix) =~ /\[\]$/
-              prefix = "#{prefix}[]"
-            end
-            build_nested_query(v, "#{prefix}")
-          end.join("&")
+          if value.empty?
+            "#{prefix}[]="
+          else
+            prefix += "[]" unless unescape(prefix).end_with?('[]')
+            value.map do |v|
+              build_nested_query(v, prefix.to_s)
+            end.join('&')
+          end
         when Hash
           value.map do |k, v|
             build_nested_query(v, prefix ? "#{prefix}[#{escape(k)}]" : escape(k))
-          end.join("&")
+          end.join('&')
         when NilClass
           prefix.to_s
         else
@@ -24,15 +30,11 @@ module Rack
         end
       end
 
-      module_function :build_nested_query
-
-      def build_multipart(params, first = true)
-        if first
-          unless params.is_a?(Hash)
-            raise ArgumentError, "value must be a Hash"
-          end
+      # Build a multipart body for the given params.
+      def build_multipart(params, _first = true, multipart = false)
+        raise ArgumentError, 'value must be a Hash' unless params.is_a?(Hash)
 
-          multipart = false
+        unless multipart
           query = lambda { |value|
             case value
             when Array
@@ -47,7 +49,18 @@ module Rack
           return nil unless multipart
         end
 
-        flattened_params = Hash.new
+        params = normalize_multipart_params(params, true)
+
+        buffer = String.new
+        build_parts(buffer, params)
+        buffer
+      end
+
+      private
+
+      # Return a flattened hash of parameter values based on the given params.
+      def normalize_multipart_params(params, first=false)
+        flattened_params = {}
 
         params.each do |key, value|
           k = first ? key.to_s : "[#{key}]"
@@ -55,96 +68,89 @@ module Rack
           case value
           when Array
             value.map do |v|
-
-              if (v.is_a?(Hash))
+              if v.is_a?(Hash)
                 nested_params = {}
-                build_multipart(v, false).each { |subkey, subvalue|
+                normalize_multipart_params(v).each do |subkey, subvalue|
                   nested_params[subkey] = subvalue
-                }
-                flattened_params["#{k}[]"] ||= []
-                flattened_params["#{k}[]"] << nested_params
+                end
+                (flattened_params["#{k}[]"] ||= []) << nested_params
               else
                 flattened_params["#{k}[]"] = value
               end
-
             end
           when Hash
-            build_multipart(value, false).each { |subkey, subvalue|
+            normalize_multipart_params(value).each do |subkey, subvalue|
               flattened_params[k + subkey] = subvalue
-            }
+            end
           else
             flattened_params[k] = value
           end
         end
 
-        if first
-          build_parts(flattened_params)
-        else
-          flattened_params
-        end
+        flattened_params
       end
 
-      module_function :build_multipart
-
-    private
-      def build_parts(parameters)
-        get_parts(parameters).join + "--#{MULTIPART_BOUNDARY}--\r"
+      # Build the multipart content for uploading.
+      def build_parts(buffer, parameters)
+        _build_parts(buffer, parameters)
+        buffer << END_BOUNDARY
       end
 
-      def get_parts(parameters)
-        parameters.map { |name, value|
-          if name =~ /\[\]\Z/ && value.is_a?(Array) && value.all? {|v| v.is_a?(Hash)}
-            value.map { |hash|
+      # Append each multipart parameter value to the buffer.
+      def _build_parts(buffer, parameters)
+        parameters.map do |name, value|
+          if name =~ /\[\]\Z/ && value.is_a?(Array) && value.all? { |v| v.is_a?(Hash) }
+            value.each do |hash|
               new_value = {}
-              hash.each { |k, v| new_value[name+k] = v }
-              get_parts(new_value).join
-            }.join
+              hash.each { |k, v| new_value[name + k] = v }
+              _build_parts(buffer, new_value)
+            end
           else
-            if value.respond_to?(:original_filename)
-              build_file_part(name, value)
-
-            elsif value.is_a?(Array) and value.all? { |v| v.respond_to?(:original_filename) }
-              value.map do |v|
-                build_file_part(name, v)
-              end.join
-
-            else
-              primitive_part = build_primitive_part(name, value)
-              Rack::Test.encoding_aware_strings? ? primitive_part.force_encoding('BINARY') : primitive_part
+            [value].flatten.map do |v|
+              if v.respond_to?(:original_filename)
+                build_file_part(buffer, name, v)
+              else
+                build_primitive_part(buffer, name, v)
+              end
             end
           end
-        }
+        end
       end
 
-      def build_primitive_part(parameter_name, value)
-        unless value.is_a? Array
-          value = [value]
-        end
-        value.map do |v|
-<<-EOF
---#{MULTIPART_BOUNDARY}\r
-Content-Disposition: form-data; name="#{parameter_name}"\r
-\r
-#{v}\r
-EOF
-        end.join
+      # Append the multipart fragment for a parameter that isn't a file upload to the buffer.
+      def build_primitive_part(buffer, parameter_name, value)
+        buffer <<
+          START_BOUNDARY <<
+          "content-disposition: form-data; name=\"" <<
+          parameter_name.to_s.b <<
+          "\"\r\n\r\n" <<
+          value.to_s.b <<
+          "\r\n"
+        buffer
       end
 
-      def build_file_part(parameter_name, uploaded_file)
-        ::File.open(uploaded_file.path, "rb") do |physical_file|
-          physical_file.set_encoding(Encoding::BINARY) if physical_file.respond_to?(:set_encoding)
-<<-EOF
---#{MULTIPART_BOUNDARY}\r
-Content-Disposition: form-data; name="#{parameter_name}"; filename="#{escape(uploaded_file.original_filename)}"\r
-Content-Type: #{uploaded_file.content_type}\r
-Content-Length: #{::File.stat(uploaded_file.path).size}\r
-\r
-#{physical_file.read}\r
-EOF
+      # Append the multipart fragment for a parameter that is a file upload to the buffer.
+      def build_file_part(buffer, parameter_name, uploaded_file)
+        buffer <<
+          START_BOUNDARY <<
+          "content-disposition: form-data; name=\"" <<
+          parameter_name.to_s.b <<
+          "\"; filename=\"" <<
+          escape_path(uploaded_file.original_filename).b <<
+          "\"\r\ncontent-type: " <<
+          uploaded_file.content_type.to_s.b <<
+          "\r\ncontent-length: " <<
+          uploaded_file.size.to_s.b <<
+          "\r\n\r\n"
+
+        # Handle old versions of Capybara::RackTest::Form::NilUploadedFile
+        if uploaded_file.respond_to?(:set_encoding)
+          uploaded_file.set_encoding(Encoding::BINARY)
+          uploaded_file.append_to(buffer)
         end
-      end
 
+        buffer << "\r\n"
+      end
     end
-
   end
 end

data/lib/rack/test/version.rb

@@ -0,0 +1,5 @@
+module Rack
+  module Test
+    VERSION = '2.1.0'.freeze
+  end
+end