rubocop-rails 2.11.2 → 2.19.1

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

@@ -10,8 +10,8 @@ module RuboCop
 
       def_node_matcher :active_record?, <<~PATTERN
         {
-          (const nil? :ApplicationRecord)
-          (const (const nil? :ActiveRecord) :Base)
+          (const {nil? cbase} :ApplicationRecord)
+          (const (const {nil? cbase} :ActiveRecord) :Base)
         }
       PATTERN
 
@@ -48,21 +48,19 @@ 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.
       # It just returns column_name if the column exists.
       # Or it tries to resolve column_name as a relation.
+      # Returns an array of column names if the relation is polymorphic.
       # It returns `nil` if it can't resolve.
       #
       # @param name [String]
       # @param class_node [RuboCop::AST::Node]
       # @param table [RuboCop::Rails::SchemaLoader::Table]
-      # @return [String, nil]
+      # @return [Array, String, nil]
       def resolve_relation_into_column(name:, class_node:, table:)
         return unless table
         return name if table.with_column?(name: name)
@@ -71,7 +69,9 @@ module RuboCop
           next unless belongs_to.first_argument.value.to_s == name
 
           fk = foreign_key_of(belongs_to) || "#{name}_id"
-          return fk if table.with_column?(name: fk)
+          next unless table.with_column?(name: fk)
+
+          return polymorphic?(belongs_to) ? [fk, "#{name}_type"] : fk
         end
         nil
       end
@@ -88,6 +88,15 @@ module RuboCop
         end
       end
 
+      def polymorphic?(belongs_to)
+        options = belongs_to.last_argument
+        return false unless options.hash_type?
+
+        options.each_pair.any? do |pair|
+          pair.key.sym_type? && pair.key.value == :polymorphic && pair.value.true_type?
+        end
+      end
+
       def in_where?(node)
         send_node = node.each_ancestor(:send).first
         send_node && WHERE_METHODS.include?(send_node.method_name)

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # A mixin to extend cops for Active Record features
+    module ActiveRecordMigrationsHelper
+      extend NodePattern::Macros
+
+      RAILS_ABSTRACT_SCHEMA_DEFINITIONS = %i[
+        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
+      POSTGRES_SCHEMA_DEFINITIONS = %i[
+        bigserial bit bit_varying cidr citext daterange hstore inet interval
+        int4range int8range jsonb ltree macaddr money numrange oid point line
+        lseg box path polygon circle serial tsrange tstzrange tsvector uuid xml
+      ].freeze
+      MYSQL_SCHEMA_DEFINITIONS = %i[
+        blob tinyblob mediumblob longblob tinytext mediumtext longtext
+        unsigned_integer unsigned_bigint unsigned_float unsigned_decimal
+      ].freeze
+
+      def_node_matcher :create_table_with_block?, <<~PATTERN
+        (block
+          (send nil? :create_table ...)
+          (args (arg _var))
+          _)
+      PATTERN
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # A mixin to return all of the class send nodes.
+    module ClassSendNodeHelper
+      def class_send_nodes(class_node)
+        class_def = class_node.body
+
+        return [] unless class_def
+
+        if class_def.send_type?
+          [class_def]
+        else
+          class_def.each_child_node(:send)
+        end
+      end
+    end
+  end
+end

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

@@ -32,7 +32,7 @@ module RuboCop
 
       def register_offense(offense_node)
         add_offense(offense_node) do |corrector|
-          corrector.replace(offense_node.source_range, self.class::SUPERCLASS)
+          corrector.replace(offense_node, self.class::SUPERCLASS)
         end
       end
     end

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
 
@@ -138,11 +134,11 @@ module RuboCop
         end
 
         def self.from_hash_brackets_map(node, match)
-          new(match, node.children.last, 'Hash['.length, ']'.length)
+          new(match, node.children.last, "#{node.receiver.source}[".length, ']'.length)
         end
 
         def strip_prefix_and_suffix(node, corrector)
-          expression = node.loc.expression
+          expression = node.source_range
           corrector.remove_leading(expression, leading)
           corrector.remove_trailing(expression, trailing)
         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, "|#{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, transforming_body_expr.source)
         end
       end
     end

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for cops working with migrations
+    module MigrationsHelper
+      extend NodePattern::Macros
+
+      def_node_matcher :migration_class?, <<~PATTERN
+        (class
+          (const {nil? cbase} _)
+          (send
+            (const (const {nil? cbase} :ActiveRecord) :Migration)
+            :[]
+            (float _))
+          _)
+      PATTERN
+
+      def in_migration?(node)
+        node.each_ancestor(:class).any? do |class_node|
+          migration_class?(class_node)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,112 @@
+# 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 :render?, <<~PATTERN
+          (send nil? :render ...)
+        PATTERN
+
+        def_node_search :action_controller?, <<~PATTERN
+          {
+            (const {nil? cbase} :ApplicationController)
+            (const (const {nil? cbase} :ActionController) :Base)
+          }
+        PATTERN
+
+        RESTRICT_ON_SEND = [:flash].freeze
+
+        def on_send(flash_node)
+          return unless flash_assignment?(flash_node)
+
+          return unless followed_by_render?(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_render?(flash_node)
+          flash_assignment_node = find_ancestor(flash_node, type: :send)
+          context = flash_assignment_node
+          if (node = context.each_ancestor(:if, :rescue).first)
+            return false if use_redirect_to?(context)
+
+            context = node
+          elsif context.right_siblings.empty?
+            return true
+          end
+          context = context.right_siblings
+
+          context.compact.any? do |render_candidate|
+            render?(render_candidate)
+          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 use_redirect_to?(context)
+          context.right_siblings.compact.any? do |sibling|
+            sibling.send_type? && sibling.method?(:redirect_to)
+          end
+        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

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # Using `ActionController::TestCase`` is discouraged and should be replaced by
+      # `ActionDispatch::IntegrationTest``. Controller tests are too close to the
+      # internals of a controller whereas integration tests mimic the browser/user.
+      #
+      # @safety
+      #   This cop's autocorrection is unsafe because the API of each test case class is different.
+      #   Make sure to update each test of your controller test cases after changing the superclass.
+      #
+      # @example
+      #   # bad
+      #   class MyControllerTest < ActionController::TestCase
+      #   end
+      #
+      #   # good
+      #   class MyControllerTest < ActionDispatch::IntegrationTest
+      #   end
+      #
+      class ActionControllerTestCase < Base
+        extend AutoCorrector
+        extend TargetRailsVersion
+
+        MSG = 'Use `ActionDispatch::IntegrationTest` instead.'
+
+        minimum_target_rails_version 5.0
+
+        def_node_matcher :action_controller_test_case?, <<~PATTERN
+          (class
+            (const _ _)
+            (const (const {nil? cbase} :ActionController) :TestCase) _)
+        PATTERN
+
+        def on_class(node)
+          return unless action_controller_test_case?(node)
+
+          add_offense(node.parent_class) do |corrector|
+            corrector.replace(node.parent_class, 'ActionDispatch::IntegrationTest')
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Rails
-      # This cop enforces the consistent use of action filter methods.
+      # Enforces the consistent use of action filter methods.
       #
       # The cop is configurable and can enforce the use of the older
       # something_filter methods or the newer something_action methods.
@@ -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,116 @@
+# 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. So, the actions specified in `ExpectedOrder` should be
+      # defined before actions not specified.
+      #
+      # [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
+        include RangeHelp
+
+        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|
+            current = correction_target(current)
+            previous = correction_target(previous)
+
+            swap_range(corrector, current, previous)
+          end
+        end
+
+        def correction_target(def_node)
+          range_with_comments_and_lines(def_node.each_ancestor(:if).first || def_node)
+        end
+
+        def add_range(range1, range2)
+          range1.with(
+            begin_pos: [range1.begin_pos, range2.begin_pos].min,
+            end_pos: [range1.end_pos, range2.end_pos].max
+          )
+        end
+
+        def range_with_comments(node)
+          # rubocop:todo InternalAffairs/LocationExpression
+          # Using `RuboCop::Ext::Comment#source_range` requires RuboCop > 1.46,
+          # which introduces https://github.com/rubocop/rubocop/pull/11630.
+          ranges = [node, *processed_source.ast_with_comments[node]].map { |comment| comment.loc.expression }
+          # rubocop:enable InternalAffairs/LocationExpression
+          ranges.reduce do |result, range|
+            add_range(result, range)
+          end
+        end
+
+        def range_with_comments_and_lines(node)
+          range_by_whole_lines(range_with_comments(node), include_final_newline: true)
+        end
+
+        def swap_range(corrector, range1, range2)
+          corrector.insert_before(range2, range1.source)
+          corrector.remove(range1)
+        end
+      end
+    end
+  end
+end

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

@@ -6,25 +6,28 @@ module RuboCop
       # Checks that ActiveRecord aliases are not used. The direct method names
       # are more clear and easier to read.
       #
+      # @safety
+      #   This cop is unsafe because custom `update_attributes` method call was changed to
+      #   `update` but the method name remained same in the method definition.
+      #
       # @example
       #   #bad
-      #   Book.update_attributes!(author: 'Alice')
+      #   book.update_attributes!(author: 'Alice')
       #
       #   #good
-      #   Book.update!(author: 'Alice')
+      #   book.update!(author: 'Alice')
       class ActiveRecordAliases < Base
         extend AutoCorrector
 
         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
 
         def on_send(node)
+          return if node.arguments.empty?
+
           method_name = node.method_name
           alias_method = ALIASES[method_name]
 

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Rails
-      # This cop checks that Active Record callbacks are declared
+      # Checks that Active Record callbacks are declared
       # in the order in which they will be executed.
       #
       # @example
@@ -71,7 +71,7 @@ module RuboCop
 
         # Autocorrect by swapping between two nodes autocorrecting them
         def autocorrect(corrector, node)
-          previous = left_siblings_of(node).reverse_each.find do |sibling|
+          previous = node.left_siblings.reverse_each.find do |sibling|
             callback?(sibling)
           end
 
@@ -96,14 +96,6 @@ module RuboCop
           node.send_type? && CALLBACKS_ORDER_MAP.key?(node.method_name)
         end
 
-        def left_siblings_of(node)
-          siblings_of(node)[0, node.sibling_index]
-        end
-
-        def siblings_of(node)
-          node.parent.children
-        end
-
         def source_range_with_comment(node)
           begin_pos = begin_pos_with_comment(node)
           end_pos = end_position_for(node)
@@ -112,7 +104,7 @@ module RuboCop
         end
 
         def end_position_for(node)
-          end_line = buffer.line_for_position(node.loc.expression.end_pos)
+          end_line = buffer.line_for_position(node.source_range.end_pos)
           buffer.line_range(end_line).end_pos
         end
 
@@ -120,8 +112,7 @@ module RuboCop
           annotation_line = node.first_line - 1
           first_comment = nil
 
-          processed_source.comments_before_line(annotation_line)
-                          .reverse_each do |comment|
+          processed_source.each_comment_in_lines(0..annotation_line).reverse_each do |comment|
             if comment.location.line == annotation_line && !inline_comment?(comment)
               first_comment = comment
               annotation_line -= 1
@@ -132,7 +123,11 @@ module RuboCop
         end
 
         def inline_comment?(comment)
+          # rubocop:todo InternalAffairs/LocationExpression
+          # Using `RuboCop::Ext::Comment#source_range` requires RuboCop > 1.46,
+          # which introduces https://github.com/rubocop/rubocop/pull/11630.
           !comment_line?(comment.loc.expression.source_line)
+          # rubocop:enable InternalAffairs/LocationExpression
         end
 
         def start_line_position(node)

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_aliases.rb

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Rails
-      # This cop checks that ActiveSupport aliases to core ruby methods
+      # Checks that ActiveSupport aliases to core ruby methods
       # are not used.
       #
       # @example