rubocop-rails 2.6.0 → 2.9.0

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

@@ -24,10 +24,12 @@ module RuboCop
       #   class Comment
       #     belongs_to :author, foreign_key: 'user_id'
       #   end
-      class RedundantForeignKey < Cop
+      class RedundantForeignKey < Base
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Specifying the default value for `foreign_key` is redundant.'
+        RESTRICT_ON_SEND = %i[belongs_to has_one has_many has_and_belongs_to_many].freeze
 
         def_node_matcher :association_with_foreign_key, <<~PATTERN
           (send nil? ${:belongs_to :has_one :has_many :has_and_belongs_to_many} ({sym str} $_)
@@ -38,18 +40,13 @@ module RuboCop
         def on_send(node)
           association_with_foreign_key(node) do |type, name, options, foreign_key_pair, foreign_key|
             if redundant?(node, type, name, options, foreign_key)
-              add_offense(node, location: foreign_key_pair.loc.expression)
-            end
-          end
-        end
+              add_offense(foreign_key_pair.loc.expression) do |corrector|
+                range = range_with_surrounding_space(range: foreign_key_pair.source_range, side: :left)
+                range = range_with_surrounding_comma(range, :left)
 
-        def autocorrect(node)
-          _type, _name, _options, foreign_key_pair, _foreign_key = association_with_foreign_key(node)
-          range = range_with_surrounding_space(range: foreign_key_pair.source_range, side: :left)
-          range = range_with_surrounding_comma(range, :left)
-
-          lambda do |corrector|
-            corrector.remove(range)
+                corrector.remove(range)
+              end
+            end
           end
         end
 

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

@@ -54,8 +54,9 @@ module RuboCop
       #       merger.invoke(another_receiver)
       #     end
       #   end
-      class RedundantReceiverInWithOptions < Cop
+      class RedundantReceiverInWithOptions < Base
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Redundant receiver in `with_options`.'
 
@@ -86,22 +87,22 @@ module RuboCop
             if send_nodes.all? { |n| same_value?(arg, n.receiver) }
               send_nodes.each do |send_node|
                 receiver = send_node.receiver
-                add_offense(send_node, location: receiver.source_range)
+                add_offense(receiver.source_range) do |corrector|
+                  autocorrect(corrector, send_node)
+                end
               end
             end
           end
         end
 
-        def autocorrect(node)
-          lambda do |corrector|
-            corrector.remove(node.receiver.source_range)
-            corrector.remove(node.loc.dot)
-            corrector.remove(block_argument_range(node))
-          end
-        end
-
         private
 
+        def autocorrect(corrector, node)
+          corrector.remove(node.receiver.source_range)
+          corrector.remove(node.loc.dot)
+          corrector.remove(block_argument_range(node))
+        end
+
         def block_argument_range(node)
           block_node = node.each_ancestor(:block).first
           block_argument = block_node.children[1].source_range

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

@@ -13,11 +13,12 @@ module RuboCop
       #
       #   # good
       #   has_many :accounts, class_name: 'Account'
-      class ReflectionClassName < Cop
+      class ReflectionClassName < Base
         MSG = 'Use a string value for `class_name`.'
+        RESTRICT_ON_SEND = %i[has_many has_one belongs_to].freeze
 
         def_node_matcher :association_with_reflection, <<~PATTERN
-          (send nil? {:has_many :has_one :belongs_to} _
+          (send nil? {:has_many :has_one :belongs_to} _ _ ?
             (hash <$#reflection_class_name ...>)
           )
         PATTERN
@@ -28,7 +29,7 @@ module RuboCop
 
         def on_send(node)
           association_with_reflection(node) do |reflection_class_name|
-            add_offense(node, location: reflection_class_name.loc.expression)
+            add_offense(reflection_class_name.loc.expression)
           end
         end
       end

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

@@ -28,8 +28,9 @@ module RuboCop
       #   refute_empty [1, 2, 3]
       #   refute_equal true, false
       #
-      class RefuteMethods < Cop
+      class RefuteMethods < Base
         include ConfigurableEnforcedStyle
+        extend AutoCorrector
 
         MSG = 'Prefer `%<good_method>s` over `%<bad_method>s`.'
 
@@ -53,21 +54,19 @@ module RuboCop
         REFUTE_METHODS = CORRECTIONS.keys.freeze
         ASSERT_NOT_METHODS = CORRECTIONS.values.freeze
 
+        RESTRICT_ON_SEND = REFUTE_METHODS + ASSERT_NOT_METHODS
+
         def_node_matcher :offensive?, '(send nil? #bad_method? ...)'
 
         def on_send(node)
           return unless offensive?(node)
 
-          message = offense_message(node.method_name)
-          add_offense(node, location: :selector, message: message)
-        end
-
-        def autocorrect(node)
-          bad_method = node.method_name
-          good_method = convert_good_method(bad_method)
+          method_name = node.method_name
+          message = offense_message(method_name)
+          range = node.loc.selector
 
-          lambda do |corrector|
-            corrector.replace(node.loc.selector, good_method.to_s)
+          add_offense(range, message: message) do |corrector|
+            corrector.replace(range, convert_good_method(method_name))
           end
         end
 

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

@@ -27,15 +27,18 @@ module RuboCop
       #       1.week.since
       #     end
       #   end
-      class RelativeDateConstant < Cop
+      class RelativeDateConstant < Base
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Do not assign %<method_name>s to constants as it ' \
               'will be evaluated only once.'
 
         def on_casgn(node)
           relative_date_assignment?(node) do |method_name|
-            add_offense(node, message: format(MSG, method_name: method_name))
+            add_offense(node, message: message(method_name)) do |corrector|
+              autocorrect(corrector, node)
+            end
           end
         end
 
@@ -48,10 +51,9 @@ module RuboCop
             next unless name.casgn_type?
 
             relative_date?(value) do |method_name|
-              add_offense(node,
-                          location: range_between(name.loc.expression.begin_pos,
-                                                  value.loc.expression.end_pos),
-                          message: format(MSG, method_name: method_name))
+              add_offense(offense_range(name, value), message: message(method_name)) do |corrector|
+                autocorrect(corrector, node)
+              end
             end
           end
         end
@@ -62,7 +64,9 @@ module RuboCop
           end
         end
 
-        def autocorrect(node)
+        private
+
+        def autocorrect(corrector, node)
           return unless node.casgn_type?
 
           scope, const_name, value = *node
@@ -72,10 +76,17 @@ module RuboCop
           new_code = ["def self.#{const_name.downcase}",
                       "#{indent}#{value.source}",
                       'end'].join("\n#{indent}")
-          ->(corrector) { corrector.replace(node.source_range, new_code) }
+
+          corrector.replace(node.source_range, new_code)
         end
 
-        private
+        def message(method_name)
+          format(MSG, method_name: method_name)
+        end
+
+        def offense_range(name, value)
+          range_between(name.loc.expression.begin_pos, value.loc.expression.end_pos)
+        end
 
         def_node_matcher :relative_date_assignment?, <<~PATTERN
           {

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop looks for inline rendering within controller actions.
+      #
+      # @example
+      #   # bad
+      #   class ProductsController < ApplicationController
+      #     def index
+      #       render inline: "<% products.each do |p| %><p><%= p.name %></p><% end %>", type: :erb
+      #     end
+      #   end
+      #
+      #   # good
+      #   # app/views/products/index.html.erb
+      #   # <% products.each do |p| %>
+      #   #   <p><%= p.name %></p>
+      #   # <% end %>
+      #
+      #   class ProductsController < ApplicationController
+      #     def index
+      #     end
+      #   end
+      #
+      class RenderInline < Base
+        MSG = 'Prefer using a template over inline rendering.'
+        RESTRICT_ON_SEND = %i[render].freeze
+
+        def_node_matcher :render_with_inline_option?, <<~PATTERN
+          (send nil? :render (hash <(pair {(sym :inline) (str "inline")} _) ...>))
+        PATTERN
+
+        def on_send(node)
+          add_offense(node) if render_with_inline_option?(node)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop identifies places where `render text:` can be
+      # replaced with `render plain:`.
+      #
+      # @example
+      #   # bad - explicit MIME type to `text/plain`
+      #   render text: 'Ruby!', content_type: 'text/plain'
+      #
+      #   # good - short and precise
+      #   render plain: 'Ruby!'
+      #
+      #   # good - explicit MIME type not to `text/plain`
+      #   render text: 'Ruby!', content_type: 'text/html'
+      #
+      # @example ContentTypeCompatibility: true (default)
+      #   # good - sets MIME type to `text/html`
+      #   render text: 'Ruby!'
+      #
+      # @example ContentTypeCompatibility: false
+      #   # bad - sets MIME type to `text/html`
+      #   render text: 'Ruby!'
+      #
+      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)
+            return unless compatible_content_type?(content_type_node)
+
+            add_offense(node) do |corrector|
+              rest_options = options_node.pairs - [option_node, content_type_node].compact
+
+              corrector.replace(node, replacement(rest_options, option_value))
+            end
+          end
+        end
+
+        private
+
+        def find_content_type(node)
+          node.pairs.find { |p| p.key.value.to_sym == :content_type }
+        end
+
+        def compatible_content_type?(node)
+          (node && node.value.value == 'text/plain') ||
+            (!node && !cop_config['ContentTypeCompatibility'])
+        end
+
+        def replacement(rest_options, option_value)
+          if rest_options.any?
+            "render plain: #{option_value.source}, #{rest_options.map(&:source).join(', ')}"
+          else
+            "render plain: #{option_value.source}"
+          end
+        end
+      end
+    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/reversible_migration.rb

@@ -129,8 +129,53 @@ module RuboCop
       #     end
       #   end
       #
+      # @example
+      #   # remove_columns
+      #
+      #   # bad
+      #   def change
+      #     remove_columns :users, :name, :email
+      #   end
+      #
+      #   # good
+      #   def change
+      #     reversible do |dir|
+      #       dir.up do
+      #         remove_columns :users, :name, :email
+      #       end
+      #
+      #       dir.down do
+      #         add_column :users, :name, :string
+      #         add_column :users, :email, :string
+      #       end
+      #     end
+      #   end
+      #
+      #   # good (Rails >= 6.1, see https://github.com/rails/rails/pull/36589)
+      #   def change
+      #     remove_columns :users, :name, :email, type: :string
+      #   end
+      #
+      # @example
+      #   # remove_index
+      #
+      #   # bad
+      #   def change
+      #     remove_index :users, name: :index_users_on_email
+      #   end
+      #
+      #   # good
+      #   def change
+      #     remove_index :users, :email
+      #   end
+      #
+      #   # good
+      #   def change
+      #     remove_index :users, column: :email
+      #   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
@@ -153,6 +198,14 @@ module RuboCop
           (send nil? :change_table $_ ...)
         PATTERN
 
+        def_node_matcher :remove_columns_call, <<~PATTERN
+          (send nil? :remove_columns ... $_)
+        PATTERN
+
+        def_node_matcher :remove_index_call, <<~PATTERN
+          (send nil? :remove_index _ $_)
+        PATTERN
+
         def on_send(node)
           return unless within_change_method?(node)
           return if within_reversible_or_up_only_block?(node)
@@ -162,6 +215,8 @@ module RuboCop
           check_reversible_hash_node(node)
           check_remove_column_node(node)
           check_remove_foreign_key_node(node)
+          check_remove_columns_node(node)
+          check_remove_index_node(node)
         end
 
         def on_block(node)
@@ -216,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
@@ -237,6 +288,30 @@ module RuboCop
           end
         end
 
+        def check_remove_columns_node(node)
+          remove_columns_call(node) do |args|
+            unless all_hash_key?(args, :type) && target_rails_version >= 6.1
+              action = target_rails_version >= 6.1 ? 'remove_columns(without type)' : 'remove_columns'
+
+              add_offense(
+                node,
+                message: format(MSG, action: action)
+              )
+            end
+          end
+        end
+
+        def check_remove_index_node(node)
+          remove_index_call(node) do |args|
+            if args.hash_type? && !all_hash_key?(args, :column)
+              add_offense(
+                node,
+                message: format(MSG, action: 'remove_index(without column)')
+              )
+            end
+          end
+        end
+
         def check_change_table_offense(receiver, node)
           method_name = node.method_name
           return if receiver != node.receiver &&
@@ -281,7 +356,7 @@ module RuboCop
             key.children.first.to_sym
           end
 
-          hash_keys & keys == keys
+          (hash_keys & keys).sort == keys
         end
       end
     end