product_tours 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8c3fecc3261d2acf6fb9267139897e7e0c4c6fa9dd3a8d52466380f2fe040c9e
-  data.tar.gz: 0112d06e16cd88171023f3dd32988348e8dd642334db67c5f33cb1c4194363a4
+  metadata.gz: 5493d4177a606096eb7c630c0dd4fbab70a5b68ec013e3033b58217ec7de5c02
+  data.tar.gz: f150d164554a4d4a710214b2924fb191aa28e8aee6f87f813cb5c3418e6c9efc
 SHA512:
-  metadata.gz: 670382b8c322e3803495d1a294aebfc21036aa69400fb7e9055a98de1243c8ba1e716dadacfcd0909885cbd18e77914f7114f54cb2caf1b388e8e9e386ec00da
-  data.tar.gz: 54eb9697c17e7fd50f170dd21e7d15ee994459acd4b7151d98def0f2622586ca40f913dba9f451ceb7676ac5c79cb33bb946b55469e2c342372c83ba4fecc189
+  metadata.gz: 137467ccfedd59ff4abaa2b4a8f35735b8b02bcde9a9439901905191036d419b221f810f92d57ae66737d45ed492b7b5583e0043006ec68eb7c193bac8fa60d5
+  data.tar.gz: 91993e998b3d5fa607b35d38d20c58c3dfe6963d9a3860df6dc2dd9c8f872f496d7bc501e3ae26301bf843987fd53a532fe2eaacd1785c9b6dc7fe093df3776f

data/CHANGELOG.md

@@ -2,6 +2,27 @@
 
 ## [Unreleased]
 
+## [1.1.0] - 2026-10-18
+
+- Add Rails edge CI and experimental Ruby 4.0+ Ractor request support. The host
+  must opt into `Rails.application.ractorize!` and use the upstream Rack/I18n
+  dependencies documented in `docs/ractors.md`.
+- Exercise actual multipart uploads and private downloads in worker Ractors
+  when Active Storage is installed, alongside the optional-dependency-free host.
+- With Action Text, dashboard/editor and tour-content responses run on the
+  main Ractor because Nokogiri is not Ractor safe. Those paths buffer request
+  bodies and responses and do not gain parallel execution; other paths stay
+  on workers.
+- Prepare immutable widget assets and a frozen configuration snapshot at
+  Ractorization. Callbacks still run for each request, with isolated captures;
+  callbacks that capture mutable state fail at boot with the setting name.
+  Normal Rails boots retain mutable configuration and lazy asset loading.
+- Bridge framework operations that are not yet Ractor safe (mounted URL
+  generation, digests/key derivation and attribute factories) to the main
+  Ractor. This adds dispatch overhead in Ractor mode; it is compatibility
+  support, not a claim of improved throughput. Existing Rails 7.1–8.1 installs
+  need no migration or initializer changes.
+
 ## [1.0.0] - 2026-08-11
 
 - **The record is a tour, all the way down.** `ProductTours::Post` is now

data/README.md

@@ -447,3 +447,9 @@ touch your own CSS — and migrations that follow your app's `primary_key_type`.
 
 MIT. If it saved you a subscription, a
 [⭐](https://github.com/yshmarov/product_tours) is a fair trade.
+
+## Rails edge and Ractors
+
+Rails edge is tested alongside Rails 7.1–8.1. Experimental Ruby 4.0+ Ractor hosting
+requires additional upstream dependencies and freezes configuration at startup.
+See [the Ractor hosting guide](docs/ractors.md) for callbacks, requirements and checks.

data/Rakefile

@@ -5,7 +5,7 @@ require 'rake/testtask'
 
 Rake::TestTask.new(:test) do |task|
   task.libs << 'test'
-  task.test_files = FileList['test/**/*_test.rb'].exclude('test/system/**/*')
+  task.test_files = FileList['test/**/*_test.rb'].exclude('test/system/**/*', 'test/ractor/**/*')
 end
 
 namespace :test do
@@ -17,3 +17,11 @@ namespace :test do
 end
 
 task default: :test
+
+namespace :test do
+  desc 'Run isolated configuration and Rails edge Ractor request tests (Ruby 4.0+)'
+  task :ractor do
+    ruby '-Itest', 'test/ractor/configuration_test.rb'
+    ruby '-Itest', 'test/ractor/requests_test.rb'
+  end
+end

data/app/models/product_tours/tour.rb

@@ -10,6 +10,13 @@ module ProductTours
 
     enum :status, STATUSES.index_by(&:itself), default: :draft
 
+    # Explicit methods work in non-main Ractors; Rails' enum-generated
+    # predicates and bang methods are currently unisolated closures.
+    def draft? = status_for_database == 'draft'
+    def draft! = update!(status: 'draft')
+    def published? = status_for_database == 'published'
+    def published! = update!(status: 'published')
+
     has_rich_text :description if respond_to?(:has_rich_text)
 
     has_one_attached :video, service: ProductTours.config.storage_service if defined?(::ActiveStorage)

data/docs/ractors.md

@@ -0,0 +1,138 @@
+# Rails edge and experimental Ractor hosting
+
+The regular CI matrix covers Rails 7.1, 7.2, 8.0 and 8.1. A required Rails
+edge job runs the same suite against `rails/rails` main. A separate job boots
+an eager-loaded host, calls `Rails.application.ractorize!`, and sends real
+Rack requests through the mounted engine in non-main Ractors, including
+simultaneous requests. The Ractor checks run in separate processes because
+Ractorization freezes Rails; they never freeze the ordinary test application.
+
+## Host prerequisites
+
+Ractor hosting currently requires Ruby 4.0+, Rails main, Rack main's
+`rack/ractorize`, and the unreleased [I18n Ractor support](https://github.com/ruby-i18n/i18n/pull/741).
+`gemfiles/rails_ractor.gemfile` records the exact I18n revision tested. These
+are development/test dependencies, not new runtime dependencies for released
+Rails. The gem's supported dependency range remains Rails >= 7.1 and < 9.
+
+For a host experimenting with Ractor hosting, the tested upstream overrides are:
+
+```ruby
+gem "rails", github: "rails/rails", branch: "main"
+gem "rack", github: "rack/rack", branch: "main"
+gem "i18n", github: "Shopify/i18n", ref: "58aa1dcd3e04c34831e1c2ec06c83391559c7c91"
+```
+
+Follow Rails' own Ractor hosting requirements: disable reloading, eager-load
+application code, use a shareable logger/cache and a Ractor-compatible job
+adapter. Before application classes load, enable Rails' callback isolation:
+
+```ruby
+require "active_support/ractors"
+ActiveSupport::Ractors.unshareable_proc_action = :raise
+```
+
+Our isolated fixture uses `ActiveSupport::Ractors::Logger`, a null
+cache, and (where jobs are loaded) `:inline`. Its separate shared counter proves
+that public submission limits remain effective across worker Ractors. The
+ordinary dummy application's `:test` job adapter is unchanged.
+
+The engine prepares itself automatically on `before_ractorize`; ordinary Rails
+boots do not freeze its configuration or load the experimental I18n extension.
+An unavailable I18n Ractor extension produces a startup error explaining the
+prerequisite. Rails edge and Ractor hosting remain experimental: this is not a
+promise that every third-party host middleware, database driver, storage
+service, mail adapter or Action Cable adapter is Ractor safe.
+
+## Configuration and callbacks
+
+Finish configuring ProductTours before calling `ractorize!`. The engine publishes
+a frozen copy of the configuration and warms/freezes widget JS, CSS and content
+fingerprints. Changes after Ractorization require a process restart. Arrays and
+hashes supplied by the host are copied before freezing.
+
+Callbacks are isolated with Ruby's `Ractor.shareable_lambda` or
+`Ractor.shareable_proc`, preserving lambda/proc arity. They continue to receive
+the same request, user, record or event arguments and run on each request.
+Isolated callbacks use arguments and constants; their implicit initializer
+`self` becomes nil, following Rails' isolated callback convention.
+
+```ruby
+ProductTours.configure do |config|
+  config.enabled = ->(request) { request.get_header("HTTP_X_WIDGET") != "off" }
+end
+```
+
+Immutable captured values must already be shareable:
+
+```ruby
+expected_host = "app.example.com".freeze
+ProductTours.configure do |config|
+  config.enabled = ->(request) { request.host == expected_host }
+end
+```
+
+Mutable captures (an array collecting notifications, an unfrozen captured
+string, or reassigned outer locals) cannot be shared. The engine fails at
+startup with `ProductTours.config.<setting>` in the error rather than failing on
+a visitor's request. Use request-local state and external persistence for
+side effects. A pre-isolated callback made with an explicit shareable `self:`
+keeps that receiver. Stateful callable objects must be copyable/shareable;
+custom objects remain subject to Ruby's Ractor rules.
+
+## Scope and cost
+
+Some Rails main paths are still being converted to Ractors. The engine warms
+model attributes and controller names, prepares ETag callbacks, and supplies
+narrow bridges for mounted URL generation, cache freshness, digest/key
+operations, GlobalID URI decoding and boot-time attribute decorators. Those bridges preserve the
+original operation on the main Ractor; requests, authorization callbacks,
+rendering and persistence orchestration execute in their worker Ractors.
+Adapter name quoting delegates to its original implementation on the main Ractor,
+which preserves escaping and avoids process-global mutable caches in workers.
+Disk-backed uploads use Ractor-local storage clients and plain temporary files
+with explicit cleanup, because Tempfile's generated delegation methods cannot
+be called from another Ractor. MIME registrations must finish before
+Ractorization, when Marcel's MIME tables become immutable. Eager model schema
+preparation adds startup database work.
+The bridges are internal compatibility code, add coordination overhead, and
+must be reviewed as upstream Rails evolves. No throughput improvement is claimed.
+
+## Run the checks
+
+Use the Ruby configured in `mise.toml`, never macOS's system Ruby.
+
+```sh
+BUNDLE_GEMFILE=gemfiles/rails_edge.gemfile bundle install
+BUNDLE_GEMFILE=gemfiles/rails_edge.gemfile bundle exec rake test
+BUNDLE_GEMFILE=gemfiles/rails_ractor.gemfile bundle install
+BUNDLE_GEMFILE=gemfiles/rails_ractor.gemfile bundle exec rake test:ractor
+```
+
+The request fixture creates and removes its own temporary database and host;
+it does not reuse or freeze `test/dummy`. The shared schema lives in
+`test/support/schema.rb` so the ordinary and Ractor suites exercise the same
+record shape. Successful checks establish the tested SQLite host and explicit
+request paths, not all combinations of host integrations.
+
+The media job also runs with `RACTOR_MEDIA=1`, exercising private disk-backed
+Active Storage downloads through the engine's authorization gate. Storage
+services are initialized per Ractor, and streamed responses use a thread local
+to that Ractor. Livechat additionally runs with `RACTOR_CABLE=1`, checking the
+signed stream token and broadcasts delegated to the main Action Cable server.
+Other storage services and production Cable adapters need host-specific QA.
+
+## Action Text and Nokogiri
+
+When Action Text is loaded, Nokogiri's native parser refuses to run outside the
+main Ractor. Product Tours therefore delegates its HTML dashboard/editor paths
+and `/widget/tour` responses to the main Rails application. It keeps the original
+Action Text sanitizer, rendering, callbacks and transactions intact, including
+rich-text editing. Request bodies and responses for those paths are buffered;
+large editor uploads therefore have an extra memory cost. These paths do not
+run in parallel. Static assets, lifecycle signals and gated media downloads
+continue in worker Ractors. A host without Action Text does not use this fallback.
+The Ractor media CI job covers both video uploads and rich-text rendering.
+
+The Product Tours Ractor matrix separately checks a minimal host, an Active
+Storage host without Action Text (`RACTOR_TEXT=0`), and a host with both engines.

data/lib/product_tours/engine.rb

@@ -4,8 +4,20 @@ require 'rails'
 
 module ProductTours
   class Engine < ::Rails::Engine
+    initializer 'product_tours.ractor_middleware' do |app|
+      app.middleware.insert_before 0, RactorSupport::Middleware
+    end
+
     isolate_namespace ProductTours
 
+    initializer 'product_tours.ractorize', before: 'action_controller.ractorize' do
+      if Rails::Application.method_defined?(:ractorize!)
+        Engine.routes.singleton_class.prepend(RactorSupport::MountedRoutes)
+      end
+
+      ActiveSupport.on_load(:before_ractorize) { ProductTours::RactorSupport.prepare! }
+    end
+
     initializer 'product_tours.helpers' do
       ActiveSupport.on_load(:action_view) do
         include ProductTours::WidgetHelper

data/lib/product_tours/ractor_support.rb

@@ -0,0 +1,519 @@
+# frozen_string_literal: true
+
+module ProductTours
+  # Used only by Rails' opt-in before_ractorize hook. Normal Rails boots keep
+  # mutable configuration and lazy assets, including on older Ruby versions.
+  module RactorSupport
+    # Small bridges for framework paths that Rails main does not prepare yet.
+    # They are installed only when the host explicitly calls ractorize!.
+    # Rails' built-in JSON renderer is still defined from an unisolated Proc.
+    # Keep its JSON/JSONP and escaping behavior in a regular Ruby method.
+    module JsonRendering
+      def _render_with_renderer_json(json, options)
+        json_options = options.except(:callback, :content_type, :status)
+        json_options[:escape] ||= false if !self.class.escape_json_responses? && options[:callback].blank?
+        json = json.to_json(json_options) unless json.is_a?(String)
+        if options[:callback].present?
+          self.content_type = :js if media_type.nil? || media_type == Mime[:json]
+          "/**/#{options[:callback]}(#{json})"
+        else
+          self.content_type = :json if media_type.nil?
+          json
+        end
+      end
+    end
+
+    module DependencyInterlock
+      def interlock
+        return super if Ractor.main?
+
+        Ractor[:engine_dependency_interlock] ||= ActiveSupport::Dependencies::Interlock.new
+      end
+    end
+
+    module LiveThreads
+      private
+
+      def new_controller_thread
+        return super if Ractor.main?
+
+        Thread.new do
+          Thread.current.abort_on_exception = true
+          yield
+        end
+      end
+    end
+
+    module UniquenessCoverage
+      private
+
+      def covered_by_unique_index?(klass, record, attribute, scope)
+        return super unless frozen?
+
+        copies = Ractor[:engine_uniqueness_validators] ||= {}
+        copy = copies[[self, klass]] ||= dup
+        copy.send(:covered_by_unique_index?, klass, record, attribute, scope)
+      end
+    end
+
+    # GlobalID calls CGI.unescape without an encoding, whose default reads a
+    # process-wide class variable. Preserve CGI's configured default on main.
+    module UriUnescaping
+      def unescape(string, *arguments)
+        return super if Ractor.main?
+
+        shared_arguments = Ractor.make_shareable([string, *arguments], copy: true)
+        ActiveSupport::Ractors.on_main(self) { unescape(*shared_arguments) }
+      end
+    end
+
+    module CacheFreshness
+      def strict_freshness
+        return super if Ractor.main?
+
+        ActiveSupport::Ractors.on_main(self) { strict_freshness }
+      end
+    end
+
+    # Attribute decorators (including Rails enums and serialized attributes)
+    # are boot-time factories. Keep their original receivers and captures on
+    # the main Ractor, rather than changing the semantics of Rails' closures.
+    class Decorator
+      def initialize(callback)
+        @key = RactorSupport.register_decorator(callback)
+        freeze
+      end
+
+      def call(*arguments)
+        return RactorSupport.call_decorator(@key, arguments) if Ractor.main?
+
+        shared_arguments = Ractor.make_shareable(arguments, copy: true)
+        ActiveSupport::Ractors.on_main(self) { RactorSupport.call_decorator(@key, shared_arguments) }
+      end
+    end
+
+    def self.register_decorator(callback)
+      @decorators ||= []
+      @decorators << callback
+      @decorators.length - 1
+    end
+
+    def self.call_decorator(key, arguments)
+      @decorators.fetch(key).call(*arguments)
+    end
+
+    def self.prepare_attributes(model)
+      prepare_attributes(model.superclass) if model.superclass.respond_to?(:pending_attribute_modifications, true)
+      model.send(:pending_attribute_modifications)&.each do |modification|
+        next unless modification.respond_to?(:decorator) && modification.decorator.is_a?(Proc)
+
+        modification.decorator = Decorator.new(modification.decorator)
+      end
+    end
+
+    module AdapterQuoting
+      def quote_column_name(name)
+        return super if Ractor.main?
+
+        shared_name = Ractor.make_shareable(name, copy: true)
+        ActiveSupport::Ractors.on_main(self) { quote_column_name(shared_name) }
+      end
+
+      def quote_table_name(name)
+        return super if Ractor.main?
+
+        shared_name = Ractor.make_shareable(name, copy: true)
+        ActiveSupport::Ractors.on_main(self) { quote_table_name(shared_name) }
+      end
+    end
+
+    # Route arguments can contain records with native Set caches. Only their
+    # to_param value is needed to generate a mount prefix; keep the caller's
+    # original record objects in the options passed to the actual route.
+    def self.routing_snapshot(value)
+      return value if Ractor.shareable?(value)
+
+      copy = case value
+             when ActiveRecord::Base then value.to_param
+             when Hash then value.to_h { |key, item| [routing_snapshot(key), routing_snapshot(item)] }
+             when Array then value.map { |item| routing_snapshot(item) }
+             when Set then Set.new(value.map { |item| routing_snapshot(item) })
+             else return Ractor.make_shareable(value, copy: true)
+             end
+      Ractor.make_shareable(copy)
+    end
+
+    module MountedRoutes
+      def find_script_name(options)
+        return super unless defined?(Ractor.shareable_proc) && !Ractor.main?
+
+        shared_options = RactorSupport.routing_snapshot(options)
+        prefix, updated = ActiveSupport::Ractors.on_main(self) do
+          local_options = shared_options.dup
+          [find_script_name(local_options), local_options]
+        end
+        (shared_options.keys - updated.keys).each { |key| options.delete(key) }
+        updated.each do |key, value|
+          options[key] = value unless shared_options.key?(key) && shared_options[key] == value
+        end
+        prefix
+      end
+    end
+
+    module Digesting
+      def hexdigest(value)
+        return super if Ractor.main?
+
+        shared_value = Ractor.make_shareable(value, copy: true)
+        ActiveSupport::Ractors.on_main(self) { hexdigest(shared_value) }
+      end
+    end
+
+    module KeyGeneration
+      def generate_key(salt, key_size = 64)
+        return super if Ractor.main?
+
+        shared_salt = Ractor.make_shareable(salt, copy: true)
+        ActiveSupport::Ractors.on_main(self) { generate_key(shared_salt, key_size) }
+      end
+    end
+
+    module UploadCleanup
+      def open
+        reopen(path, 'rb+')
+        self
+      end
+
+      # Tempfile#close takes a positional unlink flag.
+      def close(unlink_now = false) # rubocop:disable Style/OptionalBooleanParameter
+        super() unless closed?
+        unlink if unlink_now
+      end
+
+      def unlink
+        File.unlink(path)
+      rescue Errno::ENOENT
+        nil
+      end
+
+      def close!
+        close(true)
+      end
+    end
+
+    def self.upload_tempfile(filename, _content_type)
+      extension = File.extname(filename.gsub("\0", '%00'))[0, 129]
+      Tempfile.create(['RackMultipart', extension]).extend(UploadCleanup)
+    end
+
+    # Nokogiri's native parser is not Ractor safe. Keep Action Text page
+    # processing on the main Ractor, preserving Rails' renderer, sanitizer,
+    # callbacks and transaction behavior rather than duplicating their logic.
+    def self.main_page?(env)
+      return false unless @action_text && !Ractor.main?
+
+      mount = ProductTours.config.mount_path.chomp('/')
+      request_path = env['PATH_INFO'].to_s
+      return false unless request_path == mount || request_path.start_with?("#{mount}/")
+
+      path = request_path.delete_prefix(mount)
+      path.empty? || path == '/' || path == '/tours' || path.start_with?('/tours/') || path == '/widget/tour'
+    end
+
+    def self.main_page(env)
+      headers = env.select do |_key, value|
+        Ractor.shareable?(value) || value.is_a?(String) || value.is_a?(Numeric)
+      end
+      shared_env = Ractor.make_shareable(headers, copy: true)
+      shared_input = Ractor.make_shareable(env['rack.input']&.read.to_s)
+      ActiveSupport::Ractors.on_main(Rails.application) do
+        request_env = shared_env.transform_values { |value| value.is_a?(String) ? value.dup : value }
+        request_env['rack.input'] = StringIO.new(shared_input)
+        request_env['rack.errors'] = $stderr
+        status, response_headers, body = call(request_env)
+        content = +''
+        begin
+          body.each { |part| content << part }
+        ensure
+          body.close if body.respond_to?(:close)
+        end
+        [status, response_headers, [content]]
+      end
+    end
+
+    class Middleware
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        return RactorSupport.main_page(env) if RactorSupport.main_page?(env)
+
+        if (fallbacks = RactorSupport.fallbacks)
+          Fiber[:i18n_fallbacks] ||= fallbacks
+          env['rack.multipart.tempfile_factory'] ||= RactorSupport.method(:upload_tempfile) unless Ractor.main?
+        end
+        @app.call(env)
+      end
+    end
+
+    def self.fallbacks
+      @fallbacks
+    end
+
+    module StorageMetadata
+      def analyzed = read_store_attribute(:metadata, :analyzed)
+      def identified = read_store_attribute(:metadata, :identified)
+      def composed = read_store_attribute(:metadata, :composed)
+
+      def analyzed=(value)
+        write_store_attribute(:metadata, :analyzed, value)
+      end
+
+      def identified=(value)
+        write_store_attribute(:metadata, :identified, value)
+      end
+
+      def composed=(value)
+        write_store_attribute(:metadata, :composed, value)
+      end
+    end
+
+    class StorageServices
+      def initialize(configurations)
+        @configurations = Ractor.make_shareable(configurations, copy: true)
+        freeze
+      end
+
+      def fetch(name, &)
+        registry = if Ractor.main?
+                     RactorSupport.storage_registry
+                   else
+                     Ractor[:engine_storage_services] ||= ActiveStorage::Service::Registry.new(@configurations)
+                   end
+        registry.fetch(name, &)
+      end
+    end
+
+    def self.storage_registry
+      @storage_registry
+    end
+
+    module StorageChecksums
+      def checksum_implementation(**options)
+        implementation = super
+        if Ractor.main? || !implementation.respond_to?(:name) || !implementation.name&.start_with?('OpenSSL::Digest::')
+          return implementation
+        end
+
+        DigestFactory.new(implementation.name.delete_prefix('OpenSSL::Digest::'))
+      end
+    end
+
+    class DigestFactory
+      def initialize(algorithm)
+        @algorithm = algorithm.freeze
+        freeze
+      end
+
+      def new
+        OpenSSL::Digest.new(@algorithm)
+      end
+
+      def file(io)
+        new.file(io)
+      end
+
+      def base64digest(value)
+        new.base64digest(value)
+      end
+    end
+
+    def self.prepare_redirects!
+      base = ActionController::Base
+      readers = Module.new
+      %i[raise_on_open_redirects action_on_open_redirect action_on_path_relative_redirect].each do |key|
+        source = base.method(key).source_location&.first
+        next unless source&.end_with?('/action_controller/metal/redirecting.rb')
+
+        value = Ractor.make_shareable(base.public_send(key), copy: true)
+        readers.define_method(key, Ractor.shareable_proc { Ractor.main? ? super() : value })
+      end
+      return if readers.instance_methods(false).empty?
+
+      base.prepend(readers)
+      base.singleton_class.prepend(readers)
+    end
+
+    def self.prepare_previewers!
+      ActiveStorage.previewers.each do |previewer|
+        readers = Module.new
+        previewer.methods.grep(/_exists\?\z/).each do |capability|
+          method = previewer.method(capability)
+          next unless method.arity.zero? && method.source_location&.first&.include?('/active_storage/previewer/')
+
+          readers.define_method(capability, Ractor.shareable_proc do
+            if Ractor.main?
+              super()
+            else
+              ActiveSupport::Ractors.on_main(self) { public_send(capability) }
+            end
+          end)
+        end
+        previewer.singleton_class.prepend(readers) unless readers.instance_methods(false).empty?
+      end
+    end
+
+    def self.prepare_storage!
+      return unless defined?(ActiveStorage::Blob)
+
+      prepare_previewers!
+      ActiveStorage::Blob.prepend(StorageMetadata) unless ActiveStorage::Blob < StorageMetadata
+      %i[EXTENSIONS TYPE_EXTS TYPE_ALIASES TYPE_PARENTS ROOT_XML MAGIC].each do |name|
+        Ractor.make_shareable(Marcel.const_get(name)) if Marcel.const_defined?(name)
+      end
+      ActiveStorage::Service.prepend(StorageChecksums) unless ActiveStorage::Service < StorageChecksums
+      unless Ractor.shareable?(ActiveStorage::Blob.services)
+        @storage_registry = ActiveStorage::Blob.services
+        configurations = @storage_registry.instance_variable_get(:@configurations)
+        default_name = ActiveStorage::Blob.service.name
+        default_reader = Module.new
+        default_reader.define_method(:service, Ractor.shareable_proc do
+          Ractor.main? ? super() : services.fetch(default_name)
+        end)
+        ActiveStorage::Blob.singleton_class.prepend(default_reader)
+        ActiveStorage::Blob.services = StorageServices.new(configurations)
+      end
+      settings = ActiveStorage.class_variables.map { |name| name.to_s.delete_prefix('@@').to_sym }
+      settings.select! { |key| ActiveStorage.respond_to?(key) }
+      snapshot = settings.to_h { |key| [key, ActiveStorage.public_send(key)] }
+      checksum = snapshot[:checksum_implementation]
+      if checksum.is_a?(Class) && checksum.name&.start_with?('OpenSSL::Digest::')
+        snapshot[:checksum_implementation] = DigestFactory.new(checksum.name.delete_prefix('OpenSSL::Digest::'))
+      end
+      Ractor.make_shareable(snapshot)
+      readers = Module.new
+      settings.each do |key|
+        readers.define_method(key, Ractor.shareable_proc { Ractor.main? ? super() : snapshot.fetch(key) })
+      end
+      ActiveStorage.singleton_class.prepend(readers)
+    end
+
+    def self.prepare_framework!
+      CGI.singleton_class.prepend(UriUnescaping) unless CGI.singleton_class < UriUnescaping
+      Ractor.make_shareable(GlobalID.app) if defined?(GlobalID) && GlobalID.respond_to?(:app)
+      I18n.available_locales.each { |locale| I18n.transliterate('ractor', locale: locale) }
+      require 'i18n/ractorize'
+      require 'tempfile'
+      prepare_redirects!
+      %i[BASE36_ALPHABET BASE58_ALPHABET].each do |name|
+        Ractor.make_shareable(SecureRandom.const_get(name)) if SecureRandom.const_defined?(name)
+      end
+      uniqueness = ActiveRecord::Validations::UniquenessValidator
+      uniqueness.prepend(UniquenessCoverage) unless uniqueness < UniquenessCoverage
+      dependencies = ActiveSupport::Dependencies.singleton_class
+      dependencies.prepend(DependencyInterlock) unless dependencies < DependencyInterlock
+      prepare_storage!
+      Ractor.make_shareable(ActiveRecord::Associations::AssociationScope::INSTANCE)
+      Ractor.make_shareable(ActionDispatch::Http::Cache::Response::SPECIAL_KEYS)
+      freshness = ActionDispatch::Http::Cache::Request.singleton_class
+      freshness.prepend(CacheFreshness) unless freshness < CacheFreshness
+      fallbacks = I18n.fallbacks
+      I18n.available_locales.each { |locale| fallbacks[locale] }
+      @fallbacks = Ractor.make_shareable(fallbacks)
+      ActiveSupport::Digest.singleton_class.prepend(Digesting) unless ActiveSupport::Digest.singleton_class < Digesting
+      ActiveSupport::KeyGenerator.prepend(KeyGeneration) unless ActiveSupport::KeyGenerator < KeyGeneration
+      ActiveRecord::Base.connection_handler.connection_pool_list.each do |pool|
+        adapter = pool.db_config.adapter_class.singleton_class
+        adapter.prepend(AdapterQuoting) unless adapter < AdapterQuoting
+      end
+    rescue LoadError => e
+      raise LoadError,
+            "Ractor requests need the upstream I18n Ractor support (see gemfiles/rails_ractor.gemfile): #{e.message}"
+    end
+
+    def self.prepare!
+      @action_text = defined?(ActionText) ? true : false
+      # A cache store can reference the whole middleware stack and freeze
+      # other mounted engines before their own hooks run. Warm every engine's
+      # request environment before making any of that graph shareable.
+      Rails.application.railties.each do |railtie|
+        railtie.env_config if railtie.is_a?(Rails::Engine)
+      end
+      Engine.instance.env_config
+      prepare_framework!
+      ActiveRecord::Base.descendants.each do |model|
+        next if model.abstract_class? || !model.table_exists?
+
+        model.reflect_on_all_associations.each { |reflection| reflection.send(:inverse_name) }
+        prepare_attributes(model)
+        Ractor.make_shareable(model.defined_enums)
+        model.defined_enums.each do |attribute, mapping|
+          method_name = attribute.pluralize
+          source = model.method(method_name).source_location&.first
+          next unless source&.end_with?('/active_record/enum.rb')
+
+          model.define_singleton_method(method_name, Ractor.shareable_proc { mapping })
+        end
+        model.define_attribute_methods
+        if model.respond_to?(:attachment_reflections)
+          model.attachment_reflections.each_value(&:named_variants)
+          Ractor.make_shareable(model.attachment_reflections)
+        end
+      end
+      ActionController::Base.descendants.each do |controller|
+        next unless controller.name&.start_with?('ProductTours::')
+
+        controller.prepend(LiveThreads) if defined?(ActionController::Live) && controller < ActionController::Live
+        renderer_source = controller.instance_method(:_render_with_renderer_json).source_location&.first
+        if renderer_source&.end_with?('/action_controller/metal/renderers.rb') && !(controller < JsonRendering)
+          controller.prepend(JsonRendering)
+        end
+        Ractor.make_shareable(controller.controller_name)
+        controller.etaggers = controller.etaggers.map { |callback| Ractor.shareable_proc(&callback) }.freeze
+      end
+      ProductTours.instance_variable_set(:@config, configuration(ProductTours.config))
+      %i[javascript dashboard_javascript dashboard_stylesheet fingerprint
+         dashboard_fingerprint dashboard_stylesheet_fingerprint].each do |method|
+        next unless Widget.respond_to?(method)
+
+        Widget.public_send(method)
+      end
+      Widget.instance_variables.each do |variable|
+        Widget.instance_variable_set(variable, Ractor.make_shareable(Widget.instance_variable_get(variable)))
+      end
+    end
+
+    def self.configuration_value(value)
+      case value
+      when Proc
+        return value if Ractor.shareable?(value)
+
+        # Like Rails callbacks, isolated callbacks use arguments and constants,
+        # not their initializer's implicit self. Keep lambda/proc arity intact.
+        value.lambda? ? Ractor.shareable_lambda(&value) : Ractor.shareable_proc(&value)
+      when Hash
+        value.to_h { |key, item| [configuration_value(key), configuration_value(item)] }.freeze
+      when Array
+        value.map { |item| configuration_value(item) }.freeze
+      else
+        Ractor.make_shareable(value, copy: true)
+      end
+    end
+
+    def self.configuration(original)
+      prepared = original.dup
+      original.instance_variables.each do |variable|
+        value = original.instance_variable_get(variable)
+        begin
+          shared = configuration_value(value)
+          prepared.instance_variable_set(variable, shared)
+        rescue Ractor::Error, TypeError => e
+          setting = variable.to_s.delete_prefix('@')
+          raise ArgumentError, "ProductTours.config.#{setting} cannot be shared with Ractors: #{e.message}"
+        end
+      end
+      Ractor.make_shareable(prepared)
+    end
+  end
+end

data/lib/product_tours/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ProductTours
-  VERSION = '1.0.0'
+  VERSION = '1.1.0'
 end

data/lib/product_tours/widget.rb

@@ -5,9 +5,9 @@ require 'json'
 
 module ProductTours
   module Widget
-    SOURCE = File.expand_path('widget.js', __dir__)
-    DASHBOARD_SOURCE = File.expand_path('dashboard.js', __dir__)
-    DASHBOARD_STYLESHEET_SOURCE = File.expand_path('dashboard.css', __dir__)
+    SOURCE = File.expand_path('widget.js', __dir__).freeze
+    DASHBOARD_SOURCE = File.expand_path('dashboard.js', __dir__).freeze
+    DASHBOARD_STYLESHEET_SOURCE = File.expand_path('dashboard.css', __dir__).freeze
     RTL_LANGUAGES = %w[ar arc ckb dv fa ha he ks ku ps sd ug ur yi].freeze
 
     class << self

data/lib/product_tours.rb

@@ -2,6 +2,7 @@
 
 require 'product_tours/version'
 require 'product_tours/configuration'
+require 'product_tours/ractor_support'
 require 'product_tours/errors'
 require 'product_tours/video_resolver'
 require 'product_tours/video_metadata'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: product_tours
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors:
 - Yaroslav Shmarov
@@ -92,6 +92,7 @@ files:
 - config/locales/product_tours.vi.yml
 - config/locales/product_tours.zh-CN.yml
 - config/routes.rb
+- docs/ractors.md
 - docs/screenshots/01-walkthrough.jpg
 - docs/screenshots/02-dashboard.jpg
 - docs/screenshots/03-mobile.jpg
@@ -107,6 +108,7 @@ files:
 - lib/product_tours/dashboard.js
 - lib/product_tours/engine.rb
 - lib/product_tours/errors.rb
+- lib/product_tours/ractor_support.rb
 - lib/product_tours/seeds.rb
 - lib/product_tours/version.rb
 - lib/product_tours/video_metadata.rb
@@ -138,7 +140,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.16
+rubygems_version: 4.0.20
 specification_version: 4
 summary: Self-hosted product tours and video tutorials for Rails apps.
 test_files: []