rubocop-rails 2.15.2 → 2.17.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 169ed04b1f5378e9e08fbffdca151afaf4b84fd54b1867a173740aadaede60b3
-  data.tar.gz: 1a2ac75c313cfcdeec1814d7e3aff4777c5013527d2cf4a2aa4f95aeb45446bf
+  metadata.gz: 2a7a516c82d0953f3f1995b190ddc427aa251583287a9232229e82a218c93ba6
+  data.tar.gz: f224a35df6de69c04c7c6f6314f9cfa713cc5accfba1bbce9d5554c7fd50a121
 SHA512:
-  metadata.gz: 51d495edd3e825db49ece8f51bfc118c73887681f414b86d31cd47d85dc5a1a22a385a2a17ed4ebf7d1c6332989795e2cde999a364d911c60f452993dc926c4b
-  data.tar.gz: 4546785b39af93e6c7fe5a6a3b637fa5c21d4b358c38ea8ad3ebd5c272d1d0a504e8206e8201cfe3771af9199c336649d033e32b324f16b06fc7d150054dc488
+  metadata.gz: 5b3277765f3819855d3e29d3226c81ebc6231b1b1aaf583e1ae86db9e18b7b450bbc2b3f9bccaaa85623ca57e0ac139abde604c35bccc81c3081a80c4392f35d
+  data.tar.gz: a3d7b79f10c2090b04a05d1b30cc3c639645aa6b3c2ad33247fecfa7597907238d8f6e727a8e0dd088b92d69842c488489e9883f9acfd4551e08a9b8f3dd1f8c

data/config/default.yml

@@ -10,6 +10,12 @@ AllCops:
     # Exclude db/schema.rb and db/[CONFIGURATION_NAMESPACE]_schema.rb by default.
     # See: https://guides.rubyonrails.org/active_record_multiple_databases.html#setting-up-your-application
     - db/*schema.rb
+    - log/**/*
+    - public/**/*
+    - storage/**/*
+  # Enable checking Active Support extensions.
+  # See: https://docs.rubocop.org/rubocop/configuration.html#enable-checking-active-support-extensions
+  ActiveSupportExtensionsEnabled: true
   # What version of Rails is the inspected code using?  If a value is specified
   # for TargetRailsVersion then it is used.  Acceptable values are specified
   # as a float (i.e. 5.1); the patch version of Rails should not be included.
@@ -23,6 +29,24 @@ Lint/NumberConversion:
   # Add Rails' duration methods to the ignore list for `Lint/NumberConversion`
   # so that calling `to_i` on one of these does not register an offense.
   # See: https://github.com/rubocop/rubocop/issues/8950
+  AllowedMethods:
+    - ago
+    - from_now
+    - second
+    - seconds
+    - minute
+    - minutes
+    - hour
+    - hours
+    - day
+    - days
+    - week
+    - weeks
+    - fortnight
+    - fortnights
+    - in_milliseconds
+  AllowedPatterns: []
+  # Deprecated.
   IgnoredMethods:
     - ago
     - from_now
@@ -40,6 +64,18 @@ Lint/NumberConversion:
     - fortnights
     - in_milliseconds
 
+Rails:
+  Enabled: true
+  DocumentationBaseURL: https://docs.rubocop.org/rubocop-rails
+
+Rails/ActionControllerFlashBeforeRender:
+  Description: 'Use `flash.now` instead of `flash` before `render`.'
+  StyleGuide: 'https://rails.rubystyle.guide/#flash-before-render'
+  Reference: 'https://api.rubyonrails.org/classes/ActionController/FlashBeforeRender.html'
+  Enabled: 'pending'
+  SafeAutocorrect: false
+  VersionAdded: '2.16'
+
 Rails/ActionControllerTestCase:
   Description: 'Use `ActionDispatch::IntegrationTest` instead of `ActionController::TestCase`.'
   StyleGuide: 'https://rails.rubystyle.guide/#integration-testing'
@@ -62,6 +98,21 @@ Rails/ActionFilter:
     - app/controllers/**/*.rb
     - app/mailers/**/*.rb
 
+Rails/ActionOrder:
+  Description: 'Enforce consistent ordering of controller actions.'
+  Enabled: pending
+  VersionAdded: '2.17'
+  ExpectedOrder:
+    - index
+    - show
+    - new
+    - edit
+    - create
+    - update
+    - destroy
+  Include:
+    - app/controllers/**/*.rb
+
 Rails/ActiveRecordAliases:
   Description: >-
                   Avoid Active Record aliases:
@@ -96,6 +147,15 @@ Rails/ActiveSupportAliases:
   Enabled: true
   VersionAdded: '0.48'
 
+Rails/ActiveSupportOnLoad:
+  Description: 'Use `ActiveSupport.on_load(...)` to patch Rails framework classes.'
+  Enabled: 'pending'
+  Reference:
+    - 'https://api.rubyonrails.org/classes/ActiveSupport/LazyLoadHooks.html'
+    - 'https://guides.rubyonrails.org/engines.html#available-load-hooks'
+  SafeAutoCorrect: false
+  VersionAdded: '2.16'
+
 Rails/AddColumnIndex:
   Description: >-
     Rails migrations don't make use of a given `index` key, but also
@@ -306,10 +366,13 @@ Rails/DynamicFindBy:
   # The `Whitelist` has been deprecated, Please use `AllowedMethods` instead.
   Whitelist:
     - find_by_sql
+    - find_by_token_for
   AllowedMethods:
     - find_by_sql
+    - find_by_token_for
   AllowedReceivers:
     - Gem::Specification
+    - page # Prevents a warning for `page.find_by_id`. See: https://github.com/rubocop/rubocop-rails/issues/778
 
 Rails/EagerEvaluationLogMessage:
   Description: 'Checks that blocks are used for interpolated strings passed to `Rails.logger.debug`.'
@@ -407,6 +470,14 @@ Rails/FindEach:
   VersionChanged: '2.9'
   Include:
     - app/models/**/*.rb
+  AllowedMethods:
+    # Methods that don't work well with `find_each`.
+    - order
+    - limit
+    - select
+    - lock
+  AllowedPatterns: []
+  # Deprecated.
   IgnoredMethods:
     # Methods that don't work well with `find_each`.
     - order
@@ -414,6 +485,13 @@ Rails/FindEach:
     - select
     - lock
 
+Rails/FreezeTime:
+  Description: 'Prefer `freeze_time` over `travel_to` with an argument of the current time.'
+  StyleGuide: 'https://rails.rubystyle.guide/#freeze-time'
+  Enabled: pending
+  VersionAdded: '2.16'
+  SafeAutoCorrect: false
+
 Rails/HasAndBelongsToMany:
   Description: 'Prefer has_many :through to has_and_belongs_to_many.'
   StyleGuide: 'https://rails.rubystyle.guide#has-many-through'
@@ -478,6 +556,13 @@ Rails/I18nLocaleTexts:
   Enabled: pending
   VersionAdded: '2.14'
 
+Rails/IgnoredColumnsAssignment:
+  Description: 'Looks for assignments of `ignored_columns` that override previous assignments.'
+  StyleGuide: 'https://rails.rubystyle.guide/#append-ignored-columns'
+  Enabled: pending
+  SafeAutoCorrect: false
+  VersionAdded: '2.17'
+
 Rails/IgnoredSkipActionFilterOption:
   Description: 'Checks that `if` and `only` (or `except`) are not used together as options of `skip_*` action filter.'
   Reference: 'https://api.rubyonrails.org/classes/AbstractController/Callbacks/ClassMethods.html#method-i-_normalize_callback_options'
@@ -785,6 +870,12 @@ Rails/RootJoinChain:
   Enabled: pending
   VersionAdded: '2.13'
 
+Rails/RootPathnameMethods:
+  Description: 'Use `Rails.root` IO methods instead of passing it to `File`.'
+  Enabled: pending
+  SafeAutocorrect: false
+  VersionAdded: '2.16'
+
 Rails/RootPublicPath:
   Description: "Favor `Rails.public_path` over `Rails.root` with `'public'`."
   Enabled: pending
@@ -937,6 +1028,18 @@ Rails/ToFormattedS:
     - to_formatted_s
   VersionAdded: '2.15'
 
+Rails/ToSWithArgument:
+  Description: 'Identifies passing any argument to `#to_s`.'
+  Enabled: pending
+  Safe: false
+  VersionAdded: '2.16'
+
+Rails/TopLevelHashWithIndifferentAccess:
+  Description: 'Identifies top-level `HashWithIndifferentAccess`.'
+  Reference: 'https://guides.rubyonrails.org/upgrading_ruby_on_rails.html#top-level-hashwithindifferentaccess-is-soft-deprecated'
+  Enabled: pending
+  VersionAdded: '2.16'
+
 Rails/TransactionExitStatement:
   Description: 'Avoid the usage of `return`, `break` and `throw` in transaction blocks.'
   Enabled: pending
@@ -1003,12 +1106,29 @@ Rails/WhereExists:
   VersionAdded: '2.7'
   VersionChanged: '2.10'
 
+Rails/WhereMissing:
+  Description: 'Use `where.missing(...)` to find missing relationship records.'
+  StyleGuide: 'https://rails.rubystyle.guide/#finding-missing-relationship-records'
+  Enabled: pending
+  VersionAdded: '2.16'
+
 Rails/WhereNot:
   Description: 'Use `where.not(...)` instead of manually constructing negated SQL in `where`.'
   StyleGuide: 'https://rails.rubystyle.guide/#hash-conditions'
   Enabled: 'pending'
   VersionAdded: '2.8'
 
+Rails/WhereNotWithMultipleConditions:
+  Description: 'Do not use `where.not(...)` with multiple conditions.'
+  Enabled: 'pending'
+  VersionAdded: '2.17'
+
 # Accept `redirect_to(...) and return` and similar cases.
 Style/AndOr:
   EnforcedStyle: conditionals
+
+Style/SymbolProc:
+  AllowedMethods:
+    - define_method
+    - mail
+    - respond_to

data/config/obsoletion.yml

@@ -5,3 +5,13 @@
 #
 extracted:
   Rails/*: ~
+
+# Cop parameters that have been changed
+# Can be treated as a warning instead of a failure with `severity: warning`
+changed_parameters:
+  - cops: Rails/FindEach
+    parameters: IgnoredMethods
+    alternatives:
+      - AllowedMethods
+      - AllowedPatterns
+    severity: warning

data/lib/rubocop/cop/mixin/active_record_helper.rb

@@ -48,10 +48,7 @@ module RuboCop
 
         class_nodes = class_node.defined_module.each_node
         namespaces = class_node.each_ancestor(:class, :module).map(&:identifier)
-        [*class_nodes, *namespaces]
-          .reverse
-          .map { |node| node.children[1] }.join('_')
-          .tableize
+        [*class_nodes, *namespaces].reverse.map { |node| node.children[1] }.join('_').tableize
       end
 
       # Resolve relation into column name.

data/lib/rubocop/cop/mixin/active_record_migrations_helper.rb

@@ -10,9 +10,7 @@ module RuboCop
         bigint binary boolean date datetime decimal float integer json string
         text time timestamp virtual
       ].freeze
-      RAILS_ABSTRACT_SCHEMA_DEFINITIONS_HELPERS = %i[
-        column references belongs_to primary_key numeric
-      ].freeze
+      RAILS_ABSTRACT_SCHEMA_DEFINITIONS_HELPERS = %i[column references belongs_to primary_key numeric].freeze
       POSTGRES_SCHEMA_DEFINITIONS = %i[
         bigserial bit bit_varying cidr citext daterange hstore inet interval
         int4range int8range jsonb ltree macaddr money numrange oid point line

data/lib/rubocop/cop/mixin/index_method.rb

@@ -6,7 +6,7 @@ module RuboCop
     module IndexMethod # rubocop:disable Metrics/ModuleLength
       RESTRICT_ON_SEND = %i[each_with_object to_h map collect []].freeze
 
-      def on_block(node)
+      def on_block(node) # rubocop:todo InternalAffairs/NumblockHandler
         on_bad_each_with_object(node) do |*match|
           handle_possible_offense(node, match, 'each_with_object')
         end
@@ -98,10 +98,7 @@ module RuboCop
 
         captures = extract_captures(correction.match)
         correction.set_new_arg_name(captures.transformed_argname, corrector)
-        correction.set_new_body_expression(
-          captures.transforming_body_expr,
-          corrector
-        )
+        correction.set_new_body_expression(captures.transforming_body_expr, corrector)
       end
 
       # Internal helper class to hold match data
@@ -110,8 +107,7 @@ module RuboCop
         :transforming_body_expr
       ) do
         def noop_transformation?
-          transforming_body_expr.lvar_type? &&
-            transforming_body_expr.children == [transformed_argname]
+          transforming_body_expr.lvar_type? && transforming_body_expr.children == [transformed_argname]
         end
       end
 
@@ -157,17 +153,11 @@ module RuboCop
         end
 
         def set_new_arg_name(transformed_argname, corrector)
-          corrector.replace(
-            block_node.arguments.loc.expression,
-            "|#{transformed_argname}|"
-          )
+          corrector.replace(block_node.arguments.loc.expression, "|#{transformed_argname}|")
         end
 
         def set_new_body_expression(transforming_body_expr, corrector)
-          corrector.replace(
-            block_node.body.loc.expression,
-            transforming_body_expr.loc.expression.source
-          )
+          corrector.replace(block_node.body.loc.expression, transforming_body_expr.loc.expression.source)
         end
       end
     end

data/lib/rubocop/cop/rails/action_controller_flash_before_render.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # Using `flash` assignment before `render` in Rails controllers will persist the message for too long.
+      # Check https://guides.rubyonrails.org/action_controller_overview.html#flash-now
+      #
+      # @safety
+      #   This cop's autocorrection is unsafe because it replaces `flash` by `flash.now`.
+      #   Even though it is usually a mistake, it might be used intentionally.
+      #
+      # @example
+      #
+      #   # bad
+      #   class HomeController < ApplicationController
+      #     def create
+      #       flash[:alert] = "msg"
+      #       render :index
+      #     end
+      #   end
+      #
+      #   # good
+      #   class HomeController < ApplicationController
+      #     def create
+      #       flash.now[:alert] = "msg"
+      #       render :index
+      #     end
+      #   end
+      #
+      class ActionControllerFlashBeforeRender < Base
+        extend AutoCorrector
+
+        MSG = 'Use `flash.now` before `render`.'
+
+        def_node_search :flash_assignment?, <<~PATTERN
+          ^(send (send nil? :flash) :[]= ...)
+        PATTERN
+
+        def_node_search :redirect_to?, <<~PATTERN
+          (send nil? :redirect_to ...)
+        PATTERN
+
+        def_node_search :action_controller?, <<~PATTERN
+          {
+            (const nil? :ApplicationController)
+            (const (const nil? :ActionController) :Base)
+          }
+        PATTERN
+
+        RESTRICT_ON_SEND = [:flash].freeze
+
+        def on_send(flash_node)
+          return unless flash_assignment?(flash_node)
+
+          return if followed_by_redirect_to?(flash_node)
+
+          return unless instance_method_or_block?(flash_node)
+
+          return unless inherit_action_controller_base?(flash_node)
+
+          add_offense(flash_node) do |corrector|
+            corrector.replace(flash_node, 'flash.now')
+          end
+        end
+
+        private
+
+        def followed_by_redirect_to?(flash_node)
+          flash_assigment_node = find_ancestor(flash_node, type: :send)
+          context = flash_assigment_node.parent
+
+          flash_index = context.children.index(flash_assigment_node)
+          context.each_child_node.with_index.any? do |node, index|
+            index > flash_index && redirect_to?(node)
+          end
+        end
+
+        def inherit_action_controller_base?(node)
+          class_node = find_ancestor(node, type: :class)
+          return unless class_node
+
+          action_controller?(class_node)
+        end
+
+        def instance_method_or_block?(node)
+          def_node = find_ancestor(node, type: :def)
+          block_node = find_ancestor(node, type: :block)
+
+          def_node || block_node
+        end
+
+        def find_ancestor(node, type:)
+          node.each_ancestor(type).first
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/rails/action_controller_test_case.rb

@@ -31,7 +31,7 @@ module RuboCop
         def_node_matcher :action_controller_test_case?, <<~PATTERN
           (class
             (const nil? _)
-            (const (const {nil? cbase} :ActionController) :TestCase) nil?)
+            (const (const {nil? cbase} :ActionController) :TestCase) _)
         PATTERN
 
         def on_class(node)

data/lib/rubocop/cop/rails/action_filter.rb

@@ -69,7 +69,7 @@ module RuboCop
 
         RESTRICT_ON_SEND = FILTER_METHODS + ACTION_METHODS
 
-        def on_block(node)
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
           check_method_node(node.send_node)
         end
 

data/lib/rubocop/cop/rails/action_order.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # Enforces consistent ordering of the standard Rails RESTful controller actions.
+      #
+      # The cop is configurable and can enforce any ordering of the standard actions.
+      # All other methods are ignored.
+      #
+      # [source,yaml]
+      # ----
+      #  Rails/ActionOrder:
+      #    ExpectedOrder:
+      #      - index
+      #      - show
+      #      - new
+      #      - edit
+      #      - create
+      #      - update
+      #      - destroy
+      # ----
+      #
+      # @example
+      #   # bad
+      #   def index; end
+      #   def destroy; end
+      #   def show; end
+      #
+      #   # good
+      #   def index; end
+      #   def show; end
+      #   def destroy; end
+      class ActionOrder < Base
+        extend AutoCorrector
+        include VisibilityHelp
+        include DefNode
+
+        MSG = 'Action `%<current>s` should appear before `%<previous>s`.'
+
+        def_node_search :action_declarations, '(def {%1} ...)'
+
+        def on_class(node)
+          action_declarations(node, actions).each_cons(2) do |previous, current|
+            next if node_visibility(current) != :public || non_public?(current)
+            next if find_index(current) >= find_index(previous)
+
+            register_offense(previous, current)
+          end
+        end
+
+        private
+
+        def expected_order
+          cop_config['ExpectedOrder'].map(&:to_sym)
+        end
+
+        def actions
+          @actions ||= Set.new(expected_order)
+        end
+
+        def find_index(node)
+          expected_order.find_index(node.method_name)
+        end
+
+        def register_offense(previous, current)
+          message = format(
+            MSG,
+            expected_order: expected_order.join(', '),
+            previous: previous.method_name,
+            current: current.method_name
+          )
+          add_offense(current, message: message) do |corrector|
+            corrector.replace(current, previous.source)
+            corrector.replace(previous, current.source)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/rails/active_record_aliases.rb

@@ -21,10 +21,7 @@ module RuboCop
 
         MSG = 'Use `%<prefer>s` instead of `%<current>s`.'
 
-        ALIASES = {
-          update_attributes: :update,
-          update_attributes!: :update!
-        }.freeze
+        ALIASES = { update_attributes: :update, update_attributes!: :update! }.freeze
 
         RESTRICT_ON_SEND = ALIASES.keys.freeze
 

data/lib/rubocop/cop/rails/active_record_override.rb

@@ -25,12 +25,9 @@ module RuboCop
       #   end
       #
       class ActiveRecordOverride < Base
-        MSG =
-          'Use %<prefer>s callbacks instead of overriding the Active Record ' \
-          'method `%<bad>s`.'
+        MSG = 'Use %<prefer>s callbacks instead of overriding the Active Record method `%<bad>s`.'
         BAD_METHODS = %i[create destroy save update].freeze
-        ACTIVE_RECORD_CLASSES = %w[ApplicationRecord ActiveModel::Base
-                                   ActiveRecord::Base].freeze
+        ACTIVE_RECORD_CLASSES = %w[ApplicationRecord ActiveModel::Base ActiveRecord::Base].freeze
 
         def on_def(node)
           return unless BAD_METHODS.include?(node.method_name)

data/lib/rubocop/cop/rails/active_support_on_load.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # Checks for Rails framework classes that are patched directly instead of using Active Support load hooks. Direct
+      # patching forcibly loads the framework referenced, using hooks defers loading until it's actually needed.
+      #
+      # @safety
+      #   While using lazy load hooks is recommended, it changes the order in which is code is loaded and may reveal
+      #   load order dependency bugs.
+      #
+      # @example
+      #
+      #   # bad
+      #   ActiveRecord::Base.include(MyClass)
+      #
+      #   # good
+      #   ActiveSupport.on_load(:active_record) { include MyClass }
+      class ActiveSupportOnLoad < Base
+        extend AutoCorrector
+
+        MSG = 'Use `%<prefer>s` instead of `%<current>s`.'
+        RESTRICT_ON_SEND = %i[prepend include extend].freeze
+        LOAD_HOOKS = {
+          'ActionCable' => 'action_cable',
+          'ActionCable::Channel::Base' => 'action_cable_channel',
+          'ActionCable::Connection::Base' => 'action_cable_connection',
+          'ActionCable::Connection::TestCase' => 'action_cable_connection_test_case',
+          'ActionController::API' => 'action_controller',
+          'ActionController::Base' => 'action_controller',
+          'ActionController::TestCase' => 'action_controller_test_case',
+          'ActionDispatch::IntegrationTest' => 'action_dispatch_integration_test',
+          'ActionDispatch::Request' => 'action_dispatch_request',
+          'ActionDispatch::Response' => 'action_dispatch_response',
+          'ActionDispatch::SystemTestCase' => 'action_dispatch_system_test_case',
+          'ActionMailbox::Base' => 'action_mailbox',
+          'ActionMailbox::InboundEmail' => 'action_mailbox_inbound_email',
+          'ActionMailbox::Record' => 'action_mailbox_record',
+          'ActionMailbox::TestCase' => 'action_mailbox_test_case',
+          'ActionMailer::Base' => 'action_mailer',
+          'ActionMailer::TestCase' => 'action_mailer_test_case',
+          'ActionText::Content' => 'action_text_content',
+          'ActionText::Record' => 'action_text_record',
+          'ActionText::RichText' => 'action_text_rich_text',
+          'ActionView::Base' => 'action_view',
+          'ActionView::TestCase' => 'action_view_test_case',
+          'ActiveJob::Base' => 'active_job',
+          'ActiveJob::TestCase' => 'active_job_test_case',
+          'ActiveRecord::Base' => 'active_record',
+          'ActiveStorage::Attachment' => 'active_storage_attachment',
+          'ActiveStorage::Blob' => 'active_storage_blob',
+          'ActiveStorage::Record' => 'active_storage_record',
+          'ActiveStorage::VariantRecord' => 'active_storage_variant_record',
+          'ActiveSupport::TestCase' => 'active_support_test_case'
+        }.freeze
+
+        def on_send(node)
+          receiver, method, arguments = *node # rubocop:disable InternalAffairs/NodeDestructuring
+          return unless receiver && (hook = LOAD_HOOKS[receiver.const_name])
+
+          preferred = "ActiveSupport.on_load(:#{hook}) { #{method} #{arguments.source} }"
+          add_offense(node, message: format(MSG, prefer: preferred, current: node.source)) do |corrector|
+            corrector.replace(node, preferred)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/rails/add_column_index.rb

@@ -53,10 +53,7 @@ module RuboCop
         private
 
         def index_range(pair_node)
-          range_with_surrounding_comma(
-            range_with_surrounding_space(range: pair_node.loc.expression, side: :left),
-            :left
-          )
+          range_with_surrounding_comma(range_with_surrounding_space(pair_node.loc.expression, side: :left), :left)
         end
       end
     end

data/lib/rubocop/cop/rails/blank.rb

@@ -63,8 +63,7 @@ module RuboCop
 
         MSG_NIL_OR_EMPTY = 'Use `%<prefer>s` instead of `%<current>s`.'
         MSG_NOT_PRESENT = 'Use `%<prefer>s` instead of `%<current>s`.'
-        MSG_UNLESS_PRESENT = 'Use `if %<prefer>s` instead of ' \
-                             '`%<current>s`.'
+        MSG_UNLESS_PRESENT = 'Use `if %<prefer>s` instead of `%<current>s`.'
         RESTRICT_ON_SEND = %i[!].freeze
 
         # `(send nil $_)` is not actually a valid match for an offense. Nodes