turbo_form 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f7a0e172eb5fd1fceae6c061a577eb424636d03b818b4ac5468e2d917e40955b
+  data.tar.gz: 82872425eec773e4ed97db3e91c8935a6c125eeca95fd6f6214303ce86ddb0dd
+SHA512:
+  metadata.gz: ede619403754616875c64b0cd57f3a56b6bea8f4d2f4a4844ebecacef86fdce3ae16ea2f21022e0ea146c2f092ba69b43783a39ec0c8cba3f25e393b5dad97cd
+  data.tar.gz: 2a236bdc2ce28e7fbb0f7005b65b1472954d90a2581619bb311b2bf1b059e7d595afdcdbf2eefe38d3bb79cf4429104b994f6c0ded268499f86897ffa9cf4b17

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright Andy Cohen
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,173 @@
+# turbo_form
+
+Turbo-Stream backed 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
+action, a Stimulus controller and some wiring. This gem asks for two words
+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>
+<% 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 %>
+```
+
+That's the whole feature. No route, no controller, no JavaScript.
+
+## Installation
+
+```ruby
+gem "turbo_form"
+```
+
+There is nothing to mount and nothing to generate. On a stock Rails app —
+Propshaft, importmap-rails, stimulus-rails — the Stimulus controller registers
+itself. See [JavaScript](#javascript) if your app bundles with esbuild, Vite,
+Bun or webpack.
+
+## The two options
+
+### `dynamic:` on the form
+
+`dynamic: true` wires the form up and points it at
+`app/views/<resource dir>/dynamic_form.turbo_stream.*` — alongside the
+resource's own partial, so `widgets/_widget` gets `widgets/dynamic_form`.
+
+Pass a string to render something else instead:
+
+```erb
+<%= form_for @widget, dynamic: "shared/refresh_widget" %>
+```
+
+Works on `form_for` and `form_with` alike. Any template engine works — the
+template is resolved the way every other Rails template is, so `.slim` and
+`.haml` are fine.
+
+### `dynamic_trigger:` on a field
+
+```erb
+<%= f.text_field :name, dynamic_trigger: true %>       <%# on the default event %>
+<%= f.text_field :name, dynamic_trigger: :blur %>      <%# on a named event %>
+```
+
+`true` lets Stimulus pick the element's natural event: `change` for a select or
+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.
+
+Works on every Rails field helper, including the select and date families where
+Rails keeps HTML attributes in a separate hash:
+
+```erb
+<%= f.collection_select :category_id, Category.all, :id, :name, dynamic_trigger: true %>
+```
+
+### With SimpleForm
+
+turbo_form builds on `ActionView::Helpers::FormBuilder`, which SimpleForm
+inherits from, so it works without SimpleForm being involved at all:
+
+```slim
+= simple_form_for @widget, dynamic: true do |f|
+  = 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. builds a **new, unsaved** instance of the form's class from them,
+3. assigns it to `@resource`,
+4. renders the turbo_stream template.
+
+Nothing is persisted, and the resource is always freshly instantiated — even for
+an edit form. `@resource` exists to be asked what the form should now look like,
+not to be saved.
+
+The signature covers the class name, the parameter scope and the template. It is
+signed because the endpoint constantizes and renders what it names; none of that
+may come from the browser unverified.
+
+## Configuration
+
+```ruby
+# config/initializers/turbo_form.rb
+
+# The endpoint inherits from this, so your authentication applies to it. If your
+# ApplicationController enforces something the endpoint can't satisfy -- Pundit's
+# `verify_authorized`, say -- point this at a controller that doesn't.
+TurboForm.parent_controller = "ApplicationController"
+
+# Draw the route yourself instead.
+TurboForm.draw_routes = false
+```
+
+## JavaScript
+
+**importmap-rails** — nothing to do. The engine pins its controller as
+`controllers/turbo_form_controller`, which the `eagerLoadControllersFrom` /
+`lazyLoadControllersFrom` in a stock `app/javascript/controllers/index.js`
+registers as `turbo-form` on its own.
+
+If you hand-wrote that file, register it yourself:
+
+```js
+import TurboFormController from "controllers/turbo_form_controller"
+application.register("turbo-form", TurboFormController)
+```
+
+**esbuild, Vite, Bun, webpack** — install the npm package alongside the gem, at
+the same version, and register it:
+
+```bash
+yarn add turbo_form
+```
+```js
+import TurboFormController from "turbo_form"
+application.register("turbo-form", TurboFormController)
+```
+
+### Testing against it
+
+The controller counts completed round trips, so a system test can wait on one
+instead of sleeping:
+
+```ruby
+def expect_dynamic_form_request
+  form = find("[data-controller~='turbo-form']")
+  before = form["data-turbo-form-requests-value"].to_i
+  yield
+  assert_selector "[data-turbo-form-requests-value='#{before + 1}']"
+end
+```
+
+## 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, no loading state, no per-element URL
+override, and no hook for loading an existing record instead of building a new
+one. When you need those, write the action by hand — that path is still open,
+and this gem doesn't stand in front of it.
+
+## License
+
+MIT.

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/setup"
+
+APP_RAKEFILE = File.expand_path("test/dummy/Rakefile", __dir__)
+load "rails/tasks/engine.rake"
+
+require "bundler/gem_tasks"

data/app/assets/javascripts/turbo_form.js

@@ -0,0 +1,37 @@
+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.
+//
+// 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.
+export default class extends Controller {
+  static values = { url: String, requests: Number }
+
+  async submit() {
+    const response = await fetch(this.urlValue, {
+      method: "PATCH",
+      headers: this.#headers,
+      body: new FormData(this.element)
+    })
+
+    if (!response.ok) return
+
+    Turbo.renderStreamMessage(await response.text())
+
+    // Lets a system test wait on a completed round trip instead of sleeping.
+    this.requestsValue++
+  }
+
+  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
+  }
+}

data/app/controllers/turbo_form/dynamic_forms_controller.rb

@@ -0,0 +1,28 @@
+module TurboForm
+  # Renders a form again from the state the browser currently has it in.
+  #
+  # Nothing here is saved. The resource 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
+
+    def update
+      @resource = signature.model.new(form_params)
+
+      render template: signature.template_for(@resource), formats: :turbo_stream
+    end
+
+    private
+      def signature
+        @signature ||= TurboForm::Signature.verify(params[:signature])
+      end
+
+      def form_params
+        params.fetch(signature.scope, {}).permit!
+      end
+  end
+end

data/config/routes.rb

@@ -0,0 +1,10 @@
+# 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/config/turbo_form_importmap.rb

@@ -0,0 +1,5 @@
+# Keyed as `controllers/..._controller` so the stock
+# `eagerLoadControllersFrom("controllers", application)` in a Rails app finds it
+# and registers it as `turbo-form`, with nothing asked of the host. The asset
+# name is distinct so the host's own app/javascript/controllers can't shadow it.
+pin "controllers/turbo_form_controller", to: "turbo_form.js"

data/lib/tasks/turbo_form_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :turbo_form do
+#   # Task goes here
+# end

data/lib/turbo_form/engine.rb

@@ -0,0 +1,44 @@
+require "turbo-rails"
+require "turbo_form/form_helper"
+require "turbo_form/form_builder"
+require "turbo_form/signature"
+
+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
+    # here both registers ours and leaves the host able to override them.
+    # The guard keeps esbuild/vite/bun hosts booting; a `before:` naming an
+    # initializer that doesn't exist is itself harmless.
+    initializer "turbo_form.importmap", before: "importmap" do |app|
+      next unless app.config.respond_to?(:importmap)
+
+      app.config.importmap.paths << root.join("config/turbo_form_importmap.rb")
+      app.config.importmap.cache_sweepers << root.join("app/assets/javascripts")
+    end
+
+    # Propshaft puts every engine's app/assets/* on the load path by itself.
+    # Sprockets additionally wants the asset named, or the pin above silently
+    # resolves to nothing.
+    initializer "turbo_form.assets" do |app|
+      next unless app.config.respond_to?(:assets)
+
+      app.config.assets.precompile << "turbo_form.js"
+    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
+    # enough that the first form on the first request can miss the patch.
+    initializer "turbo_form.form_helpers" do
+      require "action_view"
+
+      ActionView::Helpers::FormHelper.prepend(TurboForm::FormHelper)
+      ActionView::Helpers::FormBuilder.prepend(TurboForm::FormBuilder)
+    end
+  end
+end

data/lib/turbo_form/form_builder.rb

@@ -0,0 +1,90 @@
+module TurboForm
+  # Prepended onto ActionView::Helpers::FormBuilder.
+  #
+  #   f.text_field :name, dynamic_trigger: true      # re-render on the default event
+  #   f.select :category, categories, {}, dynamic_trigger: :blur
+  #
+  # `dynamic_trigger:` always has to end up as a `data-action`, but where it
+  # *arrives* depends on the helper. Most treat their `options` hash as the tag's
+  # 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
+    def select(method, choices = nil, options = {}, html_options = {}, &block)
+      super(method, choices, *hoist_trigger(options, html_options), &block)
+    end
+
+    def collection_select(method, collection, value_method, text_method, options = {}, html_options = {})
+      super(method, collection, value_method, text_method, *hoist_trigger(options, html_options))
+    end
+
+    def grouped_collection_select(method, collection, group_method, group_label_method, option_key_method, option_value_method, options = {}, html_options = {})
+      super(method, collection, group_method, group_label_method, option_key_method, option_value_method, *hoist_trigger(options, html_options))
+    end
+
+    def collection_checkboxes(method, collection, value_method, text_method, options = {}, html_options = {}, &block)
+      super(method, collection, value_method, text_method, *hoist_trigger(options, html_options), &block)
+    end
+
+    def collection_radio_buttons(method, collection, value_method, text_method, options = {}, html_options = {}, &block)
+      super(method, collection, value_method, text_method, *hoist_trigger(options, html_options), &block)
+    end
+
+    def time_zone_select(method, priority_zones = nil, options = {}, html_options = {})
+      super(method, priority_zones, *hoist_trigger(options, html_options))
+    end
+
+    def weekday_select(method, options = {}, html_options = {})
+      super(method, *hoist_trigger(options, html_options))
+    end
+
+    def date_select(method, options = {}, html_options = {})
+      super(method, *hoist_trigger(options, html_options))
+    end
+
+    def time_select(method, options = {}, html_options = {})
+      super(method, *hoist_trigger(options, html_options))
+    end
+
+    def datetime_select(method, options = {}, html_options = {})
+      super(method, *hoist_trigger(options, html_options))
+    end
+
+    private
+      # Every other field helper -- generated and hand-written alike -- passes its
+      # attributes through here on the way to the tag.
+      def objectify_options(options)
+        super(absorb_trigger(options))
+      end
+
+      # A trailing `dynamic_trigger:` binds to `options` because Ruby folds bare
+      # keywords into the first optional positional hash -- but for these helpers
+      # that hash is the *select's* options, not the tag's. Carry it across.
+      # SimpleForm arrives on the other side, via `input_html:`, so take it from
+      # either.
+      def hoist_trigger(options, html_options)
+        return [ options, absorb_trigger(html_options) ] unless options.key?(:dynamic_trigger)
+
+        trigger = options[:dynamic_trigger]
+        [ options.except(:dynamic_trigger), absorb_trigger(html_options.merge(dynamic_trigger: trigger)) ]
+      end
+
+      def absorb_trigger(attributes)
+        return attributes unless attributes.key?(:dynamic_trigger)
+
+        trigger = attributes[:dynamic_trigger]
+        attributes = attributes.except(:dynamic_trigger)
+        return attributes unless trigger
+
+        data = (attributes[:data] || {}).dup
+        data[:action] = [ data[:action], stimulus_action_for(trigger) ].compact.join(" ")
+        attributes.merge(data: data)
+      end
+
+      # `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(trigger)
+        trigger == true ? "turbo-form#submit" : "#{trigger}->turbo-form#submit"
+      end
+  end
+end

data/lib/turbo_form/form_helper.rb

@@ -0,0 +1,38 @@
+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.
+    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.name,
+        scope: scope.to_s,
+        template: (dynamic unless dynamic == true)
+      )
+
+      wire_dynamic_form(options, signature)
+      super(model:, scope:, url:, format:, **options, &block)
+    end
+
+    private
+      # `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)
+        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/signature.rb

@@ -0,0 +1,43 @@
+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.
+  #
+  # Note that this identifies a *class*, not a record. Dynamic forms are usually
+  # editing something unsaved, which is also why GlobalID -- which requires a
+  # persisted record -- can't express it.
+  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
+
+    def initialize(model_name:, scope:, template: nil)
+      @model_name = model_name
+      @scope = scope
+      @template = template
+    end
+
+    def model = model_name.constantize
+
+    # By convention the template sits alongside the resource's own partial:
+    # `widgets/_widget` gets `widgets/dynamic_form`.
+    def template_for(resource)
+      template || File.join(File.dirname(resource.to_partial_path), "dynamic_form")
+    end
+
+    def to_s
+      TurboForm.verifier.generate({ model_name:, scope:, template: })
+    end
+    alias to_param to_s
+  end
+end

data/lib/turbo_form/version.rb

@@ -0,0 +1,3 @@
+module TurboForm
+  VERSION = "0.0.1"
+end

data/lib/turbo_form.rb

@@ -0,0 +1,31 @@
+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
+
+  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

@@ -0,0 +1,113 @@
+--- !ruby/object:Gem::Specification
+name: turbo_form
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Andy Cohen
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: actionview
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 7.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 7.1.0
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 7.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 7.1.0
+- !ruby/object:Gem::Dependency
+  name: railties
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 7.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 7.1.0
+- !ruby/object:Gem::Dependency
+  name: turbo-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.0.0
+description: Zero-configuration Turbo-Stream backed dynamic forms for Rails.
+email:
+- outlawandy@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- 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/tasks/turbo_form_tasks.rake
+- lib/turbo_form.rb
+- 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/version.rb
+homepage: https://github.com/outlawandy/turbo_form
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/outlawandy/turbo_form
+  source_code_uri: https://github.com/outlawandy/turbo_form
+  changelog_uri: https://github.com/outlawandy/turbo_form/blob/main/CHANGELOG.md
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.1'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.20
+specification_version: 4
+summary: Turbo-Stream backed dynamic forms, by convention.
+test_files: []