i18n_proofreading 1.0.1 → 1.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1018fa5f4f5be802e224bfc1a8bf5e93b1cff5c9122e854327792a9ffc89c0eb
-  data.tar.gz: 48b4c23cef0d8aac0ba47f996be007b259d3354fffa6065a1fea5f820b4802eb
+  metadata.gz: 9a73bed80d485e35617f3ea214165c0ffcfc296721ac896f09d389cbf3a1b6e8
+  data.tar.gz: 4cc2e32bf3420c01ea3af58c33582ffaa37c9fd26cf6e7425db1b554c4652c84
 SHA512:
-  metadata.gz: cb442c1774c324987f44e8a347f74f061cd7ee64388df006f77b4a7d94ff6b6e57844303190f9fce36d7f556d7391160a1ef611e2424fe9a2a090d78638f16df
-  data.tar.gz: 3094f3c4160701c912116a499be621486b1f718168450b8030956bb43d3b1864576e7a278a95e948552444969c45835b150f7a05cd50106408bd9b3dfa381587
+  metadata.gz: 1c884b9b47f7e5712ab618fc663f5160ed7d7eabd571b295818efe445f11111f2bbb81e7110336594c7885d79c032479241623a33bb81d170309165ccb522f40
+  data.tar.gz: 7c939c1e63d708c6772dcd4e703816967942b1ca2400a05027cbd8fa200ec1c446de390daf2bca70cf5313eccaa4615dc132464ffbe395a3a8cfb19d84ba04f0

data/CHANGELOG.md

@@ -2,6 +2,50 @@
 
 ## [Unreleased]
 
+## [1.1.1] - 2026-10-30
+
+### Fixed
+
+- **A Turbo visit to a page without the tool now switches the widget off.**
+  Before, the widget kept the previous page's config when the new page carried
+  none, so the pill survived a sign-out or `enabled` turning false until a hard
+  reload, and a visit made while in suggest mode (Back, `Turbo.visit`) kept
+  every click on the new page frozen. A host that worked around this with a
+  `data-turbo-track="reload"` element can drop it.
+- **The pill comes back after a Turbo render that has no `turbo:load`**, such
+  as a form answered with a 422 or a morph refresh. The widget's per-page setup
+  now runs on `turbo:render` as well as `turbo:load`; it is idempotent, so a
+  normal visit runs it twice at the cost of rebuilding one button.
+- Costs: a page with a malformed config block now gets no widget instead of the
+  previous page's; a host that injects the tag in only some layouts sees the
+  pill only on those pages. No configuration, migration, or server-side change.
+- Close a suggestion dialog that a custom render preserves after suggest mode
+  becomes unavailable or inactive, releasing its scroll and focus locks. Any
+  unsent draft in that dialog is discarded when leaving suggest mode.
+
+### Changed
+
+- Exercise real Turbo visits, cached history, 422 responses, and morph refreshes
+  in browser tests. Turbo is a development/test dependency only; the installed
+  gem still has no Turbo dependency or asset build step.
+
+## [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 widget injection, suggestions, the read-only dashboard and request
+  callbacks through the mounted engine in worker Ractors.
+- 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.1] - 2026-08-11
 
 - **A failing `on_submit` hook no longer turns a saved suggestion into a 500.**

data/README.md

@@ -314,6 +314,9 @@ configure Action View during initialization can boot reliably.
   `script-src` including `strict-dynamic`. Runtime config ships as
   `<script type="application/json">` (data, not code), so it needs no nonce and
   survives Turbo visits.
+- **The browser follows the server's gate across Turbo visits.** A page the
+  middleware injected nothing into (signed out, `enabled` false) turns the
+  widget off: no pill and no suggest mode, even when the previous page had them.
 - **Rate-limited per IP** on the submission endpoint (30/min by default,
   Rails 7.2+).
 - **Host-owned review data.** A row may contain translated text, proposed text,
@@ -357,3 +360,9 @@ touch your own CSS — and migrations that follow your app's `primary_key_type`.
 ## License
 
 MIT.
+
+## 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

@@ -10,7 +10,7 @@ require 'rake/testtask'
 # Unit/integration tests — no browser, runs on every Ruby x Rails combo.
 Rake::TestTask.new(:test) do |t|
   t.libs << 'test'
-  t.test_files = FileList['test/**/*_test.rb'].exclude('test/system/**/*')
+  t.test_files = FileList['test/**/*_test.rb'].exclude('test/system/**/*', 'test/ractor/**/*')
   t.warning = false
   t.verbose = false
 end
@@ -24,3 +24,11 @@ Rake::TestTask.new('test:system') do |t|
 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/controllers/i18n_proofreading/submissions_controller.rb

@@ -15,7 +15,7 @@ module I18nProofreading
     # Rails.cache); a no-op on Rails 7.1. Tune or disable via config.rate_limit —
     # read once at boot, after the host's initializer.
     if respond_to?(:rate_limit) && I18nProofreading.config.rate_limit
-      rate_limit(**I18nProofreading.config.rate_limit,
+      I18nProofreading::RactorSupport.rate_limit(self, **I18nProofreading.config.rate_limit,
                  only: :create,
                  with: lambda {
                    render json: { errors: ['Too many suggestions. Please slow down and try again.'] },

data/app/models/i18n_proofreading/suggestion.rb

@@ -13,6 +13,15 @@ module I18nProofreading
 
     enum :status, STATUSES.index_by(&:itself), prefix: :status, default: :pending
 
+    # Explicit methods work in non-main Ractors; Rails' enum-generated
+    # predicates and bang methods are currently unisolated closures.
+    def status_pending? = status_for_database == 'pending'
+    def status_pending! = update!(status: 'pending')
+    def status_applied? = status_for_database == 'applied'
+    def status_applied! = update!(status: 'applied')
+    def status_rejected? = status_for_database == 'rejected'
+    def status_rejected! = update!(status: 'rejected')
+
     validates :translation_key, presence: true, length: { maximum: 500 }
     validates :proposed_value, presence: true, length: { maximum: 5_000 }
     validates :old_value, length: { maximum: 5_000 }

data/docs/ractors.md

@@ -0,0 +1,123 @@
+# 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 I18nProofreading 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
+I18nProofreading.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
+I18nProofreading.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 `I18nProofreading.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.

data/lib/i18n_proofreading/engine.rb

@@ -2,8 +2,19 @@
 
 module I18nProofreading
   class Engine < ::Rails::Engine
+    initializer 'i18n_proofreading.ractor_middleware' do |app|
+      app.middleware.insert_before 0, RactorSupport::Middleware
+    end
+
     isolate_namespace I18nProofreading
 
+    initializer 'i18n_proofreading.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) { I18nProofreading::RactorSupport.prepare! }
+    end
+
     rake_tasks do
       load File.expand_path('../tasks/i18n_proofreading_tasks.rake', __dir__)
     end

data/lib/i18n_proofreading/ractor_support.rb

@@ -0,0 +1,518 @@
+# frozen_string_literal: true
+
+module I18nProofreading
+  # 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
+
+    class Middleware
+      def initialize(app)
+        @app = app
+      end
+
+      def call(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!
+      # 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?('I18nProofreading::')
+
+        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
+      I18nProofreading.instance_variable_set(:@config, configuration(I18nProofreading.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
+      ActionController::Base.descendants.each do |controller|
+        next unless controller.respond_to?(:i18n_proofreading_rate_limit_options)
+
+        options = controller.i18n_proofreading_rate_limit_options
+        controller.i18n_proofreading_rate_limit_options = share_options(options)
+      end
+      Widget.instance_variables.each do |variable|
+        Widget.instance_variable_set(variable, Ractor.make_shareable(Widget.instance_variable_get(variable)))
+      end
+    end
+
+    # Rails edge's rate_limit currently closes over reassigned keyword
+    # arguments. A named filter avoids that unshareable closure; the actual
+    # counter, cache key and rejection still use Rails' rate_limiting method.
+    def self.rate_limit(controller, to:, within:, only:, with:, **options)
+      unless Rails::Application.method_defined?(:ractorize!)
+        return controller.rate_limit(to: to, within: within, only: only, with: with, **options)
+      end
+
+      controller.class_attribute :i18n_proofreading_rate_limit_options, instance_accessor: false
+      controller.i18n_proofreading_rate_limit_options = {
+        to: to, within: within, by: -> { request.remote_ip }, with: with,
+        store: controller.cache_store, name: nil, scope: controller.controller_path
+      }.merge(options.slice(:by, :store, :name, :scope))
+      controller.i18n_proofreading_rate_limit_options[:scope] ||= controller.controller_path
+      filters = options.except(:by, :store, :name, :scope)
+      controller.before_action :i18n_proofreading_rate_limit, only: only, **filters
+      controller.class_eval <<~RUBY, __FILE__, __LINE__ + 1
+        private
+        def i18n_proofreading_rate_limit
+          rate_limiting(**self.class.i18n_proofreading_rate_limit_options)
+        end
+      RUBY
+    end
+
+    def self.share_options(options)
+      options.to_h do |key, value|
+        value = configuration_value(value) if value.is_a?(Proc)
+        [key, Ractor.make_shareable(value)]
+      end.freeze
+    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, "I18nProofreading.config.#{setting} cannot be shared with Ractors: #{e.message}"
+        end
+      end
+      Ractor.make_shareable(prepared)
+    end
+  end
+end

data/lib/i18n_proofreading/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module I18nProofreading
-  VERSION = '1.0.1'
+  VERSION = '1.1.1'
 end

data/lib/i18n_proofreading/widget.js

@@ -20,6 +20,12 @@
   if (!config || window.__i18nProofreadingLoaded) return;
   window.__i18nProofreadingLoaded = true;
 
+  // The state of a page without a config block: the middleware injected
+  // nothing, so the tool is not available there (signed out, `enabled` false,
+  // a layout without the tag). Handlers read `config.active`, so this keeps
+  // them inert instead of acting on the last page's config.
+  var UNAVAILABLE = { active: false, showPill: false };
+
   var LEFT = "⟦"; // ⟦
   var RIGHT = "⟧"; // ⟧
   var TOKEN = new RegExp(LEFT + "([^" + RIGHT + "]+)" + RIGHT);
@@ -56,9 +62,13 @@
 
     // Everything else lives in <body>, which Turbo replaces on every visit —
     // taking the pill and the active-mode highlighting with it. Re-run the
-    // per-page setup on each visit so the widget keeps working without a hard
-    // reload. render() also runs now for the initial (or non-Turbo) load.
+    // per-page setup after every body swap so the widget keeps working without
+    // a hard reload. render() also runs now for the initial (or non-Turbo) load.
+    // turbo:render covers swaps with no turbo:load after them (a form answered
+    // with a 422 or 500, a morph refresh); turbo:load covers the rest. render()
+    // is idempotent, so a visit that fires both only rebuilds one button.
     render();
+    document.addEventListener("turbo:render", render);
     document.addEventListener("turbo:load", render);
     document.addEventListener("turbo:frame-load", function () { strip(); });
 
@@ -88,18 +98,23 @@
 
   function render() {
     // Re-read on each visit: the injected config is data (not an executed
-    // script), so it reflects the page Turbo just rendered.
-    config = readConfig() || config;
-    // A Turbo body swap can drop the overlay without close(); documentElement
-    // survives the swap, so release the scroll lock or the new page is frozen.
-    if (overlay && !document.body.contains(overlay)) {
-      overlay = null;
-      unwatchViewport();
-      unlockScroll();
-    }
+    // script), so it reflects the page Turbo just rendered. No config means the
+    // tool is not available on this page, so the widget switches off rather
+    // than keep the previous page's pill or suggest mode across the visit.
+    config = readConfig() || UNAVAILABLE;
+    // A body swap can detach the dialog; a custom render can preserve it even
+    // after suggest mode is disabled. Both must release its scroll/focus lock.
+    if (overlay && (!config.active || !document.body.contains(overlay))) close();
+    // A cached snapshot or a morph can carry the previous page's pill; the
+    // current config alone decides whether one is shown.
+    removePill();
+    // <html> survives a Turbo visit, so the suggest-mode class must be cleared
+    // as well as set.
+    document.documentElement.classList.toggle("i18np-active", !!config.active);
+    if (config === UNAVAILABLE) return;
+
     injectStyles();
     if (config.showPill !== false) buildPill();
-    document.documentElement.classList.toggle("i18np-active", !!config.active);
     if (config.active) strip();
   }
 
@@ -199,10 +214,13 @@
 
   // --- pill -----------------------------------------------------------------
 
-  function buildPill() {
-    var existing = document.querySelector(".i18np-pill");
-    if (existing) existing.remove();
+  function removePill() {
+    document.querySelectorAll(".i18np-pill").forEach(function (pill) {
+      pill.remove();
+    });
+  }
 
+  function buildPill() {
     var pill = document.createElement("button");
     pill.type = "button";
     pill.className = "i18np-pill" + (config.active ? " i18np-pill-on" : "");

data/lib/i18n_proofreading/widget.rb

@@ -14,8 +14,8 @@ module I18nProofreading
     # pipeline never ingests it: Rails auto-registers every engine's
     # app/assets/* directory, which would put this file in the host's asset
     # namespace as a bare "widget.js" and into its precompiled output.
-    SOURCE = File.expand_path('widget.js', __dir__)
-    DASHBOARD_STYLESHEET_SOURCE = File.expand_path('dashboard.css', __dir__)
+    SOURCE = File.expand_path('widget.js', __dir__).freeze
+    DASHBOARD_STYLESHEET_SOURCE = File.expand_path('dashboard.css', __dir__).freeze
 
     # Right-to-left scripts, so the popover renders mirrored for those locales.
     # Matched on the language subtag, so region variants ("ar-EG") count too.
@@ -46,8 +46,10 @@ module I18nProofreading
       # The config rides in a `type="application/json"` block: it is *data*, not
       # code, so the browser never executes it and Turbo never tries to re-run it
       # on a soft visit — which means it needs no CSP nonce and, crucially, the
-      # widget can re-read the *current* page's config on every `turbo:load`
-      # instead of being stuck with whatever the last full load evaluated.
+      # widget can re-read the *current* page's config after every Turbo render
+      # instead of being stuck with whatever the last full load evaluated. A
+      # page without the block is a page the tool is off for, and the widget
+      # switches itself off there.
       #
       # The code is a same-origin `src` script served by the engine — NOT
       # inlined. Under a nonce-based CSP, Turbo Drive body swaps re-run body

data/lib/i18n_proofreading.rb

@@ -2,6 +2,7 @@
 
 require 'i18n_proofreading/version'
 require 'i18n_proofreading/configuration'
+require 'i18n_proofreading/ractor_support'
 require 'i18n_proofreading/marking'
 require 'i18n_proofreading/widget'
 require 'i18n_proofreading/tag_helper'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: i18n_proofreading
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.1.1
 platform: ruby
 authors:
 - Yaroslav Shmarov
@@ -86,6 +86,17 @@ files:
 - config/locales/i18n_proofreading.vi.yml
 - config/locales/i18n_proofreading.zh-CN.yml
 - config/routes.rb
+- docs/demo-640.mp4
+- docs/demo.gif
+- docs/ractors.md
+- docs/screenshots/01-highlight.png
+- docs/screenshots/02-suggest.png
+- docs/screenshots/03-review-board.png
+- docs/screenshots/admin-ui/after-index-mobile.png
+- docs/screenshots/admin-ui/after-index.png
+- docs/screenshots/admin-ui/after-show-mobile.png
+- docs/screenshots/admin-ui/after-show.png
+- docs/screenshots/admin-ui/before-index.png
 - lib/generators/i18n_proofreading/install/install_generator.rb
 - lib/generators/i18n_proofreading/install/templates/create_i18n_proofreading_suggestions.rb.tt
 - lib/generators/i18n_proofreading/install/templates/initializer.rb
@@ -96,6 +107,7 @@ files:
 - lib/i18n_proofreading/engine.rb
 - lib/i18n_proofreading/marking.rb
 - lib/i18n_proofreading/middleware.rb
+- lib/i18n_proofreading/ractor_support.rb
 - lib/i18n_proofreading/seeds.rb
 - lib/i18n_proofreading/tag_helper.rb
 - lib/i18n_proofreading/version.rb
@@ -124,7 +136,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: 'In-context i18n proofreading for Rails: click any translated string and
   suggest a fix.'