hotwire_club-toolbox 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: '0950bbb3f4ecf3bcf29bffd1b773e3292226a24710d4022412c33d7d5a31ade3'
+  data.tar.gz: 17433199837db374317a62fccf830caade02cf4e8a7a6c94a2d5288952a21433
+SHA512:
+  metadata.gz: ec93a18015f5ef402f5b163f71bb49d772b84a141bf97d5f1f1d7de95dc945d4ada812b16b46959070709b5bba3308a7b811afab8a66b2f53d8558a8a50a54a7
+  data.tar.gz: a1f4e48daeb95574133cef520d10ff346ac560fddb225fc7a2646a7f08bc280881cd3942208fd699fd04ac341b0c0b93b5351e3f87d8c1b39ab9f85fcdf1db1b

data/CHANGELOG.md

@@ -0,0 +1,12 @@
+# Changelog
+
+All notable changes to this project are documented here.
+
+## [0.1.0]
+
+### Added
+- Initial release.
+- **Optimistic Form** tool: an optimistic-UI form builder for Turbo that paints
+  a predicted result on submit and reconciles with the server only on failure.
+  Includes a Stimulus controller, an install generator (importmap / jsbundling /
+  vite), and documentation in `docs/optimistic-form.md`.

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright Julian Rubisch
+
+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,34 @@
+# HotwireClub::Toolbox
+Short description and motivation.
+
+## Tools
+
+A collection of loosely connected Hotwire/Rails tools and techniques. Each has its own usage guide under [`docs/`](docs/).
+
+- **[Optimistic Form](docs/optimistic-form.md)** - optimistic UI for Turbo forms: paint the predicted result instantly on submit, reconcile with the server only on failure.
+
+## Usage
+How to use my plugin.
+
+## Installation
+Add this line to your application's Gemfile:
+
+```ruby
+gem "hotwire_club-toolbox"
+```
+
+And then execute:
+```bash
+$ bundle
+```
+
+Or install it yourself as:
+```bash
+$ gem install hotwire_club-toolbox
+```
+
+## Contributing
+Contribution directions go here.
+
+## License
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/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/helpers/hotwire_club/toolbox/optimistic_form_builder.rb

@@ -0,0 +1,48 @@
+module HotwireClub
+  module Toolbox
+    # Form builder that renders the optimistic-UI scaffolding: a hidden
+    # <template> holding the turbo-stream(s) the Stimulus controller paints on
+    # submit, and (optionally) a hidden field carrying the value being toggled.
+    class OptimisticFormBuilder < ActionView::Helpers::FormBuilder
+      # Sentinel used by OptimisticFormHelper's form defaults to distinguish
+      # "no value given" from a real nil/false value.
+      UNSET = Object.new
+
+      # Wraps the optimistic markup in a <template> the Stimulus controller
+      # clones into the DOM on `turbo:submit-start`.
+      #
+      #   form.optimistic_template "cart-count", @count + 1
+      #   form.optimistic_template { turbo_stream.update("cart-count") { ... } }
+      #
+      # Positional form builds a `turbo_stream.update` for you; block form lets
+      # you author the stream(s) yourself and ignores +target+/+template+.
+      def optimistic_template(target = nil, template = nil, &block)
+        content = if block
+          @template.capture(&block)
+        else
+          @template.turbo_stream.turbo_stream_action_tag(:update, target: target, template: template)
+        end
+
+        @template.content_tag("template", data: { optimistic_form_target: "template" }) do
+          content
+        end
+      end
+
+      # Explicit hidden field for the value being submitted. Calling this marks
+      # the field as rendered so the helper skips its automatic injection.
+      #
+      #   form.optimistic_hidden_field :favorite, value: !photo.favorite
+      #
+      # +value:+ is required (a value-less field would be meaningless); pass
+      # +false+ freely, only +nil+ renders an empty value.
+      def optimistic_hidden_field(attribute_name, value:)
+        @optimistic_hidden_field_rendered = true
+        hidden_field(attribute_name, value: value)
+      end
+
+      def optimistic_hidden_field_rendered?
+        !!@optimistic_hidden_field_rendered
+      end
+    end
+  end
+end

data/app/helpers/hotwire_club/toolbox/optimistic_form_helper.rb

@@ -0,0 +1,65 @@
+module HotwireClub
+  module Toolbox
+    # View helpers that wrap `form_with` / `form_for` with the optimistic-UI
+    # form builder and Stimulus wiring.
+    #
+    #   optimistic_form_for photo, attribute_name: :favorite, value: !photo.favorite do |form|
+    #     form.optimistic_template dom_id(photo, "favorite-button"), favorite_button_icon(!photo.favorite)
+    #     form.button { favorite_button_icon(photo.favorite) }
+    #   end
+    #
+    # Pass +attribute_name:+/+value:+ to have a hidden field injected
+    # automatically, or call +form.optimistic_hidden_field+ yourself to place it.
+    module OptimisticFormHelper
+      def optimistic_form_with(attribute_name: nil, value: OptimisticFormBuilder::UNSET, **options, &block)
+        options[:builder] = OptimisticFormBuilder
+        enrich_form_with_optimistic_options(options)
+
+        form_with(**options) do |form|
+          optimistic_form_body(form, attribute_name, value, &block)
+        end
+      end
+
+      def optimistic_form_for(record, attribute_name: nil, value: OptimisticFormBuilder::UNSET, **options, &block)
+        options[:builder] = OptimisticFormBuilder
+        enrich_form_with_optimistic_options(options)
+
+        form_for(record, **options) do |form|
+          optimistic_form_body(form, attribute_name, value, &block)
+        end
+      end
+
+      private
+
+      # Capture the block first so an explicit `form.optimistic_hidden_field`
+      # call inside it wins; only auto-inject when the caller supplied
+      # attribute_name/value and didn't render the field themselves.
+      def optimistic_form_body(form, attribute_name, value, &block)
+        body = capture(form, &block)
+
+        prefix = if auto_inject_hidden_field?(form, attribute_name, value)
+          form.optimistic_hidden_field(attribute_name, value: value)
+        end
+
+        safe_join([ prefix, body ].compact)
+      end
+
+      def auto_inject_hidden_field?(form, attribute_name, value)
+        attribute_name.present? &&
+          !value.nil? &&
+          !OptimisticFormBuilder::UNSET.equal?(value) &&
+          !form.optimistic_hidden_field_rendered?
+      end
+
+      def enrich_form_with_optimistic_options(options)
+        options[:html] ||= {}
+        options[:html][:data] ||= {}
+
+        options[:html][:data][:controller] =
+          [ options[:html][:data][:controller], "optimistic-form" ].compact.join(" ")
+        options[:html][:data][:action] =
+          [ options[:html][:data][:action], "turbo:submit-start->optimistic-form#apply turbo:submit-end->optimistic-form#refresh" ].compact.join(" ")
+      end
+    end
+  end
+end

data/app/javascript/hotwire_club/toolbox/helpers/timing_helpers.js

@@ -0,0 +1,29 @@
+// Timing helpers for Stimulus controllers.
+
+export function throttle(fn, delay = 1000) {
+  let timeoutId = null;
+
+  return (...args) => {
+    if (!timeoutId) {
+      fn.apply(this, args);
+      timeoutId = setTimeout(() => (timeoutId = null), delay);
+    }
+  };
+}
+
+export function debounce(fn, delay = 1000) {
+  let timeoutId = null;
+
+  return (...args) => {
+    clearTimeout(timeoutId);
+    timeoutId = setTimeout(() => fn.apply(this, args), delay);
+  };
+}
+
+export function nextFrame() {
+  return new Promise(requestAnimationFrame);
+}
+
+export function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}

data/app/javascript/hotwire_club/toolbox/optimistic_form_controller.js

@@ -0,0 +1,34 @@
+import { Controller } from "@hotwired/stimulus";
+import { throttle } from "hotwire_club/toolbox/helpers/timing_helpers";
+
+// Applies optimistic UI on form submit by cloning the form's <template>(s)
+// into the DOM (Turbo then processes the contained turbo-stream). On submit-end
+// it reconciles against the server only when the submission failed.
+export default class extends Controller {
+  static targets = ["template"];
+
+  initialize() {
+    // Throttle so the paint fires immediately, but a burst of rapid submits on
+    // the same form can't stack duplicate clones.
+    this.apply = throttle(this.apply.bind(this), 200);
+  }
+
+  apply() {
+    if (!this.hasTemplateTarget) return;
+
+    this.templateTargets.forEach((template) => {
+      document.body.appendChild(template.content.cloneNode(true));
+    });
+  }
+
+  refresh(event) {
+    // On success the optimistic paint already reflects the new state; only
+    // refresh to reconcile when the server rejected the submission.
+    if (event.detail?.success) return;
+
+    document.body.insertAdjacentHTML(
+      "beforeend",
+      '<turbo-stream action="refresh"></turbo-stream>',
+    );
+  }
+}

data/config/importmap.rb

@@ -0,0 +1,2 @@
+pin "hotwire_club/toolbox/optimistic_form_controller", to: "hotwire_club/toolbox/optimistic_form_controller.js"
+pin "hotwire_club/toolbox/helpers/timing_helpers", to: "hotwire_club/toolbox/helpers/timing_helpers.js"

data/config/routes.rb

@@ -0,0 +1,2 @@
+Rails.application.routes.draw do
+end

data/docs/optimistic-form.md

@@ -0,0 +1,155 @@
+# Optimistic Form
+
+Optimistic UI for Turbo forms. You author the optimistic update as a Turbo Stream inside a `<template>`; on submit, a Stimulus controller clones it into the DOM so Turbo paints it instantly, then reconciles against the server only if the request fails.
+
+Because the optimistic update and the server response speak the same Turbo Stream vocabulary, there is one mental model and no bespoke DOM patching.
+
+## Installation
+
+The tool ships with the `hotwire_club-toolbox` engine. Add the gem, then run the installer:
+
+```bash
+bin/rails generate hotwire_club:toolbox:optimistic_form:install
+```
+
+The generator detects your JavaScript setup and wires the Stimulus controller:
+
+- **importmap** (the module is pinned by the engine): adds an import and `application.register("optimistic-form", …)` to `app/javascript/controllers/index.js`.
+- **jsbundling (esbuild/bun/rollup) or vite**: copies `optimistic_form_controller.js` and `helpers/timing_helpers.js` into `app/javascript/`, rewriting the import to a relative path, and registers the controller.
+
+It also ensures the Turbo morph refresh meta tags (see Prerequisites) are present in your layout.
+
+### Prerequisites
+
+- **Turbo and Stimulus** in the host app.
+- **Turbo morph page refreshes.** Reconciliation on failure uses a Turbo refresh, which must morph (not hard reload) to be seamless. The generator adds these to your layout `<head>`:
+
+  ```html
+  <meta name="turbo-refresh-method" content="morph">
+  <meta name="turbo-refresh-scroll" content="preserve">
+  ```
+
+## Basic usage
+
+A favorite toggle. The `optimistic_template` predicts the toggled state; the button shows the current one:
+
+```erb
+<%= optimistic_form_for photo, attribute_name: :favorite, value: !photo.favorite do |form| %>
+  <%= form.optimistic_template dom_id(photo, "favorite-button-icon"), favorite_button_icon(!photo.favorite) %>
+  <%= form.button do %><%= favorite_button_icon(photo.favorite) %><% end %>
+<% end %>
+```
+
+An add-to-cart button that bumps a counter elsewhere on the page:
+
+```erb
+<%= optimistic_form_with url: carts_update_path, method: :patch, attribute_name: :photo_id, value: photo.id do |form| %>
+  <%= form.optimistic_template "cart-items-count", (@cart_items_count + 1) %>
+  <%= form.button "Add to cart" %>
+<% end %>
+```
+
+`attribute_name:`/`value:` inject a hidden field carrying the submitted value (see [Hidden field](#hidden-field)).
+
+## The reconciliation model
+
+- **On submit-start**, the controller clones the form's `<template>`(s) into the document. Turbo processes the contained stream and paints the optimistic state.
+- **On submit-end**, the controller reconciles **only if the submission failed** (`event.detail.success === false`). On success the optimistic paint already reflects the new state, so nothing happens.
+
+This keeps the happy path free of extra requests. A full page refresh only ever runs when the server rejects the change, which is exactly when you want authoritative truth.
+
+## Server contract
+
+Because success trusts the optimistic paint and failure triggers a client refresh, your controller must respond accordingly:
+
+- **Success:** `head :no_content` (204), or a targeted Turbo Stream (see below). **Do not redirect.** A redirect combined with morph refreshes is itself a full reload, which defeats the optimism.
+- **Failure:** respond `4xx`/`422` so `event.detail.success` is false and the client reconciles. Set a flash if you want it surfaced after the refresh.
+
+```ruby
+def update
+  @photo = Photo.find(params[:id])
+
+  if @photo.update(photo_params)
+    head :no_content
+  else
+    flash[:alert] = "Your changes could not be saved."
+    head :unprocessable_entity
+  end
+end
+```
+
+### Authoritative correction on success (opt-in)
+
+If the true value can differ from your prediction under contention (for example a shared counter), return a targeted Turbo Stream on success. Turbo applies it over the optimistic guess; no client change is needed. To keep the prediction and the truth from drifting, render the reconcilable fragment from a **single partial** used in both places:
+
+```erb
+<%# app/views/photos/_favorite_button.html.erb (single source of truth) %>
+<span id="<%= dom_id(photo, "favorite-button-icon") %>"><%= favorite_button_icon(photo.favorite) %></span>
+```
+
+```erb
+<%# the optimistic prediction %>
+<%= form.optimistic_template dom_id(photo, "favorite-button-icon") do %>
+  <%= turbo_stream.update dom_id(photo, "favorite-button-icon") do %>
+    <%= favorite_button_icon(!photo.favorite) %>
+  <% end %>
+<% end %>
+```
+
+```ruby
+# the authoritative response
+render turbo_stream: turbo_stream.update(
+  ActionView::RecordIdentifier.dom_id(@photo, "favorite-button-icon"),
+  partial: "photos/favorite_button", locals: { photo: @photo }
+)
+```
+
+## Multiple templates in one form
+
+Declare more than one `optimistic_template` to paint several regions from a single submit (for example a counter and a button). All of them are applied:
+
+```erb
+<%= optimistic_form_with url: carts_update_path, method: :patch, attribute_name: :photo_id, value: photo.id do |form| %>
+  <%= form.optimistic_template "cart-items-count", (@cart_items_count + 1) %>
+  <%= form.optimistic_template dom_id(photo, "favorite-button-icon"), favorite_button_icon(true) %>
+  <%= form.button "Add and favorite" %>
+<% end %>
+```
+
+## Hidden field
+
+Two ways to submit the toggled value, pick one per form:
+
+- **Automatic:** pass `attribute_name:`/`value:` to the form helper and a hidden field is injected for you.
+- **Explicit:** call `form.optimistic_hidden_field :favorite, value: !photo.favorite` where you want it. This suppresses the automatic injection.
+
+`value: false` is preserved (a favorite toggle legitimately submits `false`). Only `nil` or an omitted value suppresses the field.
+
+## Block form
+
+Instead of the positional `target, template`, pass a block to author the stream(s) yourself:
+
+```erb
+<%= form.optimistic_template do %>
+  <%= turbo_stream.update("cart-items-count") { @cart_items_count + 1 } %>
+<% end %>
+```
+
+## Notes
+
+- **Escaping.** Template content is treated as trusted developer markup, the same as any `turbo_stream.update` body (this is what lets you inject SVG icons). Do not pass unescaped user input; sanitize at the call site if you must.
+- **Throttling.** `apply` is throttled per form so a burst of rapid submits cannot stack duplicate clones. The first paint is still immediate.
+
+## API reference
+
+Helpers (available in all views):
+
+- `optimistic_form_with(attribute_name: nil, value: nil, **options, &block)`
+- `optimistic_form_for(record, attribute_name: nil, value: nil, **options, &block)`
+
+Both set `options[:builder]` to `OptimisticFormBuilder`; a `builder:` you pass is overridden (the tool's builder methods depend on it).
+
+Builder methods (yielded `form`):
+
+- `optimistic_template(target = nil, template = nil, &block)` - wraps a `turbo_stream.update` (positional) or your block in the tracked `<template>`.
+- `optimistic_hidden_field(attribute_name, value:)` - renders the hidden field explicitly and suppresses auto-injection.

data/lib/generators/hotwire_club/toolbox/optimistic_form/install_generator.rb

@@ -0,0 +1,127 @@
+require "rails/generators/base"
+
+module HotwireClub
+  module Toolbox
+    module OptimisticForm
+      # Wires the optimistic-form Stimulus controller into the host app,
+      # adapting to its JavaScript setup (importmap, jsbundling/esbuild/bun, or
+      # vite), and ensures the Turbo morph refresh meta tags are present.
+      #
+      #   bin/rails generate hotwire_club:toolbox:optimistic_form:install
+      class InstallGenerator < Rails::Generators::Base
+        CONTROLLER_MODULE = "hotwire_club/toolbox/optimistic_form_controller".freeze
+        CONTROLLERS_INDEX = "app/javascript/controllers/index.js".freeze
+        LAYOUT = "app/views/layouts/application.html.erb".freeze
+
+        MORPH_META = <<~HTML
+          <meta name="turbo-refresh-method" content="morph">
+          <meta name="turbo-refresh-scroll" content="preserve">
+        HTML
+
+        def wire_javascript
+          if importmap?
+            register_for_importmap
+          elsif bundler?
+            register_for_bundler
+          else
+            say_unknown_js_setup
+          end
+        end
+
+        def ensure_morph_meta_tags
+          unless File.exist?(layout_path)
+            say "Could not find #{LAYOUT}; add the Turbo morph refresh meta tags to your layout <head>:", :yellow
+            say MORPH_META
+            return
+          end
+
+          if File.read(layout_path).include?("turbo-refresh-method")
+            say_status :identical, "morph refresh meta tags", :blue
+          else
+            inject_into_file layout_path, indent(MORPH_META), after: /<head>\n/
+          end
+        end
+
+        def print_server_contract
+          say ""
+          say "Optimistic Form installed. Remember the server contract:", :green
+          say "  • Success  -> head :no_content (204), or a targeted turbo_stream. Do not redirect."
+          say "  • Failure  -> 4xx/422 so the client reconciles."
+          say "See docs/optimistic-form.md for details."
+        end
+
+        private
+
+        def importmap?
+          File.exist?(File.join(destination_root, "config/importmap.rb"))
+        end
+
+        def bundler?
+          gem_in_bundle?("jsbundling-rails") || gem_in_bundle?("vite_rails") ||
+            File.exist?(File.join(destination_root, "package.json"))
+        end
+
+        def register_for_importmap
+          register_controller(import: %(import OptimisticFormController from "#{CONTROLLER_MODULE}"))
+        end
+
+        def register_for_bundler
+          copy_controller_sources
+          register_controller(import: %(import OptimisticFormController from "./optimistic_form_controller"))
+        end
+
+        # Copy the controller + timing helpers into the host tree, rewriting the
+        # bare-specifier import to a relative one bundlers can resolve.
+        def copy_controller_sources
+          controller = engine_js("optimistic_form_controller.js")
+            .sub(%r{from "hotwire_club/toolbox/helpers/timing_helpers"}, %(from "../helpers/timing_helpers"))
+
+          create_file "app/javascript/controllers/optimistic_form_controller.js", controller
+          create_file "app/javascript/helpers/timing_helpers.js", engine_js("helpers/timing_helpers.js")
+        end
+
+        def register_controller(import:)
+          registration = <<~JS
+            #{import}
+            application.register("optimistic-form", OptimisticFormController)
+          JS
+
+          index = File.join(destination_root, CONTROLLERS_INDEX)
+          if File.exist?(index)
+            if File.read(index).include?("optimistic-form")
+              say_status :identical, "optimistic-form registration", :blue
+            else
+              append_to_file index, "\n#{registration}"
+            end
+          else
+            say "Could not find #{CONTROLLERS_INDEX}; register the controller yourself:", :yellow
+            say registration
+          end
+        end
+
+        def say_unknown_js_setup
+          say "Could not detect your JavaScript setup (importmap / jsbundling / vite).", :yellow
+          say "Import and register the controller manually, e.g.:", :yellow
+          say %(  import OptimisticFormController from "#{CONTROLLER_MODULE}")
+          say %(  application.register("optimistic-form", OptimisticFormController))
+        end
+
+        def gem_in_bundle?(name)
+          Gem.loaded_specs.key?(name)
+        end
+
+        def engine_js(relative_path)
+          File.read(HotwireClub::Toolbox::Engine.root.join("app/javascript/hotwire_club/toolbox", relative_path))
+        end
+
+        def layout_path
+          File.join(destination_root, LAYOUT)
+        end
+
+        def indent(text)
+          text.gsub(/^/, "    ")
+        end
+      end
+    end
+  end
+end

data/lib/hotwire_club/toolbox/engine.rb

@@ -0,0 +1,28 @@
+module HotwireClub
+  module Toolbox
+    class Engine < ::Rails::Engine
+      # Make the engine's view helpers available in the host app's views.
+      # (The engine intentionally does not isolate its namespace.)
+      initializer "hotwire_club.toolbox.helpers" do
+        ActiveSupport.on_load(:action_view) do
+          include HotwireClub::Toolbox::OptimisticFormHelper
+        end
+      end
+
+      # Serve the engine's JavaScript through the asset pipeline (Propshaft).
+      initializer "hotwire_club.toolbox.assets" do |app|
+        if app.config.respond_to?(:assets)
+          app.config.assets.paths << root.join("app/javascript")
+        end
+      end
+
+      # Contribute the engine's importmap pins to host apps using importmap-rails.
+      initializer "hotwire_club.toolbox.importmap", before: "importmap" do |app|
+        if app.config.respond_to?(:importmap)
+          app.config.importmap.paths << root.join("config/importmap.rb")
+          app.config.importmap.cache_sweepers << root.join("app/javascript")
+        end
+      end
+    end
+  end
+end

data/lib/hotwire_club/toolbox/version.rb

@@ -0,0 +1,5 @@
+module HotwireClub
+  module Toolbox
+    VERSION = "0.1.0"
+  end
+end

data/lib/hotwire_club/toolbox.rb

@@ -0,0 +1,9 @@
+require "turbo-rails"
+require "hotwire_club/toolbox/version"
+require "hotwire_club/toolbox/engine"
+
+module HotwireClub
+  module Toolbox
+    # Your code goes here...
+  end
+end

data/lib/tasks/hotwire_club/toolbox_tasks.rake

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

metadata

@@ -0,0 +1,90 @@
+--- !ruby/object:Gem::Specification
+name: hotwire_club-toolbox
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Julian Rubisch
+bindir: bin
+cert_chain: []
+date: 2026-07-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 8.1.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 8.1.3
+- !ruby/object:Gem::Dependency
+  name: turbo-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+description: HotwireClub::Toolbox is a Rails engine that packages a collection of
+  loosely connected Hotwire and Rails tools and techniques, starting with an optimistic-UI
+  form builder for Turbo.
+email:
+- julian@julianrubisch.at
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- MIT-LICENSE
+- README.md
+- Rakefile
+- app/helpers/hotwire_club/toolbox/optimistic_form_builder.rb
+- app/helpers/hotwire_club/toolbox/optimistic_form_helper.rb
+- app/javascript/hotwire_club/toolbox/helpers/timing_helpers.js
+- app/javascript/hotwire_club/toolbox/optimistic_form_controller.js
+- config/importmap.rb
+- config/routes.rb
+- docs/optimistic-form.md
+- lib/generators/hotwire_club/toolbox/optimistic_form/install_generator.rb
+- lib/hotwire_club/toolbox.rb
+- lib/hotwire_club/toolbox/engine.rb
+- lib/hotwire_club/toolbox/version.rb
+- lib/tasks/hotwire_club/toolbox_tasks.rake
+homepage: https://github.com/TheHotwireClub/hotwire_club-toolbox
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/TheHotwireClub/hotwire_club-toolbox
+  source_code_uri: https://github.com/TheHotwireClub/hotwire_club-toolbox
+  changelog_uri: https://github.com/TheHotwireClub/hotwire_club-toolbox/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.2
+specification_version: 4
+summary: A collection of loosely connected Hotwire and Rails tools and techniques.
+test_files: []