rubocop-dev_doc 0.9.0 → 0.10.1

data/lib/rubocop/cop/dev_doc/test/no_persistence_in_mailer_previews.rb

@@ -0,0 +1,94 @@
+module RuboCop
+  module Cop
+    module DevDoc
+      module Test
+        # Mailer previews must not persist records. A preview renders on every
+        # GET in development, so a `save!`/`update!`/`create!` inside one
+        # mutates the development database as a side effect of merely VIEWING
+        # an email — and re-renders keep re-writing it.
+        #
+        # ## Rationale
+        # Previews are also a relocation target: when the HTTP-driven lint
+        # pushes mailer-body assertions into preview variants (snapshot-tested
+        # via generate_preview_tests), the temptation is to persist the state
+        # the variant needs. Don't — the mailer receives its objects in memory
+        # via `.with(...)`, so in-memory assignment (`record.attr = value`)
+        # renders identically with no side effect. For sample data, use
+        # fixtures/seeded rows or unsaved `new`/`build` records.
+        #
+        # This was a real defect: a preview called
+        # `checklist.update!(note_for_assignee: ...)` to stage a note variant,
+        # silently rewriting the first published checklist's note in the dev DB
+        # on every preview view. In-memory assignment renders the same body.
+        #
+        # ## When in-memory assignment can't work: add a FIXTURE, don't write
+        # Some mailers re-query their records at render time (async-safe
+        # designs re-scope ids against live access rules), so an in-memory
+        # attribute never reaches the render and persistence looks
+        # "irreducible". It still isn't — the fix is data, not code: put the
+        # state the variant needs into a fixture (or seeded row) and have the
+        # preview *select* it instead of *creating* it. Real case: a
+        # "documents shared with you" note variant used
+        # `doc.update_column(:standing_note, ...)` because the mailer
+        # re-queries the accessible documents; the fix was a fixture document
+        # that carries the standing note, with the two preview variants
+        # choosing their `document_ids` via `where(standing_note: nil)` vs
+        # all ids. Fixtures make the variant deterministic for snapshot-tested
+        # previews AND leave the dev DB untouched — never reach for an on-the-fly
+        # write (or an Exclude for this cop) before trying a fixture.
+        #
+        # `AllowedMethods` exists for projects whose preview data setup
+        # genuinely must write (e.g. a sandboxed preview database) — prefer
+        # leaving it empty.
+        #
+        # @example
+        #   # bad — viewing the preview rewrites the record
+        #   def reminder_with_note
+        #     checklist.update!(note_for_assignee: 'Standing note')
+        #     ChecklistMailer.with(checklist: checklist).reminder
+        #   end
+        #
+        #   # good — same rendered body, no side effect
+        #   def reminder_with_note
+        #     checklist.note_for_assignee = 'Standing note'
+        #     ChecklistMailer.with(checklist: checklist).reminder
+        #   end
+        class NoPersistenceInMailerPreviews < Base
+          MSG = '`%<method>s` persists from a mailer preview — previews render on every GET in ' \
+                'development, so viewing the email mutates the dev DB. Assign in memory instead ' \
+                '(`record.attr = value`): the mailer receives the object via `.with(...)`, so the ' \
+                'rendered body is identical. For sample data, use fixtures/seeded rows or unsaved ' \
+                '`new`/`build` records.'.freeze
+
+          # `delete` and `insert` are deliberately absent: Hash#delete /
+          # Array#insert are everyday preview code and would false-positive;
+          # record-level intent is still covered by destroy/delete_all/insert_all.
+          PERSISTENCE_METHODS = %i[
+            save save! create create! update update! update_column update_columns
+            update_all update_attribute delete_all destroy destroy! destroy_all
+            insert! insert_all insert_all! upsert upsert_all
+            increment! decrement! toggle! touch touch_all
+            find_or_create_by find_or_create_by! create_or_find_by create_or_find_by!
+            first_or_create first_or_create!
+          ].freeze
+
+          def on_send(node)
+            method = node.method_name
+            return unless PERSISTENCE_METHODS.include?(method)
+            return if allowed_methods.include?(method.to_s)
+
+            add_offense(node.loc.selector, message: format(MSG, method: method))
+          end
+          # Safe navigation (`record&.update_column`) arrives as csend, which
+          # on_send does NOT receive — without this alias it slips through
+          # (found by red-teaming: `first&.update_column` in a real preview).
+          alias on_csend on_send
+
+          private
+
+          def allowed_methods = cop_config.fetch('AllowedMethods', [])
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/dev_doc/test/require_unit_test_justification.rb

@@ -1,3 +1,6 @@
+require_relative 'justification_header'
+require_relative 'test_file_placement'
+
 module RuboCop
   module Cop
     module DevDoc
@@ -15,12 +18,37 @@ module RuboCop
         #    in an exempt directory means a unit test is parked where the
         #    justification-header rule (and, for test/controllers/, the runtime
         #    HTTP lint — which only reaches integration-base descendants) cannot
-        #    see it.
+        #    see it. The non-HTTP side-effect base (`NonHttpBaseClasses`, default
+        #    `Glib::NonHttpIntegrationTest`) is confined the same way to its own
+        #    directories (`NonHttpDirectories`, default: jobs, mailers,
+        #    channels): full-stack tests whose contract is a side effect (a job's
+        #    record mutations, a mailer's body) rather than an HTTP response.
+        #    Outside those directories it is an evasion vector — in
+        #    test/controllers/ it would dodge the runtime HTTP lint exactly like
+        #    a unit base, and in a unit directory it would launder a unit test
+        #    past the truthful-declaration rule. Inside them, a class on the
+        #    non-HTTP base carries the same justification-header contract as a
+        #    unit directory (it consciously opted out of HTTP), while classes on
+        #    the integration base stay header-free — job tests legitimately mix
+        #    HTTP assertions with side-effect assertions.
         # 2. **Unit-test directories** (`UnitTestDirectories`, default: models,
         #    services, helpers) — allowed only with a justification header: the
         #    leading comments (before the first class/module) must contain the
         #    marker phrase (default "deliberate exception") explaining why a
-        #    controller test can't cover this.
+        #    controller test can't cover this, AND a wiring line (`WiringPhrase`,
+        #    default "wiring:") naming the request test that still covers the
+        #    HTTP path this test's subject participates in — or why no runtime
+        #    HTTP path exists, naming the actual entry point. The justification
+        #    must state the concrete mechanism (who calls save!, where the data
+        #    comes from); stock phrases ("the controller merely surfaces the
+        #    model's errors") do not count, and a header that misstates the
+        #    mechanism is worse than none — verify the claim by tracing the
+        #    write path before writing it. Base classes are allowlisted here
+        #    (`RequireUnitBase`, default true): a *Test class must subclass a
+        #    `UnitBaseClasses` member — plain ActiveSupport::TestCase is
+        #    rejected as an unexamined default, so the confession base is
+        #    structural, not optional. Inline helpers/doubles (non-*Test names)
+        #    are not policed.
         # 3. **Anything else** — flagged as an unrecognized test directory.
         #    Adding a new test home is a reviewed decision made in this cop's
         #    config, not something a generated test can do implicitly.
@@ -53,6 +81,8 @@ module RuboCop
         #   # Per best practice, we focus on controller tests. This model test
         #   # is a deliberate exception: the safely_* guards raise on ANY direct
         #   # call, so by design no controller path can reach them.
+        #   # Wiring: none — the guards are dead-man switches with no runtime
+        #   # caller; member_soft_deletion_test covers the soft-delete flow.
         #   class MemberTest < Glib::LastResortUnitTest
         #
         # @example
@@ -63,14 +93,11 @@ module RuboCop
         #   # bad — test/controllers/member_test.rb inheriting Glib::LastResortUnitTest
         #
         #   # good — test/models/member_test.rb whose leading comments contain
-        #   # "deliberate exception" and explain why no controller path exists
+        #   # "deliberate exception" and a "Wiring:" line, and explain why no
+        #   # controller path exists
         class RequireUnitTestJustification < Base
-          MSG_JUSTIFY = 'Unit-test file without a justification header. Controller tests catch the ' \
-                        'wiring bugs unit tests miss, so first assume a controller test IS possible ' \
-                        'and look harder — that conclusion is almost always premature (see ' \
-                        'DevDoc/Test/AvoidUnitTest for patterns that reach "unit-only" behaviour ' \
-                        'end-to-end). If genuinely impossible, explain why in the leading comments, ' \
-                        'including the marker phrase "%<phrase>s".'.freeze
+          include JustificationHeader
+          include TestFilePlacement
 
           MSG_UNRECOGNIZED = 'Test file in unrecognized directory `test/%<dir>s/`. Unit tests hide in ' \
                              'uncategorized directories: move this file to a recognized home ' \
@@ -87,8 +114,23 @@ module RuboCop
                           'hiding from that enforcement — move it there and justify it, or write a ' \
                           'real %<dir>s test.'.freeze
 
+          MSG_UNIT_BASE_REQUIRED = '`%<base>s` is not a sanctioned unit-test base. A justified unit ' \
+                                   'test must subclass one of: %<unit_bases>s — the name is the ' \
+                                   'policy (a conscious last resort) and base-class-keyed tooling ' \
+                                   'relies on it; plain ActiveSupport::TestCase reads as an ' \
+                                   'unexamined default. Extend UnitBaseClasses in this cop\'s ' \
+                                   'config if your project has another sanctioned unit base.'.freeze
+
+          MSG_NON_HTTP_BASE = '`%<base>s` is the non-HTTP side-effect base — it belongs only in ' \
+                              '%<non_http_dirs>s. In `test/%<dir>s/` it evades that directory\'s ' \
+                              'enforcement (the runtime HTTP lint reaches only integration-base ' \
+                              'descendants; unit directories require a unit base under a ' \
+                              'justification header) — move the test, or subclass the base this ' \
+                              'directory is enforced through.'.freeze
+
           FORBIDDEN_BASES = %w[ActionDispatch::IntegrationTest Glib::IntegrationTest].freeze
           EXEMPT_DIRS = %w[controllers integration jobs mailers channels system linters tasks].freeze
+          NON_HTTP_DIRS = %w[jobs mailers channels].freeze
 
           def on_new_investigation
             return if processed_source.blank?
@@ -103,109 +145,93 @@ module RuboCop
 
           def enforce_directory_rules(dir)
             if exempt_directories.include?(dir)
-              check_unit_bases(dir)
+              check_confined_bases(dir)
+              check_justification if non_http_base_in_non_http_dir?(dir)
             elsif unit_test_directories.include?(dir)
               check_justification
               check_base_classes
+              check_confined_bases(dir)
             else
               add_offense(offense_range, message: format(MSG_UNRECOGNIZED, dir: dir, known: known_directories))
             end
           end
 
-          def check_justification
-            return if leading_comments_contain_phrase?
-
-            add_offense(offense_range, message: format(MSG_JUSTIFY, phrase: marker_phrase))
+          # Landing on the non-HTTP side-effect base is a conscious exception
+          # too (the class opted out of HTTP inside an integration-shaped
+          # home), so it carries the same header contract as a unit directory.
+          def non_http_base_in_non_http_dir?(dir)
+            non_http_directories.include?(dir) && class_with_base?(non_http_base_classes)
           end
 
-          # A justified unit test must also DECLARE itself truthfully: inheriting
-          # an integration base class hides the test type from readers and from
-          # base-class-keyed tooling (the observed AvoidUnitTest evasion).
+          # A justified unit test must also DECLARE itself truthfully. Two
+          # tiers: integration bases get the tailored lie-about-type message;
+          # any other base outside UnitBaseClasses (e.g. plain
+          # ActiveSupport::TestCase) is rejected as an unexamined default —
+          # allowlist semantics, so the confession base is structural, not
+          # optional (disable via RequireUnitBase: false). Non-HTTP bases are
+          # skipped here so check_confined_bases' specific message fires.
           def check_base_classes
-            each_class_with_base(forbidden_base_classes) do |superclass, base|
-              add_offense(superclass, message: format(MSG_BASE, base: base))
-            end
-          end
-
-          # The inverse rule for exempt directories: a unit base there means a
-          # unit test parked where neither the header rule nor the runtime HTTP
-          # lint (which only reaches integration-base descendants) can see it.
-          def check_unit_bases(dir)
-            each_class_with_base(unit_base_classes) do |superclass, base|
-              add_offense(superclass,
-                          message: format(MSG_UNIT_BASE, base: base, dir: dir, unit_dirs: unit_directories_list))
-            end
-          end
+            each_test_class do |class_node, base|
+              next if base.nil? || unit_base_classes.include?(base) || non_http_base_classes.include?(base)
 
-          def each_class_with_base(bases)
-            root = processed_source.ast
-            return unless root
-
-            root.each_node(:class) do |class_node|
-              base = class_node.parent_class&.const_name
-              yield(class_node.parent_class, base) if base && bases.include?(base)
+              message = base_offense_message(base)
+              add_offense(class_node.parent_class, message: message) if message
             end
           end
 
-          # First path segment after the (last) `test/` component; nil when the
-          # file is not under one, '.' for files directly in test/. Only
-          # `*_test.rb` files count — anything else (helpers, shared scenarios,
-          # previews) is never loaded by the test runner, so there is nothing to
-          # enforce. In-cop guard on purpose: the config Include says the same,
-          # but the cop must stay correct even when run with a forced config.
-          def test_subdirectory
-            path = processed_source.file_path.to_s
-            return nil unless File.basename(path).end_with?('_test.rb')
-
-            rest = path_after_test_root(path)
-            return nil unless rest
-
-            segments = rest.split('/')
-            segments.length == 1 ? '.' : segments.first
-          end
-
-          # Everything after the LAST `test/` root component (handles nesting
-          # like test/services/ai/x_test.rb and repos checked out under a
-          # directory that itself contains `test/`).
-          def path_after_test_root(path)
-            if (index = path.rindex('/test/'))
-              path[(index + '/test/'.length)..]
-            elsif path.start_with?('test/')
-              path.delete_prefix('test/')
+          def base_offense_message(base)
+            if forbidden_base_classes.include?(base)
+              format(MSG_BASE, base: base)
+            elsif require_unit_base?
+              format(MSG_UNIT_BASE_REQUIRED, base: base, unit_bases: unit_base_classes.join(', '))
             end
           end
 
-          def leading_comments_contain_phrase?
-            processed_source.comments.any? do |comment|
-              comment.location.line < first_definition_line &&
-                comment.text.downcase.include?(marker_phrase.downcase)
+          # Bases confined to a directory set — the unit base to unit-test
+          # directories, the non-HTTP side-effect base to NonHttpDirectories.
+          # Anywhere else, the base parks a test where the enforcement that
+          # directory relies on (header rule, runtime HTTP lint — which only
+          # reaches integration-base descendants) cannot see it.
+          def check_confined_bases(dir)
+            base_confinements.each do |bases, allowed_dirs, message|
+              next if allowed_dirs.include?(dir)
+
+              each_class_with_base(bases) do |superclass, base|
+                add_offense(superclass,
+                            message: format(message, base: base, dir: dir,
+                                                     unit_dirs: unit_directories_list,
+                                                     non_http_dirs: non_http_directories_list))
+              end
             end
           end
 
-          # Header comments legitimately sit between the `require`s and the test
-          # class, so "leading" means before the first class/module definition.
-          def first_definition_line
-            root = processed_source.ast
-            return Float::INFINITY unless root
-
-            definition = root.each_node(:class, :module).first
-            (definition || root).first_line
+          def base_confinements
+            [
+              [unit_base_classes, unit_test_directories, MSG_UNIT_BASE],
+              [non_http_base_classes, non_http_directories, MSG_NON_HTTP_BASE]
+            ]
           end
 
-          def marker_phrase = cop_config.fetch('MarkerPhrase', 'deliberate exception')
-
           def forbidden_base_classes = cop_config.fetch('ForbiddenBaseClasses', FORBIDDEN_BASES)
 
           def unit_base_classes = cop_config.fetch('UnitBaseClasses', %w[Glib::LastResortUnitTest])
 
+          def non_http_base_classes = cop_config.fetch('NonHttpBaseClasses', %w[Glib::NonHttpIntegrationTest])
+
+          def require_unit_base? = cop_config.fetch('RequireUnitBase', true)
+
           def unit_test_directories = cop_config.fetch('UnitTestDirectories', %w[models services helpers])
 
+          def non_http_directories = cop_config.fetch('NonHttpDirectories', NON_HTTP_DIRS)
+
           def exempt_directories = cop_config.fetch('ExemptDirectories', EXEMPT_DIRS)
 
           def known_directories = (exempt_directories + unit_test_directories).map { |d| "test/#{d}/" }.join(', ')
 
           def unit_directories_list = unit_test_directories.map { |d| "test/#{d}/" }.join(', ')
 
+          def non_http_directories_list = non_http_directories.map { |d| "test/#{d}/" }.join(', ')
+
           def offense_range
             range = processed_source.ast&.source_range || processed_source.comments.first&.source_range
             range.with(end_pos: range.begin_pos + [range.source_line.length, 1].max)

data/lib/rubocop/cop/dev_doc/test/test_file_placement.rb

@@ -0,0 +1,74 @@
+module RuboCop
+  module Cop
+    module DevDoc
+      module Test
+        # Helpers shared by test-placement cops: classifying which test/
+        # subdirectory a file belongs to, and scanning its classes for base
+        # classes that placement rules key on.
+        module TestFilePlacement
+          private
+
+          # First path segment after the (last) `test/` component; nil when the
+          # file is not under one, '.' for files directly in test/. Only
+          # `*_test.rb` files count — anything else (helpers, shared scenarios,
+          # previews) is never loaded by the test runner, so there is nothing to
+          # enforce. In-module guard on purpose: the config Include says the same,
+          # but the cop must stay correct even when run with a forced config.
+          def test_subdirectory
+            path = processed_source.file_path.to_s
+            return nil unless File.basename(path).end_with?('_test.rb')
+
+            rest = path_after_test_root(path)
+            return nil unless rest
+
+            segments = rest.split('/')
+            segments.length == 1 ? '.' : segments.first
+          end
+
+          # Everything after the LAST `test/` root component (handles nesting
+          # like test/services/ai/x_test.rb and repos checked out under a
+          # directory that itself contains `test/`).
+          def path_after_test_root(path)
+            if (index = path.rindex('/test/'))
+              path[(index + '/test/'.length)..]
+            elsif path.start_with?('test/')
+              path.delete_prefix('test/')
+            end
+          end
+
+          def each_class_with_base(bases)
+            root = processed_source.ast
+            return unless root
+
+            root.each_node(:class) do |class_node|
+              base = class_node.parent_class&.const_name
+              yield(class_node.parent_class, base) if base && bases.include?(base)
+            end
+          end
+
+          # Yields each class node whose NAME marks it as a test class
+          # (`...Test`), with its superclass const name (nil when none). Scoping
+          # to *Test names keeps inline helpers/doubles (`class FakeGateway <
+          # BaseGateway`) out of base-class enforcement.
+          def each_test_class
+            root = processed_source.ast
+            return unless root
+
+            root.each_node(:class) do |class_node|
+              name = class_node.identifier.const_name
+              next unless name&.end_with?('Test')
+
+              yield(class_node, class_node.parent_class&.const_name)
+            end
+          end
+
+          def class_with_base?(bases)
+            found = false
+            each_class_with_base(bases) { |_superclass, _base| found = true }
+            found
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/dev_doc/view/prefer_prop_over_name.rb

@@ -29,13 +29,61 @@ module RuboCop
         #   hidden fields have no label/placeholder, and they are the
         #   dominant legitimate `name:` users (echoed tokens, dynamic-group
         #   indexes, forced values).
-        # - A field on an UNBOUND form (pre-auth flows: sessions, password
-        #   reset) cannot use `prop:` — there is no model to resolve against.
-        #   Prefer binding a fresh instance (e.g. `User.new`) so `prop:`
-        #   works; otherwise keep `name:` with a per-line
-        #   `rubocop:disable ... -- <reason>`.
-        # - Virtual/transient/credential fields where model-driven resolution
-        #   is undesirable: per-line disable with a reason.
+        # - `fields_creditCard` is exempt by default: it captures transient
+        #   card credentials (tokenised client-side, stripped from params
+        #   server-side) that must never bind to a persisted model.
+        # - `fields_dynamicGroup` is exempt by default: its `name:` is the
+        #   structural array-param key for the group's rows, not a labelled
+        #   model attribute — the row template's inner fields are where
+        #   `prop:` belongs.
+        # ## How to fix — the decision ladder
+        # Work down this ladder before even considering a disable. A full
+        # convert-or-justify sweep of a mature codebase (27 offenses) ended
+        # with ZERO disables — every "deliberately raw" case fell to one of
+        # these:
+        #
+        # 1. **Form bound + real attribute** → plain `prop:`.
+        # 2. **Form unbound** (pre-auth, filters) → bind a model. A blank
+        #    record works for auth flows (`model: User.new`); for
+        #    params-driven filters, a small presentation-only ActiveModel
+        #    form object (the filtering can keep running off permitted
+        #    params — the object exists only so fields derive names, labels
+        #    and sticky values).
+        # 3. **Param namespace differs from the bound model on purpose**
+        #    (server composes another record from `other_thing[...]` params)
+        #    → bind a form object whose namespace IS the contract; override
+        #    `model_name` if the class name doesn't match, and pass an
+        #    explicit `url:` (POROs have no route for polymorphic
+        #    derivation).
+        # 4. **Virtual param** (posted key isn't a column; controller applies
+        #    it manually) → add a READER-ONLY virtual attribute to the model
+        #    that derives the prefill (e.g. a `visibility` reader derived
+        #    from an enum, a `notification_note` reader defaulting to the
+        #    saved note). No writer → no mass-assignment surface; the
+        #    controller's manual handling is unchanged.
+        # 5. **Label-less by design** → keep `prop:` and pass `label: ''`.
+        #    The empty string is truthy, so it blocks the i18n label
+        #    derivation — "it must not have a label" is NOT a reason for raw
+        #    `name:`.
+        #
+        # ## Legitimately raw (don't convert)
+        # - Deliberately TOP-LEVEL params the controller reads un-namespaced:
+        #   mode switches (`params[:mode]`), auth params (`otp_attempt`),
+        #   signed link tokens, bare GET search terms (`q`), client-routing
+        #   pass-throughs (`target_form_id`). `prop:` would namespace them
+        #   under `param_key[...]` and break the read.
+        # - Client-side-only controls that never post: select-all master
+        #   toggles, show/hide drivers referenced via `{ "var": ... }`.
+        # - Bulk selection arrays (`foo[ids][]` with per-row `checkValue:`).
+        # - Names fixed by an external protocol (`g-recaptcha-response`).
+        #
+        # ## Trade-off to be aware of
+        # `prop:` removes the literal wire name from the source: you can no
+        # longer grep `user[email]` and land in the view — the name is
+        # assembled at render time. In exchange names become predictable
+        # (always `param_key[attr]`) and attribute renames fail loudly at
+        # render (`field_assert_respond_to`) instead of silently posting a
+        # dead param.
         #
         # ## Autocorrect (unsafe)
         # `name: 'model[attr]'` becomes `prop: :attr`. Two caveats make this
@@ -65,9 +113,14 @@ module RuboCop
           extend AutoCorrector
 
           MSG = 'Bind the model attribute with `prop: :%<attr>s` instead of `name: %<name>s` — ' \
-                '`prop:` resolves label/placeholder/validation from i18n. After switching, remove ' \
-                'the now-redundant hardcoded `label:`/`placeholder:` (verify the i18n keys exist). ' \
-                'If this field deliberately posts a raw param, disable with a reason.'.freeze
+                '`prop:` derives the field name and resolves label/placeholder from i18n. ' \
+                'No bound model is not a blocker: bind a blank record or an ActiveModel form ' \
+                'object (override `model_name` when the param namespace is the contract). A ' \
+                'virtual param is not a blocker: add a reader-only attribute deriving the ' \
+                'prefill. Label-less by design is not a blocker: keep `prop:` and pass ' \
+                "`label: ''`. Raw `name:` is right only for deliberately top-level params the " \
+                'controller reads un-namespaced (mode switches, auth params, search terms) ' \
+                'and client-side-only controls.'.freeze
 
           MODEL_ATTR_NAME = /\A\w+\[(\w+)\]\z/
 
@@ -100,7 +153,7 @@ module RuboCop
           end
 
           def exempt_field_methods
-            cop_config.fetch('ExemptFieldMethods', %w[fields_hidden])
+            cop_config.fetch('ExemptFieldMethods', %w[fields_hidden fields_creditCard fields_dynamicGroup])
           end
         end
       end

data/lib/rubocop/dev_doc/version.rb

@@ -1,5 +1,5 @@
 module RuboCop
   module DevDoc
-    VERSION = "0.9.0".freeze
+    VERSION = "0.10.1".freeze
   end
 end

data/lib/rubocop/dev_doc.rb

@@ -9,5 +9,6 @@ module RuboCop
 end
 
 RuboCop::ConfigLoader.ignore_parent_exclusion = true
+RuboCop::ConfigObsoletion.files << RuboCop::DevDoc::PROJECT_ROOT.join("config", "obsoletion.yml").to_s
 
 Dir[File.join(__dir__, "cop", "dev_doc", "**", "*.rb")].each { |f| require f }

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rubocop-dev_doc
 version: !ruby/object:Gem::Version
-  version: 0.9.0
+  version: 0.10.1
 platform: ruby
 authors:
 - dev-doc contributors
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-07-05 00:00:00.000000000 Z
+date: 2026-07-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -102,7 +102,6 @@ files:
 - lib/rubocop/cop/dev_doc/i18n/translation_key_prefix.rb
 - lib/rubocop/cop/dev_doc/migration/amount_column_in_cents.rb
 - lib/rubocop/cop/dev_doc/migration/avoid_boolean_column.rb
-- lib/rubocop/cop/dev_doc/migration/avoid_bypassing_validation.rb
 - lib/rubocop/cop/dev_doc/migration/avoid_column_default.rb
 - lib/rubocop/cop/dev_doc/migration/avoid_conditional_schema_changes.rb
 - lib/rubocop/cop/dev_doc/migration/avoid_json_column.rb
@@ -115,6 +114,7 @@ files:
 - lib/rubocop/cop/dev_doc/migration/require_primary_key.rb
 - lib/rubocop/cop/dev_doc/migration/require_timestamps.rb
 - lib/rubocop/cop/dev_doc/rails/application_record_transaction.rb
+- lib/rubocop/cop/dev_doc/rails/avoid_bypassing_validation.rb
 - lib/rubocop/cop/dev_doc/rails/avoid_lifecycle_method_override.rb
 - lib/rubocop/cop/dev_doc/rails/avoid_ordering_by_id.rb
 - lib/rubocop/cop/dev_doc/rails/avoid_rails_callbacks.rb
@@ -132,7 +132,6 @@ files:
 - lib/rubocop/cop/dev_doc/style/avoid_head_response.rb
 - lib/rubocop/cop/dev_doc/style/avoid_insecure_send.rb
 - lib/rubocop/cop/dev_doc/style/avoid_options_hash.rb
-- lib/rubocop/cop/dev_doc/style/avoid_send.rb
 - lib/rubocop/cop/dev_doc/style/case_else_decision.rb
 - lib/rubocop/cop/dev_doc/style/literal_operator_in_condition.rb
 - lib/rubocop/cop/dev_doc/style/literal_or_in_when_clause.rb
@@ -146,11 +145,14 @@ files:
 - lib/rubocop/cop/dev_doc/style/tap_block_ignores_value.rb
 - lib/rubocop/cop/dev_doc/test/avoid_glib_travel_freeze.rb
 - lib/rubocop/cop/dev_doc/test/avoid_unit_test.rb
+- lib/rubocop/cop/dev_doc/test/justification_header.rb
+- lib/rubocop/cop/dev_doc/test/no_persistence_in_mailer_previews.rb
 - lib/rubocop/cop/dev_doc/test/require_glib_integration_base.rb
 - lib/rubocop/cop/dev_doc/test/require_glib_travel.rb
 - lib/rubocop/cop/dev_doc/test/require_glib_travel_block.rb
 - lib/rubocop/cop/dev_doc/test/require_unit_test_justification.rb
 - lib/rubocop/cop/dev_doc/test/response_assert_equal.rb
+- lib/rubocop/cop/dev_doc/test/test_file_placement.rb
 - lib/rubocop/cop/dev_doc/view/prefer_prop_over_name.rb
 - lib/rubocop/dev_doc.rb
 - lib/rubocop/dev_doc/plugin.rb