rubocop-dev_doc 0.10.0 → 0.10.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d919e99af15a6422fabc24cd8cd5697d45777275150060f5df47fd20be56f386
-  data.tar.gz: 4998be254bdb93920dfa694ab035a588bb5b44f768fa9f1867814c7e88feed19
+  metadata.gz: f669dc6f7e91c7e3aaac4e42e680df95fc24acbf6b467e7831387866cc2dc0d4
+  data.tar.gz: 41f06d6d2b20efd95b60389aae5f6803d206ad8f844d8de9daf04d87369ebf8f
 SHA512:
-  metadata.gz: 13dcfa0d80c10d12254a6fba6ddcbc05ec075650184739ff705ced68fc59a0743bdef285e8f990fb44bd027cc84c97db392b5fee3ba54e4b48ededd0d2c8711f
-  data.tar.gz: b8bf463155762956e6c2ed5619554f2a84a70765c9619a94fb06d3190f056d29c8230bbff1f11e4ccca8560cab3765106f9f1b4f7abe9da68a9760e1e7f236bc
+  metadata.gz: 7cdef60287b7ef58701aab3c5e025416b2033d93c3a09d06b6addc3636daaf169010584df484ec6377caa192d74d901ee52a0abf56473490c3f4e289cf6895ba
+  data.tar.gz: 84a55b7ffaf35e17e8ee436c7f696c176659c30394fa7ed6a50a7bc46fa64ecbb2b5728a5df6547d457ba0006154e9279409b7fc2f6075f4937d0a0406a37ee6

data/config/default.yml

@@ -96,7 +96,11 @@ DevDoc/Migration/BooleanColumnNotNull:
 #     Enabled: false
 # Use AllowedMethods for skips that are by-design in your project (touch,
 # counter caches) instead of per-site disables.
-DevDoc/Migration/AvoidBypassingValidation:
+# Renamed from DevDoc/Migration/AvoidBypassingValidation in 0.9.0 — the cop was
+# never migration-specific (deliberately global, no Include); the old department
+# name misled readers into thinking app code was unguarded. Old name raises a
+# rename error via config/obsoletion.yml.
+DevDoc/Rails/AvoidBypassingValidation:
   Description: "Avoid methods that bypass validations and callbacks (`update_column`, `update_all`, `insert_all`, `touch`, etc.). Superset of Rails/SkipsModelValidations — disable that cop when enabling this one."
   Enabled: false
   AllowedMethods: []
@@ -177,9 +181,16 @@ DevDoc/Rails/EnumColumnNotNull:
   Include:
     - "app/models/**/*.rb"
 
+# Receiver detection is inclusion-based (precision-first): the cop only fires
+# when the chain visibly proves a relation (where/joins/includes/order/... or
+# a scope listed in AdditionalRelationMethods). Opaque receivers and bare
+# association reads are NOT flagged — the prior exclusion-based design
+# dogfooded at 21 offenses / 0 true positives on a mature codebase. Recover
+# recall on hot association/scope names via AdditionalRelationMethods.
 DevDoc/Rails/NoBlockPredicateOnRelation:
   Description: "Avoid block-form `count`/`reject`/`select`/`find`/`any?` on AR relations; push the predicate into SQL with `.where(...)` or a scope."
   Enabled: true
+  AdditionalRelationMethods: []
   AdditionalNonRelationMethods: []
   Exclude:
     - "spec/**/*"
@@ -652,8 +663,14 @@ DevDoc/View/PreferPropOverName:
   # sibling label:/placeholder: for manual removal.
   Enabled: false
   SafeAutoCorrect: false
+  # fields_creditCard and fields_dynamicGroup are structurally non-model:
+  # credit-card fields capture transient credentials that must never bind to
+  # a persisted model, and dynamic-group names are array-param structural keys
+  # with no label/placeholder to derive.
   ExemptFieldMethods:
     - fields_hidden
+    - fields_creditCard
+    - fields_dynamicGroup
   Include:
     - "app/views/**/*.jbuilder"
     - "app/views/**/*.rb"

data/lib/rubocop/cop/dev_doc/{migration → rails}/avoid_bypassing_validation.rb

@@ -1,7 +1,7 @@
 module RuboCop
   module Cop
     module DevDoc
-      module Migration
+      module Rails
         # Avoid methods that bypass validations and callbacks.
         #
         # ## Rationale

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

@@ -59,7 +59,7 @@ module RuboCop
         # For **single records**, use `Model.increment_counter(:col, id)`
         # or `Model.update_counters(id, col: 1)` — both generate
         # parameterized SQL and surface typos in the column name. Neither
-        # is flagged by `DevDoc/Migration/AvoidBypassingValidation` (they
+        # is flagged by `DevDoc/Rails/AvoidBypassingValidation` (they
         # are the Rails-blessed atomic-counter primitives).
         #
         # For **bulk counter updates**, the only clean option is
@@ -67,7 +67,7 @@ module RuboCop
         # queries, slow on large tables, but free of the
         # validation-bypass smell. If the N-query cost is genuinely
         # unacceptable, `update_all("col = col + 1")` requires disabling
-        # BOTH this cop AND `DevDoc/Migration/AvoidBypassingValidation`
+        # BOTH this cop AND `DevDoc/Rails/AvoidBypassingValidation`
         # with reasons — the friction is the audit trail (locking
         # implications, idempotency on re-runs, and the like are worth
         # a second look).
@@ -95,7 +95,7 @@ module RuboCop
         # migration failing because a model changed.
         #
         # The correct backfill pattern goes through the model with
-        # `save!` — `DevDoc/Migration/AvoidBypassingValidation`
+        # `save!` — `DevDoc/Rails/AvoidBypassingValidation`
         # enforces this, and `best_practices/backend/en/02_migration.md`
         # shows the shape:
         #

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

@@ -28,11 +28,31 @@ module RuboCop
         # attributes, non-trivial Ruby logic). For those, add a
         # `# rubocop:disable` with a brief reason.
         #
+        # ## Receiver detection is precision-first (inclusion, not exclusion)
+        # The cop only fires when the receiver chain PROVES it is a relation:
+        # it must contain a relation-returning method (`where`, `joins`,
+        # `includes`, `order`, `limit`, ... — see RELATION_RETURNING_METHODS)
+        # or a project-declared scope from `AdditionalRelationMethods`.
+        # Opaque receivers (locals, ivars, method params, bare association
+        # reads like `user.posts`) are NOT flagged.
+        #
+        # This is a deliberate trade. The earlier exclusion-based design
+        # ("flag anything that isn't provably a non-relation") was dogfooded
+        # against a mature codebase and scored 21 offenses with ZERO true
+        # positives — params arrays, gem data, AST enumerators, and validators
+        # that must see unsaved in-memory records. A cop that is all noise
+        # teaches people to write disables, which is worse than the missed
+        # recall: a bare `user.posts.any? { }` slipping through is a perf
+        # nit; twenty reflex disables are a culture problem. Projects can
+        # recover recall selectively by listing their hot association/scope
+        # names in `AdditionalRelationMethods`.
+        #
         # ## Excluded receivers
-        # To keep false positives low, the cop skips receivers that clearly
-        # aren't AR relations: array literals (`[...]`), hash literals
-        # (`{...}`), screaming-case constants (e.g. `PRICING_PLANS`), and
-        # send-chains ending in a method known to return a non-Relation:
+        # Even within a proven relation chain, the cop skips receivers whose
+        # FINAL call is known to return a non-Relation (the collection is
+        # already materialised, so SQL push-down is no longer possible), plus
+        # obvious non-relations: array literals (`[...]`), hash literals
+        # (`{...}`), and screaming-case constants (e.g. `PRICING_PLANS`):
         # * Array-returning — `pluck`, `to_a`, `map`, `flatten`, `compact`,
         #   `uniq`, `sort`, `sort_by`, `reduce`, `inject`, `each_with_object`,
         #   `zip`, `take`, `drop`, `group_by`, `partition`, `tally`,
@@ -63,24 +83,20 @@ module RuboCop
         #   proves the element is a String.
         #
         # ## Configuration
-        # `AdditionalNonRelationMethods` (default `[]`): per-project list of
-        # method names that return non-Relation collections. Useful when a
-        # codebase has its own helper methods returning plain Arrays / Hashes
-        # (e.g. a presenter factory) — adding them here lets the cop skip
-        # send-chains ending in those methods. Example:
+        # `AdditionalRelationMethods` (default `[]`): per-project list of
+        # association/scope names the cop should treat as relation-returning.
+        # This is how a project recovers recall on its hot paths without
+        # re-opening the false-positive door. Example:
         #
         #   DevDoc/Rails/NoBlockPredicateOnRelation:
-        #     AdditionalNonRelationMethods:
-        #       - all_items
-        #       - for_account
-        #       - gst_registration_ranges
-        #
-        # NOTE: The cop cannot determine whether a local variable, instance
-        # variable, or method parameter is an AR relation or a plain
-        # collection. When the receiver is in fact a plain Array/Hash, add
-        # `# rubocop:disable DevDoc/Rails/NoBlockPredicateOnRelation` with a
-        # brief reason — the friction is intentional and ensures the choice
-        # is reviewed.
+        #     AdditionalRelationMethods:
+        #       - accessible_organization_documents
+        #       - active_subscriptions
+        #
+        # `AdditionalNonRelationMethods` (default `[]`): per-project list of
+        # method names that return non-Relation collections (e.g. a presenter
+        # factory) — a chain ENDING in one of these is skipped even when an
+        # earlier link is a relation method.
         #
         # @example
         #   # bad
@@ -108,31 +124,38 @@ module RuboCop
           # out would make the alias a zero-cost dodge.
           RESTRICT_ON_SEND = %i[count reject select filter find detect any?].freeze
 
+          # Methods returning an ActiveRecord::Relation — a chain containing one
+          # of these PROVES the receiver is a relation (inclusion-based
+          # detection; see the docstring). `merge`, `all` and `from` are
+          # deliberately absent: Hash#merge is everyday Ruby, `.all` is also
+          # the API of non-AR clients (e.g. Stripe list endpoints), and
+          # ActiveSupport adds Array#from.
+          RELATION_RETURNING_METHODS = %i[
+            where rewhere not joins left_joins left_outer_joins includes
+            preload eager_load references order reorder group having limit
+            offset distinct unscope unscoped lock readonly or
+          ].freeze
+
           # Methods whose return value is known to be a non-Relation collection
           # (Array, Hash, or Enumerator). When a `.select`/`.reject`/etc. with a
           # block is chained onto a call to one of these, the block runs over
           # the materialised collection — pushing into SQL isn't possible.
           NON_RELATION_RETURNING_METHODS = %i[
-            pluck pluck_to_hash
-            to_a to_ary
-            values keys
-            map flat_map collect collect_concat filter_map
-            flatten compact uniq sort sort_by reverse
-            reduce inject each_with_object
-            split lines chars bytes
-            zip take drop drop_while take_while
-            group_by partition tally tally_by chunk_while slice_when
-
-            slice except merge transform_values transform_keys to_h
-            compact_blank with_indifferent_access index_by index_with
-
-            each_with_index each_slice each_cons each_entry each_key each_value each_pair
-            chunk slice_before slice_after lazy with_index with_object
+            pluck pluck_to_hash to_a to_ary values keys map flat_map collect
+            collect_concat filter_map flatten compact uniq sort sort_by reverse
+            reduce inject each_with_object split lines chars bytes zip take
+            drop drop_while take_while group_by partition tally tally_by
+            chunk_while slice_when slice except merge transform_values
+            transform_keys to_h compact_blank with_indifferent_access index_by
+            index_with each_with_index each_slice each_cons each_entry each_key
+            each_value each_pair chunk slice_before slice_after lazy with_index
+            with_object
           ].freeze
 
           def on_send(node)
             return unless node.block_literal? || symbol_block_pass?(node)
             return if node.receiver.nil?
+            return unless relation_chain?(node.receiver)
             return if excluded_receiver?(node.receiver)
             return if excluded_block?(node)
 
@@ -148,55 +171,83 @@ module RuboCop
             last&.block_pass_type? && last.children.first&.sym_type?
           end
 
-          def excluded_receiver?(receiver)
-            return true if receiver.array_type? || receiver.hash_type?
-            return true if receiver.const_type? && screaming_case_const?(receiver)
-            return excluded_receiver?(receiver.children.first) if receiver.begin_type?
-            return true if receiver.send_type? && non_relation_method?(receiver.method_name)
+          # Inclusion gate: walk down the receiver chain looking for a link
+          # that PROVES this is a relation. Opaque receivers (lvars, ivars,
+          # bare association reads) never pass — that's the precision-first
+          # doctrine documented above.
+          def relation_chain?(node)
+            current = node
+            while current
+              current = unwrap_begin(current)
+              break unless current&.send_type?
+              return true if relation_method?(current.method_name)
 
+              current = current.receiver
+            end
             false
           end
 
-          # Merge built-in known-safe methods with project-specific ones from
-          # `AdditionalNonRelationMethods` in .rubocop.yml. The config knob
-          # lets each project opt-in their own domain methods (e.g. a
-          # `CashBookEntry.for_account` that returns an Array of plain Ruby
-          # presenters) without modifying this cop.
-          def non_relation_method?(method_name)
-            return true if NON_RELATION_RETURNING_METHODS.include?(method_name)
+          # A paren group's value is its LAST child (`(a; b).select { }` runs
+          # the block on `b`), so unwrap to that — `children.first` would judge
+          # the discarded statement.
+          def unwrap_begin(node)
+            node = node.children.last while node&.begin_type?
+            node
+          end
+
+          def relation_method?(method_name)
+            RELATION_RETURNING_METHODS.include?(method_name) ||
+              configured_methods('AdditionalRelationMethods').include?(method_name)
+          end
+
+          # Even inside a proven relation chain, skip when the FINAL call
+          # materialises the collection (`where(...).pluck(:id)`,
+          # `where(...).to_a`, ...): the block then runs over an in-memory
+          # collection and SQL push-down is no longer possible.
+          def excluded_receiver?(receiver)
+            receiver = unwrap_begin(receiver)
+            receiver&.send_type? && non_relation_method?(receiver.method_name)
+          end
 
-            additional = cop_config['AdditionalNonRelationMethods'] || []
-            additional.map(&:to_sym).include?(method_name)
+          # Built-in known-safe methods plus project-specific ones from
+          # `AdditionalNonRelationMethods` (e.g. a `CashBookEntry.for_account`
+          # returning an Array of plain Ruby presenters).
+          def non_relation_method?(method_name)
+            NON_RELATION_RETURNING_METHODS.include?(method_name) ||
+              configured_methods('AdditionalNonRelationMethods').include?(method_name)
           end
 
-          def screaming_case_const?(const_node)
-            const_node.short_name.to_s.match?(/\A[A-Z][A-Z0-9_]*\z/)
+          def configured_methods(key)
+            (cop_config[key] || []).map(&:to_sym)
           end
 
           # Look at the block parameters and body for evidence that the
-          # iterated element can't be an ActiveRecord record.
+          # iterated element can't be an ActiveRecord record. 2+ arg
+          # destructuring means the iterator yields a pair/tuple (Hash#each,
+          # zip, etc.) — AR relations only yield single records; for a
+          # single-arg block, inspect how the arg is used inside the body.
           def excluded_block?(send_node)
             block_node = send_node.block_node
-            return false unless block_node
-
-            args = block_node.arguments
-            return false unless args
+            return false unless block_node.respond_to?(:arguments)
+            return true if pair_destructuring_block?(block_node)
 
-            # 2+ arg destructuring means the iterator yields a pair/tuple
-            # (Hash#each, zip, etc.). AR relations only yield single records.
-            return true if args.children.length >= 2
+            # `to_a` normalises across node kinds: a block's ArgsNode yields its
+            # children; a numblock's `arguments` is already a plain (empty) Array.
+            args = block_node.arguments.to_a
+            arg_name = args.length == 1 ? block_arg_name(args.first) : nil
+            return false unless arg_name && block_node.body
 
-            # Single-arg block: inspect how the arg is used inside the body.
-            return false unless args.children.length == 1
-
-            arg_node = args.children.first
-            arg_name = block_arg_name(arg_node)
-            return false unless arg_name
+            block_arg_indicates_non_record?(block_node.body, arg_name)
+          end
 
-            body = block_node.body
-            return false unless body
+          # 2+ block params — literal `|k, v|` or numbered (`_2` yields arity 2
+          # as an Integer child, there is no ArgsNode) — mean the iterator
+          # yields a pair/tuple (Hash#each, zip, ...); AR relations yield
+          # single records.
+          def pair_destructuring_block?(block_node)
+            return block_node.children[1] >= 2 if block_node.numblock_type?
 
-            block_arg_indicates_non_record?(body, arg_name)
+            block_node.arguments.to_a.length >= 2
           end
 
           # Extract the simple name of a block argument, regardless of whether
@@ -214,18 +265,22 @@ module RuboCop
           #   * Single-character string-literal indexing — `arg[0] == '+'` —
           #     implies String
           def block_arg_indicates_non_record?(body, arg_name)
-            body.each_descendant(:send) do |send|
-              next unless send.method_name == :[]
-              next unless send.receiver&.lvar_type?
-              next unless send.receiver.children.first == arg_name
-              next unless send.arguments.length == 1
-
-              key = send.first_argument
-              return true if key.sym_type?
-              return true if key.int_type? && compared_to_single_char_string?(send)
+            body.each_descendant(:send).any? do |send|
+              indexes_block_arg?(send, arg_name) && non_record_key?(send)
             end
+          end
 
-            false
+          # `arg[...]` with exactly one index argument, on the named block arg.
+          def indexes_block_arg?(send, arg_name)
+            send.method_name == :[] &&
+              send.receiver&.lvar_type? &&
+              send.receiver.children.first == arg_name &&
+              send.arguments.length == 1
+          end
+
+          def non_record_key?(send)
+            key = send.first_argument
+            key.sym_type? || (key.int_type? && compared_to_single_char_string?(send))
           end
 
           # `arg[0] == '+'` — the [] send is one side of a `==` or `!=`

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

@@ -21,6 +21,22 @@ module RuboCop
         # 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.

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.10.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.10.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