i18n_proofreading 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6f31aa1eec6874e5a80180fbd106c1f6ea7f073241e234c8b0c9c64ae474ba45
-  data.tar.gz: c1a02f46f915c3fd496793f9b33885026c090fb70b0fcb0474d017ac0c2bbd14
+  metadata.gz: 1dba859df20dd5bc929a6c3bbde753b36591b8dfd92fb24547272ab9d1137d72
+  data.tar.gz: 284954216db75a99209bb72248c2b447ac62dbd3d28b550c996015392422c4ac
 SHA512:
-  metadata.gz: dfca53a8ba1b338b6bca4b29060c0c5f7ecb8077817d26fc6078d22b971195d7577db3ef7a433f0252213b1214bd09adbdec0daaa66938708a3556e9ca766701
-  data.tar.gz: 9bd50ba50b9a8c43b26839a9467b43cc50c96ba18e25ed0738433d0013ce18606566c61ca3b954022281ee40266701aa2c9efd5f6414baac5e561fa5b21a5338
+  metadata.gz: 47cf7fd0e919c0f1be04b1b27804238da759b955339ee316d4fb522bdfd2e34b96aa661739bd9e8dff324d0a61d7127e155a2322f99b48d8d24736c69aac4003
+  data.tar.gz: ff614c4482c8c9ee666d6a636f46cc84d724e75289925dabf8aa10b27b004d98e31ce539715476faf7f155b6d2cf3d4b26a86899e281d255a449824c05f816fd

data/AGENTS.md

@@ -5,7 +5,7 @@ Instructions for coding agents. Two audiences:
 - **[Installing i18n_proofreading into a Rails app](#installing-into-a-rails-app)** — you are working in a host app and were asked to add in-context translation review or a way for someone to suggest better wording.
 - **[Working on the gem itself](#working-on-the-gem-itself)** — you are working in this repository.
 
-Requirements: Ruby 3.2–4.0, Rails 7.1–8.1. The widget needs the CSRF token from `csrf_meta_tags`, which a standard Rails layout already has.
+Requirements: Ruby >= 3.2, Rails >= 7.1 and < 9. The widget needs the CSRF token from `csrf_meta_tags`, which a standard Rails layout already has.
 
 **Read this first: the gem never writes to your locale files, and it is not a production tool.** Both are deliberate, and both are covered below.
 
@@ -137,6 +137,11 @@ The tool's own UI ships in 26 languages, RTL mirrored, and follows system light/
 
 ## Working on the gem itself
 
+The development toolchain is pinned to Ruby 4.0.5 in `mise.toml`. Do not use
+macOS's `/usr/bin/ruby`. In shells, hooks, or automation where mise activation
+is uncertain, explicitly prepend the configured Ruby, for example
+`PATH="$(mise where ruby)/bin:$PATH" bundle exec rake test`.
+
 ```bash
 bundle exec rake test            # minitest, dummy app under test/dummy
 bundle exec rubocop              # must be clean

data/CHANGELOG.md

@@ -2,6 +2,31 @@
 
 ## [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 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.**
+  The failure is logged after persistence, so host notifications cannot make
+  the review submission appear lost.
+- **Stored page context is now privacy-filtered.** Only bounded HTTP(S) URLs
+  without credentials, query strings, or fragments are retained.
+
 ## [1.0.0] - 2026-08-11
 
 - **The documented integration surface is now the stable 1.x contract.**

data/README.md

@@ -357,3 +357,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/concerns/i18n_proofreading/request_context.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'uri'
+
 module I18nProofreading
   # Who is asking, and the gates that answer it.
   #
@@ -37,5 +39,23 @@ module I18nProofreading
 
       @current_author = I18nProofreading.config.current_user.call(request)
     end
+
+    # Browser URLs can carry password-reset tokens, signed ids, and campaign
+    # details in their query or fragment. Store only a bounded HTTP(S) location
+    # without credentials before it reaches the suggestion table.
+    def clean_page_url(value)
+      raw = value.to_s
+      return if raw.blank? || raw.length > 2_048
+
+      uri = URI.parse(raw)
+      return unless %w[http https].include?(uri.scheme&.downcase)
+      return if uri.host.blank? || uri.userinfo.present?
+
+      uri.query = nil
+      uri.fragment = nil
+      uri.to_s.first(255)
+    rescue URI::InvalidURIError
+      nil
+    end
   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.'] },
@@ -37,10 +37,11 @@ module I18nProofreading
 
     def create
       suggestion = Suggestion.new(suggestion_params)
+      suggestion.page_url = clean_page_url(suggestion.page_url)
       attribute_author(suggestion)
 
       if suggestion.save
-        I18nProofreading.config.on_submit.call(suggestion)
+        notify_host(suggestion)
         head :created
       else
         render json: { errors: suggestion.errors.full_messages }, status: :unprocessable_entity
@@ -49,6 +50,15 @@ module I18nProofreading
 
     private
 
+    # The host's hook must never turn a saved suggestion into a 500 — the
+    # suggestion is in the database; notification failures are the host's
+    # logs' problem.
+    def notify_host(suggestion)
+      I18nProofreading.config.on_submit.call(suggestion)
+    rescue StandardError => e
+      Rails.logger.error("i18n_proofreading: on_submit hook raised #{e.class}: #{e.message}")
+    end
+
     def attribute_author(suggestion)
       author = current_author
       return unless author

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.0'
+  VERSION = '1.1.0'
 end

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.

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.0
+  version: 1.1.0
 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.'