phlex-reactive 0.11.5 → 0.11.7

data/lib/phlex/reactive/component/helpers.rb

@@ -793,8 +793,34 @@ module Phlex
         # The container cloned rows land in — one per association, inside the
         # root. Server-rendered rows (an edit form's persisted children) render
         # inside it too.
-        def reactive_nested_list(association)
-          { data: { reactive_nested_list: nested_identifier!(:reactive_nested_list, :association, association) } }
+        #
+        # `as: :json` (issue #208) switches the SUBMIT wire from Rails'
+        # accepts_nested_attributes_for names to ONE hidden JSON field — for an
+        # app whose controller already parses a serialized JSON param
+        # (`JSON.parse(params[:order][:todos])`) instead of nested attributes.
+        # The container keeps its plain marker (nestedAdd/Remove still key on
+        # it), and gains data-reactive-nested-json plus a scope-aware selector
+        # naming the hidden field the client mirrors the rows into on every
+        # add/remove/input. The default (:attributes) is unchanged — the plain
+        # accepts_nested_attributes_for wire.
+        def reactive_nested_list(association, as: :attributes)
+          name = nested_identifier!(:reactive_nested_list, :association, association)
+          data = { reactive_nested_list: name }
+          return { data: } if as == :attributes
+
+          unless as == :json
+            raise ArgumentError,
+              "reactive_nested_list(as:) takes :attributes (the default, Rails nested-attribute names) " \
+              "or :json (serialize the rows into one hidden JSON field), got #{as.inspect}"
+          end
+
+          # JSON mode: mark the container and name the hidden field the client
+          # keeps in sync — a scope-aware [name="…"] selector, the same
+          # convention reactive_tags/reactive_filter use so the field resolves
+          # under reactive_scope too.
+          data[:reactive_nested_json] = name
+          data[:reactive_nested_json_field] = %([name="#{scoped_field_name(association)}"])
+          { data: }
         end
 
         # The <template> holding ONE row's markup (server-owned, inert until
@@ -814,14 +840,58 @@ module Phlex
         # The add-a-row trigger — CLIENT-ONLY (no dispatch descriptor, no
         # POST). Forced type="button": a bare button inside the surrounding
         # real <form> would submit it.
-        def reactive_nested_add(association)
-          {
-            type: "button",
-            data: {
-              action: "click->reactive#nestedAdd",
-              reactive_association_param: nested_identifier!(:reactive_nested_add, :association, association)
-            }
+        #
+        # FILL-THEN-ADD (issue #208 Scenario A). By default add clones the
+        # template and focuses the new row's first field — INLINE-EDIT (you
+        # type INTO the row). But a common form shape puts the add controls
+        # OUTSIDE the row (a preset <select>, a typeahead, plain inputs) and
+        # "Add" SNAPSHOTS those values into a new row, then clears them for the
+        # next entry. `from:` expresses that: a map of ROW FIELD name => SOURCE
+        # CONTROL selector. On click the client fills each cloned-row field
+        # from its source's current value (matching the field by the trailing
+        # bracket segment of its name — the SAME key inference JSON mode uses,
+        # so the two agree), keeps focus on the sources, and (with `clear:
+        # true`) resets the sources. It composes with BOTH wire modes: the
+        # seeded values ride the renumbered `…_attributes[i][field]` names on
+        # submit (:attributes), and the end-of-add JSON sync serializes them
+        # (as: :json) with no extra wiring.
+        #
+        #   a(**reactive_nested_add(:items,
+        #     from: { name: "#item-name", quantity: "#item-qty" }, clear: true))
+        #
+        # `from:` values are RAW CSS selectors (the escape-hatch posture of
+        # reactive_filter/reactive_tags) — the sources are author-owned markup,
+        # not reactive_field bindings — resolved root-scoped (#15 ownership).
+        def reactive_nested_add(association, from: nil, clear: false)
+          data = {
+            action: "click->reactive#nestedAdd",
+            reactive_association_param: nested_identifier!(:reactive_nested_add, :association, association)
           }
+          unless from.nil?
+            data[:reactive_nested_from_param] = nested_from_param!(from)
+            # STRING "true", not boolean: a valueless boolean attr reads "" (falsy)
+            # client-side — the on()/tags precedent.
+            data[:reactive_nested_clear_param] = "true" if clear
+          end
+          { type: "button", data: }
+        end
+
+        # Validate + compile a fill-then-add `from:` map into its JSON wire
+        # (issue #208). Each key is a ROW FIELD name (plain identifier, like the
+        # association); each value is a SOURCE CONTROL selector (non-blank). An
+        # empty map is a dead binding — fail at render (the reactive_show_targets
+        # posture), never a silent no-op.
+        def nested_from_param!(from)
+          unless from.is_a?(Hash) && from.any?
+            raise ArgumentError,
+              "reactive_nested_add from: needs at least one row-field => source-selector pair " \
+              "(e.g. from: { quantity: \"#item-qty\" }), got #{from.inspect}"
+          end
+
+          from.to_h do |field, selector|
+            [nested_identifier!(:reactive_nested_add, :field, field),
+             filter_selector!(:reactive_nested_add_from, selector)]
+          end.to_json
         end
 
         # A row's remove trigger — client-only. Draft rows leave the DOM;
@@ -864,6 +934,22 @@ module Phlex
         #
         #   reactive_show_targets(mode: { "#advanced-tab" => "advanced" },
         #                         kind: { "#premium-note" => %w[gold platinum] })
+        #
+        # MULTI-FIELD targets (issue #209): a "#id" KEY takes a full
+        # if:/if_any:/unless: conditions Hash — the SAME language reactive_show
+        # speaks, so a cross-root target can finally read a COMBINATION of
+        # owned fields (the last case forcing a bespoke JS listener):
+        #
+        #   reactive_show_targets("#trade-warning" => {
+        #     if: { type: "trade", price: ..0 }   # type == "trade" AND price <= 0
+        #   })
+        #
+        # Target-keyed and field-keyed entries mix in the ONE call (a "#" key is
+        # unambiguous — a field name may never start with "#"). The client folds
+        # the target's DNF payload with the same per-term field reads as an
+        # in-root reactive_show: every referenced field must be OWNED by this
+        # root (a missing owned field reads as blank, fail-closed); a target
+        # whose fields are ALL unowned is left alone, like the single-field skip.
         def reactive_show_targets(field, targets = nil)
           field_maps = targets.nil? ? field : { field => targets }
           unless field_maps.is_a?(Hash) && field_maps.any?
@@ -873,16 +959,12 @@ module Phlex
           end
 
           normalized = field_maps.to_h do |name, map|
-            # Catch the forgotten-field-name misuse — reactive_show_targets(
-            # "#id" => {…}) — before the per-target validation turns it into a
-            # baffling "predicate" error.
             if name.to_s.start_with?("#")
-              raise ArgumentError,
-                "reactive_show_targets: #{name.inspect} looks like a target selector, not a field " \
-                "name — call reactive_show_targets(:field, #{name.inspect} => { ... })"
+              # Target-keyed conditions (issue #209): "#id" => { if:/if_any:/unless: }.
+              [name.to_s, normalize_show_target_conditions(name.to_s, map)]
+            else
+              [name.to_s, normalize_show_target_map(name, map)]
             end
-
-            [name.to_s, normalize_show_target_map(name, map)]
           end
 
           { data: { reactive_show_targets: normalized.to_json } }
@@ -1122,6 +1204,40 @@ module Phlex
           end
         end
 
+        # Normalize + validate ONE target-keyed entry (issue #209): the "#id"
+        # key is a single id selector (the same declare-time guard as
+        # field-keyed targets), the value a full if:/if_any:/unless: conditions
+        # Hash compiled by ShowConditions into the SAME { "any" => groups } DNF
+        # payload reactive_show emits. Anything else — a bare value, unknown
+        # keys, empty conditions — raises a guided error at render (a dead
+        # binding must never reach the browser).
+        def normalize_show_target_conditions(selector, conditions)
+          unless selector.match?(DSL::MIRROR_ID_SELECTOR)
+            raise ArgumentError,
+              "reactive_show_targets target #{selector.inspect} must be a single " \
+              "ID selector (\"#id\") — cross-root visibility is id-allowlisted, like mirror: (#159)"
+          end
+          unless conditions.is_a?(Hash) && conditions.any?
+            raise ArgumentError,
+              "reactive_show_targets: a target key takes a conditions Hash — " \
+              "reactive_show_targets(#{selector.inspect} => { if: { field: value, ... } }); " \
+              "to key by field instead: reactive_show_targets(:field, #{selector.inspect} => value). " \
+              "Got #{selector.inspect} => #{conditions.inspect}"
+          end
+          # Unknown keys are reported BEFORE the presence check so { bogus: 1 }
+          # names its offender instead of the generic shape message (specific
+          # beats generic). A non-empty hash surviving this subtraction holds
+          # only condition keys, so no separate presence check remains.
+          if (unknown = conditions.keys - SHOW_CONDITION_KEYS).any?
+            raise ArgumentError,
+              "reactive_show_targets #{selector.inspect}: unknown conditions key(s) " \
+              "#{unknown.map(&:inspect).join(", ")} — a target's conditions Hash takes only " \
+              "if:/if_any:/unless: (the reactive_show language)"
+          end
+
+          { "any" => Phlex::Reactive::ShowConditions.normalize(**conditions) }
+        end
+
         # Reject the removed 0.9.5 reactive_show surface (issue #180 clean break)
         # with a GUIDED error printing the if:/if_any:/unless: rewrite. A
         # positional field, a predicate kwarg (equals:/not:/in:/gte:/…), or a

data/lib/phlex/reactive/version.rb

@@ -2,6 +2,6 @@
 
 module Phlex
   module Reactive
-    VERSION = "0.11.5"
+    VERSION = "0.11.7"
   end
 end

metadata

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