phlex-reactive 0.2.7 → 0.2.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 479ff63041e0a402939303aec9ea5fc8064dc0b01f5e63c8c58cfe989e5173b3
-  data.tar.gz: b81323095162d6b0662ff18b91b0c8cb34a8e2000028353c695e255ffa13093f
+  metadata.gz: 9b321b7411a892ec63333f9d85d988f7cf63609601386a03593efd736e88fb42
+  data.tar.gz: 00d40c394774eb54af634d328251f646a3fae1ac9bc0413ccbc89dd863608001
 SHA512:
-  metadata.gz: 80070c0e2868530f8499008a603e6f32c4815916fa34c4fccc050b3fb0772c0501ea27e569ee88ada9acb68d7f3eca5fc7333201fc3b9e4358780abd9b6e5d6a
-  data.tar.gz: 6412dc6000663fd888193bf9a1b071b9d2f1984692cac474217ebd4955f302e963103bb4bd5ad5c3407b351dfe69a5c2a7079fcdd04b65d73dfed34092c60765
+  metadata.gz: bd7a2129ec09c6b33a9f623f201037f5bc6639f7b097c95f521a6bf7ba4999b8dc8e11f53f2b922f5e617d0dfd8e2b0185cc5676e20f040a9caf97637d2d9438
+  data.tar.gz: b6e611eab9a2ab3f3d3a6afff9c4780061ba07321ddb5db89970e076facc9d7a374f7809fe8bc38958040c34303a42484eefe25109495bdfb2b6f894a597ae3e

data/CHANGELOG.md

@@ -31,6 +31,18 @@ adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ### Fixed
 
+- **Model-scoped form fields feed a nested param (issue #21).** A Rails
+  `Form(model: @invoice)` posts flat bracketed keys (`invoice[date]`,
+  `invoice[status]`) because the client keeps each input's `name` verbatim. The
+  server did exact-key matching, so a nested schema (`params: { invoice: { date:
+  :string } }`) looked for the literal key `"invoice"`, never found it, and
+  dropped the whole param. Param normalization now expands bracket notation
+  before coercion — `invoice[date]` nests under `invoice`, and
+  `items_attributes[0][qty]` becomes the Rails index-hash form the array coercer
+  already understands. A nested schema matches a normal Rails form with zero
+  field renaming, which is what makes the issue #16 nested-param types useful for
+  real forms. Pre-nested objects, plain scalars, and non-string values (a
+  checkbox boolean) pass through unchanged.
 - **Nested reactive roots no longer leak fields (issue #15).** When a reactive
   component is rendered inside another (both are `data-controller="reactive"`
   roots), an action on the outer root previously swept *every* descendant named

data/README.md

@@ -294,6 +294,18 @@ end
 Nested coercion recurses per field, drops undeclared nested keys, and accepts an
 array as either a JSON array or a Rails index hash (`{ "0" => …, "1" => … }`).
 
+**Model-scoped form fields just work.** A standard Rails `Form(model: @invoice)`
+names its inputs `invoice[date]`, `invoice[status]`, … and the client posts those
+names verbatim. A nested schema matches them with zero field renaming — the
+endpoint expands bracket notation before coercion, so `invoice[date]` nests under
+`invoice` and `invoice_items_attributes[0][qty]` becomes the index-hash form
+above:
+
+```ruby
+action :save, params: {invoice: {date: :string, status: :string}}
+# client posts { "invoice[date]": "…", "invoice[status]": "…" }  → save(invoice: { date:, status: })
+```
+
 **Nested reactive components compose.** A reactive component rendered inside
 another is its own root — field collection stops at nested
 `data-controller="reactive"` roots, so an outer action collects only *its own*

data/app/controllers/phlex/reactive/actions_controller.rb

@@ -201,12 +201,69 @@ module Phlex
       end
 
       # Unwrap ActionController::Parameters (or a plain Hash) to a string-keyed
-      # Hash so coercion can index it uniformly.
+      # Hash so coercion can index it uniformly, then expand bracket notation so
+      # a model-scoped Rails form's flat keys nest (issue #21).
       def to_param_hash(value)
-        return value.to_unsafe_h.stringify_keys if value.respond_to?(:to_unsafe_h)
-        return value.stringify_keys if value.is_a?(Hash)
+        flat =
+          if value.respond_to?(:to_unsafe_h)
+            value.to_unsafe_h.stringify_keys
+          elsif value.is_a?(Hash)
+            value.stringify_keys
+          else
+            return {}
+          end
+
+        expand_bracket_keys(flat)
+      end
+
+      # The client's #collectFields keeps a form input's name verbatim, so a
+      # Rails Form(model: @invoice) posts FLAT bracketed keys like
+      # "invoice[date]". Coercion does exact-key matching, so without this a
+      # nested schema (params: { invoice: { date: … } }) never finds "invoice"
+      # and drops everything. Expand "invoice[date]" => "2026-01-02" into
+      # { "invoice" => { "date" => "2026-01-02" } } — and "items[0][qty]" into
+      # the Rails index-hash form coerce_array already understands — deep-merging
+      # so sibling keys (invoice[date], invoice[status]) coalesce. Keys WITHOUT
+      # brackets and already-nested values pass through untouched, so a
+      # pre-nested object (issue #16) and plain scalars still work. Value types
+      # (a checkbox boolean, an explicit array) are preserved verbatim — unlike a
+      # round-trip through parse_nested_query, which only handles strings.
+      def expand_bracket_keys(flat)
+        flat.each_with_object({}) do |(key, value), out|
+          deep_assign(out, bracket_path(key), value)
+        end
+      end
+
+      # "invoice[items_attributes][0][qty]" => ["invoice", "items_attributes",
+      # "0", "qty"]. A key with no brackets is a single-element path.
+      def bracket_path(key)
+        return [key] unless key.include?("[")
+
+        head, rest = key.split("[", 2)
+        [head, *rest.scan(/[^\[\]]+/)]
+      end
+
+      # Walk/create nested hashes along `path`, then merge `value` at the leaf so
+      # a bracket key and a sibling pre-nested object coalesce regardless of which
+      # arrives first ({ "invoice[date]" => …, invoice: { status: … } } keeps
+      # both). #merge_value deep-merges hash/hash collisions and otherwise lets
+      # the later value win (a bracket key colliding with a flat scalar).
+      def deep_assign(hash, path, value)
+        *parents, leaf = path
+        node = parents.reduce(hash) do |acc, segment|
+          acc[segment] = {} unless acc[segment].is_a?(Hash)
+          acc[segment]
+        end
+        node[leaf] = merge_value(node[leaf], value)
+      end
+
+      # Combine an existing leaf value with a new one. Two hashes deep-merge (so
+      # bracket-expanded fields and a pre-nested object for the same key both
+      # survive); any other collision takes the new value.
+      def merge_value(existing, value)
+        return value unless existing.is_a?(Hash) && value.is_a?(Hash)
 
-        {}
+        existing.merge(value.stringify_keys) { |_k, old, new| merge_value(old, new) }
       end
 
       # Only components that opt into Reactive may be resolved. The signature

data/lib/phlex/reactive/version.rb

@@ -2,6 +2,6 @@
 
 module Phlex
   module Reactive
-    VERSION = "0.2.7"
+    VERSION = "0.2.8"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: phlex-reactive
 version: !ruby/object:Gem::Version
-  version: 0.2.7
+  version: 0.2.8
 platform: ruby
 authors:
 - Mikael Henriksson