hanami-controller 2.2.0.rc1 → 2.3.0.beta1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c1d4e9b1af736129911e894a09fe5d61c1a56c50ac56ef31d4e2a2d6da27b4dc
-  data.tar.gz: 9cb8f020dcd2fe5b7e5880293058c85b8fa6b74d49982035dbffcf5c0234ff06
+  metadata.gz: 16424b402710c09cc6727cf6ab94c84469edaa5d8e93f12d18c1f058cb973f00
+  data.tar.gz: '0639c98ced9c6f1cca83891bd74650f8dc6856e64490aa3a3321069810cd86a7'
 SHA512:
-  metadata.gz: 24b661dcdd3a9a75cb7842a12cd6fc8ad94a1aa814e0cb38cc89021583b9da5d5ae3d98a60fc43365b52ca537226e8a67c5bb572c9d6d884ad96a885e478e6f8
-  data.tar.gz: 9862fcb6a0f57e4dbaf5ceeb965df3c93d2b33e61da735b4ca906253dd7d3ff59dce188b545e939da23069ed8a984b80434200afebc575534ac4745a77dac976
+  metadata.gz: e353e4df54518fcdc9fc2ae60262b839772fdcc180335d56c3f451a26766dcfb31567ca6a45b852ffabe92e40638cdb1f259d55bb1539ec315bc15c2bfe70de7
+  data.tar.gz: 0434befd1175d44411ad2aa5b315ba5c212c69d47dbb2c6c990733ca07f1c4c3d1954139f21c0cd6b35d236f5be9f4b9293e286f50f189a3eac24069435fca1a

data/CHANGELOG.md

@@ -2,6 +2,27 @@
 
 Complete, fast and testable actions for Rack
 
+## v2.3.0.beta1 - 2025-10-03
+
+### Fixed
+
+- [wuarmin] Avoid false negatives in format/content type matches by checking against the request's media type, which excludes content type parameters (e.g. "test/plain" instead of "text/plain;charset=utf-8") (#471)
+
+### Added
+
+- [Wout] Add `Request#subdomains`, returning an array of subdomains for the current host, and `Request#subdomain` returning a dot-delimited subdomain string for the current host. Add `config.default_tld_length` setting for configuring the TLD length for your app's expected domain (#481)
+
+### Changed
+
+- [Kyle Plump, Tim Riley] Support Rack 3 in addition to Rack 2 (#460)
+- [Tim Riley] `request.session` is now an instance of `Hanami::Action::Request::Session`, which wraps the session object and provides access to session values via symbol keys. This was previously handled via symbolizing and reassigning the entire session hash, which is not compatible with Rack 3 (#477)
+
+## v2.2.0 - 2024-11-05
+
+### Added
+
+- [Tom de Bruijn, Tim Riley] When an action is called, add the action instance to the Rack environment under the `"hanami.action_instance"` key (#446)
+
 ## v2.2.0.rc1 - 2024-10-29
 
 ## v2.2.0.beta2 - 2024-09-25

data/README.md

@@ -54,8 +54,8 @@ They are the endpoints that respond to incoming HTTP requests.
 
 ```ruby
 class Show < Hanami::Action
-  def handle(req, res)
-    res[:article] = ArticleRepository.new.find(req.params[:id])
+  def handle(request, response)
+    response[:article] = ArticleRepository.new.find(request.params[:id])
   end
 end
 ```
@@ -63,7 +63,7 @@ end
 `Hanami::Action` follows the Hanami philosophy: a single purpose object with a minimal interface.
 
 In this case, `Hanami::Action` provides the key public interface of `#call(env)`, making your actions Rack-compatible.
-To provide custom behaviour when your actions are being called, you can implement `#handle(req, res)`
+To provide custom behaviour when your actions are being called, you can implement `#handle(request, response)`
 
 **An action is an object** and **you have full control over it**.
 In other words, you have the freedom to instantiate, inject dependencies and test it, both at the unit and integration level.
@@ -79,8 +79,8 @@ class Show < Hanami::Action
     super(configuration: configuration)
   end
 
-  def handle(req, res)
-    res[:article] = repository.find(req.params[:id])
+  def handle(request, response)
+    response[:article] = repository.find(request.params[:id])
   end
 
   private
@@ -96,16 +96,16 @@ action.call(id: 23)
 ### Params
 
 The request params are part of the request passed as an argument to the `#handle` method.
-If routed with *Hanami::Router*, it extracts the relevant bits from the Rack `env` (eg the requested `:id`).
+If routed with *Hanami::Router*, it extracts the relevant bits from the Rack `env` (e.g. the requested `:id`).
 Otherwise everything is passed as is: the full Rack `env` in production, and the given `Hash` for unit tests.
 
 With `Hanami::Router`:
 
 ```ruby
 class Show < Hanami::Action
-  def handle(req, *)
+  def handle(request, *)
     # ...
-    puts req.params # => { id: 23 } extracted from Rack env
+    puts request.params # => { id: 23 } extracted from Rack env
   end
 end
 ```
@@ -114,9 +114,9 @@ Standalone:
 
 ```ruby
 class Show < Hanami::Action
-  def handle(req, *)
+  def handle(request, *)
     # ...
-    puts req.params # => { :"rack.version"=>[1, 2], :"rack.input"=>#<StringIO:0x007fa563463948>, ... }
+    puts request.params # => { :"rack.version"=>[1, 2], :"rack.input"=>#<StringIO:0x007fa563463948>, ... }
   end
 end
 ```
@@ -125,9 +125,9 @@ Unit Testing:
 
 ```ruby
 class Show < Hanami::Action
-  def handle(req, *)
+  def handle(request, *)
     # ...
-    puts req.params # => { id: 23, key: "value" } passed as it is from testing
+    puts request.params # => { id: 23, key: "value" } passed as it is from testing
   end
 end
 
@@ -157,18 +157,18 @@ class Signup < Hanami::Action
     end
   end
 
-  def handle(req, *)
+  def handle(request, *)
     # Describe inheritance hierarchy
-    puts req.params.class            # => Signup::Params
-    puts req.params.class.superclass # => Hanami::Action::Params
+    puts request.params.class            # => Signup::Params
+    puts request.params.class.superclass # => Hanami::Action::Params
 
     # Whitelist :first_name, but not :admin
-    puts req.params[:first_name]     # => "Luca"
-    puts req.params[:admin]          # => nil
+    puts request.params[:first_name]     # => "Luca"
+    puts request.params[:admin]          # => nil
 
     # Whitelist nested params [:address][:line_one], not [:address][:line_two]
-    puts req.params[:address][:line_one] # => "69 Tender St"
-    puts req.params[:address][:line_two] # => nil
+    puts request.params[:address][:line_one] # => "69 Tender St"
+    puts request.params[:address][:line_two] # => nil
   end
 end
 ```
@@ -198,8 +198,8 @@ class Signup < Hanami::Action
     optional(:avatar).filled(size?: 1..(MEGABYTE * 3))
   end
 
-  def handle(req, *)
-    halt 400 unless req.params.valid?
+  def handle(request, *)
+    halt 400 unless request.params.valid?
     # ...
   end
 end
@@ -217,14 +217,14 @@ action = Show.new(configuration: configuration)
 action.call({}) # => #<Hanami::Action::Response:0x00007fe8be968418 @status=200 ...>
 ```
 
-This is the same `res` response object passed to `#handle`, where you can use its accessors to explicitly set status, headers, and body:
+This is the same `response` object passed to `#handle`, where you can use its accessors to explicitly set status, headers, and body:
 
 ```ruby
 class Show < Hanami::Action
-  def handle(*, res)
-    res.status  = 201
-    res.body    = "Hi!"
-    res.headers.merge!("X-Custom" => "OK")
+  def handle(*, response)
+    response.status  = 201
+    response.body    = "Hi!"
+    response.headers.merge!("X-Custom" => "OK")
   end
 end
 
@@ -239,8 +239,8 @@ By default, an action exposes the received params.
 
 ```ruby
 class Show < Hanami::Action
-  def handle(req, res)
-    res[:article] = ArticleRepository.new.find(req.params[:id])
+  def handle(request, response)
+    response[:article] = ArticleRepository.new.find(request.params[:id])
   end
 end
 
@@ -272,9 +272,9 @@ class Show < Hanami::Action
     # ...
   end
 
-  # `req` and `res` in the method signature is optional
-  def set_article(req, res)
-    res[:article] = ArticleRepository.new.find(req.params[:id])
+  # `request` and `response` in the method signature is optional
+  def set_article(request, response)
+    response[:article] = ArticleRepository.new.find(request.params[:id])
   end
 end
 ```
@@ -284,7 +284,7 @@ Callbacks can also be expressed as anonymous lambdas:
 ```ruby
 class Show < Hanami::Action
   before { ... } # do some authentication stuff
-  before { |req, res| res[:article] = ArticleRepository.new.find(req.params[:id]) }
+  before { |request, response| response[:article] = ArticleRepository.new.find(request.params[:id]) }
 
   def handle(*)
   end
@@ -332,15 +332,15 @@ You can also define custom handlers for exceptions.
 class Create < Hanami::Action
   handle_exception ArgumentError => :my_custom_handler
 
-  gle(*)
+  def handle(*)
     raise ArgumentError.new("Invalid arguments")
   end
 
   private
 
-  def my_custom_handler(req, res, exception)
-    res.status = 400
-    res.body   = exception.message
+  def my_custom_handler(request, response, exception)
+    response.status = 400
+    response.body   = exception.message
   end
 end
 
@@ -381,7 +381,7 @@ module Articles
 
     private
 
-    def handle_my_exception(req, res, exception)
+    def handle_my_exception(request, response, exception)
       # ...
     end
   end
@@ -395,7 +395,7 @@ module Articles
 
     private
 
-    def handle_standard_error(req, res, exception)
+    def handle_standard_error(request, response, exception)
       # ...
     end
   end
@@ -433,8 +433,8 @@ Alternatively, you can specify a custom message.
 
 ```ruby
 class Show < Hanami::Action
-  def handle(req, res)
-    res[:droid] = DroidRepository.new.find(req.params[:id]) or not_found
+  def handle(request, response)
+    response[:droid] = DroidRepository.new.find(request.params[:id]) or not_found
   end
 
   private
@@ -450,8 +450,8 @@ action.call({}) # => [404, {}, ["This is not the droid you're looking for"]]
 
 ### Cookies
 
-You can read the original cookies sent from the HTTP client via `req.cookies`.
-If you want to send cookies in the response, use `res.cookies`.
+You can read the original cookies sent from the HTTP client via `request.cookies`.
+If you want to send cookies in the response, use `response.cookies`.
 
 They are read as a Hash from Rack env:
 
@@ -462,9 +462,9 @@ require "hanami/action/cookies"
 class ReadCookiesFromRackEnv < Hanami::Action
   include Hanami::Action::Cookies
 
-  def handle(req, *)
+  def handle(request, *)
     # ...
-    req.cookies[:foo] # => "bar"
+    request.cookies[:foo] # => "bar"
   end
 end
 
@@ -481,9 +481,9 @@ require "hanami/action/cookies"
 class SetCookies < Hanami::Action
   include Hanami::Action::Cookies
 
-  def handle(*, res)
+  def handle(*, response)
     # ...
-    res.cookies[:foo] = "bar"
+    response.cookies[:foo] = "bar"
   end
 end
 
@@ -500,9 +500,9 @@ require "hanami/action/cookies"
 class RemoveCookies < Hanami::Action
   include Hanami::Action::Cookies
 
-  def handle(*, res)
+  def handle(*, response)
     # ...
-    res.cookies[:foo] = nil
+    response.cookies[:foo] = nil
   end
 end
 
@@ -523,9 +523,9 @@ end
 class SetCookies < Hanami::Action
   include Hanami::Action::Cookies
 
-  def handle(*, res)
+  def handle(*, response)
     # ...
-    res.cookies[:foo] = { value: "bar", max_age: 100 }
+    response.cookies[:foo] = { value: "bar", max_age: 100 }
   end
 end
 
@@ -537,7 +537,7 @@ action.call({}) # => [200, {"Set-Cookie" => "foo=bar; max-age=100;"}, "..."]
 
 Actions have builtin support for Rack sessions.
 Similarly to cookies, you can read the session sent by the HTTP client via
-`req.session`, and also manipulate it via `res.ression`.
+`request.session`, and also manipulate it via `response.session`.
 
 ```ruby
 require "hanami/controller"
@@ -546,9 +546,9 @@ require "hanami/action/session"
 class ReadSessionFromRackEnv < Hanami::Action
   include Hanami::Action::Session
 
-  def handle(req, *)
+  def handle(request, *)
     # ...
-    req.session[:age] # => "35"
+    request.session[:age] # => "35"
   end
 end
 
@@ -565,9 +565,9 @@ require "hanami/action/session"
 class SetSession < Hanami::Action
   include Hanami::Action::Session
 
-  def handle(*, res)
+  def handle(*, response)
     # ...
-    res.session[:age] = 31
+    response.session[:age] = 31
   end
 end
 
@@ -584,9 +584,9 @@ require "hanami/action/session"
 class RemoveSession < Hanami::Action
   include Hanami::Action::Session
 
-  def handle(*, res)
+  def handle(*, response)
     # ...
-    res.session[:age] = nil
+    response.session[:age] = nil
   end
 end
 
@@ -663,7 +663,7 @@ end
 
 If `resource.cache_key` is equal to `IfNoneMatch` header, then hanami will `halt 304`.
 
-An alterative to hashing based check, is the time based check:
+An alternative to hashing based check, is the time based check:
 
 ```ruby
 require "hanami/controller"
@@ -674,23 +674,23 @@ class ConditionalGetController < Hanami::Action
 
   def handle(*)
     # ...
-    fresh last_modified: resource.update_at
-    # => halt 304 with header IfModifiedSince = resource.update_at.httpdate
+    fresh last_modified: resource.updated_at
+    # => halt 304 with header IfModifiedSince = resource.updated_at.httpdate
   end
 end
 ```
 
-If `resource.update_at` is equal to `IfModifiedSince` header, then hanami will `halt 304`.
+If `resource.updated_at` is equal to `IfModifiedSince` header, then hanami will `halt 304`.
 
 ### Redirect
 
-If you need to redirect the client to another resource, use `res.redirect_to`:
+If you need to redirect the client to another resource, use `response.redirect_to`:
 
 ```ruby
 class Create < Hanami::Action
-  def handle(*, res)
+  def handle(*, response)
     # ...
-    res.redirect_to "http://example.com/articles/23"
+    response.redirect_to "http://example.com/articles/23"
   end
 end
 
@@ -702,9 +702,9 @@ You can also redirect with a custom status code:
 
 ```ruby
 class Create < Hanami::Action
-  def handle(*, res)
+  def handle(*, response)
     # ...
-    res.redirect_to "http://example.com/articles/23", status: 301
+    response.redirect_to "http://example.com/articles/23", status: 301
   end
 end
 
@@ -735,9 +735,9 @@ However, you can force this value:
 
 ```ruby
 class Show < Hanami::Action
-  def handle(*, res)
+  def handle(*, response)
     # ...
-    res.format = :json
+    response.format = :json
   end
 end
 
@@ -761,7 +761,7 @@ class Show < Hanami::Action
   end
 end
 
-# When called with "\*/\*"            => 200
+# When called with "*/*"              => 200
 # When called with "text/html"        => 200
 # When called with "application/json" => 200
 # When called with "application/xml"  => 415
@@ -771,23 +771,22 @@ You can check if the requested MIME type is accepted by the client.
 
 ```ruby
 class Show < Hanami::Action
-  def handle(req, res)
+  def handle(request, response)
     # ...
     # @_env["HTTP_ACCEPT"] # => "text/html,application/xhtml+xml,application/xml;q=0.9"
 
-    req.accept?("text/html")        # => true
-    req.accept?("application/xml")  # => true
-    req.accept?("application/json") # => false
-    res.format                      # :html
-
+    request.accept?("text/html")        # => true
+    request.accept?("application/xml")  # => true
+    request.accept?("application/json") # => false
+    response.format                     # :html
 
 
     # @_env["HTTP_ACCEPT"] # => "*/*"
 
-    req.accept?("text/html")        # => true
-    req.accept?("application/xml")  # => true
-    req.accept?("application/json") # => true
-    res.format                      # :html
+    request.accept?("text/html")        # => true
+    request.accept?("application/xml")  # => true
+    request.accept?("application/json") # => true
+    response.format                     # :html
   end
 end
 ```
@@ -811,9 +810,9 @@ response = action.call({ "HTTP_ACCEPT" => "application/custom" }) # => Content-T
 response.format                                                   # => :custom
 
 class Show < Hanami::Action
-  def handle(*, res)
+  def handle(*, response)
     # ...
-    res.format = :custom
+    response.format = :custom
   end
 end
 
@@ -833,9 +832,9 @@ configuration = Hanami::Controller::Configuration.new do |config|
 end
 
 class Csv < Hanami::Action
-  def handle(*, res)
-    res.format = :csv
-    res.body = Enumerator.new do |yielder|
+  def handle(*, response)
+    response.format = :csv
+    response.body = Enumerator.new do |yielder|
       yielder << csv_header
 
       # Expensive operation is streamed as each line becomes available

data/hanami-controller.gemspec

@@ -20,8 +20,8 @@ Gem::Specification.new do |spec|
   spec.metadata["rubygems_mfa_required"] = "true"
   spec.required_ruby_version = ">= 3.1"
 
-  spec.add_dependency "rack", "~> 2.0"
-  spec.add_dependency "hanami-utils", "~> 2.2.rc"
+  spec.add_dependency "rack", ">= 2.1"
+  spec.add_dependency "hanami-utils", "~> 2.3.0.beta1"
   spec.add_dependency "dry-configurable", "~> 1.0", "< 2"
   spec.add_dependency "dry-core", "~> 1.0"
   spec.add_dependency "zeitwerk", "~> 2.6"

data/lib/hanami/action/cache/cache_control.rb

@@ -13,6 +13,7 @@ module Hanami
         def self.included(base)
           base.class_eval do
             extend ClassMethods
+
             @cache_control_directives = nil
           end
         end

data/lib/hanami/action/cache/conditional_get.rb

@@ -86,7 +86,7 @@ module Hanami
 
         # @since 0.3.0
         # @api private
-        def fresh?
+        def fresh? # rubocop:disable Naming/PredicateMethod
           yield if @validations.any?(&:fresh?)
         end
 

data/lib/hanami/action/cache/expires.rb

@@ -13,6 +13,7 @@ module Hanami
         def self.included(base)
           base.class_eval do
             extend ClassMethods
+
             @expires_directives = nil
           end
         end

data/lib/hanami/action/config.rb

@@ -117,6 +117,24 @@ module Hanami
       #
       #   @since 0.4.0
 
+      # @!attribute [rw] default_tld_length
+      #
+      #   Sets the default TLD length for host names. It is used to extract the
+      #   subdomain(s) in `Request#subdomains`.
+      #
+      #   Defaults to 1.
+      #
+      #   @example
+      #     # For *.example.com
+      #     config.default_tld_length = 1
+      #
+      #     # Or for *.example.co.uk
+      #     config.default_tld_length = 2
+      #
+      #   @return [Integer] the number of subdomains
+      #
+      #   @since 2.3.0
+
       # @!attribute [rw] cookies
       #
       #   Sets default cookie options for all responses.

data/lib/hanami/action/constants.rb

@@ -50,14 +50,14 @@ module Hanami
     # @see http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.5
     # @see http://www.w3.org/Protocols/rfc2616/rfc2616-sec7.html
     ENTITY_HEADERS = {
-      "Allow" => true,
-      "Content-Encoding" => true,
-      "Content-Language" => true,
-      "Content-Location" => true,
-      "Content-MD5" => true,
-      "Content-Range" => true,
-      "Expires" => true,
-      "Last-Modified" => true,
+      "allow" => true,
+      "content-encoding" => true,
+      "content-language" => true,
+      "content-location" => true,
+      "content-md5" => true,
+      "content-range" => true,
+      "expires" => true,
+      "last-modified" => true,
       "extension-header" => true
     }.freeze
 
@@ -245,5 +245,9 @@ module Hanami
     # @since 2.0.0
     # @api private
     DEFAULT_CHARSET = "utf-8"
+
+    # @since 2.2.0
+    # @api private
+    ACTION_INSTANCE = "hanami.action_instance"
   end
 end

data/lib/hanami/action/errors.rb

@@ -82,7 +82,7 @@ module Hanami
             module MyApp
               class App < Hanami::App
                 # See Rack::Session::Cookie for options
-                config.sessions = :cookie, {**cookie_session_options}
+                config.actions.sessions = :cookie, {**cookie_session_options}
               end
             end
 

data/lib/hanami/action/mime.rb

@@ -222,11 +222,13 @@ module Hanami
         # @since 2.0.0
         # @api private
         def enforce_content_type(request, config)
-          content_type = request.content_type
+          # Compare media type (without parameters) instead of full Content-Type header
+          # to avoid false negatives (e.g., multipart/form-data; boundary=...)
+          media_type = request.media_type
 
-          return if content_type.nil?
+          return if media_type.nil?
 
-          return if accepted_mime_type?(content_type, config)
+          return if accepted_mime_type?(media_type, config)
 
           yield
         end

data/lib/hanami/action/params.rb

@@ -362,13 +362,7 @@ module Hanami
       # @since 0.7.0
       # @api private
       def _router_params(fallback = {})
-        env.fetch(ROUTER_PARAMS) do
-          if session = fallback.delete(Action::RACK_SESSION)
-            fallback[Action::RACK_SESSION] = Utils::Hash.deep_symbolize(session)
-          end
-
-          fallback
-        end
+        env.fetch(ROUTER_PARAMS, fallback)
       end
     end
   end

data/lib/hanami/action/rack/file.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require "rack/file"
+require "rack/files"
 
 module Hanami
   class Action
@@ -21,7 +21,7 @@ module Hanami
         # @since 0.4.3
         # @api private
         def initialize(path, root)
-          @file = ::Rack::File.new(root.to_s)
+          @file = ::Rack::Files.new(root.to_s)
           @path = path.to_s
         end
 

data/lib/hanami/action/rack_utils.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Hanami
+  class Action
+    # @since 2.2.0
+    # @api private
+    def self.rack_3?
+      defined?(::Rack::Headers)
+    end
+  end
+end

data/lib/hanami/action/request/session.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require "forwardable"
+
+module Hanami
+  class Action
+    class Request < ::Rack::Request
+      # Wrapper for Rack-provided sessions, allowing access using symbol keys.
+      #
+      # @since 2.3.0
+      # @api public
+      class Session
+        extend Forwardable
+
+        def_delegators \
+          :@session,
+          :clear,
+          :delete,
+          :empty?,
+          :size,
+          :length,
+          :each,
+          :to_h,
+          :inspect,
+          :keys,
+          :values
+
+        def initialize(session)
+          @session = session
+        end
+
+        def [](key)
+          @session[key.to_s]
+        end
+
+        def []=(key, value)
+          @session[key.to_s] = value
+        end
+
+        def key?(key)
+          @session.key?(key.to_s)
+        end
+
+        alias_method :has_key?, :key?
+        alias_method :include?, :key?
+
+        def ==(other)
+          Utils::Hash.deep_symbolize(@session) == Utils::Hash.deep_symbolize(other)
+        end
+
+        private
+
+        # Provides a fallback for any methods not handled by the def_delegators.
+        def method_missing(method_name, *args, &block)
+          if @session.respond_to?(method_name)
+            @session.send(method_name, *args, &block)
+          else
+            super
+          end
+        end
+
+        def respond_to_missing?(method_name, include_private = false)
+          @session.respond_to?(method_name, include_private) || super
+        end
+      end
+    end
+  end
+end

data/lib/hanami/action/request.rb

@@ -26,11 +26,12 @@ module Hanami
 
       # @since 2.0.0
       # @api private
-      def initialize(env:, params:, session_enabled: false)
+      def initialize(env:, params:, default_tld_length: 1, session_enabled: false)
         super(env)
 
         @params = params
         @session_enabled = session_enabled
+        @default_tld_length = default_tld_length
       end
 
       # Returns the request's ID
@@ -56,7 +57,7 @@ module Hanami
 
       # Returns the session for the request.
       #
-      # @return [Hash] the session object
+      # @return [Hanami::Request::Session] the session object
       #
       # @raise [MissingSessionError] if the session is not enabled
       #
@@ -70,7 +71,7 @@ module Hanami
           raise Hanami::Action::MissingSessionError.new("Hanami::Action::Request#session")
         end
 
-        super
+        @session ||= Session.new(super)
       end
 
       # Returns the flash for the request.
@@ -91,6 +92,31 @@ module Hanami
         @flash ||= Flash.new(session[Flash::KEY])
       end
 
+      # Returns the subdomains for the current host.
+      #
+      # @return [Array<String>]
+      #
+      # @api public
+      # @since 2.3.0
+      def subdomains(tld_length = @default_tld_length)
+        return [] if IP_ADDRESS_HOST_REGEXP.match?(host)
+
+        host.split(".")[0..-(tld_length + 2)]
+      end
+
+      IP_ADDRESS_HOST_REGEXP = /\A\d+\.\d+\.\d+\.\d+\z/
+      private_constant :IP_ADDRESS_HOST_REGEXP
+
+      # Returns the subdomain for the current host.
+      #
+      # @return [String]
+      #
+      # @api public
+      # @since 2.3.0
+      def subdomain(tld_length = @default_tld_length)
+        subdomains(tld_length).join(".")
+      end
+
       # @since 2.0.0
       # @api private
       def accept?(mime_type)

data/lib/hanami/action/response.rb

@@ -71,12 +71,15 @@ module Hanami
       # @api public
       def body=(str)
         @length = 0
-        @body   = EMPTY_BODY.dup
+        @body = EMPTY_BODY.dup
+
+        return if str.nil? || str == EMPTY_BODY
 
         if str.is_a?(::Rack::Files::BaseIterator)
           @body = str
+          buffered_body! # Ensure appropriate content-length is set
         else
-          write(str) unless str.nil? || str == EMPTY_BODY
+          write(str)
         end
       end
 

data/lib/hanami/action.rb

@@ -7,6 +7,7 @@ require "hanami/utils/kernel"
 require "hanami/utils/string"
 require "rack"
 require "rack/utils"
+require "hanami/action/rack_utils"
 require "zeitwerk"
 
 require_relative "action/constants"
@@ -61,6 +62,7 @@ module Hanami
     setting :formats, default: Config::Formats.new, mutable: true
     setting :default_charset
     setting :default_headers, default: {}, constructor: -> (headers) { headers.compact }
+    setting :default_tld_length, default: 1
     setting :cookies, default: {}, constructor: -> (cookie_options) {
       # Call `to_h` here to permit `ApplicationConfiguration::Cookies` object to be
       # provided when application actions are configured
@@ -312,7 +314,8 @@ module Hanami
         request  = build_request(
           env: env,
           params: params,
-          session_enabled: session_enabled?
+          session_enabled: session_enabled?,
+          default_tld_length: config.default_tld_length
         )
         response = build_response(
           request: request,
@@ -332,6 +335,10 @@ module Hanami
         _handle_exception(request, response, exception)
       end
 
+      # Before finishing, put ourself into the Rack env for third-party instrumentation tools to
+      # integrate with actions
+      env[ACTION_INSTANCE] = self
+
       finish(request, response, halted)
     end
 
@@ -557,7 +564,7 @@ module Hanami
     #
     #   # Both Content-Type and X-No-Pass are removed because they're not allowed
     def keep_response_header?(header)
-      ENTITY_HEADERS.include?(header)
+      ENTITY_HEADERS.include?(header.downcase)
     end
 
     # @since 2.0.0

data/lib/hanami/controller/version.rb

@@ -8,6 +8,6 @@ module Hanami
     #
     # @since 0.1.0
     # @api public
-    VERSION = "2.2.0.rc1"
+    VERSION = "2.3.0.beta1"
   end
 end

metadata

@@ -1,43 +1,42 @@
 --- !ruby/object:Gem::Specification
 name: hanami-controller
 version: !ruby/object:Gem::Version
-  version: 2.2.0.rc1
+  version: 2.3.0.beta1
 platform: ruby
 authors:
 - Luca Guidi
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-10-29 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '2.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '2.1'
 - !ruby/object:Gem::Dependency
   name: hanami-utils
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.2.rc
+        version: 2.3.0.beta1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.2.rc
+        version: 2.3.0.beta1
 - !ruby/object:Gem::Dependency
   name: dry-configurable
   requirement: !ruby/object:Gem::Requirement
@@ -193,7 +192,9 @@ files:
 - lib/hanami/action/mime/request_mime_weight.rb
 - lib/hanami/action/params.rb
 - lib/hanami/action/rack/file.rb
+- lib/hanami/action/rack_utils.rb
 - lib/hanami/action/request.rb
+- lib/hanami/action/request/session.rb
 - lib/hanami/action/response.rb
 - lib/hanami/action/session.rb
 - lib/hanami/action/validatable.rb
@@ -206,7 +207,6 @@ licenses:
 - MIT
 metadata:
   rubygems_mfa_required: 'true'
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -221,8 +221,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.22
-signing_key:
+rubygems_version: 3.6.9
 specification_version: 4
 summary: Complete, fast and testable actions for Rack and Hanami
 test_files: []