rubocop-rails 2.4.1 → 2.6.0

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

@@ -129,10 +129,6 @@ module RuboCop
       # @see https://guides.rubyonrails.org/association_basics.html#bi-directional-associations
       # @see https://api.rubyonrails.org/classes/ActiveRecord/Associations/ClassMethods.html#module-ActiveRecord::Associations::ClassMethods-label-Setting+Inverses
       class InverseOf < Cop
-        extend TargetRailsVersion
-
-        minimum_target_rails_version 4.1
-
         SPECIFY_MSG = 'Specify an `:inverse_of` option.'
         NIL_MSG = 'You specified `inverse_of: nil`, you probably meant to ' \
           'use `inverse_of: false`.'

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

@@ -42,9 +42,7 @@ module RuboCop
 
           option_nodes.map(&:children).each do |options|
             blank = options.find { |o| blank_target?(o) }
-            if blank && options.none? { |o| includes_noopener?(o) }
-              add_offense(blank)
-            end
+            add_offense(blank) if blank && options.none? { |o| includes_noopener?(o) }
           end
         end
 

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

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop enforces the use `pick` over `pluck(...).first`.
+      #
+      # @example
+      #   # bad
+      #   Model.pluck(:a).first
+      #   Model.pluck(:a, :b).first
+      #
+      #   # good
+      #   Model.pick(:a)
+      #   Model.pick(:a, :b)
+      class Pick < Cop
+        extend TargetRailsVersion
+
+        MSG = 'Prefer `pick(%<args>s)` over `pluck(%<args>s).first`.'
+
+        minimum_target_rails_version 6.0
+
+        def_node_matcher :pick_candidate?, <<~PATTERN
+          (send (send _ :pluck ...) :first)
+        PATTERN
+
+        def on_send(node)
+          pick_candidate?(node) do
+            range = node.receiver.loc.selector.join(node.loc.selector)
+            add_offense(node, location: range)
+          end
+        end
+
+        def autocorrect(node)
+          first_range = node.receiver.source_range.end.join(node.loc.selector)
+
+          lambda do |corrector|
+            corrector.remove(first_range)
+            corrector.replace(node.receiver.loc.selector, 'pick')
+          end
+        end
+
+        private
+
+        def message(node)
+          format(MSG, args: node.receiver.arguments.map(&:source).join(', '))
+        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

@@ -29,19 +29,37 @@ module RuboCop
         MSG = 'Include `:environment` task as a dependency for all Rake tasks.'
 
         def_node_matcher :task_definition?, <<~PATTERN
-          (send nil? :task ...)
+          (block $(send nil? :task ...) ...)
         PATTERN
 
-        def on_send(node)
-          return unless task_definition?(node)
-          return if task_name(node) == :default
-          return if with_dependencies?(node)
+        def on_block(node)
+          task_definition?(node) do |task_method|
+            return if task_name(task_method) == :default
+            return if with_dependencies?(task_method)
 
-          add_offense(node)
+            add_offense(task_method)
+          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/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/save_bang.rb

@@ -9,13 +9,14 @@ module RuboCop
       #
       # This will allow:
       #
-      # - update or save calls, assigned to a variable,
+      # * update or save calls, assigned to a variable,
       #   or used as a condition in an if/unless/case statement.
-      # - create calls, assigned to a variable that then has a
-      #   call to `persisted?`.
-      # - calls if the result is explicitly returned from methods and blocks,
+      # * create calls, assigned to a variable that then has a
+      #   call to `persisted?`, or whose return value is checked by
+      #   `persisted?` immediately
+      # * calls if the result is explicitly returned from methods and blocks,
       #   or provided as arguments.
-      # - calls whose signature doesn't look like an ActiveRecord
+      # * calls whose signature doesn't look like an ActiveRecord
       #   persistence method.
       #
       # By default it will also allow implicit returns from methods and blocks.
@@ -137,16 +138,19 @@ module RuboCop
           add_offense_for_node(node, CREATE_MSG)
         end
 
-        def on_send(node) # rubocop:disable Metrics/CyclomaticComplexity
+        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        def on_send(node)
           return unless persist_method?(node)
           return if return_value_assigned?(node)
           return if implicit_return?(node)
           return if check_used_in_condition_or_compound_boolean(node)
           return if argument?(node)
           return if explicit_return?(node)
+          return if checked_immediately?(node)
 
           add_offense_for_node(node)
         end
+        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         alias on_csend on_send
 
         def autocorrect(node)
@@ -214,9 +218,7 @@ module RuboCop
         def check_used_in_condition_or_compound_boolean(node)
           return false unless in_condition_or_compound_boolean?(node)
 
-          unless MODIFY_PERSIST_METHODS.include?(node.method_name)
-            add_offense_for_node(node, CREATE_CONDITIONAL_MSG)
-          end
+          add_offense_for_node(node, CREATE_CONDITIONAL_MSG) unless MODIFY_PERSIST_METHODS.include?(node.method_name)
 
           true
         end
@@ -238,8 +240,13 @@ module RuboCop
           parent.if_type? || parent.case_type?
         end
 
+        def checked_immediately?(node)
+          node.parent && call_to_persisted?(node.parent)
+        end
+
         def allowed_receiver?(node)
           return false unless node.receiver
+          return true if node.receiver.const_name == 'ENV'
           return false unless cop_config['AllowedReceivers']
 
           cop_config['AllowedReceivers'].any? do |allowed_receiver|

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

@@ -50,7 +50,10 @@ module RuboCop
                                     update_counters].freeze
 
         def_node_matcher :good_touch?, <<~PATTERN
-          (send (const nil? :FileUtils) :touch ...)
+          {
+            (send (const nil? :FileUtils) :touch ...)
+            (send _ :touch {true false})
+          }
         PATTERN
 
         def on_send(node)