rubocop-dev_doc 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 32fcdd022e9dde952826050d447d83e9fa7f9bf1cfaf7caaaddda3309e392a3b
-  data.tar.gz: e6775d4b37a1d763966c25eb3b2bf7926026b2ba2fdeae6d11fc05ae9d2ba46e
+  metadata.gz: 17a792c93018068695bb2c73dc023577864a51cbe29fc8962ba0d82f44784bd5
+  data.tar.gz: 260d22ceb74db21595f99e912a2bcbc4556718a30de5327fabf562b1174c84aa
 SHA512:
-  metadata.gz: fb0572fc498d052e2f49d45490c37ddfcfa349d5a4e17b199159537b713cb5206ee828ffa96d5466c5e386e8da7713a22b5d3e51eca9daf228041be278fbe014
-  data.tar.gz: a96d7bcdb8c34f3b0ab557a8bee46ef6ce91028174728cf06efa7df2943dafe7b67a47b9dff813260f2c824c6d7b1094bb6bc69c15bcb63fbf1c2f0bfab62333
+  metadata.gz: 6df2aae2a244e306e2a659dfd2f258a5b057fbfa0dda9d6fbc25ef4169fd6c67acc3906e03df78057eb22b4337727c9992ef0bc2b3cd6e760a63edb30dfcfb3b
+  data.tar.gz: 05b1392296eb25d9625e3f755f2310a262b955ecef1e38d0448d25e6c99352351c5284a9e61a5d3361415e2c2a91e5ae9589fbea532b077babd856a55eb3fa8c

data/config/default.yml

@@ -1,5 +1,23 @@
 # Default configuration for rubocop-dev_doc cops.
-# Cops are enabled by default; disable them in your project's .rubocop.yml if needed.
+# Cops are disabled by default; enable them in your project's .rubocop.yml.
+
+# Department-level settings: DocumentationBaseURL lets RuboCop construct per-cop
+# URLs automatically. DocumentationExtension matches the generated file format.
+DevDoc/Migration:
+  DocumentationBaseURL: https://github.com/hgani/dev-doc/blob/main/docs/cops
+  DocumentationExtension: '.md'
+
+DevDoc/Rails:
+  DocumentationBaseURL: https://github.com/hgani/dev-doc/blob/main/docs/cops
+  DocumentationExtension: '.md'
+
+DevDoc/Route:
+  DocumentationBaseURL: https://github.com/hgani/dev-doc/blob/main/docs/cops
+  DocumentationExtension: '.md'
+
+DevDoc/Style:
+  DocumentationBaseURL: https://github.com/hgani/dev-doc/blob/main/docs/cops
+  DocumentationExtension: '.md'
 
 DevDoc/Migration/AvoidJsonColumn:
   Description: 'Use `jsonb` instead of `json` for column types.'
@@ -10,7 +28,7 @@ DevDoc/Migration/AvoidJsonColumn:
 
 DevDoc/Migration/RequireTimestamps:
   Description: 'Always include `t.timestamps` in every `create_table` migration.'
-  Enabled: true
+  Enabled: false
   Include:
     - 'db/migrate/*.rb'
     - 'db/migrate/**/*.rb'
@@ -29,12 +47,14 @@ DevDoc/Migration/AvoidColumnDefault:
     - 'db/migrate/*.rb'
     - 'db/migrate/**/*.rb'
 
-DevDoc/Migration/AvoidUpdateColumn:
-  Description: 'Avoid `update_column`/`update_all`/`update_columns`; they bypass validations and callbacks.'
-  Enabled: true
-  Include:
-    - 'db/migrate/*.rb'
-    - 'db/migrate/**/*.rb'
+# Intentionally global (no Include) — these patterns are risky in any file, not only migrations.
+# Add project-specific Exclude entries (e.g. db/seeds.rb, lib/tasks/**/*.rb) in your .rubocop.yml
+# for places where bulk operations are intentional and performance-critical.
+DevDoc/Migration/AvoidBypassingValidation:
+  Description: 'Avoid methods that bypass validations and callbacks (`update_column`, `update_all`, `insert_all`, etc.).'
+  Enabled: false
+  Exclude:
+    - 'spec/**/*'
 
 DevDoc/Migration/DateColumnNaming:
   Description: 'Date columns should end with `_on`; datetime columns should end with `_at`.'
@@ -56,6 +76,9 @@ DevDoc/Migration/AvoidVagueColumnNames:
 DevDoc/Route/ResourcesRequireOnly:
   Description: 'Always use `only:` or `except:` when defining `resources` or `resource` routes.'
   Enabled: true
+  # RequireOnly: true (default) — only `only:` is accepted; `except:` is flagged.
+  # RequireOnly: false — both `only:` and `except:` are accepted; only the bare form is flagged.
+  RequireOnly: true
   Include:
     - 'config/routes.rb'
     - 'config/routes/**/*.rb'
@@ -63,6 +86,11 @@ DevDoc/Route/ResourcesRequireOnly:
 DevDoc/Rails/NoDeliverLaterInTransaction:
   Description: 'Avoid `deliver_later`/`perform_later` inside a `transaction` block; the job may use stale data.'
   Enabled: true
+  KnownAsyncWrappers:
+    - send_verification_email!
+    - send_reset_password_instructions
+    - send_confirmation_instructions
+    - send_unlock_instructions
 
 DevDoc/Rails/NoPerformLaterInModel:
   Description: 'Avoid `perform_later` inside model files; use explicit methods called from the controller.'
@@ -70,12 +98,100 @@ DevDoc/Rails/NoPerformLaterInModel:
   Include:
     - 'app/models/**/*.rb'
 
+DevDoc/Rails/EnumMustBeSymbolized:
+  Description: 'Pair every `enum :foo` with `enum_symbolize :foo` so the reader returns a symbol.'
+  Enabled: true
+  Include:
+    - 'app/models/**/*.rb'
+
 DevDoc/Style/AvoidSend:
   Description: 'Avoid `send`/`public_send` with an explicit receiver; prefer direct calls or safer alternatives.'
   Enabled: true
 
 DevDoc/Style/AvoidHeadResponse:
-  Description: 'Avoid `head()` responses; delegate error handling to Rails exceptions or model validations.'
+  Description: 'Avoid `head()` with error statuses; delegate error handling to Rails exceptions or model validations.'
   Enabled: true
   Include:
     - 'app/controllers/**/*.rb'
+  FlaggedStatuses:
+    - not_found
+    - unprocessable_entity
+    - forbidden
+    - unauthorized
+    - bad_request
+    - conflict
+    - gone
+    - method_not_allowed
+    - '404'
+    - '422'
+    - '403'
+    - '401'
+    - '400'
+    - '409'
+    - '410'
+    - '405'
+
+DevDoc/Migration/RequirePrimaryKey:
+  Description: 'Every `create_table` must have a primary key. Avoid `id: false`.'
+  Enabled: true
+  Include:
+    - 'db/migrate/*.rb'
+    - 'db/migrate/**/*.rb'
+
+DevDoc/Migration/NoCreateJoinTable:
+  Description: 'Avoid `create_join_table` — define an explicit join model with `has_many :through` instead.'
+  Enabled: true
+  Include:
+    - 'db/migrate/*.rb'
+    - 'db/migrate/**/*.rb'
+
+# This cop is heuristic: it matches column names whose last segment is a known
+# monetary word. Enable it in your project's .rubocop.yml and extend MonetaryNames
+# if your domain uses different names. Disabled by default to avoid false positives.
+DevDoc/Migration/AmountColumnInCents:
+  Description: 'Monetary columns must be stored as integer cents with an `_in_cents` suffix.'
+  Enabled: false
+  MonetaryNames:
+    - amount
+    - price
+    - balance
+    - cost
+    - fee
+    - total
+    - subtotal
+    - discount
+    - tax
+  Include:
+    - 'db/migrate/*.rb'
+    - 'db/migrate/**/*.rb'
+
+DevDoc/Rails/AvoidRailsCallbacks:
+  Description: 'Avoid Rails callback DSL (`after_create`, `before_save`, etc.) — use explicit methods instead.'
+  Enabled: true
+  Include:
+    - 'app/models/**/*.rb'
+
+DevDoc/Rails/ApplicationRecordTransaction:
+  Description: 'Use `ApplicationRecord.transaction` instead of `SomeModel.transaction` outside model files.'
+  Enabled: true
+  Exclude:
+    - 'app/models/**/*.rb'
+
+DevDoc/Style/AvoidOptionsHash:
+  Description: 'Use keyword arguments instead of `**options` — typos raise `ArgumentError`; options hashes swallow them silently.'
+  Enabled: true
+
+DevDoc/Style/StringSymbolComparison:
+  Description: 'Comparing a known-string source (params, request.headers, ENV) to a symbol literal is always false.'
+  Enabled: true
+
+Rails/CreateTableWithTimestamps:
+  Enabled: true
+  Include:
+    - 'db/migrate/*.rb'
+    - 'db/migrate/**/*.rb'
+
+Rails/SkipsModelValidations:
+  Enabled: true
+  Exclude:
+    - 'spec/**/*'

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

@@ -0,0 +1,92 @@
+module RuboCop
+  module Cop
+    module DevDoc
+      module Migration
+        # Monetary columns must be stored as integer cents with an `_in_cents` suffix.
+        #
+        # ## Rationale
+        # Storing monetary values as floats or decimals introduces floating-point
+        # precision issues. The safe approach is to store values as integer cents
+        # and convert to dollars only in user-facing forms and displays.
+        #
+        # This cop is heuristic: it matches column names whose last segment is a
+        # known monetary word (configurable via `MonetaryNames`). Extend the list
+        # in your `.rubocop.yml` if your domain uses different names.
+        #
+        #   ❌
+        #   t.float :amount
+        #   t.decimal :price
+        #   add_column :orders, :total, :decimal
+        #
+        #   ✔️
+        #   t.integer :amount_in_cents
+        #   t.integer :price_in_cents
+        #   add_column :orders, :total_in_cents, :integer
+        #
+        # To extend the monetary names list:
+        #
+        #   DevDoc/Migration/AmountColumnInCents:
+        #     Enabled: true
+        #     MonetaryNames:
+        #       - amount
+        #       - price
+        #       - balance
+        #       - cost
+        #       - fee
+        #       - total
+        #       - subtotal
+        #       - discount
+        #       - tax
+        #       - revenue   # custom addition
+        #
+        # @example
+        #   # bad
+        #   t.float :amount
+        #   t.decimal :price
+        #   add_column :orders, :total, :decimal
+        #
+        #   # good
+        #   t.integer :amount_in_cents
+        #   t.integer :price_in_cents
+        #   add_column :orders, :total_in_cents, :integer
+        class AmountColumnInCents < Base
+          DEFAULT_MONETARY_NAMES = %w[amount price balance cost fee total subtotal discount tax].freeze
+
+          MSG = 'Store monetary values as integer cents — ' \
+                'rename `%<name>s` to `%<name>s_in_cents` and use `t.integer`.'.freeze
+
+          COLUMN_METHODS = %i[float decimal integer].freeze
+
+          def on_send(node)
+            col_name_node = column_name_node(node)
+            return unless col_name_node&.sym_type?
+
+            col_name = col_name_node.value.to_s
+            return if col_name.end_with?('_in_cents')
+            return unless monetary_suffix?(col_name)
+
+            add_offense(col_name_node, message: format(MSG, name: col_name))
+          end
+
+          private
+
+          def column_name_node(node)
+            if node.method?(:add_column)
+              node.arguments[1]
+            elsif COLUMN_METHODS.include?(node.method_name)
+              node.first_argument
+            end
+          end
+
+          def monetary_suffix?(name)
+            monetary_names.include?(name.split('_').last)
+          end
+
+          def monetary_names
+            cop_config.fetch('MonetaryNames', DEFAULT_MONETARY_NAMES)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,86 @@
+module RuboCop
+  module Cop
+    module DevDoc
+      module Migration
+        # Avoid methods that bypass validations and callbacks.
+        #
+        # ## Rationale
+        # Avoid bypassing validation unless absolutely necessary. Methods like
+        # `update_column`, `update_all`, `insert_all`, `upsert_all`, `delete_all`,
+        # and `save(validate: false)` skip validations and callbacks, which hides
+        # data integrity issues rather than surfacing them.
+        #
+        # Even in migrations, check the code to see if there is any blatant
+        # reason why existing records may be invalid. If there is, fix those
+        # records first rather than bypassing validation.
+        #
+        #   ❌ Bypasses validation — hides data integrity issues
+        #   Faq.where(purpose: nil).update_all(purpose: :intro)
+        #
+        #   ✔️ Runs validation — surfaces problems early
+        #   Faq.where(purpose: nil).find_each do |faq|
+        #     faq.purpose = :intro
+        #     faq.save!
+        #   end
+        #
+        # @example
+        #   # bad
+        #   Faq.where(purpose: nil).update_all(purpose: :intro)
+        #
+        #   # bad
+        #   user.update_column(:status, 'active')
+        #
+        #   # bad
+        #   user.save(validate: false)
+        #
+        #   # bad
+        #   User.insert_all(rows)
+        #
+        #   # good
+        #   Faq.where(purpose: nil).find_each do |faq|
+        #     faq.purpose = :intro
+        #     faq.save!
+        #   end
+        class AvoidBypassingValidation < Base
+          MESSAGES = {
+            update_column: 'Avoid `update_column`; it bypasses validations. Use `save!` instead.',
+            update_columns: 'Avoid `update_columns`; it bypasses validations. Use `save!` instead.',
+            update_all: 'Avoid `update_all`; it bypasses validations. Use `save!` in a loop instead.',
+            insert_all: 'Avoid `insert_all`; it bypasses validations. Use `create!` in a loop, ' \
+                        'or `# rubocop:disable` with a reason if bulk-insert is intentional.',
+            upsert_all: 'Avoid `upsert_all`; it bypasses validations. Use `create!`/`update!` in a loop, ' \
+                        'or `# rubocop:disable` with a reason if bulk-upsert is intentional.',
+            delete_all: 'Avoid `delete_all`; it bypasses callbacks. Use `destroy_all` to run callbacks, ' \
+                        'or `# rubocop:disable` with a reason if bulk-delete is intentional.'
+          }.freeze
+
+          SAVE_MSG = 'Avoid `save(validate: false)`; it bypasses validations. Use `save!` instead.'.freeze
+
+          RESTRICT_ON_SEND = %i[update_column update_columns update_all insert_all upsert_all delete_all save].freeze
+
+          def on_send(node)
+            if node.method?(:save)
+              return unless save_with_validate_false?(node)
+
+              add_offense(node.loc.selector, message: SAVE_MSG)
+            else
+              add_offense(node.loc.selector, message: MESSAGES[node.method_name])
+            end
+          end
+
+          private
+
+          def save_with_validate_false?(node)
+            node.arguments.any? do |arg|
+              next unless arg.hash_type?
+
+              arg.pairs.any? do |pair|
+                pair.key.sym_type? && pair.key.value == :validate && pair.value.false_type?
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -43,18 +43,18 @@ module RuboCop
         #     end
         #   end
         #
-        # ## Exception
+        # ## 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
-        # immediately remove it in the same migration:
+        # immediately remove it in the same migration. The cop suppresses the
+        # offense when it detects a matching `change_column_default ..., to: nil`
+        # for the same table and column anywhere in the same method body (`def
+        # change` / `def up`), including inside `reversible do |dir| dir.up`.
         #
-        #   ✔
+        #   ✔ (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
         #
-        # NOTE: This cop currently flags the first line of the exception pattern.
-        # The follow-up `change_column_default ..., to: nil` is not auto-detected.
-        #
         # @example
         #   # bad
         #   add_column :users, :score, :integer, default: 0
@@ -65,7 +65,7 @@ module RuboCop
         #   # good
         #   add_column :users, :score, :integer
         #
-        #   # good (temporary default immediately removed)
+        #   # good (temporary default immediately removed — two-step pattern)
         #   add_column :users, :score, :integer, default: 0
         #   change_column_default :users, :score, from: 0, to: nil
         class AvoidColumnDefault < Base
@@ -80,19 +80,74 @@ module RuboCop
             (hash <(pair (sym :default) _) ...>)
           PATTERN
 
+          def_node_matcher :change_column_default_to_nil?, <<~PATTERN
+            (send _ :change_column_default (sym $_) (sym $_) (hash <(pair (sym :to) (nil)) ...>))
+          PATTERN
+
           def on_send(node)
-            return unless node.method?(:add_column) || COLUMN_METHODS.include?(node.method_name)
+            return unless column_method?(node)
+
+            options = node.arguments.find(&:hash_type?)
+            return unless options && has_default_option?(options)
+            return if two_step_pattern?(node)
 
-            check_options(node.arguments.find(&:hash_type?))
+            add_offense(find_default_pair(options))
           end
 
           private
 
-          def check_options(options)
-            return unless options && has_default_option?(options)
+          def column_method?(node)
+            node.method?(:add_column) || COLUMN_METHODS.include?(node.method_name)
+          end
+
+          def find_default_pair(options)
+            options.pairs.find { |p| p.key.sym_type? && p.key.value == :default }
+          end
+
+          def two_step_pattern?(node)
+            table_name, col_name = extract_table_and_column(node)
+            return false unless table_name && col_name
+
+            enclosing_def = node.each_ancestor(:def).first
+            return false unless enclosing_def
+
+            enclosing_def.each_descendant(:send).any? do |sibling|
+              cancels_default?(sibling, table_name, col_name)
+            end
+          end
+
+          def extract_table_and_column(node)
+            node.method?(:add_column) ? add_column_pair(node) : column_def_pair(node)
+          end
+
+          def add_column_pair(node)
+            t = node.arguments[0]
+            c = node.arguments[1]
+            [t.value, c.value] if t&.sym_type? && c&.sym_type?
+          end
+
+          def column_def_pair(node)
+            c = node.arguments[0]
+            return unless c&.sym_type?
+
+            t = enclosing_table_sym(node)
+            [t.value, c.value] if t
+          end
+
+          def enclosing_table_sym(node)
+            table_block = node.each_ancestor(:block).find do |b|
+              %i[create_table change_table].include?(b.method_name)
+            end
+            return unless table_block
+
+            arg = table_block.send_node.arguments[0]
+            arg if arg&.sym_type?
+          end
 
-            default_pair = options.pairs.find { |p| p.key.sym_type? && p.key.value == :default }
-            add_offense(default_pair)
+          def cancels_default?(node, table_name, col_name)
+            change_column_default_to_nil?(node) do |t, c|
+              t == table_name && c == col_name
+            end
           end
         end
       end

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

@@ -12,27 +12,42 @@ module RuboCop
         #
         #   ❌
         #   t.json :metadata
+        #   add_column :users, :metadata, :json
         #
         #   ✔️
         #   t.jsonb :metadata
+        #   add_column :users, :metadata, :jsonb
         #
         # @example
         #   # bad
         #   t.json :metadata
+        #   add_column :users, :metadata, :json
         #
         #   # good
         #   t.jsonb :metadata
+        #   add_column :users, :metadata, :jsonb
         class AvoidJsonColumn < Base
           extend AutoCorrector
 
           MSG = 'Use `jsonb` instead of `json`. `jsonb` supports indexing and is faster to read.'.freeze
-          RESTRICT_ON_SEND = %i[json].freeze
+          RESTRICT_ON_SEND = %i[json add_column].freeze
 
           def on_send(node)
-            add_offense(node.loc.selector) do |corrector|
-              corrector.replace(node.loc.selector, 'jsonb')
+            if node.method_name == :add_column
+              check_add_column(node)
+            else
+              add_offense(node.loc.selector) { |c| c.replace(node.loc.selector, 'jsonb') }
             end
           end
+
+          private
+
+          def check_add_column(node)
+            type_arg = node.arguments[2]
+            return unless type_arg&.sym_type? && type_arg.value == :json
+
+            add_offense(type_arg) { |c| c.replace(type_arg, ':jsonb') }
+          end
         end
       end
     end

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

@@ -0,0 +1,53 @@
+module RuboCop
+  module Cop
+    module DevDoc
+      module Migration
+        # Avoid `create_join_table` — define an explicit join model instead.
+        #
+        # ## Rationale
+        # `create_join_table` produces a PK-less table tied to
+        # `has_and_belongs_to_many`, which has well-known limitations: no
+        # timestamps, no per-row callbacks, and no room for extra columns
+        # without migration gymnastics.
+        #
+        # The preferred Rails idiom is `has_many :through` with an explicit
+        # join model, which is just a normal table with a PK and timestamps.
+        #
+        #   ❌
+        #   create_join_table :products, :categories
+        #
+        #   ✔️ Define an explicit join model
+        #   create_table :product_categories do |t|
+        #     t.belongs_to :product, null: false, foreign_key: true
+        #     t.belongs_to :category, null: false, foreign_key: true
+        #     t.timestamps
+        #   end
+        #
+        #   # In models:
+        #   class Product < ApplicationRecord
+        #     has_many :product_categories
+        #     has_many :categories, through: :product_categories
+        #   end
+        #
+        # @example
+        #   # bad
+        #   create_join_table :products, :categories
+        #
+        #   # good
+        #   create_table :product_categories do |t|
+        #     t.belongs_to :product, null: false, foreign_key: true
+        #     t.belongs_to :category, null: false, foreign_key: true
+        #     t.timestamps
+        #   end
+        class NoCreateJoinTable < Base
+          MSG = 'Avoid `create_join_table` — define an explicit join model with `has_many :through` instead.'.freeze
+          RESTRICT_ON_SEND = %i[create_join_table].freeze
+
+          def on_send(node)
+            add_offense(node.loc.selector)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+module RuboCop
+  module Cop
+    module DevDoc
+      module Migration
+        # Every `create_table` migration must have a primary key.
+        #
+        # ## Rationale
+        # A table without a primary key is hard to reference, hard to debug,
+        # and hard to migrate later. `id: false` is rarely the right answer;
+        # `has_many :through` with an explicit join model is preferred for
+        # many-to-many relationships, and that join model has its own `id`.
+        #
+        #   ❌
+        #   create_table :products_categories, id: false do |t|
+        #     t.belongs_to :product
+        #     t.belongs_to :category
+        #   end
+        #
+        #   ✔️  Use an explicit join model with has_many :through instead
+        #   create_table :product_categories do |t|
+        #     t.belongs_to :product, null: false, foreign_key: true
+        #     t.belongs_to :category, null: false, foreign_key: true
+        #     t.timestamps
+        #   end
+        #
+        # @example
+        #   # bad
+        #   create_table :products_categories, id: false do |t|
+        #     t.belongs_to :product
+        #   end
+        #
+        #   # good
+        #   create_table :product_categories do |t|
+        #     t.belongs_to :product, null: false, foreign_key: true
+        #   end
+        class RequirePrimaryKey < Base
+          MSG = 'Every table must have a primary key. Avoid `id: false` — ' \
+                'use an explicit join model with `has_many :through` instead.'.freeze
+          RESTRICT_ON_SEND = %i[create_table].freeze
+
+          def_node_matcher :id_false_pair?, <<~PATTERN
+            (pair (sym :id) (false))
+          PATTERN
+
+          def on_send(node)
+            id_false = node.each_descendant(:pair).find { |pair| id_false_pair?(pair) }
+            return unless id_false
+
+            add_offense(id_false)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -10,6 +10,10 @@ module RuboCop
         # auditing, and ordering records, and adding them later is much more
         # painful than including them up front.
         #
+        # This rule applies to **every** `create_table` call, including those
+        # with `id: false`. If a genuinely timestamp-less table is needed, add
+        # an explicit `# rubocop:disable` with a rationale comment.
+        #
         #   ❌
         #   create_table :ai_api_failures do |t|
         #     t.belongs_to :ai_chat_message, null: false, foreign_key: true
@@ -24,9 +28,6 @@ module RuboCop
         #     t.timestamps
         #   end
         #
-        # NOTE: This cop skips tables declared with `id: false` (typically join
-        # tables), where omitting timestamps is a deliberate choice.
-        #
         # @example
         #   # bad
         #   create_table :users do |t|
@@ -54,13 +55,7 @@ module RuboCop
               ...)
           PATTERN
 
-          def_node_matcher :id_false_option?, <<~PATTERN
-            (pair (sym :id) (false))
-          PATTERN
-
           def on_send(node)
-            return if skip_table?(node)
-
             block = node.parent
             return unless block&.block_type?
             return if timestamps_present?(block.body)
@@ -72,10 +67,6 @@ module RuboCop
 
           private
 
-          def skip_table?(node)
-            node.each_descendant(:pair).any? { |pair| id_false_option?(pair) }
-          end
-
           def timestamps_present?(body)
             return false if body.nil?