WIP Rack 3 compat

Author: chadlwilson

History.md

@@ -1,6 +1,7 @@
 ## 1.3.0 (UNRELEASED) 
 
 - Support Javax Servlet API 4.0 (JEE 8)
+- Support Rack 3.0 -> 3.2 (default vendored Rack is still 2.2)
 - Adds basic compatibility with JRuby 10.0
 - Drop support for JRuby 9.3
 - Drop support for Rails < 6.1

README.md

@@ -13,8 +13,8 @@ For more information on Rack, visit http://rack.github.io/.
 
 | JRuby-Rack Series                                          | Status     | Rack      | JRuby      | Java | Rails     | Target Servlet API  | Notes                                      |
 |------------------------------------------------------------|------------|-----------|------------|------|-----------|---------------------|--------------------------------------------|
-| 2.0 (_planned_)                                            | Dev        | 2.2       | 9.4 → 10.0 | 8+   | 6.1 → 8.0 | 5.0+ (Jakarta EE 9) | Pre 5.0 servlet APIs non functional.       |
-| 1.3 (master, _unreleased_)                                 | Dev        | 2.2       | 9.4 → 10.0 | 8+   | 6.1 → 8.0 | 4.0 (Java EE 8)     | Servlet 2.5 → 3.1 likely to work fine.     |
+| 2.0 (_planned_)                                            | Dev        | 2.2 → 3.x | 9.4 → 10.0 | 8+   | 6.1 → 8.0 | 5.0+ (Jakarta EE 9) | Pre 5.0 servlet APIs non functional.       |
+| 1.3 (master, _unreleased_)                                 | Dev        | 2.2 → 3.x | 9.4 → 10.0 | 8+   | 6.1 → 8.0 | 4.0 (Java EE 8)     | Servlet 2.5 → 3.1 likely to work fine.     |
 | [1.2](https://github.com/jruby/jruby-rack/tree/1.2-stable) | Maintained | 2.2       | 9.3 → 9.4  | 8+   | 5.0 → 7.2 | 3.0 (Java EE 6)     | Servlet 3.1 → 4.0 OK with some containers. |
 | [1.1](https://github.com/jruby/jruby-rack/tree/1.1-stable) | EOL        | 1.x → 2.2 | 1.6 → 9.4  | 6+   | 2.1 → 5.2 | 2.5 (Java EE 5)     | Servlet 3.0 → 4.0 OK with some containers. |
 | 1.0                                                        | EOL        | 0.9 → 1.x | 1.1 → 1.9  | 5+   | 2.1 → 3.x | 2.5 (Java EE 5)     |                                            |

src/main/java/org/jruby/rack/RackEnvironment.java

@@ -157,4 +157,10 @@ public interface RackEnvironment {
      * @return the remote user
      */
     String getRemoteUser();
+
+    /**
+     * @see javax.servlet.http.HttpServletRequest#getProtocol()
+     * @return a String containing the name of the scheme used to make this request
+     */
+    String getProtocol();
 }

src/main/ruby/jruby/rack/chunked.rb

@@ -3,21 +3,23 @@
 # See the file LICENSE.txt for details.
 #++
 
-require 'rack/chunked' # exists since Rack 1.1
+if Rack.release < '3'
+  require 'rack/chunked' # exists since Rack 1.1, removed in Rack 3.0
 
-# Disables the Rack response body chunking performed by `Rack::Chunked::Body`.
-# It is "necessary" since Rails does instantiate the body directly instead of
-# using `Rack::Chunked` as a middleware.
-# 
-# @note This monkey-patch is not required to support chunking with servlets and 
-# won't be applied unless **jruby.rack.response.dechunk** is 'patch' (default).
-# Set **jruby.rack.response.dechunk** to 'true' to simply "dechunk" the body and
-# keep the `Rack::Chunked::Body` class as is (or 'false' to do no de-chunking at
-# all).
-Rack::Chunked::Body.class_eval do
+  # Disables the Rack response body chunking performed by `Rack::Chunked::Body`.
+  # It is "necessary" since Rails does instantiate the body directly instead of
+  # using `Rack::Chunked` as a middleware.
+  #
+  # @note This monkey-patch is not required to support chunking with servlets and
+  # won't be applied unless **jruby.rack.response.dechunk** is 'patch' (default).
+  # Set **jruby.rack.response.dechunk** to 'true' to simply "dechunk" the body and
+  # keep the `Rack::Chunked::Body` class as is (or 'false' to do no de-chunking at
+  # all).
+  Rack::Chunked::Body.class_eval do
+
+    def each(&block)
+      @body.each(&block) # no-chunking on servlets
+    end
 
-  def each(&block)
-    @body.each(&block) # no-chunking on servlets
   end
-  
 end

src/main/ruby/jruby/rack/error_app/show_status.rb

@@ -15,7 +15,6 @@ def initialize(app)
 
     def call(env)
       status, headers, body = @app.call(env)
-      headers = ::Rack::Utils::HeaderHash.new(headers)
       empty = headers['Content-Length'].to_i <= 0
 
       detail = env['rack.showstatus.detail']

src/main/ruby/rack/handler/servlet/default_env.rb

@@ -19,15 +19,20 @@ class Servlet
       # ServletRequest input stream to be not read (e.g. for POSTs).
       class DefaultEnv < Hash # The environment must be an instance of Hash !
 
-        BUILTINS = %w(rack.version rack.input rack.errors rack.url_scheme
-          rack.multithread rack.multiprocess rack.run_once rack.hijack?
-          java.servlet_request java.servlet_response java.servlet_context
-          jruby.rack.version).
-          map!(&:freeze)
+        BUILTINS = Rack.release < '3' ?
+                     # rack 2.2.x
+                     Set.new(%w(rack.version rack.multithread rack.multiprocess rack.run_once
+                        rack.input rack.errors rack.url_scheme rack.hijack?
+                        java.servlet_request java.servlet_response java.servlet_context
+                        jruby.rack.context jruby.rack.version).map!(&:freeze)) :
+                     # rack 3.0 and later
+                     Set.new(%w(rack.input rack.errors rack.url_scheme rack.hijack?
+                        java.servlet_request java.servlet_response java.servlet_context
+                        jruby.rack.context jruby.rack.version).map!(&:freeze))
 
         VARIABLES = %w(CONTENT_TYPE CONTENT_LENGTH PATH_INFO QUERY_STRING
           REMOTE_ADDR REMOTE_HOST REMOTE_USER REQUEST_METHOD REQUEST_URI
-          SCRIPT_NAME SERVER_NAME SERVER_PORT SERVER_SOFTWARE).
+          SCRIPT_NAME SERVER_NAME SERVER_PORT SERVER_SOFTWARE SERVER_PROTOCOL).
           map!(&:freeze)
 
         attr_reader :env
@@ -216,6 +221,7 @@ def load_variable(env, key)
             when 'SCRIPT_NAME'     then env[key] = @servlet_env.getScriptName
             when 'SERVER_NAME'     then env[key] = @servlet_env.getServerName || ''
             when 'SERVER_PORT'     then env[key] = @servlet_env.getServerPort.to_s
+            when 'SERVER_PROTOCOL' then env[key] = @servlet_env.getProtocol
             when 'SERVER_SOFTWARE' then env[key] = rack_context.getServerInfo
             else
               # NOTE: even though we allowed for overrides and loaded all attributes
@@ -230,8 +236,10 @@ def load_variable(env, key)
         end
 
         def load_builtin(env, key)
+          return nil unless BUILTINS.include?(key)
+
           case key
-          when 'rack.version'         then env[key] = ::Rack::RELEASE
+          when 'rack.version'         then env[key] = ::Rack.release
           when 'rack.multithread'     then env[key] = true
           when 'rack.multiprocess'    then env[key] = false
           when 'rack.run_once'        then env[key] = false

src/main/ruby/rack/handler/servlet/servlet_env.rb

@@ -76,13 +76,13 @@ def load_parameters
                     get_vals << v; true
                   end
                 end
-                store_parameter(key, get_vals, query_hash)
-                store_parameter(key, post_vals, form_hash)
+                store_parameter(query_hash, key, get_vals)
+                store_parameter(form_hash, key, post_vals)
               else
-                store_parameter(key, val, query_hash)
+                store_parameter(query_hash, key, val)
               end
             else # POST param :
-              store_parameter(key, val, form_hash)
+              store_parameter(form_hash, key, val)
             end
           end
           # Rack::Request#GET
@@ -112,9 +112,10 @@ def [](key)
         #
         # @param key the param name
         # @param val the value(s) in a array-like structure
-        # @param hash the Hash to store the name, value pair
-        def store_parameter(key, val, hash)
+        # @param params the Hash to store the name, value pair
+        def store_parameter2(params, key, val, depth = 0)
           # emulating Rack::Utils.parse_nested_query behavior
+          raise ::Rack::Utils::ParamsTooDeepError if depth >= 32
 
           if match = key.match(KEY_SEP)
             n_key = match[1]; sub = match[2]
@@ -124,25 +125,108 @@ def store_parameter(key, val, hash)
 
           if sub
             if sub.empty? # e.g. foo[]=1&foo[]=2
-              if arr = hash[ n_key ]
+              if arr = params[ n_key ]
                 return mark_parameter_error "expected Array (got #{arr.class}) for param `#{n_key}'" unless arr.is_a?(Array)
-                hash[ n_key ] = arr + val.to_a; return
+                params[ n_key ] = arr + val.to_a; return
               end
-              hash[ n_key ] = val.to_a # String[]
+              params[ n_key ] = val.to_a # String[]
             else # foo[bar]=rrr&foo[baz]=zzz
-              if hsh = hash[ n_key ]
+              if hsh = params[ n_key ]
                 return mark_parameter_error "expected Hash (got #{hsh.class}) for param `#{n_key}'" unless hsh.is_a?(Hash)
-                store_parameter(sub, val, hsh)
+                store_parameter2(hsh, sub, val, depth + 1)
               else
-                hash[ n_key ] = { sub => val[ val.length - 1 ] }
+                params[ n_key ] = { sub => val[ val.length - 1 ] }
               end
             end
           else
             # for 'foo=bad&foo=bar' does { 'foo' => 'bar' }
-            hash[ n_key ] = val[ val.length - 1 ] # last
+            params[ n_key ] = val[ val.length - 1 ] # last
           end
         end
 
+        def store_parameter3(params, key, val, depth = 0)
+          raise ::Rack::Utils::ParamsTooDeepError if depth >= 32
+
+          if !key
+            # nil name, treat same as empty string (required by tests)
+            n_key = after = ''
+          elsif depth == 0
+            # Start of parsing, don't treat [] or [ at start of string specially
+            if start = key.index('[', 1)
+              # Start of parameter nesting, use part before brackets as key
+              n_key = key[0, start]
+              after = key[start, key.length]
+            else
+              # Plain parameter with no nesting
+              n_key = key
+              after = ''
+            end
+          elsif key.start_with?('[]')
+            # Array nesting
+            n_key = '[]'
+            after = key[2, key.length]
+          elsif key.start_with?('[') && (start = key.index(']', 1))
+            # Hash nesting, use the part inside brackets as the key
+            n_key = key[1, start-1]
+            after = key[start+1, key.length]
+          else
+            # Probably malformed input, nested but not starting with [
+            # treat full name as key for backwards compatibility.
+            n_key = key
+            after = ''
+          end
+
+          return if n_key.empty?
+
+          if after == ''
+            if n_key == '[]' && depth != 0
+              return [val]
+            else
+              params[n_key] = val
+            end
+          elsif after == "["
+            params[key] = val
+          elsif after == "[]"
+            params[n_key] ||= []
+            return mark_parameter_error "expected Array (got #{params[n_key].class.name}) for param `#{n_key}'" unless params[n_key].is_a?(Array)
+            params[n_key] << val
+          elsif after.start_with?('[]')
+            # Recognize x[][y] (hash inside array) parameters
+            unless after[2] == '[' && after.end_with?(']') && (child_key = after[3, after.length-4]) && !child_key.empty? && !child_key.index('[') && !child_key.index(']')
+              # Handle other nested array parameters
+              child_key = after[2, after.length]
+            end
+            params[n_key] ||= []
+            return mark_parameter_error "expected Array (got #{params[n_key].class.name}) for param `#{n_key}'" unless params[n_key].is_a?(Array)
+
+            if params[n_key].last.is_a?(Hash) && !params_hash_has_key?(params[n_key].last, child_key)
+              store_parameter3(params[n_key].last, child_key, val, depth + 1)
+            else
+              params[n_key] << store_parameter3({ }, child_key, val, depth + 1)
+            end
+          else
+            params[n_key] ||= {}
+            return mark_parameter_error "expected Hash (got #{params[n_key].class.name}) for param `#{n_key}'" unless params[n_key].is_a?(Hash)
+            params[n_key] = store_parameter3(params[n_key], after, val, depth + 1)
+          end
+
+          params
+        end
+
+        def params_hash_has_key?(hash, key)
+          return false if /\[\]/.match?(key)
+
+          key.split(/[\[\]]+/).inject(hash) do |h, part|
+            next h if part == ''
+            return false unless h.is_a?(Hash) && h.key?(part)
+            h[part]
+          end
+
+          true
+        end
+
+        alias_method :store_parameter, (Rack.release >= '3' ? :store_parameter3 : :store_parameter2)
+
         COOKIE_STRING = "rack.request.cookie_string".freeze
         COOKIE_HASH = "rack.request.cookie_hash".freeze
 

src/spec/ruby/jruby/rack/booter_spec.rb

@@ -276,7 +276,7 @@
           case name.to_sym
           when :getRealPath then
             case args.first
-            when '/WEB-INF' then File.expand_path('rails30/WEB-INF', STUB_DIR)
+            when '/WEB-INF' then File.expand_path('rails30/WEB-INF', STUB_DIR) # FIXME: rails 3.0
             end
           when :getContextPath then
             '/'

src/spec/ruby/jruby/rack/integration_spec.rb

@@ -153,10 +153,10 @@
       end
       after(:all) { restore_rails }
 
-      it "loaded rack ~> 2.2.0" do
+      it "loaded default rack version" do
         @runtime = @rack_factory.getApplication.getRuntime
         should_eval_as_not_nil "defined?(Rack.release)"
-        should_eval_as_eql_to "Rack.release.to_s[0, 3]", '2.2'
+        should_eval_as_eql_to "%w(2.2 3.1 3.2).include? Rack.release.to_s[0, 3]", true
       end
 
       it "booted with a servlet logger" do
@@ -197,6 +197,7 @@
       end
 
       it "disables rack's chunked support (by default)" do
+        skip "Only runs on Rack < 3.0" unless Rack.release < '3'
         @runtime = @rack_factory.getApplication.getRuntime
         expect_to_have_monkey_patched_chunked
       end