rubocop-dev_doc 0.10.1 → 0.10.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f669dc6f7e91c7e3aaac4e42e680df95fc24acbf6b467e7831387866cc2dc0d4
-  data.tar.gz: 41f06d6d2b20efd95b60389aae5f6803d206ad8f844d8de9daf04d87369ebf8f
+  metadata.gz: 6516cd758b54f702561cfd1ce43130ccf46bcfd04d8955bbdf065218019f374a
+  data.tar.gz: f246347aeb2054e19c26844f38057f795a1ee721a30c3c40b8f955d06b6f843a
 SHA512:
-  metadata.gz: 7cdef60287b7ef58701aab3c5e025416b2033d93c3a09d06b6addc3636daaf169010584df484ec6377caa192d74d901ee52a0abf56473490c3f4e289cf6895ba
-  data.tar.gz: 84a55b7ffaf35e17e8ee436c7f696c176659c30394fa7ed6a50a7bc46fa64ecbb2b5728a5df6547d457ba0006154e9279409b7fc2f6075f4937d0a0406a37ee6
+  metadata.gz: b30977f9056fd77d2a58227e98b2fc6860ad1333a52fb4bb9bf7ea636ab20ebca1ad9187a84a4ca3e14c8f442861ec3c779ddb88d9d940c459483bcf204726e0
+  data.tar.gz: 93ae91781dd10664b18b8e304e9b336485a572bd9a32822af81df3e399fb742420ed1d41612e21e4249eb79cbc53569082468091c8994470f552bf43dd7c7b8d

data/config/default.yml

@@ -170,7 +170,7 @@ DevDoc/Rails/NoPerformLaterInModel:
     - "app/models/**/*.rb"
 
 DevDoc/Rails/EnumMustBeSymbolized:
-  Description: "Pair every `enum :foo` with `enum_symbolize :foo` so the reader returns a symbol."
+  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."
   Enabled: true
   Include:
     - "app/models/**/*.rb"
@@ -436,6 +436,18 @@ 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/config/obsoletion.yml

@@ -0,0 +1,5 @@
+# Cop renames across rubocop-dev_doc versions. RuboCop surfaces these as
+# actionable "has been renamed" errors when a project's config or inline
+# directives use the old name.
+renamed:
+  DevDoc/Migration/AvoidBypassingValidation: DevDoc/Rails/AvoidBypassingValidation

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

@@ -2,44 +2,51 @@ module RuboCop
   module Cop
     module DevDoc
       module Rails
-        # Every Rails `enum` declaration must be paired with `enum_symbolize`
-        # so the reader returns a symbol instead of Rails' default string form.
+        # Rails `enum` must never be declared directly — use glib-web's
+        # `enum_symbolize :name, { … }` declaring form instead.
         #
         # ## Rationale
-        # 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.
+        # 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.
         #
         # 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 :payment_status, { draft: 0, pending: 1, finalized: 2 }
-        #
-        #     enum_symbolize :payment_status
+        #     enum_symbolize :payment_status, { draft: 0, pending: 1, finalized: 2 }
         #   end
         #
-        # `enum_symbolize` accepts multiple names so several enums can be
-        # paired in one call:
+        # Enum options pass straight through:
         #
         #   ✔
-        #   enum_symbolize :payment_status, :finalize_intent
+        #   enum_symbolize :finalize_intent, { unknown: 0, charge: 1 }, prefix: true
         #
         # Enums declared inside a concern's `included do` block are checked the
-        # same way — the pairing must live in the same `included do` block,
-        # which is also where it belongs so every includer gets both:
+        # same way:
         #
         #   ✔
         #   included do
-        #     enum :discount_type, DISCOUNT_TYPES
-        #     enum_symbolize :discount_type
+        #     enum_symbolize :discount_type, DISCOUNT_TYPES
         #   end
         #
         # @example
@@ -47,20 +54,16 @@ module RuboCop
         #   enum :status, { active: 0, archived: 1 }
         #
         #   # good
-        #   enum :status, { active: 0, archived: 1 }
-        #   enum_symbolize :status
+        #   enum_symbolize :status, { active: 0, archived: 1 }
         class EnumMustBeSymbolized < Base
-          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
+          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
 
           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
@@ -83,28 +86,15 @@ module RuboCop
             return unless body
 
             statements = body.begin_type? ? body.children : [body]
-            enum_decls, symbolized = scan(statements)
+            statements.each do |stmt|
+              next unless stmt.respond_to?(:send_type?) && stmt.send_type?
 
-            enum_decls.each do |name, decl|
-              next if symbolized.include?(name)
+              name = enum_call(stmt)
+              next unless name
 
-              add_offense(decl, message: format(MSG, name: name))
+              add_offense(stmt, 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.1".freeze
+    VERSION = "0.10.2".freeze
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rubocop-dev_doc
 version: !ruby/object:Gem::Version
-  version: 0.10.1
+  version: 0.10.2
 platform: ruby
 authors:
 - dev-doc contributors
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-07-07 00:00:00.000000000 Z
+date: 2026-07-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -87,6 +87,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - config/default.yml
+- config/obsoletion.yml
 - lib/dev_doc/test/best_practice_lints.rb
 - lib/dev_doc/test/lints/cron_schedule.rb
 - lib/dev_doc/test/lints/duplicate_snapshot.rb