active_storage-async_variants 0.3.1 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ed31f4592e3d865609aef29b42657856321528d5013bb2a1ec499e3de93c5bb4
-  data.tar.gz: 994460c1ae175245da3d71489b25d4143827931f926289c94c18957df8cf0610
+  metadata.gz: bc926d64601c238db11edd005f220c0842cbf4316f405d43c23d08a99ff874de
+  data.tar.gz: 177a3d4a3647e41ac5e23db1908265c556a8c4c006b5497cbb802b2cf9ebb02e
 SHA512:
-  metadata.gz: c6b94095e095899175ac9fa37497500b9947e761d2ed07a7fdd78d55a90ac05898dca086e02d8b29419fc1fde8567628a4f6c7444470826ae6fb0556220af4ef
-  data.tar.gz: 109f1670b0ad22ce670bf27751ffeac462f0f10c94d0d89f4777c211b2fb1aa179c3981373ebc9b2f36a2262c4722dcdf73cd54ff95ca29cf6b035765150357f
+  metadata.gz: 25f4d2430ce2547c9a4109bd648f338914e92cacdb38bf2e651cdfff21a9a045e90480c10e6170f0723dbcb5e675a35370cda7c91ced43ec41c5bfa3f112f2a1
+  data.tar.gz: c02fac50058fd3465435bf194e09ffb0732deda2c61316b8e960b1179e4ee8e9eb417e1dd192fdf564c0e059d87a674fe76aa852f99a385592ddfcd71fb1a453

data/CHANGELOG.md

@@ -1,3 +1,18 @@
+## [0.5.0]
+
+- Added an opt-in retry affordance to the failed state: hovering a failed variant reveals a control that opens a dialog with the error and a "Retry processing" button that re-runs the transform. Disabled by default; enable it with `ActiveStorage::AsyncVariants.retry_visible_if { … }` (the block runs in the view context, so it can check `current_user`).
+
+## [0.4.0]
+
+- **Breaking:** Replaced the polling-`<img>` architecture with a `<turbo-frame>` for unprocessed variants. `image_tag`/`video_tag` with `async: true` now emits a normal `<img>`/`<video>` when the variant is already processed, and a `<turbo-frame src="…">` otherwise. The frame hits a new gem-shipped endpoint (`GET /active_storage/async_variants/states/:signed_blob_id/:variation_key`) that renders one of `_processing`/`_failed`/`_processed` partials. Non-terminal renders include an inline `<script>` that schedules the frame's next reload, so the state polls itself until it terminates.
+- New `app/views/active_storage/async_variants/states/` partial set — apps can override any partial by creating a same-named file in their own `app/views/active_storage/async_variants/states/`. The processing state defaults to a bare `<img>`/`<video>` pointing at the variant's URL, which the gem redirects to the app's configured `processing:` SVG.
+- All CSS and JavaScript ship inline in the per-response state partials — no asset-pipeline footprint. Apps don't need to include any stylesheet or script.
+- **Breaking:** `Variant#processed` and `Preview#processed` are now no-ops on bucket-backed services (they previously also lazy-enqueued `ProcessJob` for any record that wasn't already processed). Enqueue now happens only at attachment time (via `AttachmentExtension#transform_variants_later`). Pre-existing blobs that missed the auto-enqueue won't self-heal on first view; backfill via a rake task.
+- New public `#enqueue!` method on both `Variant` and `Preview` with the same signature — no `respond_to?` dance. Creates a pending `VariantRecord` (RecordNotUnique guards dedupe) and dispatches `ProcessJob`. Replaces the previously private `enqueue_processing` / `enqueue_async_preview`.
+- The named-variant lookup now walks one level back through `preview_image` attachments, so a request for a Variant of a video's extracted preview frame can recover the named-variant declaration from the parent record's source-video field. Fixes nil-URL 500s in dev where the cold Registry can't resolve a redirect-controller request.
+- Added `turbo-rails >= 2.0` as a runtime dependency.
+- Removed `RepresentationsRedirectControllerExtension`, the `[data-async-variant-*]` polling JS, the bundled `app/assets/stylesheets/active_storage_async_variants.css`, the engine's asset precompile initializer, and the `apply_async_data!` helper machinery. Consumers depending on those data attributes must migrate to targeting the new `.async-variant-state` classes or override the partials.
+
 ## [0.3.1]
 
 - Bound the stored variant `error` to 16k chars at both write sites (the failed-status callback and `ProcessJob`'s rescue). An external transformer reporting a >64KB error payload was overflowing the `TEXT` column and 500ing the callback, leaving the variant stuck instead of marked failed.

data/README.md

@@ -97,29 +97,9 @@ ActiveStorage::AsyncVariants.cdn_host = "https://d1234abcd.cloudfront.net"
 
 The resulting URL is `"#{cdn_host}/#{variant.key}"`.
 
-### Wiring the JavaScript
+### JavaScript
 
-The gem ships a dependency-free Stimulus-like controller at `app/assets/javascripts/active_storage_async_variants.js`. It is registered with the asset pipeline by the engine but not auto-imported. Wire it up the same way as `@rails/activestorage` -- pick whichever fits your bundler:
-
-Using **importmap-rails**:
-
-```ruby
-# config/importmap.rb
-pin "@active_storage/async_variants", to: "active_storage_async_variants.js", preload: true
-```
-
-```js
-// app/javascript/application.js
-import "@active_storage/async_variants"
-```
-
-Using **the asset pipeline** (sprockets/propshaft) with a classic `javascript_include_tag`:
-
-```erb
-<%= javascript_include_tag "active_storage_async_variants" %>
-```
-
-The module auto-starts on `DOMContentLoaded` and finds elements with `data-async-variant-state-value`. Opt out by setting `window.ActiveStorageAsyncVariants = null` before the script loads, then calling `start()` yourself from the exported module when ready.
+No manual wiring is required. The async state partials are self-contained `<turbo-frame>`s. The only requirement is that the host app loads **Turbo** -- the gem depends on `turbo-rails`, which a default Rails app already includes.
 
 ## Writing a Transformer
 

data/Rakefile

@@ -5,4 +5,12 @@ require "rspec/core/rake_task"
 
 RSpec::Core::RakeTask.new(:spec)
 
-task default: :spec
+desc "Run browser-level acceptance tests (cucumber + cuprite against spec/dummy)"
+task :cucumber do
+  sh "bundle exec cucumber"
+end
+
+desc "Run rspec and cucumber"
+task all: [:spec, :cucumber]
+
+task default: :all

data/app/assets/javascripts/retry.js

@@ -0,0 +1,11 @@
+// Declarative shadow roots are only attached by the initial HTML parser, not by
+// fragment insertion (innerHTML / Turbo frame swaps), so promote them on connect.
+customElements.define("async-variant-retry", class extends HTMLElement {
+  connectedCallback() {
+    if (this.shadowRoot) return
+    const template = this.querySelector(":scope > template[shadowrootmode]")
+    if (!template) return
+    this.attachShadow({ mode: template.getAttribute("shadowrootmode") }).append(template.content)
+    template.remove()
+  }
+})

data/app/assets/stylesheets/retry.css

@@ -0,0 +1,98 @@
+/* Scoped to the retry dialog's shadow root (linked inside its <template>). */
+:host { display: contents; }
+
+button { font: inherit; cursor: pointer; }
+
+.opener {
+  position: absolute;
+  top: 6px; right: 6px;
+  width: 22px; height: 22px;
+  background: #2b7cd6;
+  color: #fff;
+  border: 2px solid #fff;
+  border-radius: 50%;
+  font-size: 13px;
+  font-weight: bold;
+  line-height: 1;
+  padding: 0;
+  box-shadow: 0 1px 3px rgba(0, 0, 0, 0.35);
+  display: var(--retry-opener-display, none);
+  align-items: center;
+  justify-content: center;
+}
+.opener:hover { background: #1a5fb0; }
+
+dialog {
+  width: 720px;
+  max-width: 90vw;
+  max-height: 80vh;
+  padding: 0;
+  border: 1px solid #999;
+  border-radius: 6px;
+  background: #fff;
+  color: #222;
+  box-shadow: 0 8px 32px rgba(0, 0, 0, 0.3);
+  font: 13px/1.4 system-ui, -apple-system, sans-serif;
+}
+dialog[open] { display: flex; flex-direction: column; }
+dialog::backdrop { background: rgba(0, 0, 0, 0.5); }
+
+dialog > button {
+  position: absolute;
+  top: 10px;
+  right: 12px;
+  width: 32px; height: 32px;
+  background: transparent;
+  border: none;
+  color: #888;
+  font-size: 24px;
+  line-height: 1;
+  padding: 0;
+  border-radius: 4px;
+  z-index: 1;
+}
+dialog > button:hover { color: #000; background: rgba(0, 0, 0, 0.08); }
+
+header { padding: 20px 24px 0 24px; }
+header h3 {
+  margin: 0;
+  font-size: 16px;
+  font-weight: bold;
+  color: #111;
+  padding-right: 32px;
+}
+
+section {
+  flex: 1 1 auto;
+  overflow: auto;
+  padding: 12px 24px 20px 24px;
+  min-height: 0;
+}
+section pre {
+  background: #f5f5f5;
+  color: #222;
+  border: 1px solid #ddd;
+  padding: 8px;
+  font: 11px/1.4 ui-monospace, Menlo, monospace;
+  white-space: pre-wrap;
+  word-break: break-all;
+  margin: 0;
+}
+
+footer {
+  flex: 0 0 auto;
+  border-top: 1px solid #ddd;
+  padding: 12px 20px;
+  display: flex;
+  justify-content: flex-end;
+  background: #fafafa;
+}
+footer button {
+  padding: 8px 16px;
+  background: #2a7;
+  color: #fff;
+  border: none;
+  border-radius: 4px;
+  font-weight: bold;
+}
+footer button:disabled { opacity: 0.5; cursor: wait; }

data/app/controllers/active_storage/async_variants/states_controller.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module ActiveStorage
+  module AsyncVariants
+    class StatesController < ActiveStorage::AsyncVariants.parent_controller.constantize
+      # signed_blob_id + variation_key in URL act as CSRF: both require app's secret.
+      skip_forgery_protection
+
+      helper "turbo/frames"
+      helper ActiveStorage::AsyncVariants::Helper
+
+      layout false
+
+      before_action :set_variant
+
+      def show
+      end
+
+      def retry
+        @variant.blob.variant_records.where(
+          variation_digest: @variant.variation.digest,
+          state: "failed",
+        ).destroy_all
+        @variant.enqueue!
+
+        redirect_to Rails.application.routes.url_helpers.async_variant_state_path(
+          signed_blob_id: params[:signed_blob_id],
+          variation_key: params[:variation_key],
+          kind: params[:kind],
+          direct: params[:direct],
+          opts: async_variant_html_options.presence,
+        ), status: :see_other
+      end
+
+      helper_method :async_variant_kind, :async_variant_direct?, :async_variant_html_options
+
+      private
+
+      def set_variant
+        blob = ActiveStorage::Blob.find_signed!(params[:signed_blob_id])
+        variation = ActiveStorage::Variation.decode(params[:variation_key])
+        @variant = blob.variant(variation)
+      rescue ActiveSupport::MessageVerifier::InvalidSignature
+        head :not_found
+      end
+
+      def async_variant_kind
+        params[:kind].to_s == "video" ? :video : :image
+      end
+
+      def async_variant_direct?
+        ActiveModel::Type::Boolean.new.cast(params[:direct])
+      end
+
+      def async_variant_html_options
+        params[:opts]
+          &.permit(*ActiveStorage::AsyncVariants::PASS_THROUGH_HTML_OPTIONS)
+          .to_h
+      end
+    end
+  end
+end

data/app/views/active_storage/async_variants/states/_failed.html.erb

@@ -0,0 +1,43 @@
+<div class="async-variant-state async-variant-failed">
+  <%= image_tag async_variant_representation_path(variant), **html_options.symbolize_keys.except(:controls, :autoplay, :preload) %>
+
+  <% if ActiveStorage::AsyncVariants.retry_visible?(self) %>
+    <% dialog_id = "#{async_variant_frame_id(variant)}-error" %>
+    <% form_id = "#{dialog_id}-form" %>
+    <%# Light DOM, so the custom property inherits into the shadow root. %>
+    <style>
+      .async-variant-failed {
+        position: relative;
+        display: inline-block;
+        --retry-opener-display: none;
+      }
+      .async-variant-failed:hover { --retry-opener-display: inline-flex; }
+    </style>
+    <%# In the light DOM so its submit reaches Turbo, and so preventDefault on the
+        buttons doesn't also cancel the submit. %>
+    <form action="<%= Rails.application.routes.url_helpers.async_variant_state_retry_path(signed_blob_id:, variation_key:, kind:, direct:, opts: html_options) %>"
+          method="post"
+          id="<%= form_id %>"
+          data-turbo-frame="<%= async_variant_frame_id(variant) %>"
+          hidden></form>
+    <async-variant-retry>
+      <template shadowrootmode="open">
+        <%= ActiveStorage::AsyncVariants.stylesheet_link_tag "retry" %>
+        <button class="opener" type="button"
+                onclick="event.preventDefault(); event.stopPropagation(); this.getRootNode().getElementById('<%= dialog_id %>').showModal()"
+                title="Variant processing failed — click for details">?</button>
+        <dialog id="<%= dialog_id %>">
+          <button type="button"
+                  onclick="event.preventDefault(); event.stopPropagation(); this.closest('dialog').close()">&times;</button>
+          <header><h3>Variant processing failed</h3></header>
+          <section><pre><%= variant.error %></pre></section>
+          <footer>
+            <button type="button"
+                    onclick="event.preventDefault(); event.stopPropagation(); this.disabled = true; this.textContent = 'Retrying…'; document.getElementById('<%= form_id %>').requestSubmit()">Retry processing</button>
+          </footer>
+        </dialog>
+      </template>
+    </async-variant-retry>
+    <%= ActiveStorage::AsyncVariants.javascript_include_tag "retry", type: "module" %>
+  <% end %>
+</div>

data/app/views/active_storage/async_variants/states/_pending.html.erb

@@ -0,0 +1 @@
+<%= render "active_storage/async_variants/states/processing", local_assigns %>

data/app/views/active_storage/async_variants/states/_processed.html.erb

@@ -0,0 +1,5 @@
+<%
+  method = kind == :video ? :video_tag : :image_tag
+  src = direct ? async_variant_direct_url(variant) : async_variant_representation_path(variant)
+%>
+<%= send method, src, **html_options.symbolize_keys %>

data/app/views/active_storage/async_variants/states/_processing.html.erb

@@ -0,0 +1,9 @@
+<div class="async-variant-state async-variant-processing">
+  <%= image_tag async_variant_representation_path(variant), **html_options.symbolize_keys.except(:controls, :autoplay, :preload) %>
+</div>
+<%# Self-perpetuating poll: Turbo runs <script>s in frame swaps, so each
+    pending/processing response schedules its own next reload. Terminal
+    partials (_failed, _processed) emit no script -> chain stops. %>
+<script>
+  setTimeout(() => document.getElementById("<%= async_variant_frame_id(variant) %>")?.reload(), 3000)
+</script>

data/app/views/active_storage/async_variants/states/show.html.erb

@@ -0,0 +1,10 @@
+<%= turbo_frame_tag async_variant_frame_id(@variant) do %>
+  <%= render "active_storage/async_variants/states/#{@variant.async_state}", {
+    variant: @variant,
+    html_options: async_variant_html_options,
+    kind: async_variant_kind,
+    direct: async_variant_direct?,
+    signed_blob_id: params[:signed_blob_id],
+    variation_key: params[:variation_key],
+  } %>
+<% end %>

data/config/routes.rb

@@ -4,4 +4,13 @@ Rails.application.routes.draw do
   post "/active_storage/async_variants/callbacks/:token",
     to: "active_storage/async_variants/callbacks#create",
     as: :active_storage_async_variant_callback
+
+  get  "/active_storage/async_variants/states/:signed_blob_id/:variation_key",
+    to: "active_storage/async_variants/states#show",
+    as: :async_variant_state
+  post "/active_storage/async_variants/states/:signed_blob_id/:variation_key/retry",
+    to: "active_storage/async_variants/states#retry",
+    as: :async_variant_state_retry
+
+  ActiveStorage::AsyncVariants::Assets.draw(self, "/active_storage/async_variants/assets")
 end

data/features/retry_flow.feature

@@ -0,0 +1,20 @@
+Feature: Clicking the retry affordance opens a dialog and resubmits the variant
+
+  Background:
+    Given a user with an attached avatar
+    And the retry affordance is visible to everyone
+
+  Scenario: Clicking the opener reveals the error inside the shadow-DOM dialog
+    Given the avatar's :thumb_proc variant is in failed state with error "boom from upstream"
+    When I visit the avatar page for the :thumb_proc variant
+    And I click the retry opener
+    Then the failure dialog should be open
+    And the failure dialog should contain "boom from upstream"
+
+  Scenario: Submitting Retry destroys the failed record and re-enqueues
+    Given the avatar's :thumb_proc variant is in failed state with error "boom"
+    When I visit the avatar page for the :thumb_proc variant
+    And I click the retry opener
+    And I click "Retry processing"
+    Then the frame should render the processing state
+    And the page should not have navigated away

data/features/retry_visibility.feature

@@ -0,0 +1,23 @@
+Feature: The retry affordance is gated by ActiveStorage::AsyncVariants.retry_visible_if
+
+  Scenario: When retry_visible_if returns true, the retry chrome renders
+    Given a user with an attached avatar
+    And the retry affordance is visible to everyone
+    And the avatar's :thumb_proc variant is in failed state with error "boom"
+    When I visit the avatar page for the :thumb_proc variant
+    Then the retry affordance should be visible
+
+  Scenario: When retry_visible_if returns false, the retry chrome is omitted
+    Given a user with an attached avatar
+    And the retry affordance is hidden
+    And the avatar's :thumb_proc variant is in failed state with error "boom"
+    When I visit the avatar page for the :thumb_proc variant
+    Then the retry affordance should NOT be visible
+
+  Scenario: A proc that consults current_user gates the affordance per-viewer
+    Given a user with an attached avatar
+    And the retry affordance requires a signed-in user
+    And the avatar's :thumb_proc variant is in failed state with error "boom"
+    When I sign in as the user
+    And I visit the avatar page for the :thumb_proc variant
+    Then the retry affordance should be visible

data/features/state_rendering.feature

@@ -0,0 +1,22 @@
+Feature: image_tag with async: true emits the right markup per variant state
+
+  Scenario: A processed variant emits a plain <img> -- no turbo-frame, no chrome
+    Given a user with an attached avatar
+    And the avatar's :thumb_proc variant is in processed state
+    When I visit the avatar page for the :thumb_proc variant
+    Then the page should NOT contain a turbo-frame
+
+  Scenario: An unprocessed variant emits a turbo-frame in processing state
+    Given a user with an attached avatar
+    And the avatar's :thumb_proc variant is in processing state
+    When I visit the avatar page for the :thumb_proc variant
+    Then the page should contain a turbo-frame
+    And the frame should render the processing state
+
+  Scenario: A failed variant renders the failed partial inside the frame
+    Given a user with an attached avatar
+    And the retry affordance is visible to everyone
+    And the avatar's :thumb_proc variant is in failed state with error "boom"
+    When I visit the avatar page for the :thumb_proc variant
+    Then the page should contain a turbo-frame
+    And the frame should render the failed state

data/features/step_definitions/dummy_steps.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+Given /^a user with an attached avatar$/ do
+  @user = User.create!
+  attach_avatar_to(@user)
+end
+
+Given /^the avatar's :(\w+) variant is in (pending|processing|processed|failed) state(?: with error "([^"]+)")?$/ do |variant_name, state, error|
+  variant = @user.avatar.variant(variant_name.to_sym)
+  if state == "processed"
+    simulate_processed_variant(variant)
+  else
+    create_variant_record(variant, state: state, error: error)
+  end
+end
+
+Given /^the retry affordance is visible to everyone$/ do
+  ActiveStorage::AsyncVariants.retry_visible_if { true }
+end
+
+Given /^the retry affordance is hidden$/ do
+  ActiveStorage::AsyncVariants.retry_visible_if { false }
+end
+
+Given /^the retry affordance requires a signed-in user$/ do
+  ActiveStorage::AsyncVariants.retry_visible_if { current_user.present? }
+end
+
+When /^I sign in as the (admin|user)$/ do |_kind|
+  visit "/session/#{@user.id}"
+end
+
+When /^I visit the avatar page for the :(\w+) variant$/ do |variant_name|
+  visit "/avatars/#{@user.id}/#{variant_name}"
+end
+
+Then /^the page should contain a turbo-frame$/ do
+  expect(page).to have_css("turbo-frame")
+end
+
+Then /^the page should NOT contain a turbo-frame$/ do
+  expect(page).to have_no_css("turbo-frame")
+  expect(page).to have_css("img")
+end
+
+Then /^the frame should render the (failed|processing|processed) state$/ do |state|
+  expect(page).to have_css("turbo-frame .async-variant-#{state}")
+end
+
+Then /^the retry affordance should be visible$/ do
+  expect(page).to have_css("async-variant-retry", visible: :all)
+end
+
+Then /^the retry affordance should NOT be visible$/ do
+  expect(page).to have_no_css("async-variant-retry", visible: :all)
+end
+
+Then /^the page should not have navigated away$/ do
+  expect(page).to have_css("h1#page-marker")
+end
+
+Then /^the failure dialog should be open$/ do
+  expect(page).to have_css("async-variant-retry", visible: :all)
+  open = page.evaluate_script(<<~JS)
+    (() => {
+      const host = document.querySelector("async-variant-retry")
+      if (!host || !host.shadowRoot) return false
+      const dialog = host.shadowRoot.querySelector("dialog")
+      return dialog ? dialog.open : false
+    })()
+  JS
+  expect(open).to eq(true)
+end
+
+Then /^the failure dialog should contain "([^"]+)"$/ do |text|
+  contains = page.evaluate_script(<<~JS)
+    (() => {
+      const host = document.querySelector("async-variant-retry")
+      if (!host || !host.shadowRoot) return false
+      return host.shadowRoot.textContent.includes(#{text.inspect})
+    })()
+  JS
+  expect(contains).to eq(true)
+end
+
+# Wait for Turbo to swap the frame and our shim to attach the shadow root.
+def wait_for_shadow!
+  Timeout.timeout(5) do
+    loop do
+      attached = page.evaluate_script("!!document.querySelector('async-variant-retry')?.shadowRoot")
+      break if attached
+      sleep 0.05
+    end
+  end
+end
+
+When /^I click the retry opener$/ do
+  wait_for_shadow!
+  page.evaluate_script(<<~JS)
+    document.querySelector("async-variant-retry").shadowRoot.querySelector(".opener").click()
+  JS
+end
+
+When /^I click "Retry processing"$/ do
+  wait_for_shadow!
+  page.evaluate_script(<<~JS)
+    document.querySelector("async-variant-retry").shadowRoot.querySelector("footer button").click()
+  JS
+end
+
+When /^I close the failure dialog$/ do
+  wait_for_shadow!
+  page.evaluate_script(<<~JS)
+    document.querySelector("async-variant-retry").shadowRoot.querySelector("dialog > button[type=button]").click()
+  JS
+end

data/features/support/env.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+ENV["RAILS_ENV"] ||= "test"
+require File.expand_path("../../spec/dummy/config/environment", __dir__)
+
+require "capybara"
+require "capybara/cucumber"
+require "capybara/cuprite"
+require_relative "../../spec/support/schema"
+
+DummySchema.load!
+
+Capybara.register_driver(:cuprite) do |app|
+  Capybara::Cuprite::Driver.new(app, window_size: [1200, 900], timeout: 10, process_timeout: 20, js_errors: true)
+end
+Capybara.app                = Rails.application
+Capybara.javascript_driver  = :cuprite
+Capybara.default_driver     = :cuprite
+Capybara.server             = :puma, { Silent: true }
+
+ActionController::Base.allow_forgery_protection = false
+
+# Test adapter just records enqueued jobs -- we don't want them to actually run
+# during browser tests (they'd call real transformers and modify variant_records
+# behind the test's back). The retry step seeds the new state explicitly.
+ActiveJob::Base.queue_adapter = :test
+
+Before { DummySchema.cleanup! }

data/gemfiles/rails_7.2.gemfile

@@ -10,5 +10,9 @@ gem "simplecov", require: false
 gem "rspec-rails"
 gem "rails", "~> 7.2.0"
 gem "sqlite3"
+gem "cucumber"
+gem "capybara"
+gem "cuprite"
+gem "puma"
 
 gemspec path: "../"

data/gemfiles/rails_8.0.gemfile

@@ -10,5 +10,9 @@ gem "simplecov", require: false
 gem "rspec-rails"
 gem "rails", "~> 8.0.0"
 gem "sqlite3"
+gem "cucumber"
+gem "capybara"
+gem "cuprite"
+gem "puma"
 
 gemspec path: "../"

data/gemfiles/rails_8.1.gemfile

@@ -10,5 +10,9 @@ gem "simplecov", require: false
 gem "rspec-rails"
 gem "rails", "~> 8.1.0"
 gem "sqlite3"
+gem "cucumber"
+gem "capybara"
+gem "cuprite"
+gem "puma"
 
 gemspec path: "../"