active_storage-async_variants 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 4395d49e7c04b9206145e2c8dbe0bf3f4466ed736054ec5e9fc3b8fc7dea3a1c
+  data.tar.gz: 1cf4f1090be29b6ff6a7a50be05ecaa2bcc79f50de9a203ec26d99c9d8e58fc8
+SHA512:
+  metadata.gz: 1d696905633e0039f8489377d41ea120fd89d5fccfcadbd8872981ea916d9032395f5f66091eba170de40f03547b7b93c90457e6796f15868ae3e7d3ecf937c4
+  data.tar.gz: 21c13be811dc6c6b9b19123f6ef8c9c23c1e2cbc0360ee9f79a88b4bf83d023f514d61964e75b749c2b073ad19e7db52f878a2b55de8c90b4018ff831a4d3f2d

data/.github/workflows/ci.yml

@@ -0,0 +1,27 @@
+name: CI
+
+on:
+  push:
+    branches: [master]
+  pull_request:
+    branches: [master]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        ruby: ["3.3", "3.4", "4.0"]
+        rails: ["rails-7.2", "rails-8.0", "rails-8.1"]
+        exclude:
+          - ruby: "4.0"
+            rails: "rails-7.2"
+    steps:
+      - uses: actions/checkout@v4
+      - uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: ${{ matrix.ruby }}
+          bundler-cache: true
+      - run: bundle exec appraisal ${{ matrix.rails }} bundle install
+      - run: bundle exec appraisal ${{ matrix.rails }} rake

data/.ruby-gemset

@@ -0,0 +1 @@
+active_storage-async_variants

data/.ruby-version

@@ -0,0 +1 @@
+ruby-3.4.2

data/Appraisals

@@ -0,0 +1,11 @@
+appraise "rails-7.2" do
+  gem "rails", "~> 7.2.0"
+end
+
+appraise "rails-8.0" do
+  gem "rails", "~> 8.0.0"
+end
+
+appraise "rails-8.1" do
+  gem "rails", "~> 8.1.0"
+end

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## [Unreleased]
+
+## [0.1.0] - 2026-03-03
+
+- Initial release

data/CLAUDE.md

@@ -0,0 +1,48 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## What This Is
+
+A Rails engine gem that extends Active Storage with async-safe variant processing. Solves the problem where slow transformations (e.g., video transcoding) block requests or fail silently. The `fallback:` option on a variant definition opts it into async processing.
+
+## Commands
+
+```bash
+bundle exec rake          # Run full test suite (default task is :spec)
+bundle exec rspec         # Run all specs
+bundle exec rspec spec/active_storage/async_variants_spec.rb  # Run the main spec file
+bundle exec rspec spec/active_storage/async_variants_spec.rb -e "description" # Run specific example
+```
+
+## Architecture
+
+The gem works by prepending extension modules onto Active Storage classes:
+
+- **`VariationExtension`** → `ActiveStorage::Variation` — extracts async options (`fallback:`, `transformer:`, `max_retries:`) from variant config before passing the rest to standard Active Storage
+- **`AttachmentExtension`** → `ActiveStorage::Attachment` — hooks into `transform_variants_later` to enqueue `ProcessJob` for variants with `fallback:`
+- **`VariantWithRecordExtension`** → `ActiveStorage::VariantWithRecord` — overrides URL generation to serve fallback while processing; adds state query methods (`ready?`, `processing?`, `pending?`, `failed?`)
+- **`ProcessJob`** — background job that determines transformer type (inline vs external) and processes accordingly
+
+### Transformer Types
+
+- **Inline**: implements `process(file, **options)` → blocks worker, returns `{ io:, content_type:, filename: }`
+- **External**: implements `initiate(source_url:, destination_url:, callback_url:, **options)` → frees worker immediately, external service POSTs to callback URL when done
+
+The gem detects which type by checking if `process` is overridden on the transformer class.
+
+### Callback Endpoint
+
+`CallbacksController` mounted at `/active_storage/async_variants/callbacks/:token` receives webhook POSTs from external services. Tokens are signed with `ActiveStorage.verifier`.
+
+### State Machine
+
+`VariantRecord.state`: `pending` → `processing` → `processed` (success) or `failed` (with error message and attempt count)
+
+## Testing
+
+- Uses RSpec with a dummy Rails app in `spec/dummy/`
+- SQLite in-memory database defined in `spec/support/active_record.rb`
+- Jobs use `:test` queue adapter (not executed automatically — use `perform_enqueued_jobs` to run them)
+- Test helpers `create_variant_record` and `simulate_processed_variant` are defined in `spec/support/active_record.rb`
+- There is one main spec file: `spec/active_storage/async_variants_spec.rb`

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 Micah Geisel
+
+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,228 @@
+# ActiveStorage::AsyncVariants
+
+Extends Active Storage with pluggable per-variant transformers, async-safe variant processing, and failure handling.
+
+## The Problem
+
+Active Storage's variant system assumes transformations are fast and reliable -- like generating an image thumbnail. But some transformations are slow (transcoding a 1GB video to 720p VP9) and fallible (the transcode may permanently fail). When you use `process: :later`, Active Storage enqueues a background job, but if the variant is requested before the job finishes, it falls through to synchronous processing -- blocking the request for minutes or timing out entirely. And if the transformation fails, the error bubbles up with no tracking or retry limits.
+
+## Installation
+
+```ruby
+gem "active_storage-async_variants"
+```
+
+```bash
+bin/rails active_storage_async_variants:install:migrations
+bin/rails db:migrate
+```
+
+## Usage
+
+Add `fallback:` to any named variant to opt into the async pipeline:
+
+```ruby
+class User < ApplicationRecord
+  has_one_attached :video do |attachable|
+    attachable.variant :web,
+      transformer: VideoTranscoder,
+      codec: "vp9",
+      resolution: "720p",
+      fallback: :original
+  end
+end
+```
+
+The presence of `fallback:` is what opts a variant into async processing. Without it, variants behave exactly as they do in standard Active Storage. The `transformer:` option is independent -- you can use a custom transformer synchronously, or use the default transformer asynchronously:
+
+```ruby
+has_one_attached :video do |attachable|
+  # Async with custom transformer (video transcode)
+  attachable.variant :web,
+    transformer: VideoTranscoder,
+    codec: "vp9",
+    fallback: :original
+
+  # Async with default transformer (large image resize that's too slow for inline)
+  attachable.variant :thumbnail,
+    resize_to_limit: [200, 200],
+    fallback: :original
+
+  # Sync with custom transformer (fast custom processing, no fallback needed)
+  attachable.variant :watermarked,
+    transformer: WatermarkStamper
+end
+```
+
+In views, use the same Active Storage helpers:
+
+```erb
+<%= video_tag user.video.variant(:web).url %>
+```
+
+If the variant is still processing, this serves the original video. Once processing completes, it serves the transcoded variant.
+
+## Writing a Transformer
+
+Transformers come in two flavors: **inline** (the job blocks until processing completes) and **external** (the job kicks off remote work and a webhook signals completion).
+
+### External Transformers (recommended for slow work)
+
+An external transformer delegates to a remote service and returns immediately, freeing up the job worker. The remote service uploads the result directly to storage and hits a callback URL when done.
+
+```ruby
+class LambdaTranscoder < ActiveStorage::AsyncVariants::Transformer
+  def initiate(source_url:, destination_url:, callback_url:, **options)
+    Http.post("https://transcode.example.com/jobs",
+      source_url: source_url,
+      destination_url: destination_url,
+      callback_url: callback_url,
+      codec: options[:codec],
+      resolution: options[:resolution],
+    )
+  end
+end
+```
+
+The gem calls `initiate` with:
+- `source_url` -- a presigned GET URL for the original file
+- `destination_url` -- a presigned PUT URL where the result should be uploaded
+- `callback_url` -- a signed webhook URL to POST to when done
+
+The remote service does its work (which could take minutes or hours), uploads the result to `destination_url`, then POSTs to `callback_url`:
+
+```
+POST <callback_url>
+Content-Type: application/json
+
+{ "status": "success", "content_type": "video/webm", "byte_size": 52428800 }
+```
+
+Or on failure:
+
+```
+POST <callback_url>
+Content-Type: application/json
+
+{ "status": "failed", "error": "ffmpeg exited with status 1" }
+```
+
+The callback URL is signed -- no authentication is needed on the caller's side.
+
+### Callback Endpoint
+
+The gem mounts a callback endpoint at:
+
+```
+POST /active_storage/async_variants/callbacks/:token
+```
+
+The `:token` is a signed, single-use token that identifies the variant record. The gem generates this URL and passes it to `initiate` as `callback_url`. Your external service just POSTs to it -- no API keys or authentication headers required.
+
+Expected request body:
+
+```json
+{ "status": "success", "content_type": "video/webm", "byte_size": 52428800 }
+```
+
+```json
+{ "status": "failed", "error": "ffmpeg exited with status 1" }
+```
+
+### Inline Transformers (simpler, blocks the worker)
+
+For cases where you're running the transformation locally (e.g., ffmpeg on the same machine), an inline transformer blocks until done:
+
+```ruby
+class LocalTranscoder < ActiveStorage::AsyncVariants::Transformer
+  def process(file, **options)
+    output = Tempfile.new(["output", ".webm"])
+    system("ffmpeg", "-i", file.path,
+      "-c:v", "libvpx-vp9",
+      "-vf", "scale=-2:#{options[:resolution]&.delete("p") || 720}",
+      "-c:a", "libopus",
+      output.path,
+      exception: true,
+    )
+    { io: output, content_type: "video/webm", filename: "video.webm" }
+  end
+end
+```
+
+The `process` method receives the source file and all non-reserved options from the variant definition. It returns a hash with `io:`, `content_type:`, and `filename:`.
+
+The gem determines the mode by which method the transformer implements: `initiate` for external, `process` for inline.
+
+## Checking Variant State
+
+```ruby
+variant = user.video.variant(:web)
+
+variant.ready?       # => true if processed successfully
+variant.processing?  # => true if job is running or external service is working
+variant.pending?     # => true if job is enqueued
+variant.failed?      # => true if permanently failed
+variant.error        # => error message string, or nil
+```
+
+## Fallback Options
+
+The `fallback:` option controls what gets served while a variant is processing (or after it fails):
+
+```ruby
+# Serve the original unprocessed file
+attachable.variant :web, fallback: :original
+
+# Return nil -- let the view handle it
+attachable.variant :web, fallback: :blank
+
+# Custom fallback
+attachable.variant :web,
+  fallback: -> (blob) { "/placeholders/processing.svg" }
+```
+
+## Failure Handling
+
+By default, a variant is retried 3 times before being marked as permanently failed. Configure per-variant:
+
+```ruby
+attachable.variant :web,
+  transformer: VideoTranscoder,
+  codec: "vp9",
+  resolution: "720p",
+  fallback: :original,
+  max_retries: 5
+```
+
+Inspect failures:
+
+```ruby
+variant = user.video.variant(:web)
+variant.failed? # => true
+variant.error   # => "ffmpeg exited with status 1: ..."
+```
+
+## How It Works
+
+### External transformer flow
+
+1. User uploads a file to an attachment that has async variants defined
+2. After attachment, a background job is enqueued for each async variant
+3. `VariantRecord` is created with state `pending`
+4. The job calls the transformer's `initiate` method with presigned source/destination URLs and a signed callback URL, then exits -- the worker is free
+5. The external service processes the file, uploads the result to the destination URL
+6. The external service POSTs to the callback URL with success/failure status
+7. The gem's callback endpoint transitions the `VariantRecord` to `processed` or `failed`
+8. When a view requests the variant URL, the gem checks state and serves the variant or the fallback
+
+### Inline transformer flow
+
+1-3. Same as above
+4. The job calls the transformer's `process` method, blocking until complete
+5. On success, the output is uploaded, the `VariantRecord` transitions to `processed`
+6. On failure, the error is recorded and the job is re-enqueued (up to `max_retries`)
+7. When a view requests the variant URL, the gem checks state and serves the variant or the fallback
+
+## License
+
+MIT

data/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module ActiveStorage
+  module AsyncVariants
+    class CallbacksController < ActionController::API
+      def create
+        variant_record_id = ActiveStorage.verifier.verify(params[:token], purpose: :async_variant_callback)
+        variant_record = ActiveStorage::VariantRecord.find(variant_record_id)
+
+        case params[:status]
+        when "success"
+          variant_record.update!(state: "processed")
+        when "failed"
+          variant_record.update!(state: "failed", error: params[:error])
+        else
+          head :unprocessable_entity and return
+        end
+
+        head :ok
+      rescue ActiveSupport::MessageVerifier::InvalidSignature
+        head :unauthorized
+      end
+    end
+  end
+end

data/config/routes.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+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
+end

data/gemfiles/rails_7.2.gemfile

@@ -0,0 +1,13 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "appraisal"
+gem "irb"
+gem "rake", "~> 13.0"
+gem "rspec", "~> 3.0"
+gem "rspec-rails"
+gem "rails", "~> 7.2.0"
+gem "sqlite3"
+
+gemspec path: "../"

data/gemfiles/rails_7.2.gemfile.lock

@@ -0,0 +1,269 @@
+PATH
+  remote: ..
+  specs:
+    active_storage-async_variants (0.1.0)
+      activestorage (>= 7.1)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    actioncable (7.2.3)
+      actionpack (= 7.2.3)
+      activesupport (= 7.2.3)
+      nio4r (~> 2.0)
+      websocket-driver (>= 0.6.1)
+      zeitwerk (~> 2.6)
+    actionmailbox (7.2.3)
+      actionpack (= 7.2.3)
+      activejob (= 7.2.3)
+      activerecord (= 7.2.3)
+      activestorage (= 7.2.3)
+      activesupport (= 7.2.3)
+      mail (>= 2.8.0)
+    actionmailer (7.2.3)
+      actionpack (= 7.2.3)
+      actionview (= 7.2.3)
+      activejob (= 7.2.3)
+      activesupport (= 7.2.3)
+      mail (>= 2.8.0)
+      rails-dom-testing (~> 2.2)
+    actionpack (7.2.3)
+      actionview (= 7.2.3)
+      activesupport (= 7.2.3)
+      cgi
+      nokogiri (>= 1.8.5)
+      racc
+      rack (>= 2.2.4, < 3.3)
+      rack-session (>= 1.0.1)
+      rack-test (>= 0.6.3)
+      rails-dom-testing (~> 2.2)
+      rails-html-sanitizer (~> 1.6)
+      useragent (~> 0.16)
+    actiontext (7.2.3)
+      actionpack (= 7.2.3)
+      activerecord (= 7.2.3)
+      activestorage (= 7.2.3)
+      activesupport (= 7.2.3)
+      globalid (>= 0.6.0)
+      nokogiri (>= 1.8.5)
+    actionview (7.2.3)
+      activesupport (= 7.2.3)
+      builder (~> 3.1)
+      cgi
+      erubi (~> 1.11)
+      rails-dom-testing (~> 2.2)
+      rails-html-sanitizer (~> 1.6)
+    activejob (7.2.3)
+      activesupport (= 7.2.3)
+      globalid (>= 0.3.6)
+    activemodel (7.2.3)
+      activesupport (= 7.2.3)
+    activerecord (7.2.3)
+      activemodel (= 7.2.3)
+      activesupport (= 7.2.3)
+      timeout (>= 0.4.0)
+    activestorage (7.2.3)
+      actionpack (= 7.2.3)
+      activejob (= 7.2.3)
+      activerecord (= 7.2.3)
+      activesupport (= 7.2.3)
+      marcel (~> 1.0)
+    activesupport (7.2.3)
+      base64
+      benchmark (>= 0.3)
+      bigdecimal
+      concurrent-ruby (~> 1.0, >= 1.3.1)
+      connection_pool (>= 2.2.5)
+      drb
+      i18n (>= 1.6, < 2)
+      logger (>= 1.4.2)
+      minitest (>= 5.1)
+      securerandom (>= 0.3)
+      tzinfo (~> 2.0, >= 2.0.5)
+    appraisal (2.5.0)
+      bundler
+      rake
+      thor (>= 0.14.0)
+    base64 (0.3.0)
+    benchmark (0.5.0)
+    bigdecimal (4.0.1)
+    builder (3.3.0)
+    cgi (0.5.1)
+    concurrent-ruby (1.3.6)
+    connection_pool (3.0.2)
+    crass (1.0.6)
+    date (3.5.1)
+    diff-lcs (1.6.2)
+    drb (2.2.3)
+    erb (6.0.2)
+    erubi (1.13.1)
+    globalid (1.3.0)
+      activesupport (>= 6.1)
+    i18n (1.14.8)
+      concurrent-ruby (~> 1.0)
+    io-console (0.8.2)
+    irb (1.17.0)
+      pp (>= 0.6.0)
+      prism (>= 1.3.0)
+      rdoc (>= 4.0.0)
+      reline (>= 0.4.2)
+    logger (1.7.0)
+    loofah (2.25.0)
+      crass (~> 1.0.2)
+      nokogiri (>= 1.12.0)
+    mail (2.9.0)
+      logger
+      mini_mime (>= 0.1.1)
+      net-imap
+      net-pop
+      net-smtp
+    marcel (1.1.0)
+    mini_mime (1.1.5)
+    minitest (6.0.2)
+      drb (~> 2.0)
+      prism (~> 1.5)
+    net-imap (0.6.3)
+      date
+      net-protocol
+    net-pop (0.1.2)
+      net-protocol
+    net-protocol (0.2.2)
+      timeout
+    net-smtp (0.5.1)
+      net-protocol
+    nio4r (2.7.5)
+    nokogiri (1.19.1-aarch64-linux-gnu)
+      racc (~> 1.4)
+    nokogiri (1.19.1-aarch64-linux-musl)
+      racc (~> 1.4)
+    nokogiri (1.19.1-arm-linux-gnu)
+      racc (~> 1.4)
+    nokogiri (1.19.1-arm-linux-musl)
+      racc (~> 1.4)
+    nokogiri (1.19.1-arm64-darwin)
+      racc (~> 1.4)
+    nokogiri (1.19.1-x86_64-darwin)
+      racc (~> 1.4)
+    nokogiri (1.19.1-x86_64-linux-gnu)
+      racc (~> 1.4)
+    nokogiri (1.19.1-x86_64-linux-musl)
+      racc (~> 1.4)
+    pp (0.6.3)
+      prettyprint
+    prettyprint (0.2.0)
+    prism (1.9.0)
+    psych (5.3.1)
+      date
+      stringio
+    racc (1.8.1)
+    rack (3.2.5)
+    rack-session (2.1.1)
+      base64 (>= 0.1.0)
+      rack (>= 3.0.0)
+    rack-test (2.2.0)
+      rack (>= 1.3)
+    rackup (2.3.1)
+      rack (>= 3)
+    rails (7.2.3)
+      actioncable (= 7.2.3)
+      actionmailbox (= 7.2.3)
+      actionmailer (= 7.2.3)
+      actionpack (= 7.2.3)
+      actiontext (= 7.2.3)
+      actionview (= 7.2.3)
+      activejob (= 7.2.3)
+      activemodel (= 7.2.3)
+      activerecord (= 7.2.3)
+      activestorage (= 7.2.3)
+      activesupport (= 7.2.3)
+      bundler (>= 1.15.0)
+      railties (= 7.2.3)
+    rails-dom-testing (2.3.0)
+      activesupport (>= 5.0.0)
+      minitest
+      nokogiri (>= 1.6)
+    rails-html-sanitizer (1.7.0)
+      loofah (~> 2.25)
+      nokogiri (>= 1.15.7, != 1.16.7, != 1.16.6, != 1.16.5, != 1.16.4, != 1.16.3, != 1.16.2, != 1.16.1, != 1.16.0.rc1, != 1.16.0)
+    railties (7.2.3)
+      actionpack (= 7.2.3)
+      activesupport (= 7.2.3)
+      cgi
+      irb (~> 1.13)
+      rackup (>= 1.0.0)
+      rake (>= 12.2)
+      thor (~> 1.0, >= 1.2.2)
+      tsort (>= 0.2)
+      zeitwerk (~> 2.6)
+    rake (13.3.1)
+    rdoc (7.2.0)
+      erb
+      psych (>= 4.0.0)
+      tsort
+    reline (0.6.3)
+      io-console (~> 0.5)
+    rspec (3.13.2)
+      rspec-core (~> 3.13.0)
+      rspec-expectations (~> 3.13.0)
+      rspec-mocks (~> 3.13.0)
+    rspec-core (3.13.6)
+      rspec-support (~> 3.13.0)
+    rspec-expectations (3.13.5)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.13.0)
+    rspec-mocks (3.13.8)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.13.0)
+    rspec-rails (8.0.3)
+      actionpack (>= 7.2)
+      activesupport (>= 7.2)
+      railties (>= 7.2)
+      rspec-core (~> 3.13)
+      rspec-expectations (~> 3.13)
+      rspec-mocks (~> 3.13)
+      rspec-support (~> 3.13)
+    rspec-support (3.13.7)
+    securerandom (0.4.1)
+    sqlite3 (2.9.1-aarch64-linux-gnu)
+    sqlite3 (2.9.1-aarch64-linux-musl)
+    sqlite3 (2.9.1-arm-linux-gnu)
+    sqlite3 (2.9.1-arm-linux-musl)
+    sqlite3 (2.9.1-arm64-darwin)
+    sqlite3 (2.9.1-x86_64-darwin)
+    sqlite3 (2.9.1-x86_64-linux-gnu)
+    sqlite3 (2.9.1-x86_64-linux-musl)
+    stringio (3.2.0)
+    thor (1.5.0)
+    timeout (0.6.0)
+    tsort (0.2.0)
+    tzinfo (2.0.6)
+      concurrent-ruby (~> 1.0)
+    useragent (0.16.11)
+    websocket-driver (0.8.0)
+      base64
+      websocket-extensions (>= 0.1.0)
+    websocket-extensions (0.1.5)
+    zeitwerk (2.7.5)
+
+PLATFORMS
+  aarch64-linux-gnu
+  aarch64-linux-musl
+  arm-linux-gnu
+  arm-linux-musl
+  arm64-darwin
+  x86_64-darwin
+  x86_64-linux-gnu
+  x86_64-linux-musl
+
+DEPENDENCIES
+  active_storage-async_variants!
+  appraisal
+  irb
+  rails (~> 7.2.0)
+  rake (~> 13.0)
+  rspec (~> 3.0)
+  rspec-rails
+  sqlite3
+
+BUNDLED WITH
+   2.6.2