active_storage-async_variants 0.8.0 → 0.9.0

data/features/state_rendering.feature

@@ -1,40 +0,0 @@
-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 processing variant renders an indeterminate progress bar before any heartbeat
-    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 a progress bar
-    And the progress bar should be indeterminate
-    And the placeholder image should reserve layout
-
-  Scenario: A processing variant with reported progress renders a determinate progress bar
-    Given a user with an attached avatar
-    And the avatar's :thumb_proc variant is in processing state
-    And the avatar's :thumb_proc variant has reported 42% progress
-    When I visit the avatar page for the :thumb_proc variant
-    Then the page should contain a turbo-frame
-    And the progress bar should show 42%
-
-  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
-    And the frame should render an error progress bar

data/features/step_definitions/dummy_steps.rb

@@ -1,144 +0,0 @@
-# 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 avatar's :(\w+) variant has reported (\d+)% progress$/ do |variant_name, percent|
-  variant = @user.avatar.variant(variant_name.to_sym)
-  record = variant.blob.variant_records.find_by(variation_digest: variant.variation.digest)
-  record.update!(progress: percent.to_i)
-end
-
-Then /^the frame should render a progress bar$/ do
-  expect(page).to have_css("turbo-frame progress-bar", visible: :all)
-end
-
-Then /^the frame should render an error progress bar$/ do
-  expect(page).to have_css("turbo-frame progress-bar[error]", visible: :all)
-end
-
-Then /^the progress bar should be indeterminate$/ do
-  expect(page).to have_css("turbo-frame progress-bar:not([percent])", visible: :all)
-end
-
-Then /^the progress bar should show (\d+)%$/ do |percent|
-  expect(page).to have_css(%(turbo-frame progress-bar[percent="#{percent}"]), visible: :all)
-end
-
-# Default (visible-only) matcher: passes only because the placeholder is hidden
-# via opacity (not visibility/display), so Capybara still sees it.
-Then /^the placeholder image should reserve layout$/ do
-  expect(page).to have_css("turbo-frame .async-variant-processing img")
-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

@@ -1,28 +0,0 @@
-# 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/lib/active_storage/async_variants/asset_tag_helper_extension.rb

@@ -1,59 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveStorage
-  module AsyncVariants
-    # Prepended onto ActionView::Helpers::AssetTagHelper. Adds `async:` and
-    # `direct:` options to image_tag/video_tag; routes unprocessed variants
-    # through a <turbo-frame> whose body lives in StatesController#show.
-    module AssetTagHelperExtension
-      include ActiveStorage::AsyncVariants::Helper
-
-      def image_tag(source, options = {})
-        async_variant_tag(:image, [source], options) do |urls, opts|
-          super(urls.first, opts)
-        end
-      end
-
-      def video_tag(*sources)
-        options = sources.extract_options!
-        async_variant_tag(:video, sources, options) do |urls, opts|
-          super(*urls, opts)
-        end
-      end
-
-      private
-
-      def async_variant_tag(kind, sources, options)
-        options = options.symbolize_keys
-        async = options.delete(:async)
-        direct = options.delete(:direct)
-        return yield(sources, options) if !async && !direct
-
-        variant, *rest = sources
-        assert_async_variant!(variant)
-
-        if async && !async_variant_processed_inline?(variant)
-          async_variant_turbo_frame(variant, kind:, direct:, html_options: options)
-        else
-          yield [async_variant_resolved_src(variant, direct:), *rest], options
-        end
-      end
-
-      def assert_async_variant!(source)
-        unless source.is_a?(ActiveStorage::VariantWithRecord) || source.is_a?(ActiveStorage::Preview)
-          raise ArgumentError, "image_tag/video_tag with async:/direct: requires an ActiveStorage::VariantWithRecord or Preview, got #{source.class}"
-        end
-      end
-
-      def async_variant_turbo_frame(variant, kind:, direct:, html_options:)
-        content_tag(
-          :"turbo-frame",
-          "",
-          id: async_variant_frame_id(variant),
-          src: async_variant_frame_src(variant, kind: kind, direct: direct, html_options: html_options),
-          refresh: "morph",
-        )
-      end
-    end
-  end
-end

data/lib/active_storage/async_variants/helper.rb

@@ -1,80 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveStorage
-  module AsyncVariants
-    # View/controller helper methods. Included in the AssetTagHelperExtension
-    # (so image_tag/video_tag can use them) and added to StatesController via
-    # `helper ActiveStorage::AsyncVariants::Helper` (so the state partials can
-    # use them).
-    module Helper
-      # Invisible box reserving layout for the progress bar. The image src is a
-      # tiny gem GIF whose URL ends in the media filename (no original fetched);
-      # the video placeholder carries no <source>.
-      def async_variant_placeholder_tag(variant, html_options = {}, kind: :image)
-        opts = async_variant_box_dimensions(variant)
-          .merge(html_options.symbolize_keys.except(:src, :controls, :autoplay, :preload, :poster))
-        if kind == :video
-          content_tag(:video, "", opts)
-        else
-          src = Rails.application.routes.url_helpers.async_variant_placeholder_path(variant.blob.filename.to_s)
-          image_tag(src, opts)
-        end
-      end
-
-      def async_variant_box_dimensions(variant)
-        resize = variant.variation.transformations
-          .values_at(:resize_to_limit, :resize_to_fit, :resize_to_fill)
-          .compact.first
-        resize.is_a?(Array) ? { width: resize[0], height: resize[1] } : {}
-      end
-
-      # In test with non-bucket-backed services, the gem defers to vanilla
-      # ActiveStorage (synchronous vips transform) -- inline rendering keeps
-      # those environments simple. Otherwise, only inline a normal <img> when
-      # the variant has reached the processed terminal state.
-      def async_variant_processed_inline?(variant)
-        !variant.blob.bucket_backed? || variant.async_state == "processed"
-      end
-
-      def async_variant_resolved_src(variant, direct:)
-        if direct && variant.async_state == "processed"
-          async_variant_direct_url(variant)
-        else
-          variant.processed if variant.blob.bucket_backed?
-          async_variant_representation_path(variant)
-        end
-      end
-
-      def async_variant_frame_id(variant)
-        digest = variant.variation.digest.gsub(/[^a-zA-Z0-9_-]/, "")
-        "async-variant-#{variant.blob.id}-#{digest}"
-      end
-
-      def async_variant_frame_src(variant, kind:, direct:, html_options: {})
-        async_variant_state_path(
-          signed_blob_id: variant.blob.signed_id,
-          variation_key: variant.variation.key,
-          kind:,
-          direct:,
-          opts: html_options.slice(*PASS_THROUGH_HTML_OPTIONS),
-        )
-      end
-
-      def async_variant_direct_url(variant)
-        if cdn = ActiveStorage::AsyncVariants.cdn_host
-          "#{cdn}/#{variant.key}"
-        else
-          variant.image.url
-        end
-      end
-
-      def async_variant_representation_path(variant)
-        Rails.application.routes.url_helpers.rails_blob_representation_path(
-          variant.blob.signed_id,
-          variant.variation.key,
-          variant.blob.filename.to_s,
-        )
-      end
-    end
-  end
-end