turbo_form 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e9cee9bf341b5d0a6bf59ac5334065a7c71f66c0cfe99636471af207054c6484
-  data.tar.gz: 6d60f46ff0e7e74e43ba80a6db207a7fc5d30cf79afb0a7baf5ca8fa3a08fad5
+  metadata.gz: c69a1768a1d65dd2bdfa4d77ea5e58ea239923d54280820b5197bec043376b91
+  data.tar.gz: 5958181f35cc5c6cfbdbd50c9a4da9eea692c5670867dfa86d55459355a07c08
 SHA512:
-  metadata.gz: 87318b7b8397c9e71d1754cea8b527f7d813865b6ad8d4101183494f8788815b1f77ea3a22053b0cfe7ec2418a9f644b21380bde114839ba98adf6b38d155241
-  data.tar.gz: b62767b018f4c05fce71f7af5060d68526d0c4bfb3f47d6b872405f89c879489f4d4320b93a09d2e55f452b3c158b3ac0af4520d8567788e6d32ee3548d5dbdd
+  metadata.gz: 76dbea8632fa0087c403cbaa95682fae7b16ed8c3370586007e873e4c7ad3277a06f73a436782834ffb8d2b81fa8302a4d7c3e61130e48adbf6dd28ebd53d6a4
+  data.tar.gz: c89bdf36b175d24708012a869ec06692217a38d8b0d3d889c1692dca95237a7ce0039d020cab93463d34491b452b0a8ce309b2cb969396d0a1662534e358861d

data/README.md

@@ -1,6 +1,6 @@
 # turbo_form
 
-Turbo-Stream backed dynamic forms for Rails, by convention.
+Dynamic forms for Rails, by convention.
 
 A form that needs to change as it is filled in — a dependent dropdown, a section
 that appears once you pick a type — usually costs you a route, a controller
@@ -10,26 +10,18 @@ instead:
 ```erb
 <%= form_for @widget, dynamic: true do |f| %>
   <%= f.select :category, @widget.categories, {}, dynamic_trigger: true %>
-
-  <div id="flavor-field">
-    <%= f.select :flavor, @widget.flavors %>
-  </div>
+  <%= f.select :flavor, @widget.flavors %>
 <% end %>
 ```
 
-Pick a category and the form is sent to the server as it currently stands. The
-server rebuilds `@resource` from what you typed and renders
-`app/views/widgets/dynamic_form.turbo_stream.erb`:
-
-```erb
-<%= fields model: @resource do |f| %>
-  <%= turbo_stream.update "flavor-field" do %>
-    <%= f.select :flavor, @resource.flavors %>
-  <% end %>
-<% end %>
-```
+Pick a category and the page reloads with the form as it currently stands. The
+form assigns what was typed to `@widget` before its fields render, so
+`@widget.flavors` answers for the category just picked. Turbo morphs the page in
+place, so focus, scroll and everything else typed survive the reload.
 
-That's the whole feature. No route, no controller, no JavaScript.
+That's the whole feature. No route, no controller action, no template, no
+JavaScript. The page is rendered by its own controller, so its authentication,
+authorization and partials are the ones it always had.
 
 ## Installation
 
@@ -37,9 +29,9 @@ That's the whole feature. No route, no controller, no JavaScript.
 gem "turbo_form"
 ```
 
-There is nothing to mount. On a stock Rails app — Propshaft, importmap-rails,
-stimulus-rails — the Stimulus controller registers itself and there is nothing
-to generate either. If your app bundles with esbuild, Vite, Bun or webpack:
+On a stock Rails app — Propshaft, importmap-rails, stimulus-rails — the Stimulus
+controller registers itself and there is nothing to generate. If your app
+bundles with esbuild, Vite, Bun or webpack:
 
 ```bash
 rails generate turbo_form:install
@@ -51,22 +43,9 @@ See [JavaScript](#javascript) for what that does and how to do it by hand.
 
 ### `dynamic:` on the form
 
-`dynamic: true` makes the form dynamic. When a trigger fires, the gem renders a
-template named `dynamic_form`, looked up just as the controller that rendered
-the form would look up one of its own views:
-
-- A form rendered by `WidgetsController` gets
-  `widgets/dynamic_form.turbo_stream.erb`.
-- If that doesn't exist, lookup follows controller inheritance, ending at
-  `application/dynamic_form.turbo_stream.erb`.
-- Partials resolve the same way, so `render "fields"` inside the template finds
-  `widgets/_fields`, just as it would in the form itself.
-
-To render a different template, pass its name instead of `true`:
-
-```erb
-<%= form_for @widget, dynamic: "shared/refresh_widget" %>
-```
+`dynamic: true` makes the form dynamic: on a reload, it assigns the submitted
+values under its scope to its object, via `assign_attributes`, before any field
+renders.
 
 ### `dynamic_trigger:` on a field
 
@@ -80,30 +59,6 @@ checkbox, `input` for a text field, `click` for a button. Name an event when you
 want something else — `:blur` on text fields is usually what you want, since the
 default fires on every keystroke.
 
-#### Sending the form somewhere else
-
-A trigger can answer to a different endpoint than its own form, and can add to
-what the form sends:
-
-```erb
-<%= f.button "Run", type: "button", dynamic_trigger: {
-      event: :click,
-      url: formula_preview_widgets_path,
-      params: { attribute: :rafter_count }
-    } %>
-```
-
-`url:` replaces the form's own endpoint for that one trigger; everything else on
-the form keeps using the form's. `params:` are appended to the submitted form
-data, so one endpoint can tell which of several triggers asked. Both are
-optional, and either can be given without the other.
-
-That endpoint is yours, not the gem's — it's an ordinary action rendering an
-ordinary turbo_stream template, so the whole form arrives as `params` under its
-usual scope. Use it when one form feeds several actions: a dozen fields that
-each preview themselves, or a select that belongs to a nested form with its own
-controller.
-
 Works on every Rails field helper, including the select and date families where
 Rails keeps HTML attributes in a separate hash:
 
@@ -121,85 +76,61 @@ inherits from, so it works without SimpleForm being involved at all:
   = f.input :category, input_html: { dynamic_trigger: true }
 ```
 
-## What the endpoint does
-
-A `dynamic: true` form carries a signed description of itself to a single
-endpoint the gem draws into your routes. Given a valid signature it:
-
-1. permits the submitted parameters wholesale,
-2. rebuilds the form's object and assigns them to it — an edit form's record is
-   found again by id, and a new form's object is rebuilt from the attributes it
-   was built with (a parent's foreign key from `@order.line_items.new`, say) before
-   the submitted ones are applied,
-3. assigns it to `@resource`,
-4. runs `TurboForm.before_render` inside the controller with the resource, if one is set,
-5. renders the turbo_stream template.
-
-Nothing is persisted. `@resource` exists to be asked what the form should now
-look like, not to be saved — and since Active Record saves some assignments on
-the spot (`has_many` writers, `*_ids=`), an Active Record resource is rebuilt
-inside a transaction that is always rolled back.
-
-The signature covers the class name, the parameter scope, the template, the view
-paths the form was rendered under, and the record's id or starting attributes. It is signed because the endpoint
-constantizes, loads and renders what it names; none of that may come from the
-browser unverified. It is not encrypted, so those starting attributes are
-readable in the page, as the form itself is.
-
-## Configuration
+## What a reload does
 
-```ruby
-# config/initializers/turbo_form.rb
-
-# The endpoint inherits from this, so your authentication applies to it. Point
-# it at a narrower controller when that inheritance brings something the
-# endpoint shouldn't have.
-TurboForm.parent_controller = "ApplicationController"
+A trigger visits the page's own URL with the form's fields in the query string,
+leaving out the authenticity token and `_method`, and marks the request with an
+`X-Turbo-Form` header. On the server:
 
-# Draw the route yourself instead.
-TurboForm.draw_routes = false
+1. the page's controller runs as it would for any visit, building `@widget` the
+   way it always does — found by id, built from a parent, whatever it does,
+2. the form assigns the submitted values to that object as it starts to render,
+3. the whole request runs inside a database transaction that is always rolled
+   back.
 
-# Run something before the render. See below.
-TurboForm.before_render = ->(resource) { }
-```
+Only a request carrying the header is assigned anything. A plain link can't set
+a header, and another origin can't without a CORS preflight, so a hand-crafted
+URL with form values in it renders the page as if they weren't there.
 
-### `before_render`
+The rollback is there because Active Record saves some assignments on the spot
+(`has_many` writers, `*_ids=`). A reload exists to render, so nothing it does is
+kept — including anything else the action writes.
 
-The endpoint is a controller you never wrote, inheriting filters written for
-controllers that save things. `before_render` is where you get to treat it like
-one of your own: it runs in a `before_action`, after the signature is verified
-and the resource is built, and is handed that resource. It runs *inside* the
-controller, so its protected helpers — Pundit's among them — are in reach.
+### Needing the values before the form
 
-Satisfy a filter the endpoint can't — the most common need, since nothing here
-is authorized because nothing here is saved:
+The form assigns as it starts to render, so everything from the form down — and
+the layout, which Rails renders after the template — sees what was typed. The
+controller, and anything in the template above the form, sees the object as it
+was built. When those need it too, assign in the action:
 
 ```ruby
-# Pundit's after_action :verify_authorized
-TurboForm.before_render = ->(resource) { skip_authorization }
-
-# Action Policy's verify_authorized
-TurboForm.before_render = ->(resource) { skip_verify_authorized! }
+def new
+  @widget = turbo_form_assign(Widget.new)
+end
 ```
 
-Or authorize it for real, if re-rendering a form is something you'd rather gate.
-Name the query explicitly: the endpoint's action is `update`, which is not the
-permission you mean.
+`turbo_form_assign` returns the object, assigns only on a reload, and takes
+`scope:` when the form's scope isn't the object's param key. The form assigns
+the same values again when it renders, which changes nothing.
 
-```ruby
-# Pundit
-TurboForm.before_render = ->(resource) { authorize resource, :edit? }
+### Switching an STI subclass
 
-# Action Policy
-TurboForm.before_render = ->(resource) { authorize! resource, to: :edit? }
+When the submitted values include the inheritance column, the form switches its
+object to the subclass it names, with `becomes`, before assigning — so a `type`
+select can turn a `Gizmo` into a `Doohickey` and the rest of the form answers
+as one. Give the form its base class's scope (`scope: :gadget`) so the switched
+object reads and posts under the same name.
 
-# CanCanCan -- this also satisfies `check_authorization`, which has no runtime skip
-TurboForm.before_render = ->(resource) { authorize! :edit, resource }
-```
+The switched object shares its attributes with the original, so everything
+outside the form sees the same values. To have it be the new subclass too, keep
+what `turbo_form_assign` returns — it switches the same way.
+
+### After a failed save
 
-Raising works the way it does in any `before_action`: your
-`rescue_from`s catch it, since the endpoint inherits them too. Rendering or
-redirecting halts the chain as usual.
+Rendering `:new` or `:edit` with `422` after a failed save leaves the browser on
+the form's own URL, since Turbo renders it without touching history — so a
+trigger reloads the right page. The reload builds a fresh object that has not
+been validated, so the error messages go away.
 
 ## JavaScript
 
@@ -238,7 +169,7 @@ To do it by hand, write that file yourself and run `rails stimulus:manifest:upda
 
 ### Testing against it
 
-A re-render is a round trip, so the line after a trigger is racing it. Wrap the
+A reload is a round trip, so the line after a trigger is racing it. Wrap the
 trigger and the wait comes with it:
 
 ```ruby
@@ -247,16 +178,23 @@ select "Barrel Aged", from: "Flavor"
 ```
 
 `expect_dynamic_form_request` is available in system tests with nothing to
-require or include — Minitest and RSpec both. It waits on the controller's
-count of completed round trips rather than on the fields that came back, so it
-doesn't care what the response changed. Scope it with Capybara's `within` when
-a page carries more than one dynamic form.
+require or include — Minitest and RSpec both. It waits on a count of
+completed reloads kept on `<html>` rather than on the fields that came back, so
+it doesn't care what the reload changed.
 
 ## What this deliberately doesn't do
 
-It handles the common case well and gets out of the way otherwise. There is no
-debouncing, no request cancellation and no loading state. When you need those, write the action by hand — that path is still open,
-and this gem doesn't stand in front of it.
+It handles the common case well and gets out of the way otherwise.
+
+- **No debouncing, request cancellation or loading state.** Write the action by
+  hand when you need those — that path is still open.
+- **The form rides in the URL.** Very large forms can hit URL length limits,
+  file inputs are left out, and what was typed lands in browser history and any
+  access log outside Rails' own parameter filtering.
+- **Only the primary database is rolled back**, and only writes: jobs enqueued
+  or mail sent during a reload still happen. A streamed response renders after
+  the transaction has closed.
+- **A form with Turbo turned off** reloads whatever URL a failed save left it on.
 
 ## License
 

data/app/assets/javascripts/turbo_form.js

@@ -1,44 +1,45 @@
 import { Controller } from "@hotwired/stimulus"
 import { Turbo } from "@hotwired/turbo-rails"
 
-// Re-renders the form it is attached to, from the server, as a Turbo Stream.
+// Never worth putting in a URL: the token is a secret, and the page's own
+// verb is GET whatever the form says.
+const UNSENT = new Set(["authenticity_token", "_method"])
+
+// Reloads the page with the form's current state in the query string. The
+// page's own action renders it again, and the form assigns that state to its
+// object on the way, so the whole page answers as the user now has it. The
+// header is what tells the server this is that reload and not an ordinary
+// visit to the same URL.
 //
-// The whole form is submitted so the server sees exactly the state the user is
-// looking at; nothing is saved, and the response only describes what should
-// change on screen.
+// A morphing refresh keeps focus and scroll, so it reads as the form updating
+// in place rather than as a navigation.
 export default class extends Controller {
-  static values = { url: String, requests: Number }
+  perform() {
+    const url = new URL(location.href)
+    const data = new FormData(this.element)
 
-  // A trigger can send the form somewhere other than the form's own endpoint,
-  // and can add to what it sends. Both ride in as Stimulus action params, so
-  // one form can feed several actions without needing several forms.
-  async perform({ params: { url, query } }) {
-    const body = new FormData(this.element)
+    for (const name of new Set(data.keys())) url.searchParams.delete(name)
+    for (const [name, value] of data) {
+      if (typeof value === "string" && !UNSENT.has(name)) url.searchParams.append(name, value)
+    }
 
-    if (query) Object.entries(query).forEach(([name, value]) => body.append(name, value))
+    const markReload = ({ detail: { url: requested, fetchOptions } }) => {
+      if (requested.href !== url.href) return
 
-    const response = await fetch(url || this.urlValue, {
-      method: "PATCH",
-      headers: this.#headers,
-      body
-    })
+      fetchOptions.headers["X-Turbo-Form"] = "reload"
+      document.removeEventListener("turbo:before-fetch-request", markReload)
+    }
 
-    if (!response.ok) return
-
-    Turbo.renderStreamMessage(await response.text())
-
-    // Lets a system test wait on a completed round trip instead of sleeping.
-    this.requestsValue++
+    document.addEventListener("turbo:before-fetch-request", markReload)
+    document.addEventListener("turbo:load", countVisit, { once: true })
+    Turbo.visit(url, { action: "replace", shouldCacheSnapshot: false, refresh: { method: "morph", scroll: "preserve" } })
   }
+}
 
-  get #headers() {
-    const headers = { Accept: "text/vnd.turbo-stream.html" }
-    const token = document.querySelector("meta[name=csrf-token]")?.content
-
-    // The form's own authenticity_token rides along in the body; this covers
-    // the forms that don't carry one.
-    if (token) headers["X-CSRF-Token"] = token
-
-    return headers
-  }
+// Kept on <html> because a morph rewrites <body> to what the server sent, and
+// the server never knows the count. Lets a system test wait on a completed
+// reload instead of sleeping.
+function countVisit() {
+  const root = document.documentElement.dataset
+  root.turboFormVisits = Number(root.turboFormVisits || 0) + 1
 }

data/lib/turbo_form/engine.rb

@@ -1,13 +1,9 @@
 require "turbo-rails"
 require "turbo_form/form_helper"
 require "turbo_form/form_builder"
-require "turbo_form/signature"
+require "turbo_form/reload"
 
 module TurboForm
-  # Deliberately *not* `isolate_namespace`: the template this engine renders
-  # belongs to the host, and isolating would point its route helpers at this
-  # engine's own (empty) route set -- so `widgets_path` in a host's
-  # dynamic_form template would raise.
   class Engine < ::Rails::Engine
     # importmap-rails reads config.importmap.paths exactly once, in its own
     # `importmap` initializer, and draws the host's pins last -- so appending
@@ -53,6 +49,11 @@ module TurboForm
       end
     end
 
+    initializer "turbo_form.reload" do |app|
+      app.middleware.use TurboForm::Reload::Middleware
+      ActiveSupport.on_load(:action_controller_base) { include TurboForm::Reload::Controller }
+    end
+
     # Deliberately eager rather than `ActiveSupport.on_load(:action_view)`: that
     # hook doesn't fire until Action View is first loaded, which in an app that
     # isn't eager loading is partway through rendering the first view -- late

data/lib/turbo_form/form_builder.rb

@@ -9,6 +9,15 @@ module TurboForm
   # HTML attributes; the select and date families keep those in a trailing
   # `html_options` instead, which is where these overrides earn their keep.
   module FormBuilder
+    # A dynamic form's trigger reloads the page with the form's current state in
+    # the query string. Assigning it here, before the form's block runs, lets
+    # every field -- and every question the form asks of its object -- answer
+    # as the user now has it.
+    def initialize(object_name, object, template, options)
+      super
+      @object = TurboForm::Reload.assign(object, @template.params[object_name]) if options[:dynamic] && TurboForm::Reload.requested?(@template.try(:request))
+    end
+
     def select(method, choices = nil, options = {}, html_options = {}, &block)
       super(method, choices, *hoist_trigger(options, html_options), &block)
     end
@@ -75,28 +84,14 @@ module TurboForm
         attributes = attributes.except(:dynamic_trigger)
         return attributes unless trigger
 
-        event, url, query = destructure_trigger(trigger)
-
         data = (attributes[:data] || {}).dup
-        data[:action] = [ data[:action], stimulus_action_for(event) ].compact.join(" ")
-        data[:turbo_form_url_param] = url if url
-        data[:turbo_form_query_param] = query if query
+        data[:action] = [ data[:action], stimulus_action_for(trigger) ].compact.join(" ")
         attributes.merge(data: data)
       end
 
-      # The short forms say when to fire and nothing else. The hash form also
-      # says where to send the form and what to send with it, which is what a
-      # field needs when it answers to a different action than its own form does.
-      def destructure_trigger(trigger)
-        return trigger.values_at(:event, :url, :params) if trigger.is_a?(Hash)
-
-        [ trigger, nil, nil ]
-      end
-
-      # `true` -- or a hash that names no event -- leaves the event off the
-      # descriptor so Stimulus binds the element's own default: `change` for a
-      # select, `input` for a text field, `click` for a button. Anything else is
-      # taken as the event name.
+      # `true` leaves the event off the descriptor so Stimulus binds the
+      # element's own default: `change` for a select, `input` for a text field,
+      # `click` for a button. Anything else is taken as the event name.
       def stimulus_action_for(event)
         event.nil? || event == true ? "turbo-form#perform" : "#{event}->turbo-form#perform"
       end

data/lib/turbo_form/form_helper.rb

@@ -2,49 +2,24 @@ module TurboForm
   # Prepended onto ActionView::Helpers::FormHelper.
   #
   #   form_for @widget, dynamic: true
-  #   form_for @widget, dynamic: "shared/refresh"   # render this template instead
   module FormHelper
-    # `form_for` ends in `form_with`, so overriding one covers both.
+    # `form_for` ends in `form_with`, so overriding one covers both. `dynamic:`
+    # stays in the options so the builder sees it; Rails slices the form tag's
+    # attributes out by name, so it never reaches the HTML.
     def form_with(model: false, scope: nil, url: nil, format: nil, **options, &block)
-      dynamic = options.delete(:dynamic)
-      return super unless dynamic
-
-      object = _object_for_form_builder(model)
-      raise ArgumentError, "form_for/form_with needs a :model to build a dynamic form from" unless object
-
-      scope ||= model_name_from_record_or_class(object).param_key
-      signature = TurboForm::Signature.new(
-        model_name: (object.class.try(:base_class) || object.class).name,
-        scope: scope.to_s,
-        template: (dynamic unless dynamic == true),
-        prefixes: lookup_context.prefixes,
-        **origin_of(object)
-      )
-
-      wire_dynamic_form(options, signature)
-      super(model:, scope:, url:, format:, **options, &block)
+      wire_dynamic_form(options) if options[:dynamic]
+      super
     end
 
     private
-      # A saved record is found again by id. An unsaved one is rebuilt from what
-      # it had already been given -- a parent's foreign key, say -- since the
-      # form may not submit that back. A plain form object with no dirty
-      # tracking has nothing to carry.
-      def origin_of(object)
-        return { id: object.id } if object.try(:persisted?)
-
-        { seed: object.try(:changes).to_h.transform_values(&:last) }
-      end
-
       # `form_for` funnels HTML attributes through options[:html] while `form_with`
       # takes them at the top level. Write wherever the caller already is, and sit
       # alongside any Stimulus controller they asked for rather than replacing it.
-      def wire_dynamic_form(options, signature)
+      def wire_dynamic_form(options)
         attributes = options.key?(:html) ? (options[:html] ||= {}) : options
         data = attributes[:data] ||= {}
 
         data[:controller] = [ data[:controller], "turbo-form" ].compact.join(" ")
-        data[:turbo_form_url_value] = turbo_form_path(signature)
       end
   end
 end

data/lib/turbo_form/reload.rb

@@ -0,0 +1,68 @@
+module TurboForm
+  # A dynamic trigger reloads its page with this header set. Only a request
+  # carrying it has its form's state assigned, and only such a request has its
+  # writes discarded -- one predicate for both, so the one can't happen without
+  # the other. A plain link can't set a header, and a cross-origin page can't
+  # without a CORS preflight, so a crafted URL assigns nothing.
+  module Reload
+    HEADER = "X-Turbo-Form"
+
+    def self.requested?(request) = request&.headers&.key?(HEADER)
+
+    # Answers with the object the form should now render, which is a different
+    # one when the submitted `type` picks another STI subclass.
+    def self.assign(object, submitted)
+      return object unless submitted.is_a?(ActionController::Parameters)
+
+      retype(object, submitted).tap { |record| record.assign_attributes(submitted.permit!) }
+    end
+
+    # Let `new` pick the subclass by Active Record's own STI rules, and switch
+    # before assigning so nested records land on the object that is kept.
+    # `becomes` shares its attributes with the original, so whoever still holds
+    # that one sees the same values, if not the subclass's behaviour.
+    def self.retype(object, submitted)
+      column = object.class.try(:inheritance_column)
+      return object unless column && submitted.key?(column)
+
+      subclass = object.class.base_class.new(column => submitted[column]).class
+      object.instance_of?(subclass) ? object : object.becomes(subclass)
+    end
+
+    # Included into ActionController::Base, for an action that needs the form's
+    # state before the form itself is rendered:
+    #
+    #   @widget = turbo_form_assign(Widget.new)
+    #
+    # The form assigns the same state again when it renders, which changes
+    # nothing. Keep what it returns: that is the switched object when the form
+    # picked another STI subclass.
+    module Controller
+      private
+        def turbo_form_assign(object, scope: object.model_name.param_key)
+          return object unless TurboForm::Reload.requested?(request)
+
+          TurboForm::Reload.assign(object, params[scope])
+        end
+    end
+
+    # Assigning to a saved record is not always inert -- Active Record saves
+    # `has_many` writers and `*_ids=` on the spot -- and a reload exists only to
+    # render, so nothing it does is kept.
+    class Middleware
+      def initialize(app) = @app = app
+
+      def call(env)
+        return @app.call(env) unless defined?(ActiveRecord::Base) && Reload.requested?(ActionDispatch::Request.new(env))
+
+        response = nil
+        ActiveRecord::Base.transaction do
+          # ponytail: a streamed body renders after this returns, outside the transaction
+          response = @app.call(env)
+          raise ActiveRecord::Rollback
+        end
+        response
+      end
+    end
+  end
+end

data/lib/turbo_form/system_test_helper.rb

@@ -1,23 +1,13 @@
 module TurboForm::SystemTestHelper
-  # Waits for a dynamic form to finish re-rendering itself.
-  #
-  # A trigger sends the form to the server and swaps part of it out when the
-  # response lands, so anything a test does on the next line is racing that
-  # response -- and loses often enough to be flaky rather than broken. The
-  # Stimulus controller counts completed round trips; waiting on that count is
-  # both cheaper and steadier than waiting on whichever field came back.
+  # Waits for a dynamic form to finish reloading the page.
   #
   #   expect_dynamic_form_request { select "Bourbon", from: "Category" }
   #   select "Barrel Aged", from: "Flavor"
-  #
-  # Scope it with Capybara's own `within` when a page carries more than one
-  # dynamic form.
   def expect_dynamic_form_request
-    form = page.find("[data-controller~='turbo-form']")
-    completed = form["data-turbo-form-requests-value"].to_i + 1
+    completed = page.find("html")["data-turbo-form-visits"].to_i + 1
 
     yield
 
-    page.assert_selector "[data-turbo-form-requests-value='#{completed}']"
+    page.assert_selector "html[data-turbo-form-visits='#{completed}']"
   end
 end

data/lib/turbo_form/version.rb

@@ -1,3 +1,3 @@
 module TurboForm
-  VERSION = "0.4.0"
+  VERSION = "0.5.0"
 end

data/lib/turbo_form.rb

@@ -1,39 +1,2 @@
-require "active_support/core_ext/module/attribute_accessors"
 require "turbo_form/version"
 require "turbo_form/engine"
-
-module TurboForm
-  # The controller the engine's endpoint inherits from. Defaulting to the host's
-  # own `ApplicationController` means its `before_action`s -- authentication
-  # above all -- apply to dynamic renders for free. Point it elsewhere when that
-  # inheritance brings something the endpoint shouldn't have.
-  mattr_accessor :parent_controller, default: "ApplicationController"
-
-  # Set to false to keep the engine out of the host's route set and draw its
-  # route yourself.
-  mattr_accessor :draw_routes, default: true
-
-  # Run as the body of a `before_action`, inside the endpoint, and handed the
-  # resource the form was rebuilt into. The endpoint is an inherited controller
-  # the host never wrote, so this is where it gets to treat it like one of its
-  # own: authorize the render, skip a filter the endpoint can't satisfy
-  # (`skip_authorization`), set something the template needs. Left alone, only
-  # the host's own inherited filters apply.
-  mattr_accessor :before_render
-
-  class << self
-    attr_writer :verifier
-
-    # Signs the description of a form so the endpoint can trust the class it is
-    # about to instantiate and the template it is about to render. Derived from
-    # the application's own key generator, the way SignedGlobalID is. `url_safe`
-    # so the token can live in a path segment; JSON so nothing Marshalled ever
-    # crosses the wire.
-    def verifier
-      @verifier ||= ActiveSupport::MessageVerifier.new(
-        Rails.application.key_generator.generate_key("turbo_form"),
-        url_safe: true, serializer: JSON
-      )
-    end
-  end
-end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: turbo_form
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Andy Cohen
@@ -76,8 +76,6 @@ files:
 - README.md
 - Rakefile
 - app/assets/javascripts/turbo_form.js
-- app/controllers/turbo_form/dynamic_forms_controller.rb
-- config/routes.rb
 - config/turbo_form_importmap.rb
 - lib/generators/turbo_form/install/install_generator.rb
 - lib/generators/turbo_form/install/templates/turbo_form_controller.js
@@ -86,7 +84,7 @@ files:
 - lib/turbo_form/engine.rb
 - lib/turbo_form/form_builder.rb
 - lib/turbo_form/form_helper.rb
-- lib/turbo_form/signature.rb
+- lib/turbo_form/reload.rb
 - lib/turbo_form/system_test_helper.rb
 - lib/turbo_form/version.rb
 homepage: https://github.com/outlawandy/turbo_form

data/app/controllers/turbo_form/dynamic_forms_controller.rb

@@ -1,56 +0,0 @@
-module TurboForm
-  # Renders a form again from the state the browser currently has it in.
-  #
-  # Nothing here is saved. The form's object is rebuilt only so the template can
-  # ask it what the form should now look like, which is why the parameters are
-  # taken whole: narrowing them would only make the re-rendered form disagree
-  # with what the user actually typed.
-  class DynamicFormsController < TurboForm.parent_controller.constantize
-    rescue_from TurboForm::Signature::Invalid do
-      head :bad_request
-    end
-
-    around_action :discard_writes
-    before_action :build_resource
-    before_action { instance_exec(@resource, &TurboForm.before_render) if TurboForm.before_render }
-
-    def update
-      render signature.template || "dynamic_form", formats: :turbo_stream
-    end
-
-    private
-      def build_resource
-        @resource = signature.rebuild(form_params)
-      end
-
-      # Assigning to a saved record is not always inert: Active Record saves
-      # `has_many` writers and `*_ids=` on the spot.
-      def discard_writes
-        return yield unless defined?(ActiveRecord::Base) && signature.model < ActiveRecord::Base
-
-        signature.model.transaction do
-          yield
-          raise ActiveRecord::Rollback
-        end
-      end
-
-      # Renders as if it were the controller that rendered the form, so the
-      # template's relative partials resolve the way the form's own did.
-      #
-      # Read while the lookup context is built, before `rescue_from` is in play,
-      # so a bad signature falls through here and is answered by the action.
-      def _prefixes
-        signature.prefixes
-      rescue TurboForm::Signature::Invalid
-        super
-      end
-
-      def signature
-        @signature ||= TurboForm::Signature.verify(params[:signature])
-      end
-
-      def form_params
-        params.fetch(signature.scope, {}).permit!
-      end
-  end
-end

data/config/routes.rb

@@ -1,10 +0,0 @@
-# Drawn straight into the host's route set so that installing the gem is the
-# whole installation -- there is nothing to mount. Set `TurboForm.draw_routes`
-# to false to take that over.
-#
-# PATCH rather than POST for two reasons: whole forms outgrow a query string,
-# and an edit form's `_method=patch` hidden field would make Rack rewrite a POST
-# out from under us.
-Rails.application.routes.draw do
-  patch "/turbo_form/:signature" => "turbo_form/dynamic_forms#update", as: :turbo_form
-end if TurboForm.draw_routes

data/lib/turbo_form/signature.rb

@@ -1,64 +0,0 @@
-module TurboForm
-  # A tamper-proof description of a dynamic form, carried in the URL the browser
-  # posts back to.
-  #
-  # It is signed because the endpoint acts on every word of it: `model_name` gets
-  # constantized and instantiated, `template` gets rendered. Neither may come
-  # from the client unverified.
-  #
-  # `prefixes` are the view paths the form was rendered under, so the endpoint
-  # can find its template and partials the way the form's own controller would.
-  #
-  # It also says where the form's object came from, so the endpoint can rebuild
-  # that object rather than a blank one: the `id` of a saved record, or the
-  # `seed` of attributes an unsaved one already had -- the `tank_id` of
-  # `@tank.rings.new` -- which the form itself may never submit.
-  class Signature
-    class Invalid < StandardError; end
-
-    def self.verify(token)
-      payload = TurboForm.verifier.verified(token.to_s)
-      raise Invalid, "not a signature this application generated" unless payload
-
-      new(**payload.symbolize_keys)
-    end
-
-    attr_reader :model_name, :scope, :template, :prefixes, :id, :seed
-
-    def initialize(model_name:, scope:, template: nil, prefixes: [], id: nil, seed: {})
-      @model_name = model_name
-      @scope = scope
-      @template = template
-      @prefixes = prefixes
-      @id = id
-      @seed = seed
-    end
-
-    def model = model_name.constantize
-
-    # The form's object as the user now has it. A new one is built in a single
-    # step so the submitted `type` picks its STI subclass.
-    def rebuild(params)
-      return model.new(seed.merge(params.to_h)) unless id
-
-      retype(model.find(id), params).tap { |resource| resource.assign_attributes(params) }
-    end
-
-    def to_s
-      TurboForm.verifier.generate({ model_name:, scope:, template:, prefixes:, id:, seed: })
-    end
-    alias to_param to_s
-
-    private
-      # `find` answers with the subclass that was saved, not the one just picked.
-      # Let `new` choose by Active Record's own STI rules, and switch before
-      # assigning so nested records land on the object that is kept.
-      def retype(record, params)
-        type = params.to_h.slice(model.try(:inheritance_column).to_s)
-        return record if type.empty?
-
-        subclass = model.new(type).class
-        record.instance_of?(subclass) ? record : record.becomes(subclass)
-      end
-  end
-end