rubocop-dev_doc 0.10.2 → 0.10.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6516cd758b54f702561cfd1ce43130ccf46bcfd04d8955bbdf065218019f374a
-  data.tar.gz: f246347aeb2054e19c26844f38057f795a1ee721a30c3c40b8f955d06b6f843a
+  metadata.gz: 0ba7422e97cc011bf4700f5f6bfd1c87fd7e358c9c707baf73b5360abbf40129
+  data.tar.gz: 10ced56ec89a8d05f3897c76ff85df357cb52a9dc97d155f7caf11b1917faaa6
 SHA512:
-  metadata.gz: b30977f9056fd77d2a58227e98b2fc6860ad1333a52fb4bb9bf7ea636ab20ebca1ad9187a84a4ca3e14c8f442861ec3c779ddb88d9d940c459483bcf204726e0
-  data.tar.gz: 93ae91781dd10664b18b8e304e9b336485a572bd9a32822af81df3e399fb742420ed1d41612e21e4249eb79cbc53569082468091c8994470f552bf43dd7c7b8d
+  metadata.gz: 403c116d677b765d86ef3a8852b1087ffa5821a12a1db76f59343d067cfd6c942c4fe1ae69c65a67ae1ad24a07922e7312f2a4f2a84b5164e379f8928c90a57c
+  data.tar.gz: 4bd0b0fb718cf6ac10540735e49077da57e0d34b54111dcc5fe9da0a531383546eb83a9300503a10612f7bb0f90b6f6434acf0b307ea6125316202563bd89a52

data/config/default.yml

@@ -170,7 +170,7 @@ DevDoc/Rails/NoPerformLaterInModel:
     - "app/models/**/*.rb"
 
 DevDoc/Rails/EnumMustBeSymbolized:
-  Description: "Declare enums with `enum_symbolize :foo, { … }` instead of a bare `enum`, so the attribute type is set before the enum and the reader returns a symbol."
+  Description: "Pair every `enum :foo` with `enum_symbolize :foo` so the reader returns a symbol."
   Enabled: true
   Include:
     - "app/models/**/*.rb"
@@ -436,18 +436,6 @@ Rails/SaveBang:
   Exclude:
     - "app/controllers/**/*"
 
-# MySQL-oriented performance cop: it wants multiple ALTER TABLE operations on
-# one table combined into `change_table :t, bulk: true` to avoid repeated
-# full-table rewrites. That payoff is real on MySQL/MariaDB but marginal on
-# PostgreSQL, where ALTER sub-commands are cheap metadata ops — and our projects
-# run PostgreSQL. It also contradicts our own doctrine: the `bulk: true` form it
-# demands trips DevDoc/Migration/AvoidColumnDefault (on the backfill `default:`)
-# and Rails/ReversibleMigration (on `t.change_default`), neither disable-able
-# inline, for the standard add-column-then-drop-default backfill — making the
-# three rules mutually unsatisfiable. Off for all projects.
-Rails/BulkChangeTable:
-  Enabled: false
-
 # Superseded by DevDoc/Style/CaseElseDecision below: same detection, but the
 # offense message carries the raise/report/fall-through decision framework
 # instead of upstream's "Missing else statement" (which teaches the wrong

data/lib/dev_doc/i18n/pseudo_locale.rb

@@ -0,0 +1,168 @@
+# Pseudo-localization backend — a hardcoded-text detector.
+#
+# When installed (see PseudoLocale.install!), an extra locale `en-PSEUDO`
+# becomes available. Every string resolved through Rails `t()` is returned as
+# its real English value, accented and wrapped in `⟦ ⟧` markers, e.g.
+#
+#     t('energies.show.title')  # "Monthly Statement"
+#       --> rendered under en-PSEUDO -->  "⟦Móñţĥļý Šţáţéméñţ⟧"
+#
+# Render any page under the pseudo locale and scan the output: any user-facing
+# text WITHOUT the `⟦ ⟧` markers never went through `t()` and is therefore a
+# hardcoded-string candidate — regardless of whether it came from a view,
+# helper, concern, module, or service object.
+#
+# ---------------------------------------------------------------------------
+# Per-project integration
+# ---------------------------------------------------------------------------
+# This gem is a `:development, :test`-only dependency, so it is NOT loaded in
+# production and this file is only required when detection mode is on. The
+# project initializer requires it and installs the backend under PSEUDO_I18N=1:
+#
+#   # config/initializers/pseudo_locale.rb
+#   if ENV['PSEUDO_I18N'] == '1'
+#     require 'dev_doc/i18n/pseudo_locale'
+#     DevDoc::I18n::PseudoLocale.install!
+#   end
+#
+# `mark` (below) is called from production code paths to flag externally-managed
+# strings for the scanner. Because this gem is absent in production, call it
+# through a null-guard so it degrades to the identity when the gem is not
+# loaded — the value is untouched anyway when detection mode is off:
+#
+#   def pseudo_mark(value)
+#     return value unless defined?(DevDoc::I18n::PseudoLocale)
+#     DevDoc::I18n::PseudoLocale.mark(value)
+#   end
+#
+# Guarded behind PSEUDO_I18N, so normal dev/prod is untouched and the fake
+# locale can never leak to real users.
+module DevDoc
+  module I18n
+    module PseudoLocale
+      PSEUDO_LOCALE = 'en-PSEUDO'
+      MARKER = '⟦'
+
+      def self.active?
+        ENV['PSEUDO_I18N'] == '1'
+      end
+
+      # Marks an externally-managed string — CMS content, assessment-YAML
+      # values, or a chosen ActiveRecord display value — so the hardcoded-text
+      # scanner treats it as already-handled and skips it. Returns the string
+      # untouched when detection mode is off, so it is safe on production paths
+      # (call it through a null-guard; see the header comment).
+      def self.mark(value)
+        return value unless active?
+        return value unless value.is_a?(String) && !value.empty?
+
+        value.include?(MARKER) ? value : "#{MARKER}#{value}⟧"
+      end
+
+      # Letter map — readable but unmistakably "transformed".
+      MAP = {
+        'a' => 'á', 'b' => 'ƀ', 'c' => 'ç', 'd' => 'ð', 'e' => 'é', 'f' => 'ƒ',
+        'g' => 'ĝ', 'h' => 'ĥ', 'i' => 'í', 'j' => 'ĵ', 'k' => 'ķ', 'l' => 'ļ',
+        'm' => 'ɱ', 'n' => 'ñ', 'o' => 'ö', 'p' => 'þ', 'q' => 'ɋ', 'r' => 'ŕ',
+        's' => 'š', 't' => 'ţ', 'u' => 'ü', 'v' => 'ṽ', 'w' => 'ŵ', 'x' => 'ӿ',
+        'y' => 'ý', 'z' => 'ž',
+        'A' => 'Á', 'B' => 'Ɓ', 'C' => 'Ç', 'D' => 'Ð', 'E' => 'É', 'F' => 'Ƒ',
+        'G' => 'Ĝ', 'H' => 'Ĥ', 'I' => 'Í', 'J' => 'Ĵ', 'K' => 'Ķ', 'L' => 'Ļ',
+        'M' => 'Ṁ', 'N' => 'Ñ', 'O' => 'Ö', 'P' => 'Þ', 'Q' => 'Ɋ', 'R' => 'Ŕ',
+        'S' => 'Š', 'T' => 'Ţ', 'U' => 'Ü', 'V' => 'Ṽ', 'W' => 'Ŵ', 'X' => 'Ӿ',
+        'Y' => 'Ý', 'Z' => 'Ž'
+      }.freeze
+
+      # Wires the pseudo backend into I18n and forces every request to render in
+      # it. Idempotent — safe to call once from the project initializer.
+      def self.install!
+        ::I18n::Backend::Simple.prepend(Backend)
+        ::I18n.available_locales |= [PSEUDO_LOCALE.to_sym]
+        force_locale!
+        ::Rails.logger.info('[pseudo_locale] en-PSEUDO locale enabled (forced) for hardcoded-text detection') if defined?(::Rails.logger)
+      end
+
+      # Force every request to render in the pseudo locale.
+      #
+      # Without this, an app's `default_url_options` typically derives the URL
+      # locale via `I18n.locale.to_s.split('-')[0]` ("en-PSEUDO" -> "en"), so
+      # every link and redirect the app generates carries `locale=en`;
+      # `set_locale` then honours that param and renders plain English — the
+      # pseudo transform never fires on any navigated page. Overriding
+      # `set_locale` here pins the locale regardless of the incoming param,
+      # which is exactly what a "render everything pseudo" detection mode wants.
+      def self.force_locale!
+        ::Rails.application.config.to_prepare do
+          ApplicationController.class_eval do
+            private
+
+            def set_locale
+              ::I18n.locale = DevDoc::I18n::PseudoLocale::PSEUDO_LOCALE.to_sym
+            end
+          end
+        end
+      end
+
+      # I18n backend override: resolves the real English entry, then accents it.
+      module Backend
+        # Namespaces whose values are format directives / structural data, not
+        # copy. Accenting these would corrupt strftime (`%A`), number formats.
+        SKIP_NAMESPACES = %w[i18n date time datetime number support].freeze
+
+        def lookup(locale, key, scope = [], options = ::I18n::EMPTY_HASH)
+          return super unless locale.to_s == PSEUDO_LOCALE
+
+          # Resolve the real English entry (template, before interpolation).
+          real = super(:en, key, scope, options)
+          return real if real.nil? || skip?(key, scope)
+
+          pseudoize(real)
+        end
+
+        private
+
+        def skip?(key, scope)
+          head = Array(scope).first || key.to_s[/\A[^.]+/]
+          SKIP_NAMESPACES.include?(head.to_s)
+        end
+
+        # Recurses so pluralization hashes ({ one:, other: }) and arrays work.
+        def pseudoize(value)
+          case value
+          when String then wrap(value)
+          when Hash   then value.transform_values { |v| pseudoize(v) }
+          when Array  then value.map { |v| pseudoize(v) }
+          else value
+          end
+        end
+
+        # Some t() values are not display copy — asset filenames, paths, URLs.
+        # The asset helpers feed these to Vite, which raises on a missing
+        # manifest entry, so accenting them 500s the page. Leave them untouched.
+        #
+        # Note: do NOT treat a bare "/" as a path — display copy legitimately
+        # contains slashes ("Lamp/Bulbs", "Food/Food Scraps"). A real path is an
+        # all-lowercase identifier chain (`shared/layouts/main`, `images/icon`);
+        # copy has capitals or spaces, so it won't match the lowercase-path rule.
+        NON_COPY = %r{
+          \A\s*\z                              # blank
+          | \Ahttps?://                        # url
+          | \A[a-z0-9_]+(?:[/.][a-z0-9_]+)+\z  # lowercase path / dotted id (shared/layouts/main)
+        }x
+
+        ASSET_EXT = /\.(?:png|jpe?g|svg|gif|webp|ico|bmp|css|js|mjs|html?|pdf|woff2?|ttf|otf|mp[34]|json|xml|csv)\z/i
+
+        def wrap(str)
+          return str if str.match?(NON_COPY) || str.match?(ASSET_EXT)
+
+          # Split on %{name} placeholders (captured), accent only the literal
+          # segments so interpolation variables and their data stay intact.
+          body = str.split(/(%\{[^}]+\})/).each_with_index.map do |part, i|
+            i.odd? ? part : part.chars.map { |c| MAP[c] || c }.join
+          end.join
+          "⟦#{body}⟧"
+        end
+      end
+    end
+  end
+end

data/lib/dev_doc/test/pseudo_i18n_crawler.rb

@@ -0,0 +1,254 @@
+require 'set'
+
+module DevDoc
+  module Test
+    # Pseudo-localization hardcoded-text crawler.
+    #
+    # Reuses the glib-web JSON-UI crawler (per-role login + fixtures + full
+    # reachability) but renders every page under the `en-PSEUDO` locale and
+    # reports any localizable text prop that comes back WITHOUT the `⟦ ⟧`
+    # marker — i.e. user-facing text that bypassed Rails `t()` and is therefore
+    # a hardcoded-string candidate, no matter which view/helper/concern/module/
+    # service emitted it. See dev_doc/i18n/pseudo_locale.rb.
+    #
+    # Unlike the golden-file JSON-UI crawler this does NOT assert the page log
+    # (the accented pseudo output would never match committed baselines); it
+    # drives the router directly and only collects unwrapped text.
+    #
+    # ------------------------------------------------------------------------
+    # Per-project integration
+    # ------------------------------------------------------------------------
+    # Include this module in a single integration test and supply the project's
+    # own login credentials as `test` cases. The host class must also include
+    # `Glib::TestHelpers` (for HOST / login / logout) and load fixtures. The
+    # pseudo backend must be installed — see dev_doc/i18n/pseudo_locale.rb.
+    #
+    #   # test/integration/pseudo_i18n_crawler_test.rb
+    #   require 'test_helper'
+    #   require 'dev_doc/test/pseudo_i18n_crawler'
+    #
+    #   class PseudoI18nCrawlerTest < ActionDispatch::IntegrationTest
+    #     include Glib::TestHelpers
+    #     include DevDoc::Test::PseudoI18nCrawler
+    #
+    #     self.fixture_paths = ['test/fixtures']
+    #     fixtures :all
+    #
+    #     test 'crawl superadmin' do
+    #       crawl_pseudo(email: 'super@admin.com', password: 'password', device: 'web', version: nil)
+    #     end
+    #   end
+    #
+    # Run with the pseudo backend enabled:
+    #
+    #   PSEUDO_I18N=1 bin/rails test test/integration/pseudo_i18n_crawler_test.rb
+    #
+    # Findings are printed and written to
+    # test/integration/pseudo_i18n_crawler_test_results/<email>.txt
+    module PseudoI18nCrawler
+      MARKER = '⟦'.freeze
+
+      # Mirrors the cop's DEFAULT_LOCALIZABLE_KEYS — keep in sync with
+      # lib/rubocop/cop/dev_doc/i18n/localizable_props.rb. The crawler can only
+      # flag hardcoded text on keys it walks, so any key the cop treats as
+      # localizable (message/description on dialogs & banners, uploadText on
+      # fields_upload, on/left/rightText on switch & toggles) must be listed.
+      TEXT_KEYS = %w[
+        title
+        subtitle
+        subsubtitle
+        label
+        placeholder
+        text
+        message
+        description
+        uploadText
+        leftText
+        rightText
+        onLabel
+      ].to_set
+
+      # The test class that included the module — the prepended Scanner (a
+      # single module shared across the Http class) dispatches scan results
+      # back to it.
+      class << self
+        attr_accessor :host_class
+      end
+
+      # Scan every crawled JSON-UI response as it is fetched.
+      module Scanner
+        # Signature must mirror Glib::JsonCrawler::Http#fetch for the
+        # prepend/super override to work, so the boolean positional arg can't
+        # become a kwarg.
+        def fetch(method, url, action, params = {}, inspect_result = true) # rubocop:disable Style/OptionalBooleanParameter
+          result = super
+          if method == :get
+            rec = instance_variable_get(:@content_history)&.last
+            PseudoI18nCrawler.host_class.scan_body(url, rec[:response]) if rec && rec[:url] == url
+          end
+          result
+        end
+      end
+
+      def self.included(base)
+        base.extend(ClassMethods)
+        PseudoI18nCrawler.host_class = base
+
+        # Prepend the Scanner onto the crawler HTTP client exactly once, no
+        # matter how many test classes include the module.
+        unless Glib::JsonCrawler::Http.ancestors.include?(Scanner)
+          Glib::JsonCrawler::Http.prepend(Scanner)
+        end
+
+        base.setup do
+          skip 'Set PSEUDO_I18N=1 to run the pseudo-localization scan.' unless ENV['PSEUDO_I18N'] == '1'
+          skip 'en-PSEUDO locale not loaded — is config/initializers/pseudo_locale.rb active?' unless ::I18n.available_locales.include?(:'en-PSEUDO')
+
+          self.class.hits = {}
+          @previous_default_locale = ::I18n.default_locale
+          # The app's set_locale falls back to I18n.default_locale when no
+          # `_lang` param is present (crawler URLs carry none), so this renders
+          # every page in pseudo without touching the crawler's URLs.
+          ::I18n.default_locale = :'en-PSEUDO'
+        end
+
+        base.teardown do
+          ::I18n.default_locale = @previous_default_locale if @previous_default_locale
+        end
+      end
+
+      module ClassMethods
+        attr_accessor :hits # { url => [ "[key] value", ... ] }
+
+        # Directory of the fixtures scanned to filter out AR display values.
+        def fixture_dir
+          @fixture_dir ||= ::Rails.root.join('test/fixtures').to_s
+        end
+
+        # Where per-role reports are written.
+        def report_dir
+          @report_dir ||= ::Rails.root.join('test/integration/pseudo_i18n_crawler_test_results').to_s
+        end
+
+        def scan_body(url, body)
+          return unless body.is_a?(String) && body.lstrip.start_with?('{', '[')
+
+          json = begin
+            JSON.parse(body)
+          rescue JSON::ParserError
+            return
+          end
+
+          walk(json) do |key, value|
+            if value.include?(MARKER)
+              @wrapped = (@wrapped || 0) + 1
+            elsif trivial?(value)
+              next
+            elsif fixture_strings.include?(value.strip)
+              # ActiveRecord display value (record title/name/user copy) that
+              # came straight from the DB — data, not a hardcoded UI string.
+              @data_sourced = (@data_sourced || 0) + 1
+            else
+              @unwrapped = (@unwrapped || 0) + 1
+              (hits[url] ||= []) << "[#{key}] #{value.inspect}"
+            end
+          end
+        end
+
+        # Verbatim string values from the fixtures. A candidate equal to one of
+        # these is an ActiveRecord display value (loaded from the DB, so it
+        # never went through t() by design) rather than hardcoded copy, and is
+        # excluded to cut the bulk of the AR noise. Exact match only — a
+        # hardcoded string that happens to equal a fixture value would be
+        # skipped too, an acceptable trade for ~85% less noise. Built once;
+        # fixtures contain no ERB so static YAML parsing is exact.
+        def fixture_strings
+          @fixture_strings ||= Dir[File.join(fixture_dir, '**', '*.yml')].each_with_object(Set.new) do |file, set|
+            data = YAML.safe_load(File.read(file), permitted_classes: [Date, Time], aliases: true)
+            collect_strings(data, set)
+          rescue Psych::Exception
+            next
+          end
+        end
+
+        def collect_strings(node, set)
+          case node
+          when Hash  then node.each_value { |v| collect_strings(v, set) }
+          when Array then node.each { |v| collect_strings(v, set) }
+          when String
+            s = node.strip
+            set << s unless s.empty?
+          end
+        end
+
+        def diag
+          "wrapped(localized via t)=#{@wrapped || 0}  data-sourced(fixtures, skipped)=#{@data_sourced || 0}  " \
+            "unwrapped(candidates)=#{@unwrapped || 0}"
+        end
+
+        def walk(node, &blk)
+          case node
+          when Hash
+            node.each do |k, v|
+              blk.call(k, v) if TEXT_KEYS.include?(k) && v.is_a?(String)
+              walk(v, &blk)
+            end
+          when Array
+            node.each { |v| walk(v, &blk) }
+          end
+        end
+
+        # Skip values that are not copy: blank, no letters (numbers/units/
+        # symbols), or ALL_CAPS code identifiers. Tune as real noise surfaces.
+        def trivial?(str)
+          s = str.strip
+          s.empty? || !s.match?(/[A-Za-z]/) || s.match?(/\A[A-Z0-9_]+\z/)
+        end
+      end
+
+      private
+
+      def crawl_pseudo(user)
+        user[:token] = login(user)
+
+        router = Glib::JsonCrawler::Router.new
+        http   = Glib::JsonCrawler::Http.new(self, user, router, inspect_result: true)
+        router.host = HOST
+        router.skip_similar_page = true
+
+        ENV['CRAWLER_MODE'] = 'true'
+        router.step(
+          http,
+          'onClick' => {
+            'action' => 'initiate_navigation',
+            'url' => "http://#{HOST}/users/me?format=json&redirect=default"
+          }
+        )
+      ensure
+        ENV['CRAWLER_MODE'] = nil
+        logout
+        report!(user)
+      end
+
+      def report!(user)
+        hits = self.class.hits
+        report_dir = self.class.report_dir
+        FileUtils.mkdir_p(report_dir)
+        path = File.join(report_dir, "#{user[:email]}.txt")
+
+        lines = []
+        hits.sort.each do |url, values|
+          lines << url
+          values.uniq.each { |v| lines << "    #{v}" }
+          lines << ''
+        end
+        total = hits.values.sum { |v| v.uniq.size }
+        summary = "#{total} hardcoded candidate(s) across #{hits.size} page(s) for #{user[:email]}"
+
+        File.write(path, ([summary, ''] + lines).join("\n"))
+        puts "\n[pseudo_i18n] #{summary}\n              report: #{path}"
+        puts "[pseudo_i18n] DIAG: #{self.class.diag}"
+      end
+    end
+  end
+end

data/lib/rubocop/cop/dev_doc/rails/enum_must_be_symbolized.rb

@@ -2,51 +2,44 @@ module RuboCop
   module Cop
     module DevDoc
       module Rails
-        # Rails `enum` must never be declared directly — use glib-web's
-        # `enum_symbolize :name, { … }` declaring form instead.
+        # Every Rails `enum` declaration must be paired with `enum_symbolize`
+        # so the reader returns a symbol instead of Rails' default string form.
         #
         # ## Rationale
-        # Two problems with a bare `enum`:
-        #
-        # 1. **Type.** `enum` resolves its attribute type by introspecting the
-        #    DB column. When the column doesn't exist yet — a not-yet-migrated
-        #    column loaded on deploy, eager-loaded CI, or an un-migrated local
-        #    DB — Rails raises "Undeclared attribute type for enum". Declaring
-        #    the attribute up front (which `enum_symbolize` does, from the enum's
-        #    own values) removes that dependency on the column.
-        # 2. **Reader.** `enum` defines a reader that returns the string form, so
-        #    `record.status == :active` silently fails (`:foo == 'foo'` is
-        #    false). `enum_symbolize` overrides the reader to return a symbol.
-        #
-        # The `enum_symbolize :name, { … }` form does both in one call — it
-        # declares the attribute, defines the enum, adds a presence validation,
-        # and symbolizes the reader — so neither footgun can be reintroduced by
-        # forgetting a pairing line.
+        # Strings and symbols are not equal in Ruby (`:foo == 'foo'` is `false`).
+        # Rails' `enum` macro defines a reader that returns the string form, so
+        # downstream comparisons like `record.status == :active` silently fail.
+        # Pairing `enum :status, …` with `enum_symbolize :status` overrides the
+        # reader to hand back a symbol, eliminating the footgun.
         #
         # See `best_practices/backend/en/01a_defensive_programming.md` item 7.
         #
         #   ❌
         #   class Order < ApplicationRecord
         #     enum :payment_status, { draft: 0, pending: 1, finalized: 2 }
-        #     enum_symbolize :payment_status
         #   end
         #
         #   ✔
         #   class Order < ApplicationRecord
-        #     enum_symbolize :payment_status, { draft: 0, pending: 1, finalized: 2 }
+        #     enum :payment_status, { draft: 0, pending: 1, finalized: 2 }
+        #
+        #     enum_symbolize :payment_status
         #   end
         #
-        # Enum options pass straight through:
+        # `enum_symbolize` accepts multiple names so several enums can be
+        # paired in one call:
         #
         #   ✔
-        #   enum_symbolize :finalize_intent, { unknown: 0, charge: 1 }, prefix: true
+        #   enum_symbolize :payment_status, :finalize_intent
         #
         # Enums declared inside a concern's `included do` block are checked the
-        # same way:
+        # same way — the pairing must live in the same `included do` block,
+        # which is also where it belongs so every includer gets both:
         #
         #   ✔
         #   included do
-        #     enum_symbolize :discount_type, DISCOUNT_TYPES
+        #     enum :discount_type, DISCOUNT_TYPES
+        #     enum_symbolize :discount_type
         #   end
         #
         # @example
@@ -54,16 +47,20 @@ module RuboCop
         #   enum :status, { active: 0, archived: 1 }
         #
         #   # good
-        #   enum_symbolize :status, { active: 0, archived: 1 }
+        #   enum :status, { active: 0, archived: 1 }
+        #   enum_symbolize :status
         class EnumMustBeSymbolized < Base
-          MSG = 'Declare enums with `enum_symbolize :%<name>s, { … }` instead of `enum`, so the ' \
-                'attribute type is set before the enum (surviving a not-yet-migrated column) and the ' \
-                'reader returns a symbol (see backend/01a_defensive_programming.md item 7).'.freeze
+          MSG = 'Pair `enum :%<name>s` with `enum_symbolize :%<name>s` so the reader returns a symbol ' \
+                '(see backend/01a_defensive_programming.md item 7).'.freeze
 
           def_node_matcher :enum_call, <<~PATTERN
             (send nil? :enum (sym $_) ...)
           PATTERN
 
+          def_node_matcher :enum_symbolize_call, <<~PATTERN
+            (send nil? :enum_symbolize $...)
+          PATTERN
+
           def_node_matcher :included_block?, <<~PATTERN
             (block (send nil? :included) (args) _)
           PATTERN
@@ -86,15 +83,28 @@ module RuboCop
             return unless body
 
             statements = body.begin_type? ? body.children : [body]
-            statements.each do |stmt|
-              next unless stmt.respond_to?(:send_type?) && stmt.send_type?
+            enum_decls, symbolized = scan(statements)
 
-              name = enum_call(stmt)
-              next unless name
+            enum_decls.each do |name, decl|
+              next if symbolized.include?(name)
 
-              add_offense(stmt, message: format(MSG, name: name))
+              add_offense(decl, message: format(MSG, name: name))
             end
           end
+
+          def scan(statements)
+            sends = statements.select { |stmt| stmt.respond_to?(:send_type?) && stmt.send_type? }
+            enum_decls = sends.filter_map { |stmt| (name = enum_call(stmt)) && [name, stmt] }
+            symbolized = sends.flat_map { |stmt| symbolized_names(stmt) }
+            [enum_decls, symbolized]
+          end
+
+          def symbolized_names(stmt)
+            args = enum_symbolize_call(stmt)
+            return [] unless args
+
+            args.select(&:sym_type?).map(&:value)
+          end
         end
       end
     end

data/lib/rubocop/dev_doc/version.rb

@@ -1,5 +1,5 @@
 module RuboCop
   module DevDoc
-    VERSION = "0.10.2".freeze
+    VERSION = "0.10.3".freeze
   end
 end

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: rubocop-dev_doc
 version: !ruby/object:Gem::Version
-  version: 0.10.2
+  version: 0.10.3
 platform: ruby
 authors:
 - dev-doc contributors
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-07-09 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -80,19 +79,19 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '2.29'
-description:
-email:
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
 - config/default.yml
 - config/obsoletion.yml
+- lib/dev_doc/i18n/pseudo_locale.rb
 - lib/dev_doc/test/best_practice_lints.rb
 - lib/dev_doc/test/lints/cron_schedule.rb
 - lib/dev_doc/test/lints/duplicate_snapshot.rb
 - lib/dev_doc/test/lints/http_driven_controller_tests.rb
 - lib/dev_doc/test/lints/no_file_excludes.rb
+- lib/dev_doc/test/pseudo_i18n_crawler.rb
 - lib/rubocop-dev_doc.rb
 - lib/rubocop/cop/dev_doc/auth/current_user_branching.rb
 - lib/rubocop/cop/dev_doc/auth/load_resource_current_user_guard.rb
@@ -158,12 +157,10 @@ files:
 - lib/rubocop/dev_doc.rb
 - lib/rubocop/dev_doc/plugin.rb
 - lib/rubocop/dev_doc/version.rb
-homepage:
 licenses: []
 metadata:
   default_lint_roller_plugin: RuboCop::DevDoc::Plugin
   rubygems_mfa_required: 'true'
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -178,8 +175,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.6
-signing_key:
+rubygems_version: 4.0.6
 specification_version: 4
 summary: RuboCop cops enforcing dev-doc best practices
 test_files: []