hanami-action 3.0.0.rc1 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b9b156467d57f721bbaab92d9e6382db78ab4733c2aecb02062785cd7227cd40
-  data.tar.gz: 1a5baa55a4a80cd089ec9112068c3717584bd3c1a5bc620949409bb4b503025d
+  metadata.gz: cfd2248b12d546b250ad80e1c7115aa23dbcfab93eb7620dca331a4939af34f0
+  data.tar.gz: aa6a3f85fe8328a8e5d796be22b9d802cff6f74d643a8f1189f8cef89aafc3d8
 SHA512:
-  metadata.gz: f6b529f0489f57aca23fb72dba975bd325f4aed512a3b5bc00584e1836af453e52b14df01f98a6b627b042682fd47b856b0228d9efc16c5c85713dd680c5e1ef
-  data.tar.gz: f2aeb12850e6e8a87d0a7ded31936ff491692c39898c2239483a5e9bf1073dbae2efb637aa9d2cb0ac096a4083097ab56197a7bc0603a6d742c734e6ab8e494d
+  metadata.gz: 687db93c36b074e4015349842759091cbbb7fb35dda5f30ca1097cc629a1ee48767a2e3740ae54df491b4aee33e315b81e3e0e09a07b0fc0c37995f44c422a4f
+  data.tar.gz: 29676466bb1d6aba7f7724aadc8c4bdc80f04d7c02bcb11414ad507e09fb623e628b75a23892b7fc10876a8141c180e49443cd503f61c26122196b7e89731088

data/CHANGELOG.md

@@ -9,26 +9,69 @@ and this project adheres to [Break Versioning](https://www.taoensso.com/break-ve
 
 ### Added
 
-- Parse request bodies based on formats config. (@timriley in #500, #503, #511, @cllns in #508)
+### Changed
+
+### Deprecated
+
+### Removed
+
+### Fixed
+
+### Security
+
+[Unreleased]: https://github.com/hanami/hanami-action/compare/v3.0.0...HEAD
+
+## [3.0.0] - 2026-06-30
+
+### Added
+
+- Parse request bodies based on formats config. (@timriley in #500, #503, #511, #519, @cllns in #508)
 
     Parsers for multipart form bodies and JSON are included by default. These require `formats.accept :html` and `formats.accept :json` respectively. When no formats are configured, multipart form bodies are parsed if found.
 
     Custom parsers may be registered via e.g. `formats.register(:custom, "application/custom", parser: ->(body, env) { ... })` or directly via `formats.body_parsers["application/custom"] = parser`.
 
-    Parsed body keys are deeply symbolized. Non-hash bodies are wrapped in `{_: parsed_body}`.
+    Parsed body params are symbolized as part of becoming the `Hanami::Action::Params` instance. Non-hash bodies are wrapped in `{"_" => parsed_body}`.
+- Support additional `Cache-Control` directives in `response.cache_control`: `:immutable`, `:must_understand`, `stale_while_revalidate:` and `stale_if_error:`. (@timriley in #522)
 - Full JRuby support. (@katafrakt in #498)
 
 ### Changed
 
-### Deprecated
+- Renamed gem from hanami-controller to hanami-action. You should now `require "hanami-action"` or `require "hanami/action"`. (@timriley in #507, @cllns in df365b5)
+- Check for the dry-validation gem (instead of hanami-validations, which is now retired) before loading `Action.params` and `Action.contract` support. (@timriley in #505)
+- Raise `ArgumentError` from `response.cache_control` for unknown directives, instead of silently dropping them. (@timriley in #522)
+- Cache the action's resolved configuration as a frozen `Data` snapshot (via dry-configurable's `#to_data`) at initialization, avoiding repeated config lookups on the request hot path for improved memory usage and speed. Required bumping `dry-configurable` to `~> 1.4`. (@cllns in #512)
+
+  **Possibly breaking:** the action's config is now finalized (frozen) when the action is initialized, so mutating it from instance code is no longer possible. This was only ever an undocumented side-effect of implementation, not a supported pattern.
+- Cut per-request allocations on the `Hanami::Action#call` hot path, roughly halving allocations and increasing throughput ~1.5–2.5x per action invocation. A minimal action drops from 51 to 16 allocations (69% fewer, 2.45x faster); an action with formats negotiating an `Accept` header drops from 95 to 61 allocations (36% fewer, 1.55x faster). (@cllns in #514)
+- Require Ruby 3.3 or newer.
 
 ### Removed
 
-### Fixed
+- Removed deprecated format config methods: `Action.format`, `config.format`, `config.formats.add`, `config.formats.values`.  (@timriley in #504)
+- Removed `Hanami::Action::Params.params` and support for defining a contract by subclassing `Hanami::Action::Params`. If you are subclassing `Hanami::Action::Params`, take your params block and move it into a `Dry::Validation::Contract` subclass.  Then pass this contract class to `Hanami::Action.params` or `Hanami::Action.contract`. (@timriley in #513)
 
-### Security
+  ```ruby
+  # Before
+  # class SignupParams < Hanami::Action::Params
+  #   params do
+  #     required(:email).filled(:str?)
+  #   end
+  # end
+  
+  # After
+  class SignupContract < Dry::Validation::Contract
+    params do
+      required(:email).filled(:str?)
+    end
+  end
+  
+  class Signup < Hanami::Action
+    params SignupParams
+  end
+  ```
 
-[Unreleased]: https://github.com/hanami/hanami-action/compare/v3.0.0.rc1...HEAD
+[3.0.0]: https://github.com/hanami/hanami-action/compare/v2.3.2...v3.0.0
 
 ## [3.0.0.rc1] - 2026-06-16
 
@@ -50,7 +93,7 @@ and this project adheres to [Break Versioning](https://www.taoensso.com/break-ve
 - Cache the action's resolved configuration as a frozen `Data` snapshot (via dry-configurable's `#to_data`) at initialization, avoiding repeated config lookups on the request hot path for improved memory usage and speed. Required bumping `dry-configurable` to `~> 1.4`. (@cllns in #512)
 
   **Possibly breaking:** the action's config is now finalized (frozen) when the action is initialized, so mutating it from instance code is no longer possible. This was only ever an undocumented side-effect of implementation, not a supported pattern.
-- Cut per-request allocations on the `Hanami::Action#call` hot path, roughly halving allocations and increasing throughput ~1.5–2.5× per action invocation. A minimal action drops from 51 to 16 allocations (69% fewer, 2.45× faster); an action with formats negotiating an `Accept` header drops from 95 to 61 allocations (36% fewer, 1.55× faster). (@cllns in #514)
+- Cut per-request allocations on the `Hanami::Action#call` hot path, roughly halving allocations and increasing throughput ~1.5–2.5x per action invocation. A minimal action drops from 51 to 16 allocations (69% fewer, 2.45x faster); an action with formats negotiating an `Accept` header drops from 95 to 61 allocations (36% fewer, 1.55x faster). (@cllns in #514)
 - Require Ruby 3.3 or newer.
 
 ### Removed

data/lib/hanami/action/body_parser.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require "rack"
-require "hanami/utils/hash"
 
 module Hanami
   class Action
@@ -9,7 +8,7 @@ module Hanami
     #
     # @api private
     module BodyParser
-      FALLBACK_KEY = :_
+      FALLBACK_KEY = "_"
 
       class << self
         # rubocop:disable Metrics/AbcSize, Metrics/PerceivedComplexity
@@ -25,7 +24,7 @@ module Hanami
           if env.key?(ROUTER_PARSED_BODY)
             parsed = env[ROUTER_PARSED_BODY]
             env[ACTION_PARSED_BODY] = parsed
-            env[ACTION_BODY_PARAMS] = symbolize_body(parsed)
+            env[ACTION_BODY_PARAMS] = body_params(parsed)
             return
           end
 
@@ -59,7 +58,7 @@ module Hanami
           parsed = parser.call(body, env)
 
           env[ACTION_PARSED_BODY] = parsed
-          env[ACTION_BODY_PARAMS] = symbolize_body(parsed)
+          env[ACTION_BODY_PARAMS] = body_params(parsed)
         end
 
         # rubocop:enable Metrics/AbcSize, Metrics/PerceivedComplexity
@@ -83,25 +82,12 @@ module Hanami
           body
         end
 
-        # Symbolizes the parsed body, wrapping non-hash values in a fallback key.
-        def symbolize_body(parsed)
-          if parsed.is_a?(::Hash)
-            deep_symbolize(parsed)
-          else
-            {FALLBACK_KEY => deep_symbolize(parsed)}
-          end
-        end
-
-        # Recursively symbolizes hash keys within any structure (arrays or hashes).
-        def deep_symbolize(value)
-          case value
-          when ::Hash
-            Utils::Hash.deep_symbolize(value)
-          when ::Array
-            value.map { deep_symbolize(_1) }
-          else
-            value
-          end
+        # Wraps a parsed body into a hash suitable for merging into params.
+        #
+        # Hash bodies are returned as-is; non-hash bodies (e.g. JSON arrays) are wrapped under
+        # {FALLBACK_KEY}. Keys are left as strings. Symbolization happens in {Params}.
+        def body_params(parsed)
+          parsed.is_a?(::Hash) ? parsed : {FALLBACK_KEY => parsed}
         end
       end
     end

data/lib/hanami/action/config/formats.rb

@@ -31,7 +31,7 @@ module Hanami
         #
         # @return [Hash{String => #call}]
         #
-        # @since x.x.x
+        # @since 3.0.0
         # @api public
         attr_reader :body_parsers
 

data/lib/hanami/action/constants.rb

@@ -235,34 +235,40 @@ module Hanami
     # @api private
     RACK_INPUT = ::Rack::RACK_INPUT
 
-    # The key that returns a request body parsed by Hanami Action.
+    # The key that holds the body parser's verbatim output for the request.
     #
-    # This is the canonical key for body parsing.
+    # This holds whatever the parser returned, and may be any type (a hash for most bodies, but
+    # possibly an array or scalar for JSON bodies). It mirrors the router's {ROUTER_PARSED_BODY} as
+    # the faithful representation of the parsed body.
+    #
+    # For the params-ready form (always a hash, with keys merged into the request params), see
+    # {ACTION_BODY_PARAMS}.
     #
-    # @since x.x.x
     # @api private
     ACTION_PARSED_BODY = "hanami.action.parsed_body"
 
-    # The key that returns params from a parsed body by Hanami Action.
+    # The key that holds the parsed body normalized into a hash for merging into the request params.
+    #
+    # Hash bodies keep the string keys sent by the client; these are symbolized later by
+    # {Hanami::Action::Params}.. Non-Hash bodies (such as a top-level JSON array) are wrapped under
+    # `"_"` so they can still be merged.
     #
-    # This is the canonical key for parsed body params.
+    # For the parser's verbatim (possibly non-hash) output, see {ACTION_PARSED_BODY}.
     #
-    # @since x.x.x
     # @api private
     ACTION_BODY_PARAMS = "hanami.action.body_params"
 
     # The key that returns a request body parsed by Hanami Router.
     #
-    # This is maintained for backward compatibility with Hanami Router.
+    # This is maintained for compatibility with Hanami Router's body parser middlware.
     #
     # @api private
     ROUTER_PARSED_BODY = "router.parsed_body"
 
     # The key that returns router params from the Rack env.
     #
-    # This is maintained for backward compatibility with Hanami Router.
+    # This is maintained for compatibility with Hanami Router's body parser middlware.
     #
-    # @since 2.0.0
     # @api private
     ROUTER_PARAMS = "router.params"
 

data/lib/hanami/action/errors.rb

@@ -61,7 +61,7 @@ module Hanami
     # Error raised when body parsing fails.
     #
     # @api public
-    # @since x.x.x
+    # @since 3.0.0
     class BodyParsingError < Error
     end
 

data/lib/hanami/action/version.rb

@@ -8,6 +8,6 @@ module Hanami
     #
     # @since 3.0.0
     # @api public
-    VERSION = "3.0.0.rc1"
+    VERSION = "3.0.0"
   end
 end

data/lib/hanami/action.rb

@@ -288,7 +288,6 @@ module Hanami
     # exactly the same; Config-specific methods like `#handle_exception` are not available on
     # instances and must be called on the class config instead.
     #
-    # @since x.x.x
     # @api private
     private attr_reader :config
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: hanami-action
 version: !ruby/object:Gem::Version
-  version: 3.0.0.rc1
+  version: 3.0.0
 platform: ruby
 authors:
 - Hanakai team
@@ -147,7 +147,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.14
+rubygems_version: 3.6.9
 specification_version: 4
 summary: Complete, fast and testable actions for Rack and Hanami
 test_files: []