rubocop-dev_doc 0.3.1 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 163ac4a232d22f5d731e680d4ae882172570cdcf3085a07be7d6c3195223e365
-  data.tar.gz: a3eae8c77dcb707ddc4875be90255bea2fa33bcaeba370c7aff06436cd045661
+  metadata.gz: 2076123d07503e775a29287eafcd8dc9d8cf6e344eeb4b462d29120fdef12879
+  data.tar.gz: 910414d217e37c808b7626add2b876d24f6ef214a725b373e86dc736acb24ff7
 SHA512:
-  metadata.gz: a605681c5f22058138abe3d8bdcd1e12eb94073f74e02fde30bc1f1df0baa538022b69fe33c4f83279cfaed995e60e5c9a4936de43cad7a89f07105c4b6e7a24
-  data.tar.gz: 0e845bcf2236245a8c4b0289a02d7731e12c9ac0023732f6135127f02f436c78f349012b98bd18127e89cdb4e70736597c2fc5313229ed3faaf572294e847168
+  metadata.gz: 7681307dae1b8d09d0344c199d4be497bc4c986b4314711ae39550d7d8ced8d8b811d07d98997f8e3fc85d294e6fde1b97c8cb6cdc3c33a40ad3074cda985d62
+  data.tar.gz: a047b648abfcaeb1842158a562c17028601a2f24c67e1f0aa2cdc548377cccd1658dae4b6b68cee1cb4906275a59822f2870160380e71cb5d730c04ce5d44196

data/config/default.yml

@@ -79,11 +79,12 @@ DevDoc/Migration/DateColumnNaming:
     - "db/migrate/**/*.rb"
 
 DevDoc/Migration/AvoidVagueColumnNames:
-  Description: "Avoid vague column names like `status` or `group`. Use more specific names."
+  Description: "Avoid vague column names like `status`, `group`, or `kind`. Use more specific names."
   Enabled: true
   VagueNames:
     - status
     - group
+    - kind
   Include:
     - "db/migrate/*.rb"
     - "db/migrate/**/*.rb"
@@ -146,10 +147,10 @@ DevDoc/Rails/EnumColumnNotNull:
 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
+  AdditionalNonRelationMethods: []
   Exclude:
     - "spec/**/*"
     - "test/**/*"
-    - "db/seeds.rb"
     - "db/seeds/**/*.rb"
     - "lib/tasks/**/*.rb"
 
@@ -165,6 +166,10 @@ DevDoc/Style/AvoidSend:
   Description: "Avoid `send`/`public_send` with an explicit receiver; prefer direct calls or safer alternatives."
   Enabled: true
 
+DevDoc/Style/PreferPublicSend:
+  Description: "Prefer `public_send` over `send` — visibility-respecting dispatch surfaces typos/misconfig and documents intent."
+  Enabled: true
+
 DevDoc/Style/RepeatedSafeNavigationReceiver:
   Description: "Avoid using `&.` on the same receiver more than once in a method body — assign once and use `.` after."
   Enabled: true
@@ -177,6 +182,10 @@ DevDoc/Style/MinimizeVariableScope:
   Description: "Assign a variable inside the `if` condition that guards it, to keep its scope local to the branch."
   Enabled: true
 
+DevDoc/Style/TapBlockIgnoresValue:
+  Description: "Flag `tap` whose block ignores the yielded value — `tap` is for operating on the receiver, not eliding a temp var."
+  Enabled: true
+
 DevDoc/Style/AvoidHeadResponse:
   Description: "Avoid `head()` with error statuses; delegate error handling to Rails exceptions or model validations."
   Enabled: true
@@ -247,6 +256,17 @@ DevDoc/Rails/AvoidRailsCallbacks:
   Include:
     - "app/models/**/*.rb"
 
+DevDoc/Rails/AvoidLifecycleMethodOverride:
+  Description: "Avoid overriding Rails validation/persistence lifecycle methods (run_validations!, valid?, etc.) to dodge AvoidRailsCallbacks."
+  Enabled: true
+  Include:
+    - "app/models/**/*.rb"
+  Methods:
+    - run_validations!
+    - valid?
+    - invalid?
+    - perform_validations
+
 DevDoc/Rails/ApplicationRecordTransaction:
   Description: "Use `ApplicationRecord.transaction` instead of `SomeModel.transaction` outside model files."
   Enabled: true
@@ -296,6 +316,14 @@ DevDoc/Rails/StrongParametersExpect:
   Include:
     - "app/controllers/**/*.rb"
 
+DevDoc/Rails/AvoidRawSql:
+  Description: "Avoid raw SQL — prefer the hash/array form, parameterized fragments, or Arel; disable with a reason when raw SQL is genuinely required."
+  Enabled: true
+
+DevDoc/Rails/AvoidOrderingById:
+  Description: "Avoid `order`/`reorder` by `id` as the primary (sole or leftmost) sort — order by a business column, or use `id` only as a secondary tiebreaker."
+  Enabled: true
+
 # `save!` / `update!` raise on persistence failure, which is what
 # we want in jobs/services/rake tasks — silent `false` returns
 # hide bugs. Excluded for controllers, which lean on `save`
@@ -368,4 +396,3 @@ DevDoc/Auth/CurrentUserBranching:
     - "app/helpers/**/*.rb"
     - "app/controllers/concerns/**/*.rb"
     - "app/views/layouts/**/*"
-    - "app/controllers/application_controller.rb"

data/lib/rubocop/cop/dev_doc/auth/current_user_branching.rb

@@ -56,13 +56,56 @@ module RuboCop
         #
         # ## Allowed paths (Exclude:)
         # By default the cop is silent in:
-        #   app/policies/**/*.rb
+        #   app/policies/**/*.rb          ← auth-dependent checks belong here
         #   app/helpers/**/*.rb
         #   app/controllers/concerns/**/*.rb
-        #   app/views/layouts/**/*
-        #   app/controllers/application_controller.rb
+        #   app/views/layouts/**/*        ← display branching (nav bars, etc.)
         #
-        # Override via `Exclude:` in your `.rubocop.yml`.
+        # Override via `Exclude:` in your `.rubocop.yml`. Note: literal file
+        # paths (e.g. `app/controllers/application_controller.rb`) in
+        # `.rubocop.yml` `Exclude:` lists are flagged by the
+        # `DevDoc::Test::Lints::NoFileExcludes` lint — they hide the
+        # suppression from readers of that file. If `ApplicationController`
+        # needs an exception, use an inline `# rubocop:disable` at the
+        # specific line with a reason.
+        #
+        # ## Before disabling inline, consider the Policy
+        # The Policy exclusion is not accidental — it's the canonical
+        # Rails home for auth-dependent branching. If the flagged line
+        # is an authorization check (`return if @record.accessible_by?(current_user)`,
+        # `if current_user.admin?`, etc.), the right move is almost
+        # always to push that check into a Pundit policy method, not
+        # disable inline. The controller becomes
+        # `return unless policy(@record).access?` — same behaviour,
+        # no `current_user` reference in the controller, and the auth
+        # logic is reusable + testable in isolation.
+        #
+        # Even better: declare `glib_authorize_resource` at the
+        # controller level. glib-web runs the appropriate policy
+        # method before each action automatically, so the per-action
+        # `verify_access` / `authorize @record` line is usually not
+        # needed at all — the controller body no longer references
+        # `current_user` because the auth check has moved out of the
+        # action entirely. See `best_practices/backend/en/05_controller.md`
+        # item #7 for the canonical pattern.
+        #
+        #   ❌ Auth check in the controller — flagged
+        #   def verify_access
+        #     return if @support_question.accessible_by?(current_user)
+        #     # ... token fallback ...
+        #   end
+        #
+        #   ✔️ Same check in the Policy — silently allowed
+        #   # app/policies/support_question_policy.rb
+        #   def access?
+        #     user.present? && record.accessible_by?(user)
+        #   end
+        #
+        #   # in the controller:
+        #   def verify_access
+        #     return if policy(@support_question).access?
+        #     # ... token fallback ...
+        #   end
         #
         # NOTE: The cop does not autocorrect — there is no mechanical fix. The
         # right response depends on developer intent: drop the branch (if auth

data/lib/rubocop/cop/dev_doc/migration/avoid_column_default.rb

@@ -43,6 +43,13 @@ module RuboCop
         #     end
         #   end
         #
+        # ## Forms covered
+        # The cop catches `default:` set at column-creation time AND `default:`
+        # set later via `change_column_default(..., to: <non-nil>)`. Both are
+        # the same anti-pattern — a permanent default living in the schema.
+        # `change_column_default(..., to: nil)` (removing a default) is not
+        # flagged; that is the cleanup form.
+        #
         # ## Exception (auto-detected)
         # For performance reasons (large tables with millions of records) or when
         # using `null: false`, you may temporarily set a default and then
@@ -51,6 +58,10 @@ module RuboCop
         # for the same table and column anywhere in the same method body (`def
         # change` / `def up`), including inside `reversible do |dir| dir.up`.
         #
+        # The exception applies symmetrically:
+        # - `add_column ... default: X` paired with `change_column_default ... to: nil` → no offense
+        # - `change_column_default ... to: X` paired with `change_column_default ... to: nil` → no offense
+        #
         #   ✔ (no offense — two-step pattern auto-detected)
         #   add_column :users, :profile_completion_rate, :float, default: 0.0
         #   change_column_default :users, :profile_completion_rate, from: 0.0, to: nil
@@ -62,14 +73,22 @@ module RuboCop
         #   # bad
         #   t.string :status, default: 'active'
         #
+        #   # bad — permanent default set via change_column_default
+        #   change_column_default :users, :score, from: nil, to: 0
+        #
         #   # good
         #   add_column :users, :score, :integer
         #
         #   # good (temporary default immediately removed — two-step pattern)
         #   add_column :users, :score, :integer, default: 0
         #   change_column_default :users, :score, from: 0, to: nil
+        #
+        #   # good (removing an existing default)
+        #   change_column_default :users, :score, from: 0, to: nil
         class AvoidColumnDefault < Base
           MSG = 'Avoid setting `default:` in migrations. Keep business logic defaults in the application layer.'.freeze
+          MSG_CHANGE = 'Avoid setting a non-nil default via `change_column_default`. ' \
+                       'Keep business logic defaults in the application layer.'.freeze
 
           COLUMN_METHODS = %i[
             string integer float boolean datetime date text binary decimal
@@ -84,9 +103,22 @@ module RuboCop
             (send _ :change_column_default (sym $_) (sym $_) (hash <(pair (sym :to) (nil)) ...>))
           PATTERN
 
+          # change_column_default(:table, :col, ..., to: <non-nil>, ...) — captures table + col.
+          def_node_matcher :change_column_default_to_non_nil?, <<~PATTERN
+            (send _ :change_column_default (sym $_) (sym $_) (hash <(pair (sym :to) !nil) ...>))
+          PATTERN
+
           def on_send(node)
-            return unless column_method?(node)
+            if node.method?(:change_column_default)
+              check_change_column_default(node)
+            elsif column_method?(node)
+              check_column_method(node)
+            end
+          end
+
+          private
 
+          def check_column_method(node)
             options = node.arguments.find(&:hash_type?)
             return unless options && has_default_option?(options)
             return if two_step_pattern?(node)
@@ -94,7 +126,16 @@ module RuboCop
             add_offense(find_default_pair(options))
           end
 
-          private
+          def check_change_column_default(node)
+            captures = change_column_default_to_non_nil?(node)
+            return unless captures
+
+            table_name, col_name = captures
+            return if cancelled_in_same_method?(node, table_name, col_name)
+
+            options = node.arguments.find(&:hash_type?)
+            add_offense(find_to_pair(options), message: MSG_CHANGE)
+          end
 
           def column_method?(node)
             node.method?(:add_column) || COLUMN_METHODS.include?(node.method_name)
@@ -104,10 +145,20 @@ module RuboCop
             options.pairs.find { |p| p.key.sym_type? && p.key.value == :default }
           end
 
+          def find_to_pair(options)
+            options.pairs.find { |p| p.key.sym_type? && p.key.value == :to }
+          end
+
           def two_step_pattern?(node)
             table_name, col_name = extract_table_and_column(node)
             return false unless table_name && col_name
 
+            cancelled_in_same_method?(node, table_name, col_name)
+          end
+
+          # Is there a `change_column_default(..., to: nil)` for the same
+          # (table, col) anywhere in the enclosing method? Used by both forms.
+          def cancelled_in_same_method?(node, table_name, col_name)
             enclosing_def = node.each_ancestor(:def).first
             return false unless enclosing_def
 

data/lib/rubocop/cop/dev_doc/migration/avoid_vague_column_names.rb

@@ -2,20 +2,24 @@ module RuboCop
   module Cop
     module DevDoc
       module Migration
-        # Avoid vague column names like `status` or `group`.
+        # Avoid vague column names like `status`, `group`, or `kind`.
         #
         # ## Rationale
         # Use more specific names that describe the domain context. A column
         # named `status` reveals nothing about *what* status it tracks; a column
         # named `processing_status` makes the intent obvious at the call site.
+        # `kind` is the same shape — a content-free "what variety" label that
+        # reads no better than `type` (which Rails reserves for STI).
         #
         #   ❌
         #   t.string :status
         #   add_column :orders, :group, :integer
+        #   t.integer :kind
         #
         #   ✔️
         #   t.string :processing_status
         #   add_column :orders, :user_group, :integer
+        #   t.integer :membership_kind
         #
         # ## Note about `type`
         # `type` is reserved by Rails for Single Table Inheritance (STI). Even
@@ -29,10 +33,12 @@ module RuboCop
         #   # bad
         #   t.string :status
         #   add_column :orders, :group, :integer
+        #   t.integer :kind
         #
         #   # good
         #   t.string :processing_status
         #   add_column :orders, :user_group, :integer
+        #   t.integer :membership_kind
         class AvoidVagueColumnNames < Base
           MSG = 'Avoid vague column name `%<name>s`. Use a more specific name that includes context.'.freeze
 

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

@@ -0,0 +1,107 @@
+module RuboCop
+  module Cop
+    module DevDoc
+      module Rails
+        # Avoid overriding Rails validation/persistence *lifecycle* methods in
+        # model files (`run_validations!`, `valid?`, etc.).
+        #
+        # ## Rationale
+        # `DevDoc/Rails/AvoidRailsCallbacks` bans the callback DSL so lifecycle
+        # behaviour stays visible at explicit call sites. Overriding a lifecycle
+        # method is a loophole — it reproduces the same hidden control flow
+        # without tripping that cop:
+        #
+        #   # Flagged by AvoidRailsCallbacks:
+        #   before_validation :do_something
+        #
+        #   # NOT flagged by it — but functionally identical, and worse:
+        #   def run_validations!
+        #     do_something
+        #     super
+        #   end
+        #
+        # `def run_validations!; do_something; super; end` is a
+        # `before_validation :do_something` in disguise, and it's strictly worse:
+        #
+        # - **Silent on typo.** Misspell the method name (drop the `!`, or
+        #   `run_validatons!`) and it's just a never-called method — no load-time
+        #   error, no override in effect, behaviour silently reverts to stock
+        #   Rails. The callback DSL fails loudly (`NoMethodError`) on a mistyped
+        #   macro or symbol, caught by the first test that validates.
+        # - **More obscure.** Overriding an internal Rails method hides the
+        #   lifecycle hook even more than the DSL it's avoiding.
+        #
+        # This cop pairs with (it does not replace) `AvoidRailsCallbacks`: the two
+        # cover the two ways to inject lifecycle behaviour — the DSL, and the
+        # override.
+        #
+        # ## What to do instead
+        # 1. Prefer an explicit method at the call site (e.g. `save_with_*`) that
+        #    makes the behaviour visible, or a plain `validate :some_check` where
+        #    a validation-time check is all you need.
+        # 2. If an override is genuinely required (e.g. a model whose validators
+        #    read access-gated attributes and must wrap the *entire* validation
+        #    run — something `validate` can't express), disable this cop inline
+        #    with a written justification:
+        #
+        #      def run_validations! # rubocop:disable DevDoc/Rails/AvoidLifecycleMethodOverride
+        #        # Reason: <explanation>
+        #        with_access { super }
+        #      end
+        #
+        # ## Not airtight
+        # A determined dodge can still `prepend` a module, `alias_method`, or use
+        # `method_missing`. This cop raises the bar and makes the documented path
+        # (inline disable + justification) the easy one; it does not seal every
+        # hole.
+        #
+        # ## Configuration
+        # The flagged methods are configurable via `Methods`. The default is the
+        # validation-lifecycle set — the cleanest 1:1 substitute for the
+        # validation callbacks `AvoidRailsCallbacks` bans, with the least
+        # false-positive noise. Projects that also want to guard persistence
+        # verbs can add `save`/`save!`/`create`/`update`/`destroy` etc.
+        #
+        # @example
+        #   # bad
+        #   def run_validations!
+        #     normalize
+        #     super
+        #   end
+        #
+        #   # bad
+        #   def valid?(context = nil)
+        #     toggle_access { super }
+        #   end
+        #
+        #   # good — an explicit method / a plain validation declaration
+        #   validate :assert_consistent
+        #
+        #   # good — a non-lifecycle override is fine
+        #   def to_param
+        #     slug
+        #   end
+        class AvoidLifecycleMethodOverride < Base
+          MSG = 'Avoid overriding the Rails lifecycle method `%<method>s` — it hides ' \
+                'callback-like control flow and silently no-ops if mistyped. Prefer an ' \
+                'explicit method or a `validate` declaration; if an override is genuinely ' \
+                'required, disable this cop inline with a written justification.'.freeze
+
+          DEFAULT_METHODS = %w[run_validations! valid? invalid? perform_validations].freeze
+
+          def on_def(node)
+            return unless flagged_methods.include?(node.method_name)
+
+            add_offense(node.loc.name, message: format(MSG, method: node.method_name))
+          end
+
+          private
+
+          def flagged_methods
+            @flagged_methods ||= Array(cop_config['Methods'] || DEFAULT_METHODS).map(&:to_sym)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,167 @@
+module RuboCop
+  module Cop
+    module DevDoc
+      module Rails
+        # Avoid ordering by `id` as the primary (sole or leftmost) sort.
+        #
+        # ## Rationale
+        # `order(id: ...)` / `order(:id)` sorts by the primary key, which
+        # reflects insertion order (and, for UUIDs, random order) rather
+        # than a column the reader can reason about. It makes a list read
+        # as "most recent" by accident, hides the real ordering intent,
+        # and silently breaks the moment rows are imported out of sequence
+        # or the primary key type changes.
+        #
+        # Order by a meaningful business column instead, and reach for
+        # `id` only as a **secondary** key to break ties deterministically:
+        #
+        #   ❌ Primary key is not a sort the reader can reason about
+        #   Snapshot.order(id: :desc)
+        #
+        #   ✔️ Business column carries the intent
+        #   Snapshot.order(created_at: :desc)
+        #
+        #   ✔️ `id` as a deterministic tiebreaker — never the primary sort
+        #   Snapshot.order(created_at: :desc, id: :desc)
+        #
+        # See `best_practices/backend/en/05_controller.md` — always `.order()`
+        # when displaying more than one record, and reserve `order(id: ...)`
+        # for the rare case where id-ordering is genuinely intended.
+        #
+        # ## Scope
+        # Flags `order` and `reorder` where `:id` is the **sole** ordering
+        # column or the **leftmost** (primary) one, in hash form
+        # (`order(id: :desc)`), symbol form (`order(:id)`,
+        # `order(:id, :name)`), or array form (`order([:id])`).
+        #
+        # Only the FIRST argument is inspected — it is the primary sort;
+        # every later argument is a tiebreaker. Raw-SQL string ordering
+        # (`order("id")`, `order("id DESC")`) is the domain of
+        # `DevDoc/Rails/AvoidRawSql`, so this cop defers the moment its
+        # leading argument is a string, an `Arel.sql(...)`, or anything
+        # other than a hash/symbol/array — the primary sort can't be read
+        # statically, and flagging would risk a false positive on a
+        # tiebreaker.
+        #
+        # NOTE: Each `order`/`reorder` call is inspected in isolation, so a
+        # chained form like `rel.order(:created_at).order(id: :desc)` is
+        # flagged even though Rails *appends* chained `order` calls — making
+        # `id` a secondary tiebreaker there. The deterministic-tiebreaker
+        # idiom this cop endorses is the single-call hash/symbol form
+        # (`order(created_at: :desc, id: :desc)`); prefer that, or disable
+        # inline with a reason when the chained form is genuinely intended.
+        #
+        # ## `id` as a secondary key is allowed
+        # `order(created_at: :desc, id: :desc)` is the standard pattern for
+        # deterministic ordering — `id` only breaks ties after the business
+        # column. The cop allows `:id` in any non-primary position:
+        #
+        #   ✔️ `id` breaks ties only — primary sort is `created_at`
+        #   Snapshot.order(created_at: :desc, id: :desc)
+        #   Snapshot.order(:created_at, :id)
+        #
+        # ## Exception
+        # When `id` is genuinely the intended primary sort (rare — usually a
+        # sign something is special about the code), suppress the offense
+        # with an inline disable comment and a brief reason — e.g. an
+        # append-only audit log where `id` is creation order, so
+        # id-ordering is the real intent rather than an accident.
+        #
+        # NOTE: A named scope or model method that wraps the offense hides
+        # it at the call site — `scope :newest, -> { order(id: :desc) }` is
+        # flagged in the model file, but callers of `.newest` are not. The
+        # cop flags the definition, which is where the decision belongs.
+        #
+        # NOTE: Prefer `order(created_at: :desc)` for deterministic
+        # results — see `best_practices/backend/en/05_controller.md` #4.
+        # The rare legitimate `order(id:)` cases (see Exception above) —
+        # e.g. a test grabbing a record a controller just created, where
+        # `created_at` ties across one request and `id` is the only
+        # reliable insertion-order proxy — take an inline disable with a
+        # reason, not a blanket `Exclude` of `spec/**`/`test/**` (that
+        # silences accidental id-ordering in tests).
+        #
+        # @example
+        #   # bad — `id` is the sole or primary sort
+        #   Snapshot.order(id: :desc)
+        #   Snapshot.order(:id)
+        #   Snapshot.order(id: :desc, created_at: :desc)
+        #   Snapshot.order(:id, :created_at)
+        #   submission.snapshots.reorder(id: :asc)
+        #
+        #   # good — business column primary, `id` as a tiebreaker
+        #   Snapshot.order(created_at: :desc)
+        #   Snapshot.order(created_at: :desc, id: :desc)
+        #   Snapshot.order(:created_at, :id)
+        class AvoidOrderingById < Base
+          MSG = 'Ordering by `id` as the primary sort exposes the primary ' \
+                "key's insertion order rather than a meaningful column. " \
+                'Order by a business column (e.g. `created_at:`), or move ' \
+                '`id` to a secondary position as a deterministic tiebreaker. ' \
+                'Disable with a reason when `id` is genuinely the intended ' \
+                'primary sort.'.freeze
+
+          RESTRICT_ON_SEND = %i[order reorder].freeze
+
+          def on_send(node)
+            first = first_ordering_column(node)
+            return unless first
+            return unless id_column?(first)
+
+            add_offense(node.loc.selector)
+          end
+
+          # Safe navigation (`rel&.order(id: :desc)`) parses as a `:csend`
+          # node, which `on_send` does not visit — alias it so the same
+          # check covers both dispatch forms.
+          alias on_csend on_send
+
+          private
+
+          # The leftmost ordering column, or nil when the primary sort
+          # isn't statically knowable. Only the FIRST argument is inspected
+          # — it alone is the primary sort; every later argument is a
+          # tiebreaker.
+          #
+          #   order(:created_at, id: :desc) → :created_at  (id secondary)
+          #   order(id: :desc)              → :id pair key
+          #   order([:id])                  → :id           (array recurses)
+          #
+          # Returns nil (defers) for a raw-SQL string (`DevDoc/Rails/
+          # AvoidRawSql` owns it) AND for any other non-structured leading
+          # arg — an `Arel.sql` node, a helper call, a splat, a literal —
+          # because the primary sort can't be read statically and flagging
+          # would risk a false positive on what may be a tiebreaker.
+          def first_ordering_column(node)
+            ordering_column_of(node.arguments.first)
+          end
+
+          # Resolve the primary sort from a single argument node, recursing
+          # into an array (`order([:id])`) so the array form matches the
+          # bare-symbol form.
+          def ordering_column_of(arg)
+            return nil unless arg
+            return nil if arg.str_type? || arg.dstr_type?
+            return first_hash_key(arg) if arg.hash_type?
+            return ordering_column_of(arg.children.first) if arg.array_type?
+            return arg if arg.sym_type?
+
+            nil
+          end
+
+          def first_hash_key(hash_node)
+            pair = hash_node.pairs.first
+            return nil unless pair
+
+            key = pair.key
+            key if key&.sym_type?
+          end
+
+          def id_column?(node)
+            node.sym_type? && node.value == :id
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -22,12 +22,19 @@ module RuboCop
         #   class Order < ApplicationRecord
         #     def save_with_confirmation_email
         #       transaction do
-        #         save!
-        #         OrderMailer.confirmation(self).deliver_later
+        #         saved = save
+        #         invoice.save! if saved
         #       end
+        #       OrderMailer.confirmation(self).deliver_later if saved
         #     end
         #   end
         #
+        # The `deliver_later` is *outside* the transaction deliberately —
+        # `DevDoc/Rails/NoDeliverLaterInTransaction` flags mailers/jobs
+        # queued inside a transaction (the job may run before commit and
+        # read stale data). The `saved` local leaks out of the block
+        # (Ruby's normal scoping), gating the mailer on actual success.
+        #
         # ## When you have multiple call sites needing the same guard
         # The single-method-per-place pattern above works when there is one
         # natural call site. When several controllers/jobs/bulk operations all
@@ -101,8 +108,11 @@ module RuboCop
         #
         #   # good
         #   def save_with_confirmation
-        #     transaction { save! }
-        #     send_confirmation
+        #     transaction do
+        #       saved = save
+        #       invoice.save! if saved
+        #     end
+        #     send_confirmation if saved
         #   end
         class AvoidRailsCallbacks < Base
           CALLBACKS = %i[

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

@@ -0,0 +1,227 @@
+module RuboCop
+  module Cop
+    module DevDoc
+      module Rails
+        # Avoid raw SQL in query methods and `connection.execute`.
+        #
+        # ## Rationale
+        # Raw SQL bypasses Rails' adapter abstraction, hides typos in
+        # column and table names (a misspelled column silently returns
+        # nothing instead of raising `NameError`), is non-reversible in
+        # migrations, and ships no audit trail for why raw SQL was chosen
+        # over the Rails idiom. Every raw-SQL site should be a deliberate,
+        # reviewable choice — not a default.
+        #
+        # Prefer, in order:
+        #
+        # - The hash/array form: `where(status: "active")`,
+        #   `where(status: ["active", "pending"])`.
+        # - Parameterized fragments: `where("col = ?", val)`,
+        #   `where("col = :sym", sym: val)`. The `?` / `:name` placeholder
+        #   binds the value safely and the column name is the only
+        #   user-controlled surface.
+        # - Arel nodes for database-specific constructs that the hash
+        #   form can't express.
+        #
+        #   ❌ Raw SQL — typo in `statu` returns nothing, silently
+        #   User.where("statu = 'active'")
+        #
+        #   ✔️ Hash form — typo raises `ArgumentError` at the query layer
+        #   User.where(status: "active")
+        #
+        #   ✔️ Parameterized fragment — value bound, column name spelled
+        #   User.where("status = ?", status)
+        #
+        # ## Scope
+        # The cop covers any string argument to:
+        #
+        # - **Execution methods** — `execute`, `exec_query`, `exec_update`,
+        #   `exec_delete`, `exec_insert`, `find_by_sql`, `select_rows`,
+        #   `select_values`, `select_one`, `select_all`, `update_sql`,
+        #   `insert_sql`, `delete_sql`, `update_all`, `delete_all`.
+        # - **Query fragment methods** — `where`, `having`, `order`,
+        #   `reorder`, `joins`, `select`, `group`, `from`, `lock`, `pluck`.
+        # - **`Arel.sql`** — the explicit opt-in to raw SQL (see below).
+        #
+        # Applies everywhere — application code AND migrations. A
+        # migration's `execute "UPDATE ..."` is the same smell as an
+        # app code `where("...")`; both bypass the adapter and offer no
+        # audit trail.
+        #
+        # ## `Arel.sql`
+        # Always flagged. `Arel.sql` exists specifically to bypass Rails'
+        # raw-SQL protection — reaching for it should require
+        # justification, not be a reflex. If a fragment is genuinely
+        # needed, disable inline with a reason; otherwise express it as
+        # an Arel AST node or a parameterized query.
+        #
+        # ## Counter updates (`update_all("col = col + 1")`)
+        # 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
+        # are the Rails-blessed atomic-counter primitives).
+        #
+        # For **bulk counter updates**, the only clean option is
+        # `find_each { |m| Model.increment_counter(:col, m.id) }` — N
+        # 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`
+        # with reasons — the friction is the audit trail (locking
+        # implications, idempotency on re-runs, and the like are worth
+        # a second look).
+        #
+        #   ❌ Single-record counter update via raw SQL
+        #   User.where(id: id).update_all("login_count = login_count + 1")
+        #
+        #   ✔️ Parameterized — generates safe SQL
+        #   User.increment_counter(:login_count, id)
+        #
+        # ## Exception
+        # Genuine raw-SQL needs — database-specific DDL
+        # (`CREATE INDEX CONCURRENTLY`, `ALTER TYPE ... ADD VALUE`),
+        # complex joins that don't fit Arel, analytic queries with CTEs
+        # — go through an inline disable comment with a brief reason.
+        # The friction is the feature: every raw-SQL site ends up in
+        # code review with an articulated justification.
+        #
+        # ## Migration backfills are NOT an exception
+        # A common AI-agent reflex is to justify
+        # `execute "UPDATE users SET role = 0 ..."` with "models can
+        # drift, so raw SQL is safer." That justification is rejected
+        # here. The data-integrity cost of bypassing validations and
+        # callbacks outweighs the (rare, usually catchable) risk of a
+        # migration failing because a model changed.
+        #
+        # The correct backfill pattern goes through the model with
+        # `save!` — `DevDoc/Migration/AvoidBypassingValidation`
+        # enforces this, and `best_practices/backend/en/02_migration.md`
+        # shows the shape:
+        #
+        #   ✔️ Model through the migration — validations run, callbacks fire
+        #   User.where(role: nil).find_each do |user|
+        #     user.role = 0
+        #     user.save!
+        #   end
+        #
+        # If existing rows would fail validation, fix the data first
+        # rather than bypassing validation — that's the signal, not an
+        # obstacle.
+        #
+        # NOTE: Parameterized fragments are detected by the presence of
+        # a `?` or `:name` placeholder plus at least one additional
+        # argument. A `?` appearing in literal SQL that isn't a
+        # placeholder (`where("name LIKE '%?%'")`) is a residual false
+        # negative; inline-disable if it surfaces.
+        #
+        # NOTE: Interpolated strings (`where("col = '#{val}'")`) are
+        # ALWAYS flagged — they cannot be parameterized by construction
+        # and are a SQL-injection risk. Use the `?` placeholder form.
+        #
+        # NOTE: Method calls returning strings (`where(some_helper)`)
+        # are not flagged — the cop only inspects literal strings.
+        # Helper methods that wrap raw SQL should themselves carry the
+        # disable.
+        #
+        # @example
+        #   # bad — raw SQL
+        #   execute "UPDATE users SET role = 0 WHERE role IS NULL"
+        #   User.where("status = 'active'")
+        #   User.where("status = '#{status}'")
+        #   User.order("created_at")
+        #   User.joins("INNER JOIN items ON items.user_id = users.id")
+        #   User.update_all("login_count = login_count + 1")
+        #   User.select("DISTINCT status")
+        #   Arel.sql("NULLS LAST")
+        #
+        #   # good — hash / array / symbol form
+        #   User.where(status: "active")
+        #   User.where(status: ["active", "pending"])
+        #   User.order(:created_at)
+        #   User.joins(:items)
+        #   User.update_all(status: "active")
+        #   User.select(:status)
+        #
+        #   # good — parameterized fragment
+        #   User.where("status = ?", status)
+        #   User.where("status = :sym", sym: status)
+        #   User.find_by_sql("SELECT * FROM users WHERE id = ?", id)
+        #
+        #   # good — counter update on a single record
+        #   User.increment_counter(:login_count, id)
+        class AvoidRawSql < Base
+          MSG = 'Avoid raw SQL — prefer the hash/array form, a ' \
+                'parameterized fragment, or an Arel node. Disable with ' \
+                'a reason when raw SQL is genuinely required.'.freeze
+
+          EXECUTION_METHODS = %i[
+            execute exec_query exec_update exec_delete exec_insert
+            find_by_sql select_rows select_values select_one select_all
+            update_sql insert_sql delete_sql update_all delete_all
+          ].freeze
+
+          FRAGMENT_METHODS = %i[
+            where having order reorder joins select group from lock pluck
+          ].freeze
+
+          SQL_METHODS = (EXECUTION_METHODS + FRAGMENT_METHODS).freeze
+
+          RESTRICT_ON_SEND = (SQL_METHODS + [:sql]).freeze
+
+          def on_send(node)
+            if arel_sql?(node)
+              check_arel_sql(node)
+            elsif SQL_METHODS.include?(node.method_name)
+              check_sql_method(node)
+            end
+          end
+
+          private
+
+          # `Arel.sql("...")` — the explicit opt-in to raw SQL. The
+          # receiver must be the `Arel` constant so unrelated
+          # `obj.sql(...)` calls don't false-positive.
+          def arel_sql?(node)
+            node.method_name == :sql &&
+              node.receiver&.const_type? &&
+              node.receiver.const_name == 'Arel'
+          end
+
+          # Arel.sql is always flagged (no parameterized exemption) —
+          # reaching for it is itself the smell being audited.
+          def check_arel_sql(node)
+            arg = node.first_argument
+            return unless arg && string?(arg)
+
+            add_offense(arg)
+          end
+
+          def check_sql_method(node)
+            arg = node.first_argument
+            return unless arg && string?(arg)
+            return if parameterized?(node, arg)
+
+            add_offense(arg)
+          end
+
+          def string?(arg)
+            arg.str_type? || arg.dstr_type?
+          end
+
+          # A literal string (`str`) is parameterized when it contains a
+          # `?` or `:name` placeholder AND there's at least one more
+          # argument to bind. An interpolated string (`dstr`) is NEVER
+          # parameterized — the value is concatenated in, not bound.
+          def parameterized?(send_node, string_arg)
+            return false if string_arg.dstr_type?
+            return false unless send_node.arguments.count > 1
+
+            value = string_arg.value
+            value.include?('?') || value.match?(/:[a-z_][a-z0-9_]*/i)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -120,15 +120,21 @@ module RuboCop
           end
 
           # Build the replacement for `params.require(:key).permit(*args)`.
-          # Symbol args stay as-is; hash args are wrapped in `{ }` since they
-          # need explicit braces when placed inside an array literal.
+          # Symbol args stay as-is; hash args need explicit braces when placed
+          # inside the `expect` array literal.
           def build_require_permit_replacement(params_node, key, permit_args)
             inner = permit_args.map { |arg| permit_arg_source(arg) }.join(', ')
             "#{params_node.source}.expect(#{key}: [#{inner}])"
           end
 
+          # A hash arg written WITHOUT braces (the trailing-kwargs form,
+          # `permit(:a, b: [1])`) has a brace-less source, so add them. A hash
+          # arg written WITH explicit braces (`permit(:a, { b: [1] })`) already
+          # includes them in its source — wrapping again would emit `{ {...} }`.
           def permit_arg_source(arg)
-            arg.hash_type? ? "{ #{arg.source} }" : arg.source
+            return arg.source unless arg.hash_type?
+
+            arg.braces? ? arg.source : "{ #{arg.source} }"
           end
         end
       end

data/lib/rubocop/cop/dev_doc/style/prefer_public_send.rb

@@ -0,0 +1,86 @@
+module RuboCop
+  module Cop
+    module DevDoc
+      module Style
+        # Prefer `public_send` over `send` when dispatching dynamically.
+        #
+        # ## Rationale
+        # `public_send` respects Ruby's method visibility. When the dispatched
+        # name should resolve to a public API method (the common case for
+        # generic validators, form helpers, attribute readers, etc.), using
+        # `public_send`:
+        #
+        # - **Surfaces typos / misconfig immediately.** A name that drifts to
+        #   a private internal raises `NoMethodError` instead of silently
+        #   invoking it.
+        # - **Future-proofs the call site.** If the target method later moves
+        #   to private (refactor, contract narrowing), `public_send` raises
+        #   on the next run; `send` keeps silently working — potentially
+        #   masking a real bug.
+        # - **Documents intent.** A reader of `public_send` knows the author
+        #   meant a public-API call. `send` leaves it ambiguous whether
+        #   private access was wanted.
+        #
+        # ## Relationship to AvoidSend
+        # `DevDoc/Style/AvoidSend` flags *dynamic* dispatch (both `send` and
+        # `public_send`) as risky. This cop is orthogonal: it flags `send`
+        # specifically, including the cases AvoidSend exempts (literal-symbol
+        # args, prefix-string args). The friction asymmetry is intentional —
+        # `send` is the deeper exception, so it costs an extra disable:
+        #
+        #   obj.public_send(method_name)        # AvoidSend: 1 disable
+        #   obj.public_send(:foo)               # clean
+        #   obj.send(method_name)               # AvoidSend + this cop: 2 disables
+        #   obj.send(:foo)                      # this cop only: 1 disable
+        #
+        # ## When `send` IS the right choice
+        # Reach for `send` only when you have an articulable reason to bypass
+        # visibility — and leave a comment so the next reader knows it's
+        # deliberate:
+        #
+        # - **Tests** calling a private helper:
+        #
+        #     # rubocop:disable DevDoc/Style/PreferPublicSend -- unit-testing private method
+        #     assert_equal 5, calculator.send(:internal_carry)
+        #     # rubocop:enable DevDoc/Style/PreferPublicSend
+        #
+        # - **Framework / introspection** code that intentionally calls
+        #   private callbacks (e.g. `record.send(:_run_save_callbacks)`).
+        #
+        # ## Receiver-less `send` is exempt
+        # `send(:foo)` (no explicit receiver) calls a method on `self` and is
+        # commonly used inside a class to dispatch to its own private methods.
+        # Rewriting to `public_send` would either change semantics (the
+        # method must become public) or fail. Same exemption as `AvoidSend`.
+        #
+        # @example
+        #   # bad — prefer public_send
+        #   record.send(attribute)
+        #   instance.send(:public_method)
+        #   obj.send("export_#{x}")
+        #
+        #   # good — visibility-respecting dispatch
+        #   record.public_send(attribute)
+        #   instance.public_send(:public_method)
+        #   obj.public_send("export_#{x}")
+        #
+        #   # good — receiver-less send (calling self's own method)
+        #   send(:internal_helper)
+        class PreferPublicSend < Base
+          MSG = 'Prefer `public_send` over `send` — it respects method ' \
+                'visibility, surfacing typos/misconfig that would otherwise ' \
+                'silently invoke a private method. Disable with a reason ' \
+                'when bypassing visibility is intentional.'.freeze
+
+          RESTRICT_ON_SEND = %i[send].freeze
+
+          def on_send(node)
+            return if node.receiver.nil?
+
+            add_offense(node.loc.selector)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/dev_doc/style/tap_block_ignores_value.rb

@@ -0,0 +1,123 @@
+module RuboCop
+  module Cop
+    module DevDoc
+      module Style
+        # Flag `Object#tap` whose block ignores the yielded value.
+        #
+        # ## Rationale
+        # `tap` exists to **operate on the yielded receiver and return it** —
+        # `obj.tap { |x| configure(x) }`. The yielded value is the whole
+        # point of the method.
+        #
+        # When the block **ignores** the yielded value, `tap` is no longer
+        # doing that job. It's being used purely as a temp-variable-elision
+        # trick for "run a side effect, then return the receiver":
+        #
+        #   ❌ Block never references the yielded value — `tap` is eliding a temp var
+        #   read_value.tap { do_side_effect }
+        #
+        # This costs readability for no benefit:
+        #
+        # - **It hides the return value in the receiver position.** `tap`'s
+        #   "returns self" behaviour is its *less obvious* property. A reader
+        #   has to stop and recall that the expression returns the receiver,
+        #   not the block's value. The explicit form puts the return value on
+        #   its own line where "what does this return" is literal.
+        # - **Footgun magnet.** Return-value semantics here are subtle — it's
+        #   easy to nearby-edit the block into something whose value you think
+        #   matters, or to confuse it with the broken `expr; side_effect`
+        #   sequence (which returns the side effect's value, not `expr`'s).
+        #   Code whose contract is "return this value" reads and edits more
+        #   safely when the return is explicit.
+        # - **Equal stakes → prefer the duller form.** Both forms are correct
+        #   and neither is faster. With no functional difference, the more
+        #   obvious one wins in a shared codebase.
+        #
+        #   ✔️ Explicit intent, return value on its own line
+        #   result = read_value
+        #   do_side_effect
+        #   result
+        #
+        # ## When `tap` IS the right choice
+        # Reserve `tap` for its canonical use — when the block references the
+        # yielded value:
+        #
+        #   ✔️ Block uses the yielded value — this is what `tap` is for
+        #   Model.new.tap { |m| m.role = :admin; m.save }
+        #   record.tap { |r| logger.debug(r.to_sql) }
+        #
+        # ## Exception
+        # Genuine intentional uses (e.g. a logging side effect that reads
+        # clearer in tap position) go through an inline `# rubocop:disable`
+        # with a reason. The friction is the feature — it forces the choice
+        # to be articulated and reviewed.
+        #
+        # NOTE: Numbered-param (`_1`) and implicit-`it` (Ruby 3.4+) forms are
+        # not flagged — by construction, those forms reference the yielded
+        # value, which is the canonical use of `tap`. Block-pass (`&:sym`) is
+        # likewise not flagged; it isn't a block node.
+        #
+        # NOTE: If a nested block *shadows* the outer arg name
+        # (`tap { |v| items.each { |v| v.foo } }`), the inner reference is
+        # treated as covering the outer — a rare residual false negative.
+        # Inline-disable if it ever matters.
+        #
+        # @example
+        #   # bad — block ignores the yielded value
+        #   read_value.tap { do_side_effect }
+        #   record.tap { |r| log_event }
+        #   value.tap { }
+        #
+        #   # good — block references the yielded value
+        #   Model.new.tap { |m| m.role = :admin; m.save }
+        #   record.tap { |r| logger.debug(r.to_sql) }
+        #
+        #   # good — a reference inside a nested block still counts
+        #   items.tap { |i| [1, 2].each { i << _1 } }
+        #
+        #   # good — preferred explicit form when the value is unused
+        #   result = read_value
+        #   do_side_effect
+        #   result
+        class TapBlockIgnoresValue < Base
+          MSG = '`tap` is for operating on the yielded value — when the ' \
+                'block ignores it, prefer an explicit assign-and-return. ' \
+                'Disable with a reason when the side effect reads clearer ' \
+                'in `tap` position.'.freeze
+
+          def on_block(node)
+            return unless node.send_node.method?(:tap)
+            return if block_uses_yielded_value?(node)
+
+            add_offense(node.send_node.loc.selector)
+          end
+
+          private
+
+          def block_uses_yielded_value?(node)
+            args = node.arguments
+            return false unless args
+            return false if args.children.empty? # no param declared → value ignored
+
+            # `tap` yields one value; multi-arg / destructuring is unusual.
+            # Be conservative — don't flag what we can't confidently call
+            # "ignoring the value".
+            return true if args.children.length >= 2
+
+            arg = args.children.first
+            return true unless arg.respond_to?(:name)
+
+            return false unless node.body # empty body with declared arg → flag
+
+            # Walk from the block node (not `body`): `each_descendant`
+            # excludes the receiver, so a body that *is* an lvar
+            # (`tap { |v| v }`) would be missed otherwise. Nested blocks
+            # are walked too, so a reference inside one counts as "used".
+            # The shadowing edge case is documented above as a NOTE.
+            node.each_descendant(:lvar).any? { |n| n.children.first == arg.name }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -13,6 +13,18 @@ module RuboCop
         # controller test (very rare) — e.g. a search-ranking detail the
         # controller never exposes.
         #
+        # The danger a unit test hides: it can stay green while the feature is
+        # broken in production. It proves a method works in isolation — NOT that
+        # the real request path calls that method, in the right order, inside the
+        # transaction it needs. A model method can be flawless in a unit test
+        # while the controller calls the wrong method, skips it, or runs it
+        # outside its transaction; the unit test stays green and the feature is
+        # broken. Controller tests fail when the *wiring* is wrong — which is
+        # where regressions actually live. So a passing unit test is not evidence
+        # the feature works; it is false confidence about production. Reach for
+        # one only when you are sure a controller test genuinely cannot reach the
+        # path, not because it is quicker to write.
+        #
         # This cop flags only the literal `< ActiveSupport::TestCase`
         # superclass. The blessed blackbox bases —
         # `ActionDispatch::IntegrationTest`, `Glib::IntegrationTest`,
@@ -20,6 +32,18 @@ module RuboCop
         # though they inherit from `ActiveSupport::TestCase` transitively.
         #
         # ## Escape hatch
+        # Before reaching for a unit test, assume a controller test IS possible
+        # and look harder — that conclusion is almost always premature. Behaviour
+        # that feels inherently unit-level is usually reachable end-to-end:
+        #   - Transaction rollback / "a failure mid-request": inject the failure
+        #     at a class-method chokepoint the gem/service calls (stub it to
+        #     raise), drive the real request, and assert the observable rollback
+        #     (e.g. `assert_no_difference` on the record count). Even atomicity,
+        #     which feels inherently unit-level, is reachable this way.
+        #   - "The controller wraps it in a transaction so I can't isolate the
+        #     model's own": you usually don't need to — assert the *observable*
+        #     guarantee through the real path; that is what matters in production.
+        #
         # When a unit test is genuinely necessary, suppress with a reason that
         # explains why a controller test can't cover the path. That reason IS the
         # required justification — keep it specific and reviewable:

data/lib/rubocop/dev_doc/version.rb

@@ -1,5 +1,5 @@
 module RuboCop
   module DevDoc
-    VERSION = "0.3.1".freeze
+    VERSION = "0.5.0".freeze
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rubocop-dev_doc
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.5.0
 platform: ruby
 authors:
 - dev-doc contributors
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-06-11 00:00:00.000000000 Z
+date: 2026-06-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -107,7 +107,10 @@ 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_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
+- lib/rubocop/cop/dev_doc/rails/avoid_raw_sql.rb
 - lib/rubocop/cop/dev_doc/rails/bang_save_in_transaction.rb
 - lib/rubocop/cop/dev_doc/rails/enum_column_not_null.rb
 - lib/rubocop/cop/dev_doc/rails/enum_must_be_symbolized.rb
@@ -123,9 +126,11 @@ files:
 - lib/rubocop/cop/dev_doc/style/avoid_send.rb
 - lib/rubocop/cop/dev_doc/style/minimize_variable_scope.rb
 - lib/rubocop/cop/dev_doc/style/no_unscoped_method_definitions.rb
+- lib/rubocop/cop/dev_doc/style/prefer_public_send.rb
 - lib/rubocop/cop/dev_doc/style/repeated_bracket_read.rb
 - lib/rubocop/cop/dev_doc/style/repeated_safe_navigation_receiver.rb
 - lib/rubocop/cop/dev_doc/style/string_symbol_comparison.rb
+- 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/response_assert_equal.rb