rubocop-rails 2.8.0 → 2.10.1

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

@@ -24,30 +24,25 @@ module RuboCop
       #   # bad - sets MIME type to `text/html`
       #   render text: 'Ruby!'
       #
-      class RenderPlainText < Cop
+      class RenderPlainText < Base
+        extend AutoCorrector
+
         MSG = 'Prefer `render plain:` over `render text:`.'
+        RESTRICT_ON_SEND = %i[render].freeze
 
         def_node_matcher :render_plain_text?, <<~PATTERN
           (send nil? :render $(hash <$(pair (sym :text) $_) ...>))
         PATTERN
 
         def on_send(node)
-          render_plain_text?(node) do |options_node, _option_node, _option_value|
-            content_type_node = find_content_type(options_node)
-            add_offense(node) if compatible_content_type?(content_type_node)
-          end
-        end
-
-        def autocorrect(node)
           render_plain_text?(node) do |options_node, option_node, option_value|
             content_type_node = find_content_type(options_node)
-            rest_options = options_node.pairs - [option_node, content_type_node].compact
+            return unless compatible_content_type?(content_type_node)
+
+            add_offense(node) do |corrector|
+              rest_options = options_node.pairs - [option_node, content_type_node].compact
 
-            lambda do |corrector|
-              corrector.replace(
-                node,
-                replacement(rest_options, option_value)
-              )
+              corrector.replace(node, replacement(rest_options, option_value))
             end
           end
         end

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

@@ -19,11 +19,13 @@ module RuboCop
       #
       #   # good
       #   request.referrer
-      class RequestReferer < Cop
+      class RequestReferer < Base
         include ConfigurableEnforcedStyle
+        extend AutoCorrector
 
         MSG = 'Use `request.%<prefer>s` instead of ' \
               '`request.%<current>s`.'
+        RESTRICT_ON_SEND = %i[referer referrer].freeze
 
         def_node_matcher :referer?, <<~PATTERN
           (send (send nil? :request) {:referer :referrer})
@@ -33,17 +35,15 @@ module RuboCop
           referer?(node) do
             return unless node.method?(wrong_method_name)
 
-            add_offense(node.source_range, location: node.source_range)
+            add_offense(node.source_range) do |corrector|
+              corrector.replace(node, "request.#{style}")
+            end
           end
         end
 
-        def autocorrect(node)
-          ->(corrector) { corrector.replace(node, "request.#{style}") }
-        end
-
         private
 
-        def message(_node)
+        def message(_range)
           format(MSG, prefer: style, current: wrong_method_name)
         end
 

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

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop checks for the usage of `require_dependency`.
+      #
+      # `require_dependency` is an obsolete method for Rails applications running in Zeitwerk mode.
+      # In Zeitwerk mode, the semantics should match Ruby's and no need to be defensive with load order,
+      # just refer to classes and modules normally.
+      # If the constant name is dynamic, camelize if needed, and constantize.
+      #
+      # Applications running in Zeitwerk mode should not use `require_dependency`.
+      #
+      # NOTE: This cop is disabled by default. Please enable it if you are using Zeitwerk mode.
+      #
+      # @example
+      #   # bad
+      #   require_dependency 'some_lib'
+      class RequireDependency < Base
+        extend TargetRailsVersion
+
+        minimum_target_rails_version 6.0
+
+        MSG = 'Do not use `require_dependency` with Zeitwerk mode.'
+        RESTRICT_ON_SEND = %i[require_dependency].freeze
+
+        def_node_matcher :require_dependency_call?, <<~PATTERN
+          (send {nil? (const _ :Kernel)} :require_dependency _)
+        PATTERN
+
+        def on_send(node)
+          require_dependency_call?(node) { add_offense(node) }
+        end
+      end
+    end
+  end
+end

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

@@ -175,7 +175,7 @@ module RuboCop
       #   end
       #
       # @see https://api.rubyonrails.org/classes/ActiveRecord/Migration/CommandRecorder.html
-      class ReversibleMigration < Cop
+      class ReversibleMigration < Base
         MSG = '%<action>s is not reversible.'
 
         def_node_matcher :irreversible_schema_statement_call, <<~PATTERN
@@ -237,7 +237,7 @@ module RuboCop
 
         def check_drop_table_node(node)
           drop_table_call(node) do
-            unless node.parent.block_type?
+            unless node.parent.block_type? || node.last_argument.block_pass_type?
               add_offense(
                 node,
                 message: format(MSG, action: 'drop_table(without block)')
@@ -271,11 +271,7 @@ module RuboCop
         def check_remove_foreign_key_node(node)
           remove_foreign_key_call(node) do |arg|
             if arg.hash_type? && !all_hash_key?(arg, :to_table)
-              add_offense(
-                node,
-                message: format(MSG,
-                                action: 'remove_foreign_key(without table)')
-              )
+              add_offense(node, message: format(MSG, action: 'remove_foreign_key(without table)'))
             end
           end
         end
@@ -360,7 +356,7 @@ module RuboCop
             key.children.first.to_sym
           end
 
-          hash_keys & keys == keys
+          (hash_keys & keys).sort == keys
         end
       end
     end

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

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop checks whether the migration implements
+      # either a `change` method or both an `up` and a `down`
+      # method.
+      #
+      # @example
+      #   # bad
+      #   class SomeMigration < ActiveRecord::Migration[6.0]
+      #     def up
+      #       # up migration
+      #     end
+      #
+      #     # <----- missing down method
+      #   end
+      #
+      #   class SomeMigration < ActiveRecord::Migration[6.0]
+      #     # <----- missing up method
+      #
+      #     def down
+      #       # down migration
+      #     end
+      #   end
+      #
+      #   # good
+      #   class SomeMigration < ActiveRecord::Migration[6.0]
+      #     def change
+      #       # reversible migration
+      #     end
+      #   end
+      #
+      #   # good
+      #   class SomeMigration < ActiveRecord::Migration[6.0]
+      #     def up
+      #       # up migration
+      #     end
+      #
+      #     def down
+      #       # down migration
+      #     end
+      #   end
+      class ReversibleMigrationMethodDefinition < Base
+        MSG = 'Migrations must contain either a `change` method, or ' \
+              'both an `up` and a `down` method.'
+
+        def_node_matcher :migration_class?, <<~PATTERN
+          (class
+            (const nil? _)
+            (send
+              (const (const nil? :ActiveRecord) :Migration)
+              :[]
+              (float _))
+            _)
+        PATTERN
+
+        def_node_matcher :change_method?, <<~PATTERN
+          [ #migration_class? `(def :change (args) _) ]
+        PATTERN
+
+        def_node_matcher :up_and_down_methods?, <<~PATTERN
+          [ #migration_class? `(def :up (args) _) `(def :down (args) _) ]
+        PATTERN
+
+        def on_class(node)
+          return if change_method?(node) || up_and_down_methods?(node)
+
+          add_offense(node)
+        end
+      end
+    end
+  end
+end

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

@@ -36,38 +36,57 @@ module RuboCop
       #   foo&.bar
       #   foo&.bar(baz)
       #   foo&.bar { |e| e.baz }
-      class SafeNavigation < Cop
+      class SafeNavigation < Base
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Use safe navigation (`&.`) instead of `%<try>s`.'
+        RESTRICT_ON_SEND = %i[try try!].freeze
 
         def_node_matcher :try_call, <<~PATTERN
-          (send !nil? ${:try :try!} $_ ...)
+          (send _ ${:try :try!} $_ ...)
         PATTERN
 
+        # Monkey patching for `Style/RedundantSelf` of RuboCop core.
+        # rubocop:disable Style/ClassAndModuleChildren
+        class Style::RedundantSelf
+          def self.autocorrect_incompatible_with
+            [Rails::SafeNavigation]
+          end
+        end
+        # rubocop:enable Style/ClassAndModuleChildren
+
+        def self.autocorrect_incompatible_with
+          [Style::RedundantSelf]
+        end
+
         def on_send(node)
           try_call(node) do |try_method, dispatch|
             return if try_method == :try && !cop_config['ConvertTry']
             return unless dispatch.sym_type? && dispatch.value.match?(/\w+[=!?]?/)
 
-            add_offense(node, message: format(MSG, try: try_method))
+            add_offense(node, message: format(MSG, try: try_method)) do |corrector|
+              autocorrect(corrector, node)
+            end
           end
         end
 
-        def autocorrect(node)
+        private
+
+        def autocorrect(corrector, node)
           method_node, *params = *node.arguments
           method = method_node.source[1..-1]
 
-          range = range_between(node.loc.dot.begin_pos,
-                                node.loc.expression.end_pos)
+          range = if node.receiver
+                    range_between(node.loc.dot.begin_pos, node.loc.expression.end_pos)
+                  else
+                    corrector.insert_before(node, 'self')
+                    node
+                  end
 
-          lambda do |corrector|
-            corrector.replace(range, replacement(method, params))
-          end
+          corrector.replace(range, replacement(method, params))
         end
 
-        private
-
         def replacement(method, params)
           new_params = params.map(&:source).join(', ')
 

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

@@ -19,7 +19,9 @@ module RuboCop
       #   do_something if foo.blank?
       #   do_something unless foo.blank?
       #
-      class SafeNavigationWithBlank < Cop
+      class SafeNavigationWithBlank < Base
+        extend AutoCorrector
+
         MSG =
           'Avoid calling `blank?` with the safe navigation operator ' \
           'in conditionals.'
@@ -31,15 +33,8 @@ module RuboCop
         def on_if(node)
           return unless safe_navigation_blank_in_conditional?(node)
 
-          add_offense(node)
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
-            corrector.replace(
-              safe_navigation_blank_in_conditional?(node).location.dot,
-              '.'
-            )
+          add_offense(node) do |corrector|
+            corrector.replace(safe_navigation_blank_in_conditional?(node).location.dot, '.')
           end
         end
       end

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

@@ -98,8 +98,9 @@ module RuboCop
       #   Services::Service::Mailer.update(message: 'Message')
       #   Service::Mailer::update
       #
-      class SaveBang < Cop
+      class SaveBang < Base
         include NegativeConditional
+        extend AutoCorrector
 
         MSG = 'Use `%<prefer>s` instead of `%<current>s` if the return ' \
               'value is not checked.'
@@ -113,11 +114,10 @@ module RuboCop
                                     first_or_create find_or_create_by].freeze
         MODIFY_PERSIST_METHODS = %i[save
                                     update update_attributes destroy].freeze
-        PERSIST_METHODS = (CREATE_PERSIST_METHODS +
-                           MODIFY_PERSIST_METHODS).freeze
+        RESTRICT_ON_SEND = (CREATE_PERSIST_METHODS + MODIFY_PERSIST_METHODS).freeze
 
-        def join_force?(force_class)
-          force_class == VariableForce
+        def self.joining_forces
+          VariableForce
         end
 
         def after_leaving_scope(scope, _variable_table)
@@ -135,7 +135,7 @@ module RuboCop
           return unless persist_method?(node, CREATE_PERSIST_METHODS)
           return if persisted_referenced?(assignment)
 
-          add_offense_for_node(node, CREATE_MSG)
+          register_offense(node, CREATE_MSG)
         end
 
         # rubocop:disable Metrics/CyclomaticComplexity
@@ -148,25 +148,22 @@ module RuboCop
           return if explicit_return?(node)
           return if checked_immediately?(node)
 
-          add_offense_for_node(node)
+          register_offense(node, MSG)
         end
         # rubocop:enable Metrics/CyclomaticComplexity
         alias on_csend on_send
 
-        def autocorrect(node)
-          save_loc = node.loc.selector
-          new_method = "#{node.method_name}!"
-
-          ->(corrector) { corrector.replace(save_loc, new_method) }
-        end
-
         private
 
-        def add_offense_for_node(node, msg = MSG)
-          name = node.method_name
-          full_message = format(msg, prefer: "#{name}!", current: name.to_s)
+        def register_offense(node, msg)
+          current_method = node.method_name
+          bang_method = "#{current_method}!"
+          full_message = format(msg, prefer: bang_method, current: current_method)
 
-          add_offense(node, location: :selector, message: full_message)
+          range = node.loc.selector
+          add_offense(range, message: full_message) do |corrector|
+            corrector.replace(range, bang_method)
+          end
         end
 
         def right_assignment_node(assignment)
@@ -218,7 +215,7 @@ module RuboCop
         def check_used_in_condition_or_compound_boolean(node)
           return false unless in_condition_or_compound_boolean?(node)
 
-          add_offense_for_node(node, CREATE_CONDITIONAL_MSG) unless MODIFY_PERSIST_METHODS.include?(node.method_name)
+          register_offense(node, CREATE_CONDITIONAL_MSG) unless MODIFY_PERSIST_METHODS.include?(node.method_name)
 
           true
         end
@@ -318,7 +315,7 @@ module RuboCop
           assignment&.lvasgn_type?
         end
 
-        def persist_method?(node, methods = PERSIST_METHODS)
+        def persist_method?(node, methods = RESTRICT_ON_SEND)
           methods.include?(node.method_name) &&
             expected_signature?(node) &&
             !allowed_receiver?(node)

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

@@ -13,8 +13,9 @@ module RuboCop
       #
       #   # good
       #   scope :something, -> { where(something: true) }
-      class ScopeArgs < Cop
+      class ScopeArgs < Base
         MSG = 'Use `lambda`/`proc` instead of a plain method call.'
+        RESTRICT_ON_SEND = %i[scope].freeze
 
         def_node_matcher :scope?, '(send nil? :scope _ $send)'
 

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

@@ -38,8 +38,9 @@ module RuboCop
       #   t :key
       #   l Time.now
       #
-      class ShortI18n < Cop
+      class ShortI18n < Base
         include ConfigurableEnforcedStyle
+        extend AutoCorrector
 
         MSG = 'Use `%<good_method>s` instead of `%<bad_method>s`.'
 
@@ -48,6 +49,8 @@ module RuboCop
           localize: :l
         }.freeze
 
+        RESTRICT_ON_SEND = PREFERRED_METHODS.keys.freeze
+
         def_node_matcher :long_i18n?, <<~PATTERN
           (send {nil? (const nil? :I18n)} ${:translate :localize} ...)
         PATTERN
@@ -58,15 +61,10 @@ module RuboCop
           long_i18n?(node) do |method_name|
             good_method = PREFERRED_METHODS[method_name]
             message = format(MSG, good_method: good_method, bad_method: method_name)
+            range = node.loc.selector
 
-            add_offense(node, location: :selector, message: message)
-          end
-        end
-
-        def autocorrect(node)
-          long_i18n?(node) do |method_name|
-            lambda do |corrector|
-              corrector.replace(node.loc.selector, PREFERRED_METHODS[method_name])
+            add_offense(range, message: message) do |corrector|
+              corrector.replace(range, PREFERRED_METHODS[method_name])
             end
           end
         end