weft 0.1.0 → 0.2.0

data/lib/weft/resolver.rb

@@ -1,32 +1,60 @@
 # frozen_string_literal: true
 
+require "bigdecimal/util"
+
 module Weft
-  # Maps request params (string keys/values) to component attribute hashes.
-  # Coerces types based on attribute defaults. Future home of the reification
-  # step (wire primitives → rich objects).
+  # Projects a wire params hash (string or symbol keys) onto a component
+  # class's declared schema, coercing values with declared types.
+  # Components self-resolve at build time (see DSL::Params); the Router
+  # also calls this directly for error-path bookkeeping. Future home of
+  # the reification step (wire primitives → rich objects).
   class Resolver
-    def resolve(component_class, params)
-      component_class.attributes.each_with_object({}) do |(name, meta), result|
-        raw = params[name.to_s] || params[name]
-        result[name] = raw.nil? ? meta[:default] : coerce(raw, meta[:default])
+    # The declarable wire types, each self-describing: how to coerce a
+    # present wire value (permissive Ruby — never raises on malformed
+    # input), and the classes a declared default may already be an
+    # instance of (declaration-side validation lives in DSL::Params).
+    # Self-description is the seam a future registration API extends.
+    TYPES = {
+      string: { coerce: :to_s.to_proc, classes: [String] },
+      integer: { coerce: :to_i.to_proc, classes: [Integer] },
+      float: { coerce: :to_f.to_proc, classes: [Float] },
+      boolean: { coerce: ->(v) { [true, "true", "1"].include?(v) },
+                 classes: [TrueClass, FalseClass] },
+      decimal: { coerce: :to_d.to_proc, classes: [BigDecimal] }
+    }.freeze
+
+    class << self
+      def resolve(component_class, params)
+        component_class.params.each_with_object({}) do |(name, meta), result|
+          raw = fetch_raw(params, name)
+          result[name] = raw.nil? ? meta[:default] : coerce(raw, meta[:type])
+        end
       end
-    end
 
-    private
+      # Coerce only the keys actually present on the wire — no default fill.
+      # The construction-time source stack uses this to tell wire-satisfied
+      # keys apart from keys that fall through to lower sources.
+      def resolve_present(component_class, params)
+        component_class.params.each_with_object({}) do |(name, meta), result|
+          raw = fetch_raw(params, name)
+          result[name] = coerce(raw, meta[:type]) unless raw.nil?
+        end
+      end
+
+      private
 
-    def coerce(value, default)
-      case default
-      when Integer then value.to_i
-      when Float then value.to_f
-      when true, false then coerce_boolean(value)
-      else value
+      # Try both key shapes without `||` — a literal false must read as present.
+      def fetch_raw(params, name)
+        key = name.to_s
+        key = name unless params.key?(key)
+        params[key]
       end
-    end
 
-    def coerce_boolean(value) # rubocop:disable Naming/PredicateMethod
-      case value
-      when true, "true", "1" then true
-      else false
+      # A declared type: coerces via its TYPES entry; untyped params accept
+      # any value as-is.
+      def coerce(value, type)
+        entry = TYPES[type]
+        entry ? entry[:coerce].call(value) : value
       end
     end
   end

data/lib/weft/router/actions.rb

@@ -1,5 +1,10 @@
 # frozen_string_literal: true
 
+require "weft/dsl/sandbox"
+require "weft/params"
+require "weft/params/assembly"
+require "weft/redirect"
+
 module Weft
   class Router
     # Action-dispatch slice of the Router. Resolves a request path to a
@@ -9,9 +14,10 @@ module Weft
     # `render_error`; the small `render_action_error` wrapper sets the
     # destructive-swap header before delegating.
     #
-    # Depends on Router internals: `resolver`, `filtered_params`,
-    # `handle_redirect`, `apply_trigger_header`, `render_oob_includes`,
-    # `render_error`, `headers`.
+    # Depends on Router internals: `filtered_params`, `handle_redirect`,
+    # `apply_trigger_header`, `render_error`, `headers`, and the
+    # OOB-include slice's `render_companions` / `applicable_inclusions` /
+    # `explicitly_named_inclusions`.
     module Actions
       private
 
@@ -40,37 +46,115 @@ module Weft
         nil
       end
 
+      # State 1 — what the request composes from the wire before any of the
+      # component's own code runs — is the bag the first verb block sees, and
+      # it carries every door `build` reads: wire params, derivations (still
+      # lazy), and defines. Only `receives` is missing, and structurally so:
+      # an action request has no caller and no enclosing build to hand
+      # anything over.
+      #
+      # A failure is recovered from wherever the request had got to, walked
+      # from whoever was in charge at the time: the declarer's chain against
+      # state 1 while its callable runs, and — once the callable has returned
+      # and control has passed on — the rendering component's chain against
+      # state 2.
       def handle_action(action, component_class)
-        resolved_attrs = resolver.resolve(component_class, filtered_params)
-        attrs = Weft::Attributes.new(resolved_attrs)
-
-        returned = action.callable&.call(attrs)
+        state = Weft::Params::Assembly.for_request(component_class, filtered_params)
+        returned = Weft::DSL::Sandbox.run(state, &action.callable) if action.callable
         return handle_redirect(returned) if returned.is_a?(Weft::Redirect)
+      rescue StandardError => e
+        render_action_error(action, component_class, state || Weft::Params.new({}), e)
+      else
+        render_action_response(action, component_class, state, returned)
+      end
 
-        render_action_response(action, component_class, resolved_attrs, returned)
+      # One universe per request: the response renders against the request's
+      # own wire, with the callable's returned hash riding as an overlay —
+      # every component in the response (the rendered class, its nested
+      # children, OOB companions) resolves from the same substrate, and the
+      # delta overrides or clears wire values at any depth. The rendered
+      # class projects its own schema; the declaring class's resolution
+      # never crowns a new universe.
+      #
+      # Delete-swap actions skip the primary render entirely: htmx discards
+      # the body on a delete swap, and the component's record is typically
+      # gone by now. OOB includes still ride (a 200, never a 204 — htmx
+      # refuses to swap 204s, which would skip the delete itself).
+      def render_action_response(action, component_class, state, returned)
+        overlay = returned.is_a?(Hash) ? returned : {}
+        composed = state.overlay(overlay)
+        apply_trigger_header(component_class, action.name)
+        slots = Set.new
+        primary = build_action_primary(action, overlay, composed, slots)
+        (primary ? primary.to_s : "") +
+          render_companions(action_companions(action, component_class, primary, composed, overlay), slots)
       rescue StandardError => e
-        render_action_error(action, component_class, resolved_attrs || {}, e)
+        render_action_error(action, action.renders, composed, e)
+      end
+
+      # Which companions ride this response, in precedence order: the
+      # rendered component's first, then — on a transfer — the declaring
+      # component's explicitly named ones. One list, so two companions
+      # claiming a single DOM id are caught across the two sources and the
+      # rendered component's declaration keeps the slot.
+      def action_companions(action, component_class, primary, composed, overlay)
+        target = target_companions(action, component_class, primary, composed, overlay)
+        return target if action.renders.equal?(component_class)
+
+        target + declarer_companions(component_class, action.name, composed, overlay)
+      end
+
+      # The rendered component's companions: its block reads the primary's
+      # rendered bag (rich values included) and each one branches it.
+      def target_companions(action, component_class, primary, composed, overlay)
+        context = action.renders.equal?(component_class) ? :action : :transfer
+        env = { universe: filtered_params, overlays: overlay, branch_bag: primary&.params }
+        view = includes_view(primary, composed, overlay)
+        applicable_inclusions(action.renders, context, action.name).map { |inc| [inc, view, env] }
+      end
+
+      # The declaring component's companions on a transfer. This branch
+      # forks before the hand-off, so the block reads the declarer's own
+      # params plus the callable's overlay — never the target's picture —
+      # and there is no primary bag to branch, because nothing rendered the
+      # declarer and so no rich values exist on this path.
+      def declarer_companions(component_class, action_name, composed, overlay)
+        env = { universe: filtered_params, overlays: overlay }
+        explicitly_named_inclusions(component_class, action_name).map { |inc| [inc, composed, env] }
+      end
+
+      # Delete-swap actions skip the primary render: htmx discards the body
+      # on a delete swap, and the component's record is typically gone.
+      # The primary claims its DOM slot first, so a companion aimed at the
+      # same id is turned away rather than swapping over the very fragment
+      # the response is about.
+      #
+      # The primary branches the state the request has already composed, so a
+      # derivation the callable forced isn't paid for twice — and a transfer
+      # target inherits it exactly as a nested child inherits its parent's.
+      # Declared defaults don't ride a branch, so the target's own fallbacks
+      # stay its own; to override an inherited value, return the key (an
+      # explicit nil clears it).
+      def build_action_primary(action, overlay, composed, slots)
+        return nil if action.swap == :delete
+
+        build_component_with_wire(action.renders, filtered_params, overlays: overlay,
+                                                                   branch_bag: composed, slots: slots)
       end
 
-      # Successive resolution across the component-class boundary. The bag
-      # accumulates the declaring component's resolved attrs plus any hash the
-      # callable returned; the rendered class then runs its OWN resolution pass
-      # over the bag, so only its declared attributes reach the builder splat
-      # (closing the cross-class leak). The bag itself keeps every key so
-      # downstream OOB includes still see callable-returned attrs.
-      def render_action_response(action, component_class, resolved_attrs, returned)
-        bag = returned.is_a?(Hash) ? resolved_attrs.merge(returned) : resolved_attrs
-        apply_trigger_header(component_class)
-        html = action.renders.render(**resolver.resolve(action.renders, bag))
-        html + render_oob_includes(component_class, Weft::Attributes.new(bag), action_name: action.name)
+      # The params view an inclusion block receives: the rendered primary's
+      # bag with the overlay applied (undeclared delta keys stay readable).
+      # On a delete-swap there is no primary — the composed state stands in.
+      def includes_view(primary, composed, overlay)
+        primary ? primary.params.overlay(overlay) : composed
       end
 
       # Error handling for actions. Adds HX-Reswap header when the action's
       # swap strategy is destructive (e.g., :delete) so the error fragment
       # renders visibly instead of the element being silently removed.
-      def render_action_error(action, component_class, resolved_attrs, error)
+      def render_action_error(action, component_class, resolved_params, error)
         headers["HX-Reswap"] = "outerHTML" if action.swap == :delete
-        render_error(component_class, resolved_attrs, error)
+        render_error(component_class, resolved_params, error)
       end
     end
   end