rubocop-rails 2.19.1 → 2.30.3

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

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # A mixin to extend cops in order to determine the database type.
+    #
+    # This module automatically detect an adapter from `development` environment
+    # in `config/database.yml` or the environment variable `DATABASE_URL`
+    # when the `Database` option is not set.
+    module DatabaseTypeResolvable
+      MYSQL = 'mysql'
+      POSTGRESQL = 'postgresql'
+
+      def database
+        cop_config['Database'] || database_from_yaml || database_from_env
+      end
+
+      private
+
+      def database_from_yaml
+        return unless database_yaml
+
+        case database_adapter
+        when 'mysql2', 'trilogy'
+          MYSQL
+        when 'postgresql', 'postgis'
+          POSTGRESQL
+        end
+      end
+
+      def database_from_env
+        url = ENV['DATABASE_URL'].presence
+        return unless url
+
+        case url
+        when %r{\A(mysql2|trilogy)://}
+          MYSQL
+        when %r{\Apostgres(ql)?://}
+          POSTGRESQL
+        end
+      end
+
+      def database_yaml
+        return unless File.exist?('config/database.yml')
+
+        yaml = if YAML.respond_to?(:unsafe_load_file)
+                 YAML.unsafe_load_file('config/database.yml')
+               else
+                 YAML.load_file('config/database.yml')
+               end
+        return unless yaml.is_a? Hash
+
+        config = yaml['development']
+        return unless config.is_a?(Hash)
+
+        config
+      rescue Psych::SyntaxError
+        # noop
+      end
+
+      def database_adapter
+        database_yaml['adapter'] || database_yaml.first.last['adapter']
+      end
+    end
+  end
+end

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

@@ -6,7 +6,72 @@ module RuboCop
     module IndexMethod # rubocop:disable Metrics/ModuleLength
       RESTRICT_ON_SEND = %i[each_with_object to_h map collect []].freeze
 
-      def on_block(node) # rubocop:todo InternalAffairs/NumblockHandler
+      # Internal helper class to hold match data
+      Captures = ::Struct.new(
+        :transformed_argname,
+        :transforming_body_expr
+      ) do
+        def noop_transformation?
+          transforming_body_expr.lvar_type? && transforming_body_expr.children == [transformed_argname]
+        end
+      end
+
+      # Internal helper class to hold autocorrect data
+      Autocorrection = ::Struct.new(:match, :block_node, :leading, :trailing) do
+        def self.from_each_with_object(node, match)
+          new(match, node, 0, 0)
+        end
+
+        def self.from_to_h(node, match)
+          new(match, node, 0, 0)
+        end
+
+        def self.from_map_to_h(node, match)
+          if node.block_literal?
+            strip_trailing_chars = 0
+          else
+            map_range = node.children.first.source_range
+            node_range = node.source_range
+            strip_trailing_chars = node_range.end_pos - map_range.end_pos
+          end
+
+          new(match, node.children.first, 0, strip_trailing_chars)
+        end
+
+        def self.from_hash_brackets_map(node, match)
+          new(match, node.children.last, "#{node.receiver.source}[".length, ']'.length)
+        end
+
+        def strip_prefix_and_suffix(node, corrector)
+          expression = node.source_range
+          corrector.remove_leading(expression, leading)
+          corrector.remove_trailing(expression, trailing)
+        end
+
+        def set_new_method_name(new_method_name, corrector)
+          range = block_node.send_node.loc.selector
+          if (send_end = block_node.send_node.loc.end)
+            # If there are arguments (only true in the `each_with_object` case)
+            range = range.begin.join(send_end)
+          end
+          corrector.replace(range, new_method_name)
+        end
+
+        def set_new_arg_name(transformed_argname, corrector)
+          return if block_node.numblock_type?
+
+          corrector.replace(block_node.arguments, "|#{transformed_argname}|")
+        end
+
+        def set_new_body_expression(transforming_body_expr, corrector)
+          body_source = transforming_body_expr.source
+          body_source = "{ #{body_source} }" if transforming_body_expr.hash_type? && !transforming_body_expr.braces?
+
+          corrector.replace(block_node.body, body_source)
+        end
+      end
+
+      def on_block(node)
         on_bad_each_with_object(node) do |*match|
           handle_possible_offense(node, match, 'each_with_object')
         end
@@ -18,6 +83,8 @@ module RuboCop
         end
       end
 
+      alias on_numblock on_block
+
       def on_send(node)
         on_bad_map_to_h(node) do |*match|
           handle_possible_offense(node, match, 'map { ... }.to_h')
@@ -100,66 +167,6 @@ module RuboCop
         correction.set_new_arg_name(captures.transformed_argname, corrector)
         correction.set_new_body_expression(captures.transforming_body_expr, corrector)
       end
-
-      # Internal helper class to hold match data
-      Captures = Struct.new(
-        :transformed_argname,
-        :transforming_body_expr
-      ) do
-        def noop_transformation?
-          transforming_body_expr.lvar_type? && transforming_body_expr.children == [transformed_argname]
-        end
-      end
-
-      # Internal helper class to hold autocorrect data
-      Autocorrection = Struct.new(:match, :block_node, :leading, :trailing) do
-        def self.from_each_with_object(node, match)
-          new(match, node, 0, 0)
-        end
-
-        def self.from_to_h(node, match)
-          new(match, node, 0, 0)
-        end
-
-        def self.from_map_to_h(node, match)
-          strip_trailing_chars = 0
-
-          unless node.parent&.block_type?
-            map_range = node.children.first.source_range
-            node_range = node.source_range
-            strip_trailing_chars = node_range.end_pos - map_range.end_pos
-          end
-
-          new(match, node.children.first, 0, strip_trailing_chars)
-        end
-
-        def self.from_hash_brackets_map(node, match)
-          new(match, node.children.last, "#{node.receiver.source}[".length, ']'.length)
-        end
-
-        def strip_prefix_and_suffix(node, corrector)
-          expression = node.source_range
-          corrector.remove_leading(expression, leading)
-          corrector.remove_trailing(expression, trailing)
-        end
-
-        def set_new_method_name(new_method_name, corrector)
-          range = block_node.send_node.loc.selector
-          if (send_end = block_node.send_node.loc.end)
-            # If there are arguments (only true in the `each_with_object` case)
-            range = range.begin.join(send_end)
-          end
-          corrector.replace(range, new_method_name)
-        end
-
-        def set_new_arg_name(transformed_argname, corrector)
-          corrector.replace(block_node.arguments, "|#{transformed_argname}|")
-        end
-
-        def set_new_body_expression(transforming_body_expr, corrector)
-          corrector.replace(block_node.body, transforming_body_expr.source)
-        end
-      end
     end
   end
 end

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for cops working with routes.
+    module RoutesHelper
+      extend NodePattern::Macros
+
+      HTTP_METHODS = %i[get post put patch delete].freeze
+
+      def_node_matcher :routes_draw?, <<~PATTERN
+        (send (send _ :routes) :draw)
+      PATTERN
+
+      def within_routes?(node)
+        node.each_ancestor(:block).any? { |block| routes_draw?(block.send_node) }
+      end
+    end
+  end
+end

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

@@ -4,12 +4,37 @@ module RuboCop
   module Cop
     # Common functionality for checking target rails version.
     module TargetRailsVersion
+      # Informs the base RuboCop gem that it the Rails version is checked via `requires_gem` API,
+      # without needing to call this `#support_target_rails_version` method.
+      USES_REQUIRES_GEM_API = true
+      # Look for `railties` instead of `rails`, to support apps that only use a subset of `rails`
+      # See https://github.com/rubocop/rubocop/pull/11289
+      TARGET_GEM_NAME = 'railties' # :nodoc:
+
       def minimum_target_rails_version(version)
-        @minimum_target_rails_version = version
+        if respond_to?(:requires_gem)
+          case version
+          when Integer, Float then requires_gem(TARGET_GEM_NAME, ">= #{version}")
+          when String then requires_gem(TARGET_GEM_NAME, version)
+          end
+        else
+          # Fallback path for previous versions of RuboCop which don't support the `requires_gem` API yet.
+          @minimum_target_rails_version = version
+        end
       end
 
       def support_target_rails_version?(version)
-        @minimum_target_rails_version <= version
+        if respond_to?(:requires_gem)
+          return false unless gem_requirements
+
+          gem_requirement = gem_requirements[TARGET_GEM_NAME]
+          return true unless gem_requirement # If we have no requirement, then we support all versions
+
+          gem_requirement.satisfied_by?(Gem::Version.new(version))
+        else
+          # Fallback path for previous versions of RuboCop which don't support the `requires_gem` API yet.
+          @minimum_target_rails_version <= version
+        end
       end
     end
   end

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

@@ -85,7 +85,7 @@ module RuboCop
 
         def inherit_action_controller_base?(node)
           class_node = find_ancestor(node, type: :class)
-          return unless class_node
+          return false unless class_node
 
           action_controller?(class_node)
         end
@@ -99,6 +99,8 @@ module RuboCop
 
         def use_redirect_to?(context)
           context.right_siblings.compact.any? do |sibling|
+            # Unwrap `return redirect_to :index`
+            sibling = sibling.children.first if sibling.return_type? && sibling.children.one?
             sibling.send_type? && sibling.method?(:redirect_to)
           end
         end

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

@@ -3,8 +3,8 @@
 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
+      # 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

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

@@ -8,6 +8,9 @@ module RuboCop
       # The cop is configurable and can enforce the use of the older
       # something_filter methods or the newer something_action methods.
       #
+      # IMPORTANT: This cop is deprecated. Because the `*_filter` methods were removed in Rails 4.2,
+      # and that Rails version is no longer supported by RuboCop Rails. This cop will be removed in RuboCop Rails 3.0.
+      #
       # @example EnforcedStyle: action (default)
       #   # bad
       #   after_filter :do_stuff

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

@@ -92,11 +92,7 @@ module RuboCop
         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 = [node, *processed_source.ast_with_comments[node]].map(&:source_range)
           ranges.reduce do |result, range|
             add_range(result, range)
           end

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

@@ -11,10 +11,10 @@ module RuboCop
       #   `update` but the method name remained same in the method definition.
       #
       # @example
-      #   #bad
+      #   # bad
       #   book.update_attributes!(author: 'Alice')
       #
-      #   #good
+      #   # good
       #   book.update!(author: 'Alice')
       class ActiveRecordAliases < Base
         extend AutoCorrector

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

@@ -123,11 +123,7 @@ 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
+          !comment_line?(comment.source_range.source_line)
         end
 
         def start_line_position(node)

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

@@ -27,13 +27,13 @@ module RuboCop
 
         ALIASES = {
           starts_with?: {
-            original: :start_with?, matcher: '(send str :starts_with? _)'
+            original: :start_with?, matcher: '(call str :starts_with? _)'
           },
           ends_with?: {
-            original: :end_with?, matcher: '(send str :ends_with? _)'
+            original: :end_with?, matcher: '(call str :ends_with? _)'
           },
-          append: { original: :<<, matcher: '(send array :append _)' },
-          prepend: { original: :unshift, matcher: '(send array :prepend _)' }
+          append: { original: :<<, matcher: '(call array :append _)' },
+          prepend: { original: :unshift, matcher: '(call array :prepend _)' }
         }.freeze
 
         ALIASES.each do |aliased_method, options|
@@ -47,13 +47,14 @@ module RuboCop
             preferred_method = ALIASES[aliased_method][:original]
             message = format(MSG, prefer: preferred_method, current: aliased_method)
 
-            add_offense(node, message: message) do |corrector|
+            add_offense(node.loc.selector.join(node.source_range.end), message: message) do |corrector|
               next if append(node)
 
               corrector.replace(node.loc.selector, preferred_method)
             end
           end
         end
+        alias on_csend on_send
       end
     end
   end

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

@@ -55,15 +55,35 @@ module RuboCop
           'ActiveSupport::TestCase' => 'active_support_test_case'
         }.freeze
 
+        RAILS_5_2_LOAD_HOOKS = {
+          'ActiveRecord::ConnectionAdapters::SQLite3Adapter' => 'active_record_sqlite3adapter'
+        }.freeze
+
+        RAILS_7_1_LOAD_HOOKS = {
+          'ActiveRecord::TestFixtures' => 'active_record_fixtures',
+          'ActiveModel::Model' => 'active_model',
+          'ActionText::EncryptedRichText' => 'action_text_encrypted_rich_text',
+          'ActiveRecord::ConnectionAdapters::PostgreSQLAdapter' => 'active_record_postgresqladapter',
+          'ActiveRecord::ConnectionAdapters::Mysql2Adapter' => 'active_record_mysql2adapter',
+          'ActiveRecord::ConnectionAdapters::TrilogyAdapter' => 'active_record_trilogyadapter'
+        }.freeze
+
         def on_send(node)
           receiver, method, arguments = *node # rubocop:disable InternalAffairs/NodeDestructuring
-          return unless receiver && (hook = LOAD_HOOKS[receiver.const_name])
+          return unless arguments && (hook = hook_for_const(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
+
+        def hook_for_const(const_name)
+          hook = LOAD_HOOKS[const_name]
+          hook ||= RAILS_5_2_LOAD_HOOKS[const_name] if target_rails_version >= 5.2
+          hook ||= RAILS_7_1_LOAD_HOOKS[const_name] if target_rails_version >= 7.1
+          hook
+        end
       end
     end
   end

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

@@ -19,6 +19,7 @@ module RuboCop
       class AddColumnIndex < Base
         extend AutoCorrector
         include RangeHelp
+        include MigrationsHelper
 
         MSG = '`add_column` does not accept an `index` key, use `add_index` instead.'
         RESTRICT_ON_SEND = %i[add_column].freeze

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

@@ -48,7 +48,7 @@ module RuboCop
           seen_callback_names = {}
 
           each_after_commit_callback(class_node) do |node|
-            callback_name = node.arguments[0].value
+            callback_name = node.first_argument.value
             if seen_callback_names.key?(callback_name)
               add_offense(node, message: format(MSG, name: callback_name))
             else

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

@@ -5,6 +5,10 @@ module RuboCop
     module Rails
       # Checks that models subclass `ApplicationRecord` with Rails 5.0.
       #
+      # It is a common practice to define models inside migrations in order to retain forward
+      # compatibility by avoiding loading any application code. And so migration files are excluded
+      # by default for this cop.
+      #
       # @safety
       #   This cop's autocorrection is unsafe because it may let the logic from `ApplicationRecord`
       #   sneak into an Active Record model that is not purposed to inherit logic common among other

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

@@ -3,7 +3,6 @@
 module RuboCop
   module Cop
     module Rails
-      #
       # Use `assert_not` instead of `assert !`.
       #
       # @example

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

@@ -66,7 +66,7 @@ module RuboCop
 
         def_node_matcher :match_belongs_to_with_options, <<~PATTERN
           (send _ :belongs_to ...
-            (hash <$(pair (sym :required) ${true false}) ...>)
+            (hash <$(pair (sym :required) $boolean) ...>)
           )
         PATTERN
 

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

@@ -123,7 +123,7 @@ module RuboCop
         def on_if(node)
           return unless cop_config['UnlessPresent']
           return unless node.unless?
-          return if node.else? && config.for_cop('Style/UnlessElse')['Enabled']
+          return if node.else? && config.cop_enabled?('Style/UnlessElse')
 
           unless_present?(node) do |method_call, receiver|
             range = unless_condition(node, method_call)

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

@@ -12,8 +12,9 @@ module RuboCop
       # The `bulk` option is only supported on the MySQL and
       # the PostgreSQL (5.2 later) adapter; thus it will
       # automatically detect an adapter from `development` environment
-      # in `config/database.yml` when the `Database` option is not set.
-      # If the adapter is not `mysql2` or `postgresql`,
+      # in `config/database.yml` or the environment variable `DATABASE_URL`
+      # when the `Database` option is not set.
+      # If the adapter is not `mysql2`, `trilogy`, `postgresql`, or `postgis`,
       # this Cop ignores offenses.
       #
       # @example
@@ -63,6 +64,9 @@ module RuboCop
       #     end
       #   end
       class BulkChangeTable < Base
+        include DatabaseTypeResolvable
+        include MigrationsHelper
+
         MSG_FOR_CHANGE_TABLE = <<~MSG.chomp
           You can combine alter queries using `bulk: true` options.
         MSG
@@ -70,9 +74,6 @@ module RuboCop
           You can use `change_table :%<table>s, bulk: true` to combine alter queries.
         MSG
 
-        MYSQL = 'mysql'
-        POSTGRESQL = 'postgresql'
-
         MIGRATION_METHODS = %i[change up down].freeze
 
         COMBINABLE_TRANSFORMATIONS = %i[
@@ -113,8 +114,10 @@ module RuboCop
         MYSQL_COMBINABLE_ALTER_METHODS = %i[rename_column add_index remove_index].freeze
 
         POSTGRESQL_COMBINABLE_TRANSFORMATIONS = %i[change_default].freeze
+        POSTGRESQL_COMBINABLE_TRANSFORMATIONS_SINCE_6_1 = %i[change_null].freeze
 
         POSTGRESQL_COMBINABLE_ALTER_METHODS = %i[change_column_default].freeze
+        POSTGRESQL_COMBINABLE_ALTER_METHODS_SINCE_6_1 = %i[change_column_null].freeze
 
         def on_def(node)
           return unless support_bulk_alter?
@@ -138,9 +141,9 @@ module RuboCop
           return unless support_bulk_alter?
           return unless node.command?(:change_table)
           return if include_bulk_options?(node)
-          return unless node.block_node
+          return unless (body = node.block_node&.body)
 
-          send_nodes = send_nodes_from_change_table_block(node.block_node.body)
+          send_nodes = send_nodes_from_change_table_block(body)
 
           add_offense_for_change_table(node) if count_transformations(send_nodes) > 1
         end
@@ -174,39 +177,6 @@ module RuboCop
           options.hash_type? && options.keys.any? { |key| key.sym_type? && key.value == :bulk }
         end
 
-        def database
-          cop_config['Database'] || database_from_yaml
-        end
-
-        def database_from_yaml
-          return nil unless database_yaml
-
-          case database_yaml['adapter']
-          when 'mysql2'
-            MYSQL
-          when 'postgresql'
-            POSTGRESQL
-          end
-        end
-
-        def database_yaml
-          return nil unless File.exist?('config/database.yml')
-
-          yaml = if YAML.respond_to?(:unsafe_load_file)
-                   YAML.unsafe_load_file('config/database.yml')
-                 else
-                   YAML.load_file('config/database.yml')
-                 end
-          return nil unless yaml.is_a? Hash
-
-          config = yaml['development']
-          return nil unless config.is_a?(Hash)
-
-          config
-        rescue Psych::SyntaxError
-          nil
-        end
-
         def support_bulk_alter?
           case database
           when MYSQL
@@ -229,7 +199,9 @@ module RuboCop
           when MYSQL
             COMBINABLE_ALTER_METHODS + MYSQL_COMBINABLE_ALTER_METHODS
           when POSTGRESQL
-            COMBINABLE_ALTER_METHODS + POSTGRESQL_COMBINABLE_ALTER_METHODS
+            result = COMBINABLE_ALTER_METHODS + POSTGRESQL_COMBINABLE_ALTER_METHODS
+            result += POSTGRESQL_COMBINABLE_ALTER_METHODS_SINCE_6_1 if target_rails_version >= 6.1
+            result
           end
         end
 
@@ -238,14 +210,16 @@ module RuboCop
           when MYSQL
             COMBINABLE_TRANSFORMATIONS + MYSQL_COMBINABLE_TRANSFORMATIONS
           when POSTGRESQL
-            COMBINABLE_TRANSFORMATIONS + POSTGRESQL_COMBINABLE_TRANSFORMATIONS
+            result = COMBINABLE_TRANSFORMATIONS + POSTGRESQL_COMBINABLE_TRANSFORMATIONS
+            result += POSTGRESQL_COMBINABLE_TRANSFORMATIONS_SINCE_6_1 if target_rails_version >= 6.1
+            result
           end
         end
 
         # @param node [RuboCop::AST::SendNode]
         def add_offense_for_alter_methods(node)
           # arguments: [{(sym :table)(str "table")} ...]
-          table_node = node.arguments[0]
+          table_node = node.first_argument
           return unless table_node.is_a? RuboCop::AST::BasicLiteralNode
 
           message = format(MSG_FOR_ALTER_METHODS, table: table_node.value)
@@ -267,10 +241,10 @@ module RuboCop
           # @param new_node [RuboCop::AST::SendNode]
           def process(new_node)
             # arguments: [{(sym :table)(str "table")} ...]
-            table_node = new_node.arguments[0]
+            table_node = new_node.first_argument
             if table_node.is_a? RuboCop::AST::BasicLiteralNode
               flush unless @nodes.all? do |node|
-                node.arguments[0].value.to_s == table_node.value.to_s
+                node.first_argument.value.to_s == table_node.value.to_s
               end
               @nodes << new_node
             else