rubocop-rails 2.0.1 → 2.19.1

data/config/obsoletion.yml

@@ -0,0 +1,17 @@
+#
+# Configuration for obsoletion.
+#
+# See: https://docs.rubocop.org/rubocop/extensions.html#config-obsoletions
+#
+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

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # A mixin to extend cops for Active Record features
+    module ActiveRecordHelper
+      extend NodePattern::Macros
+
+      WHERE_METHODS = %i[where rewhere].freeze
+
+      def_node_matcher :active_record?, <<~PATTERN
+        {
+          (const {nil? cbase} :ApplicationRecord)
+          (const (const {nil? cbase} :ActiveRecord) :Base)
+        }
+      PATTERN
+
+      def_node_search :find_set_table_name, <<~PATTERN
+        (send self :table_name= {str sym})
+      PATTERN
+
+      def_node_search :find_belongs_to, <<~PATTERN
+        (send nil? :belongs_to {str sym} ...)
+      PATTERN
+
+      def inherit_active_record_base?(node)
+        node.each_ancestor(:class).any? { |class_node| active_record?(class_node.parent_class) }
+      end
+
+      def external_dependency_checksum
+        return @external_dependency_checksum if defined?(@external_dependency_checksum)
+
+        schema_path = RuboCop::Rails::SchemaLoader.db_schema_path
+        return nil if schema_path.nil?
+
+        schema_code = File.read(schema_path)
+
+        @external_dependency_checksum ||= Digest::SHA1.hexdigest(schema_code)
+      end
+
+      def schema
+        RuboCop::Rails::SchemaLoader.load(target_ruby_version)
+      end
+
+      def table_name(class_node)
+        table_name = find_set_table_name(class_node).to_a.last&.first_argument
+        return table_name.value.to_s if table_name
+
+        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
+      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 [Array, String, nil]
+      def resolve_relation_into_column(name:, class_node:, table:)
+        return unless table
+        return name if table.with_column?(name: name)
+
+        find_belongs_to(class_node) do |belongs_to|
+          next unless belongs_to.first_argument.value.to_s == name
+
+          fk = foreign_key_of(belongs_to) || "#{name}_id"
+          next unless table.with_column?(name: fk)
+
+          return polymorphic?(belongs_to) ? [fk, "#{name}_type"] : fk
+        end
+        nil
+      end
+
+      def foreign_key_of(belongs_to)
+        options = belongs_to.last_argument
+        return unless options.hash_type?
+
+        options.each_pair.find do |pair|
+          next unless pair.key.sym_type? && pair.key.value == :foreign_key
+          next unless pair.value.sym_type? || pair.value.str_type?
+
+          break pair.value.value.to_s
+        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)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for enforcing a specific superclass.
+    module EnforceSuperclass
+      def self.included(base)
+        base.def_node_matcher :class_definition, <<~PATTERN
+          (class (const _ !:#{base::SUPERCLASS}) #{base::BASE_PATTERN} ...)
+        PATTERN
+
+        base.def_node_matcher :class_new_definition, <<~PATTERN
+          [!^(casgn {nil? cbase} :#{base::SUPERCLASS} ...)
+           !^^(casgn {nil? cbase} :#{base::SUPERCLASS} (block ...))
+           (send (const {nil? cbase} :Class) :new #{base::BASE_PATTERN})]
+        PATTERN
+      end
+
+      def on_class(node)
+        class_definition(node) do
+          register_offense(node.children[1])
+        end
+      end
+
+      def on_send(node)
+        class_new_definition(node) do
+          register_offense(node.children.last)
+        end
+      end
+
+      private
+
+      def register_offense(offense_node)
+        add_offense(offense_node) do |corrector|
+          corrector.replace(offense_node, self.class::SUPERCLASS)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,165 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for Rails/IndexBy and Rails/IndexWith
+    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
+        on_bad_each_with_object(node) do |*match|
+          handle_possible_offense(node, match, 'each_with_object')
+        end
+
+        return if target_ruby_version < 2.6
+
+        on_bad_to_h(node) do |*match|
+          handle_possible_offense(node, match, 'to_h { ... }')
+        end
+      end
+
+      def on_send(node)
+        on_bad_map_to_h(node) do |*match|
+          handle_possible_offense(node, match, 'map { ... }.to_h')
+        end
+
+        on_bad_hash_brackets_map(node) do |*match|
+          handle_possible_offense(node, match, 'Hash[map { ... }]')
+        end
+      end
+
+      def on_csend(node)
+        on_bad_map_to_h(node) do |*match|
+          handle_possible_offense(node, match, 'map { ... }.to_h')
+        end
+      end
+
+      private
+
+      # @abstract Implemented with `def_node_matcher`
+      def on_bad_each_with_object(_node)
+        raise NotImplementedError
+      end
+
+      # @abstract Implemented with `def_node_matcher`
+      def on_bad_to_h(_node)
+        raise NotImplementedError
+      end
+
+      # @abstract Implemented with `def_node_matcher`
+      def on_bad_map_to_h(_node)
+        raise NotImplementedError
+      end
+
+      # @abstract Implemented with `def_node_matcher`
+      def on_bad_hash_brackets_map(_node)
+        raise NotImplementedError
+      end
+
+      def handle_possible_offense(node, match, match_desc)
+        captures = extract_captures(match)
+
+        return if captures.noop_transformation?
+
+        add_offense(
+          node, message: "Prefer `#{new_method_name}` over `#{match_desc}`."
+        ) do |corrector|
+          correction = prepare_correction(node)
+          execute_correction(corrector, node, correction)
+        end
+      end
+
+      def extract_captures(match)
+        argname, body_expr = *match
+        Captures.new(argname, body_expr)
+      end
+
+      def new_method_name
+        raise NotImplementedError
+      end
+
+      def prepare_correction(node)
+        if (match = on_bad_each_with_object(node))
+          Autocorrection.from_each_with_object(node, match)
+        elsif (match = on_bad_to_h(node))
+          Autocorrection.from_to_h(node, match)
+        elsif (match = on_bad_map_to_h(node))
+          Autocorrection.from_map_to_h(node, match)
+        elsif (match = on_bad_hash_brackets_map(node))
+          Autocorrection.from_hash_brackets_map(node, match)
+        else
+          raise 'unreachable'
+        end
+      end
+
+      def execute_correction(corrector, node, correction)
+        correction.strip_prefix_and_suffix(node, corrector)
+        correction.set_new_method_name(new_method_name, corrector)
+
+        captures = extract_captures(correction.match)
+        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/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,14 +3,11 @@
 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.
       #
-      # If the TargetRailsVersion is set to less than 4.0, the cop will enforce
-      # the use of filter methods.
-      #
       # @example EnforcedStyle: action (default)
       #   # bad
       #   after_filter :do_stuff
@@ -32,9 +29,9 @@ module RuboCop
       #   after_filter :do_stuff
       #   append_around_filter :do_stuff
       #   skip_after_filter :do_stuff
-      class ActionFilter < Cop
-        extend TargetRailsVersion
+      class ActionFilter < Base
         include ConfigurableEnforcedStyle
+        extend AutoCorrector
 
         MSG = 'Prefer `%<prefer>s` over `%<current>s`.'
 
@@ -70,9 +67,9 @@ module RuboCop
           skip_action_callback
         ].freeze
 
-        minimum_target_rails_version 4.0
+        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
 
@@ -80,24 +77,17 @@ module RuboCop
           check_method_node(node) unless node.receiver
         end
 
-        def autocorrect(node)
-          lambda do |corrector|
-            corrector.replace(node.loc.selector,
-                              preferred_method(node.loc.selector.source).to_s)
-          end
-        end
-
         private
 
         def check_method_node(node)
-          return unless bad_methods.include?(node.method_name)
+          method_name = node.method_name
+          return unless bad_methods.include?(method_name)
 
-          add_offense(node, location: :selector)
-        end
+          message = format(MSG, prefer: preferred_method(method_name), current: method_name)
 
-        def message(node)
-          format(MSG, prefer: preferred_method(node.method_name),
-                      current: node.method_name)
+          add_offense(node.loc.selector, message: message) do |corrector|
+            corrector.replace(node.loc.selector, preferred_method(node.loc.selector.source))
+          end
         end
 
         def bad_methods