rubocop-rails 2.4.2 → 2.7.0

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop identifies places where `pluck` is used in `where` query methods
+      # and can be replaced with `select`.
+      #
+      # Since `pluck` is an eager method and hits the database immediately,
+      # using `select` helps to avoid additional database queries.
+      #
+      # @example
+      #   # bad
+      #   Post.where(user_id: User.active.pluck(:id))
+      #
+      #   # good
+      #   Post.where(user_id: User.active.select(:id))
+      #
+      class PluckInWhere < Cop
+        include ActiveRecordHelper
+
+        MSG = 'Use `select` instead of `pluck` within `where` query method.'
+
+        def on_send(node)
+          add_offense(node, location: :selector) if node.method?(:pluck) && in_where?(node)
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.replace(node.loc.selector, 'select')
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -76,15 +76,11 @@ module RuboCop
           return if ignore_if_node?(node)
 
           redundant_receiver_and_other(node) do |receiver, other|
-            unless ignore_other_node?(other) || receiver.nil?
-              add_offense(node, message: message(node, receiver, other))
-            end
+            add_offense(node, message: message(node, receiver, other)) unless ignore_other_node?(other) || receiver.nil?
           end
 
           redundant_negative_receiver_and_other(node) do |receiver, other|
-            unless ignore_other_node?(other) || receiver.nil?
-              add_offense(node, message: message(node, receiver, other))
-            end
+            add_offense(node, message: message(node, receiver, other)) unless ignore_other_node?(other) || receiver.nil?
           end
         end
 

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

@@ -41,8 +41,25 @@ module RuboCop
           end
         end
 
+        def autocorrect(node)
+          lambda do |corrector|
+            task_name = node.arguments[0]
+            task_dependency = correct_task_dependency(task_name)
+
+            corrector.replace(task_name.loc.expression, task_dependency)
+          end
+        end
+
         private
 
+        def correct_task_dependency(task_name)
+          if task_name.sym_type?
+            task_name.source.delete(':|\'|"') + ': :environment'
+          else
+            "#{task_name.source} => :environment"
+          end
+        end
+
         def task_name(node)
           first_arg = node.arguments[0]
           case first_arg&.type

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

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop detects cases where the `:foreign_key` option on associations
+      # is redundant.
+      #
+      # @example
+      #   # bad
+      #   class Post
+      #     has_many :comments, foreign_key: 'post_id'
+      #   end
+      #
+      #   class Comment
+      #     belongs_to :post, foreign_key: 'post_id'
+      #   end
+      #
+      #   # good
+      #   class Post
+      #     has_many :comments
+      #   end
+      #
+      #   class Comment
+      #     belongs_to :author, foreign_key: 'user_id'
+      #   end
+      class RedundantForeignKey < Cop
+        include RangeHelp
+
+        MSG = 'Specifying the default value for `foreign_key` is redundant.'
+
+        def_node_matcher :association_with_foreign_key, <<~PATTERN
+          (send nil? ${:belongs_to :has_one :has_many :has_and_belongs_to_many} ({sym str} $_)
+            $(hash <$(pair (sym :foreign_key) ({sym str} $_)) ...>)
+          )
+        PATTERN
+
+        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
+
+        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)
+          end
+        end
+
+        private
+
+        def redundant?(node, association_type, association_name, options, foreign_key)
+          foreign_key.to_s == default_foreign_key(node, association_type, association_name, options)
+        end
+
+        def default_foreign_key(node, association_type, association_name, options)
+          if association_type == :belongs_to
+            "#{association_name}_id"
+          elsif (as = find_as_option(options))
+            "#{as}_id"
+          else
+            node.parent_module_name&.foreign_key
+          end
+        end
+
+        def find_as_option(options)
+          options.pairs.find do |pair|
+            pair.key.sym_type? && pair.key.value == :as
+          end&.value&.value
+        end
+      end
+    end
+  end
+end

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

@@ -55,11 +55,8 @@ module RuboCop
       #     end
       #   end
       class RedundantReceiverInWithOptions < Cop
-        extend TargetRailsVersion
         include RangeHelp
 
-        minimum_target_rails_version 4.2
-
         MSG = 'Redundant receiver in `with_options`.'
 
         def_node_matcher :with_options?, <<~PATTERN

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

@@ -6,7 +6,7 @@ module RuboCop
       #
       # Use `assert_not` methods instead of `refute` methods.
       #
-      # @example
+      # @example EnforcedStyle: assert_not (default)
       #   # bad
       #   refute false
       #   refute_empty [1, 2, 3]
@@ -17,29 +17,43 @@ module RuboCop
       #   assert_not_empty [1, 2, 3]
       #   assert_not_equal true, false
       #
+      # @example EnforcedStyle: refute
+      #   # bad
+      #   assert_not false
+      #   assert_not_empty [1, 2, 3]
+      #   assert_not_equal true, false
+      #
+      #   # good
+      #   refute false
+      #   refute_empty [1, 2, 3]
+      #   refute_equal true, false
+      #
       class RefuteMethods < Cop
-        MSG = 'Prefer `%<assert_method>s` over `%<refute_method>s`.'
+        include ConfigurableEnforcedStyle
+
+        MSG = 'Prefer `%<good_method>s` over `%<bad_method>s`.'
 
         CORRECTIONS = {
-          refute:             'assert_not',
-          refute_empty:       'assert_not_empty',
-          refute_equal:       'assert_not_equal',
-          refute_in_delta:    'assert_not_in_delta',
-          refute_in_epsilon:  'assert_not_in_epsilon',
-          refute_includes:    'assert_not_includes',
-          refute_instance_of: 'assert_not_instance_of',
-          refute_kind_of:     'assert_not_kind_of',
-          refute_nil:         'assert_not_nil',
-          refute_operator:    'assert_not_operator',
-          refute_predicate:   'assert_not_predicate',
-          refute_respond_to:  'assert_not_respond_to',
-          refute_same:        'assert_not_same',
-          refute_match:       'assert_no_match'
+          refute:             :assert_not,
+          refute_empty:       :assert_not_empty,
+          refute_equal:       :assert_not_equal,
+          refute_in_delta:    :assert_not_in_delta,
+          refute_in_epsilon:  :assert_not_in_epsilon,
+          refute_includes:    :assert_not_includes,
+          refute_instance_of: :assert_not_instance_of,
+          refute_kind_of:     :assert_not_kind_of,
+          refute_nil:         :assert_not_nil,
+          refute_operator:    :assert_not_operator,
+          refute_predicate:   :assert_not_predicate,
+          refute_respond_to:  :assert_not_respond_to,
+          refute_same:        :assert_not_same,
+          refute_match:       :assert_no_match
         }.freeze
 
-        OFFENSIVE_METHODS = CORRECTIONS.keys.freeze
+        REFUTE_METHODS = CORRECTIONS.keys.freeze
+        ASSERT_NOT_METHODS = CORRECTIONS.values.freeze
 
-        def_node_matcher :offensive?, '(send nil? #refute_method? ...)'
+        def_node_matcher :offensive?, '(send nil? #bad_method? ...)'
 
         def on_send(node)
           return unless offensive?(node)
@@ -49,27 +63,39 @@ module RuboCop
         end
 
         def autocorrect(node)
+          bad_method = node.method_name
+          good_method = convert_good_method(bad_method)
+
           lambda do |corrector|
-            corrector.replace(
-              node.loc.selector,
-              CORRECTIONS[node.method_name]
-            )
+            corrector.replace(node.loc.selector, good_method.to_s)
           end
         end
 
         private
 
-        def refute_method?(method_name)
-          OFFENSIVE_METHODS.include?(method_name)
+        def bad_method?(method_name)
+          if style == :assert_not
+            REFUTE_METHODS.include?(method_name)
+          else
+            ASSERT_NOT_METHODS.include?(method_name)
+          end
         end
 
         def offense_message(method_name)
           format(
             MSG,
-            refute_method: method_name,
-            assert_method: CORRECTIONS[method_name]
+            bad_method: method_name,
+            good_method: convert_good_method(method_name)
           )
         end
+
+        def convert_good_method(bad_method)
+          if style == :assert_not
+            CORRECTIONS.fetch(bad_method)
+          else
+            CORRECTIONS.invert.fetch(bad_method)
+          end
+        end
       end
     end
   end

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

@@ -0,0 +1,48 @@
+# 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 < Cop
+        MSG = 'Prefer using a template over inline rendering.'
+
+        def_node_matcher :render_with_options?, <<~PATTERN
+          (send nil? :render $(hash ...))
+        PATTERN
+
+        def on_send(node)
+          render_with_options?(node) do |options|
+            add_offense(node) if includes_inline_key?(options)
+          end
+        end
+
+        private
+
+        def includes_inline_key?(node)
+          node.keys.find { |key| key.value.to_sym == :inline }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,76 @@
+# 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 < Cop
+        MSG = 'Prefer `render plain:` over `render text:`.'
+
+        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
+
+            lambda do |corrector|
+              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/reversible_migration.rb

@@ -90,6 +90,11 @@ module RuboCop
       #     remove_foreign_key :accounts, :branches
       #   end
       #
+      #   # good
+      #   def change
+      #     remove_foreign_key :accounts, to_table: :branches
+      #   end
+      #
       # @example
       #   # change_table
       #
@@ -210,7 +215,7 @@ module RuboCop
 
         def check_remove_foreign_key_node(node)
           remove_foreign_key_call(node) do |arg|
-            if arg.hash_type?
+            if arg.hash_type? && !all_hash_key?(arg, :to_table)
               add_offense(
                 node,
                 message: format(MSG,

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

@@ -48,7 +48,7 @@ module RuboCop
         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 =~ /\w+[=!?]?/
+            return unless dispatch.sym_type? && dispatch.value.match?(/\w+[=!?]?/)
 
             add_offense(node, message: format(MSG, try: try_method))
           end