Support only Rack 2.x with Rails, removing old 1.x rack/rails compat

Rack 2.x wraps the @env within @Req so previous overrides were not working correctly in all cases.

Author: chadlwilson

Gemfile

@@ -4,7 +4,7 @@ group :default do
   if rack_version = ENV['RACK_VERSION']
     gem 'rack', rack_version
   else
-    gem 'rack', '< 3.0'
+    gem 'rack', '~> 2.2', '< 3.0'
   end
 end
 

Gemfile.lock

@@ -29,7 +29,7 @@ PLATFORMS
 
 DEPENDENCIES
   appraisal (< 1.0)
-  rack (< 3.0)
+  rack (~> 2.2, < 3.0)
   rake (~> 13.2)
   rspec
 

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

@@ -10,74 +10,38 @@
 module JRuby::Rack
   module Session
 
-    if defined?(::Rack::Session::Abstract::SessionHash) # Rack 1.3+
+    class SessionHash < ::Rack::Session::Abstract::SessionHash
 
-      # as of rails 3.1.x the rack session hash implementation is used
-      # rather than the custom rails AbstractStore::SessionHash class
-      class SessionHash < ::Rack::Session::Abstract::SessionHash; end
-
-      # 1.5.0 removed SessionHash http://github.com/rack/rack/commit/83a270d64820
-      OptionsHash = if defined?(::Rack::Session::Abstract::OptionsHash)
-        ::Rack::Session::Abstract::OptionsHash
-      else nil
+      def enabled? # Rails 7.0 added a need for this in Sessions, and forgot to make it optional within flash middleware
+        true
       end
 
-    elsif defined?(ActionDispatch::Session::AbstractStore) # Rails 3.0
-
-      require 'active_support/core_ext/hash' # non-loaded SessionHash dependency
-
-      class SessionHash < ActionDispatch::Session::AbstractStore::SessionHash; end
-
-      OptionsHash = ActionDispatch::Session::AbstractStore::OptionsHash
-
-    else # a fallback for (old) Rails 2.3
-
-      class SessionHash < ActionController::Session::AbstractStore::SessionHash; end
-
-      OptionsHash = ActionController::Session::AbstractStore::OptionsHash
-
-    end
-
-    SessionHash.class_eval do
-
       # Allows direct delegation to servlet session methods when session is active
       def method_missing(method, *args, &block)
-        servlet_session = store.get_servlet_session(@env)
+        servlet_session = @store.get_servlet_session(@req.env)
         if servlet_session && servlet_session.respond_to?(method)
           servlet_session.send(method, *args, &block)
         else
           super
         end
       end
-
-      private
-      def store
-        @store ||= defined?(@store) ? @store : @by # Rack 1.5 renamed @by
-      end
-
     end
 
     # Rack based SessionStore implementation but compatible with (older) AbstractStore.
     class SessionStore < ::Rack::Session::Abstract::ID
 
-      ENV_SESSION_KEY = defined?(::Rack::Session::Abstract::ENV_SESSION_KEY) ?
-        ::Rack::Session::Abstract::ENV_SESSION_KEY : 'rack.session'.freeze
-
-      ENV_SESSION_OPTIONS_KEY = defined?(::Rack::Session::Abstract::ENV_SESSION_OPTIONS_KEY) ?
-        ::Rack::Session::Abstract::ENV_SESSION_OPTIONS_KEY : 'rack.session.options'.freeze
-
       ENV_SERVLET_SESSION_KEY = 'java.servlet_session'.freeze
-
       RAILS_SESSION_KEY = "__current_rails_session".freeze
 
       def initialize(app, options={})
         super(app, options.merge!(:cookie_only => false, :defer => true))
       end
 
-      def context(env, app = @app) # adapt Rack 1.1/1.2 to be compatible with 1.3+
-        prepare_session(env)
-        status, headers, body = app.call(env)
-        commit_session(env, status, headers, body)
+      def context(env, app = @app)
+        req = make_request env
+        prepare_session(req)
+        status, headers, body = app.call(req.env)
+        commit_session(req, status, headers, body)
       end
 
       # (public) servlet specific methods :
@@ -117,20 +81,9 @@ def generate_sid(secure = @sid_secure)
           nil # dummy method - no session id generation with servlet API
         end
 
-        def prepare_session(env) # exist since Rack 1.3
-          session_was = env[ENV_SESSION_KEY]
-          env[ENV_SESSION_KEY] = session_class.new(self, env)
-          if options_hash = ::JRuby::Rack::Session::OptionsHash
-            env[ENV_SESSION_OPTIONS_KEY] = options_hash.new(self, env, @default_options)
-          else
-            env[ENV_SESSION_OPTIONS_KEY] = @default_options.dup
-          end
-          env[ENV_SESSION_KEY].merge! session_was if session_was
-        end
-
-        def load_session(env, session_id = nil) # session_id arg for get_session alias
+        def load_session(req) # session_id arg for get_session alias
           session_id, session = false, {}
-          if servlet_session = get_servlet_session(env)
+          if servlet_session = get_servlet_session(req.env)
             begin
               session_id = servlet_session.getId
               servlet_session.synchronized do
@@ -152,42 +105,36 @@ def load_session(env, session_id = nil) # session_id arg for get_session alias
           end
           [ session_id, session ]
         end
-        alias :get_session :load_session # for AbstractStore::SessionHash compatibility
 
-        def extract_session_id(env)
-          servlet_session = get_servlet_session(env)
+        def extract_session_id(req)
+          servlet_session = get_servlet_session(req.env)
           servlet_session.getId rescue nil if servlet_session
         end
 
-        def current_session_id(env)
-          env[ENV_SESSION_OPTIONS_KEY][:id] # 1.5.0: env[ENV_SESSION_KEY].id
-        end if ::JRuby::Rack::Session::OptionsHash
-
-        def session_exists?(env)
-          value = current_session_id(env)
+        def session_exists?(req)
+          value = current_session_id(req)
           value && ! value.empty?
         end
-        alias :exists? :session_exists? # for AbstractStore::SessionHash compatibility
 
         def loaded_session?(session)
           ! session.is_a?(::JRuby::Rack::Session::SessionHash) || session.loaded?
         end
 
-        def commit_session(env, status, headers, body)
-          session = env[ENV_SESSION_KEY]
-          options = env[ENV_SESSION_OPTIONS_KEY]
+        def commit_session(req, status, headers, body)
+          session = req.env[::Rack::RACK_SESSION]
+          options = req.env[::Rack::RACK_SESSION_OPTIONS]
 
           if options[:drop] || options[:renew]
-            destroy_session(env, options[:id], options)
+            destroy_session(req.env, options[:id], options)
           end
 
           return [status, headers, body] if options[:drop] || options[:skip]
 
           if loaded_session?(session)
             session_id = session.respond_to?(:id=) ? session.id : options[:id]
             session_data = session.to_hash.delete_if { |_,v| v.nil? }
-            unless set_session(env, session_id, session_data, options)
-              env["rack.errors"].puts("WARNING #{self.class.name} failed to save session. Content dropped.")
+            unless set_session(req.env, session_id, session_data, options)
+              req.env["rack.errors"].puts("WARNING #{self.class.name} failed to save session. Content dropped.")
             end
           end
 
@@ -245,7 +192,6 @@ def destroy_session(env, session_id = nil, options = nil)
         rescue java.lang.IllegalStateException # if session already invalid
           nil
         end
-        alias :destroy :destroy_session # for AbstractStore::SessionHash compatibility
 
     end
 

src/spec/ruby/action_controller/session/java_servlet_store_spec.rb

@@ -32,10 +32,6 @@
     @session_store = ActionController::Session::JavaServletStore.new(@app)
   end
 
-  it "should raise an error if the servlet request is not present" do
-    expect { @session_store.call({}) }.to raise_error(RuntimeError)
-  end
-
   it "should do nothing if the session is not accessed" do
     @app.should_receive(:call)
     @session_store.call(@env)
@@ -95,7 +91,7 @@
     @request.should_receive(:getSession).with(false).and_return @session
     @app.should_receive(:call)
     @session_store.call(@env)
-    @session_store.send(:extract_session_id, @env).should == @session_id
+    expect(@session_store.send(:extract_session_id, Rack::Request.new(@env))).to eq @session_id
   end
 
   it "should retrieve the marshalled session from the java session" do
@@ -313,7 +309,7 @@ def new_session_hash(*args)
     else
       store = @session_store; env = args[0];
     end
-    ::JRuby::Rack::Session::SessionHash.new(store, env)
+    ::JRuby::Rack::Session::SessionHash.new(store, ::Rack::Request.new(env))
   end
 
 end if defined? Rails