rubocop 0.89.0 → 0.92.0

data/lib/rubocop/cop/style/redundant_self.rb

@@ -41,7 +41,9 @@ module RuboCop
       #       self.bar == bar  # Resolves name clash with argument of the block.
       #     end
       #   end
-      class RedundantSelf < Cop
+      class RedundantSelf < Base
+        extend AutoCorrector
+
         MSG = 'Redundant `self` detected.'
         KERNEL_METHODS = Kernel.methods(false)
         KEYWORDS = %i[alias and begin break case class def defined? do
@@ -57,7 +59,7 @@ module RuboCop
         def initialize(config = nil, options = nil)
           super
           @allowed_send_nodes = []
-          @local_variables_scopes = Hash.new { |hash, key| hash[key] = [] }
+          @local_variables_scopes = Hash.new { |hash, key| hash[key] = [] }.compare_by_identity
         end
 
         # Assignment of self.x
@@ -106,24 +108,20 @@ module RuboCop
 
           return if allowed_send_node?(node)
 
-          add_offense(node)
+          add_offense(node) do |corrector|
+            corrector.remove(node.receiver)
+            corrector.remove(node.loc.dot)
+          end
         end
 
         def on_block(node)
           add_scope(node, @local_variables_scopes[node])
         end
 
-        def autocorrect(node)
-          lambda do |corrector|
-            corrector.remove(node.receiver)
-            corrector.remove(node.loc.dot)
-          end
-        end
-
         private
 
         def add_scope(node, local_variables = [])
-          node.descendants.each do |child_node|
+          node.each_descendant do |child_node|
             @local_variables_scopes[child_node] = local_variables
           end
         end

data/lib/rubocop/cop/style/redundant_self_assignment.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for places where redundant assignments are made for in place
+      # modification methods.
+      #
+      # This cop is marked as unsafe, because it can produce false positives for
+      # user defined methods having one of the expected names, but not modifying
+      # its receiver in place.
+      #
+      # @example
+      #   # bad
+      #   args = args.concat(ary)
+      #   hash = hash.merge!(other)
+      #
+      #   # good
+      #   args.concat(foo)
+      #   args += foo
+      #   hash.merge!(other)
+      #
+      #   # bad
+      #   self.foo = foo.concat(ary)
+      #
+      #   # good
+      #   foo.concat(ary)
+      #   self.foo += ary
+      #
+      class RedundantSelfAssignment < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Redundant self assignment detected. '\
+              'Method `%<method_name>s` modifies its receiver in place.'
+
+        METHODS_RETURNING_SELF = %i[
+          append clear collect! compare_by_identity concat delete_if
+          fill initialize_copy insert keep_if map! merge! prepend push
+          rehash replace reverse! rotate! shuffle! sort! sort_by!
+          transform_keys! transform_values! unshift update
+        ].to_set.freeze
+
+        ASSIGNMENT_TYPE_TO_RECEIVER_TYPE = {
+          lvasgn: :lvar,
+          ivasgn: :ivar,
+          cvasgn: :cvar,
+          gvasgn: :gvar
+        }.freeze
+
+        def on_lvasgn(node)
+          lhs, rhs = *node
+          receiver, method_name, = *rhs
+          return unless receiver && method_returning_self?(method_name)
+
+          receiver_type = ASSIGNMENT_TYPE_TO_RECEIVER_TYPE[node.type]
+          return unless receiver.type == receiver_type && receiver.children.first == lhs
+
+          message = format(MSG, method_name: method_name)
+          add_offense(node.loc.operator, message: message) do |corrector|
+            corrector.replace(node, rhs.source)
+          end
+        end
+        alias on_ivasgn on_lvasgn
+        alias on_cvasgn on_lvasgn
+        alias on_gvasgn on_lvasgn
+
+        def on_send(node)
+          # TODO: replace with #end_with? after supporting only ruby >= 2.7
+          return unless node.method_name.match?(/=$/)
+          return unless redundant_assignment?(node)
+
+          message = format(MSG, method_name: node.first_argument.method_name)
+          add_offense(node.loc.operator, message: message) do |corrector|
+            corrector.remove(correction_range(node))
+          end
+        end
+
+        private
+
+        def method_returning_self?(method_name)
+          METHODS_RETURNING_SELF.include?(method_name)
+        end
+
+        def_node_matcher :redundant_self_assignment?, <<~PATTERN
+          (send
+            (self) _
+            (send
+              (send
+                {(self) nil?} %1) #method_returning_self?
+              ...))
+        PATTERN
+
+        def_node_matcher :redundant_nonself_assignment?, <<~PATTERN
+          (send
+            %1 _
+            (send
+              (send
+                %1 %2) #method_returning_self?
+              ...))
+        PATTERN
+
+        def redundant_assignment?(node)
+          receiver_name = node.method_name.to_s[0...-1].to_sym
+
+          redundant_self_assignment?(node, receiver_name) ||
+            redundant_nonself_assignment?(node, node.receiver, receiver_name)
+        end
+
+        def correction_range(node)
+          range_between(node.source_range.begin_pos, node.first_argument.source_range.begin_pos)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/style/redundant_sort.rb

@@ -49,13 +49,14 @@ module RuboCop
       #   # good
       #   arr.max_by(&:foo)
       #
-      class RedundantSort < Cop
+      class RedundantSort < Base
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Use `%<suggestion>s` instead of '\
               '`%<sorter>s...%<accessor_source>s`.'
 
-        SORT_METHODS = %i[sort sort_by].freeze
+        RESTRICT_ON_SEND = %i[sort sort_by].freeze
 
         def_node_matcher :redundant_sort?, <<~MATCHER
           {
@@ -73,10 +74,7 @@ module RuboCop
           }
         MATCHER
 
-        # rubocop:disable Metrics/AbcSize
         def on_send(node)
-          return unless sort_method?(node)
-
           if (sort_node, sorter, accessor = redundant_sort?(node.parent))
             ancestor = node.parent
           elsif (sort_node, sorter, accessor = redundant_sort?(node.parent&.parent))
@@ -85,38 +83,21 @@ module RuboCop
             return
           end
 
-          add_offense(ancestor,
-                      location: offense_range(sort_node, ancestor),
-                      message: message(ancestor,
-                                       sorter,
-                                       accessor))
-        end
-        # rubocop:enable Metrics/AbcSize
-
-        def autocorrect(node)
-          sort_node, sorter, accessor = redundant_sort?(node)
-
-          lambda do |corrector|
-            # Remove accessor, e.g. `first` or `[-1]`.
-            corrector.remove(
-              range_between(
-                accessor_start(node),
-                node.loc.expression.end_pos
-              )
-            )
+          message = message(ancestor, sorter, accessor)
 
-            # Replace "sort" or "sort_by" with the appropriate min/max method.
-            corrector.replace(
-              sort_node.loc.selector,
-              suggestion(sorter, accessor, arg_value(node))
-            )
+          add_offense(offense_range(sort_node, ancestor), message: message) do |corrector|
+            autocorrect(corrector, ancestor, sort_node, sorter, accessor)
           end
         end
 
         private
 
-        def sort_method?(node)
-          SORT_METHODS.include?(node.method_name)
+        def autocorrect(corrector, node, sort_node, sorter, accessor)
+          # Remove accessor, e.g. `first` or `[-1]`.
+          corrector.remove(range_between(accessor_start(node), node.loc.expression.end_pos))
+
+          # Replace "sort" or "sort_by" with the appropriate min/max method.
+          corrector.replace(sort_node.loc.selector, suggestion(sorter, accessor, arg_value(node)))
         end
 
         def offense_range(sort_node, ancestor)

data/lib/rubocop/cop/style/redundant_sort_by.rb

@@ -15,8 +15,9 @@ module RuboCop
       #
       #   # good
       #   array.sort
-      class RedundantSortBy < Cop
+      class RedundantSortBy < Base
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Use `sort` instead of `sort_by { |%<var>s| %<var>s }`.'
 
@@ -28,17 +29,12 @@ module RuboCop
           redundant_sort_by(node) do |send, var_name|
             range = sort_by_range(send, node)
 
-            add_offense(node,
-                        location: range,
-                        message: format(MSG, var: var_name))
+            add_offense(range, message: format(MSG, var: var_name)) do |corrector|
+              corrector.replace(range, 'sort')
+            end
           end
         end
 
-        def autocorrect(node)
-          send = node.send_node
-          ->(corrector) { corrector.replace(sort_by_range(send, node), 'sort') }
-        end
-
         private
 
         def sort_by_range(send, node)

data/lib/rubocop/cop/style/regexp_literal.rb

@@ -81,23 +81,24 @@ module RuboCop
       # @example AllowInnerSlashes: true
       #   # good
       #   x =~ /home\//
-      class RegexpLiteral < Cop
+      class RegexpLiteral < Base
         include ConfigurableEnforcedStyle
         include RangeHelp
+        extend AutoCorrector
 
         MSG_USE_SLASHES = 'Use `//` around regular expression.'
         MSG_USE_PERCENT_R = 'Use `%r` around regular expression.'
 
         def on_regexp(node)
-          if slash_literal?(node)
-            check_slash_literal(node)
-          else
-            check_percent_r_literal(node)
-          end
-        end
+          message = if slash_literal?(node)
+                      MSG_USE_PERCENT_R unless allowed_slash_literal?(node)
+                    else
+                      MSG_USE_SLASHES unless allowed_percent_r_literal?(node)
+                    end
+
+          return unless message
 
-        def autocorrect(node)
-          lambda do |corrector|
+          add_offense(node, message: message) do |corrector|
             correct_delimiters(node, corrector)
             correct_inner_slashes(node, corrector)
           end
@@ -105,18 +106,6 @@ module RuboCop
 
         private
 
-        def check_slash_literal(node)
-          return if allowed_slash_literal?(node)
-
-          add_offense(node, message: MSG_USE_PERCENT_R)
-        end
-
-        def check_percent_r_literal(node)
-          return if allowed_percent_r_literal?(node)
-
-          add_offense(node, message: MSG_USE_SLASHES)
-        end
-
         def allowed_slash_literal?(node)
           style == :slashes && !contains_disallowed_slash?(node) ||
             allowed_mixed_slash?(node)

data/lib/rubocop/cop/style/rescue_modifier.rb

@@ -52,20 +52,40 @@ module RuboCop
         end
 
         def autocorrect(node)
+          parenthesized = parenthesized?(node)
+          lambda do |corrector|
+            corrector.replace(node, corrected_block(node, parenthesized))
+            ParenthesesCorrector.correct(corrector, node.parent) if parenthesized
+          end
+        end
+
+        private
+
+        def parenthesized?(node)
+          node.parent && parentheses?(node.parent)
+        end
+
+        def corrected_block(node, parenthesized)
           operation, rescue_modifier, = *node
           *_, rescue_args = *rescue_modifier
 
-          indent = indentation(node)
-          correction =
-            "begin\n" \
-            "#{operation.source.gsub(/^/, indent)}" \
-            "\n#{offset(node)}rescue\n" \
-            "#{rescue_args.source.gsub(/^/, indent)}" \
-            "\n#{offset(node)}end"
+          node_indentation, node_offset = indentation_and_offset(node, parenthesized)
 
-          lambda do |corrector|
-            corrector.replace(node, correction)
+          "begin\n" \
+            "#{operation.source.gsub(/^/, node_indentation)}" \
+            "\n#{node_offset}rescue\n" \
+            "#{rescue_args.source.gsub(/^/, node_indentation)}" \
+            "\n#{node_offset}end"
+        end
+
+        def indentation_and_offset(node, parenthesized)
+          node_indentation = indentation(node)
+          node_offset = offset(node)
+          if parenthesized
+            node_indentation = node_indentation[0...-1]
+            node_offset = node_offset[0...-1]
           end
+          [node_indentation, node_offset]
         end
       end
     end

data/lib/rubocop/cop/style/rescue_standard_error.rb

@@ -70,10 +70,11 @@ module RuboCop
       #   rescue StandardError, SecurityError
       #     bar
       #   end
-      class RescueStandardError < Cop
+      class RescueStandardError < Base
         include RescueNode
         include ConfigurableEnforcedStyle
         include RangeHelp
+        extend AutoCorrector
 
         MSG_IMPLICIT = 'Omit the error class when rescuing ' \
           '`StandardError` by itself.'
@@ -94,28 +95,31 @@ module RuboCop
           case style
           when :implicit
             rescue_standard_error?(node) do |error|
-              add_offense(node,
-                          location: node.loc.keyword.join(error.loc.expression),
-                          message: MSG_IMPLICIT)
+              offense_for_implicit_enforced_style(node, error)
             end
           when :explicit
             rescue_without_error_class?(node) do
-              add_offense(node, location: :keyword, message: MSG_EXPLICIT)
+              offense_for_exlicit_enforced_style(node)
             end
           end
         end
 
-        def autocorrect(node)
-          lambda do |corrector|
-            case style
-            when :implicit
-              error = rescue_standard_error?(node)
-              range = range_between(node.loc.keyword.end_pos,
-                                    error.loc.expression.end_pos)
-              corrector.remove(range)
-            when :explicit
-              corrector.insert_after(node.loc.keyword, ' StandardError')
-            end
+        private
+
+        def offense_for_implicit_enforced_style(node, error)
+          range = node.loc.keyword.join(error.loc.expression)
+
+          add_offense(range, message: MSG_IMPLICIT) do |corrector|
+            error = rescue_standard_error?(node)
+            range = range_between(node.loc.keyword.end_pos, error.loc.expression.end_pos)
+
+            corrector.remove(range)
+          end
+        end
+
+        def offense_for_exlicit_enforced_style(node)
+          add_offense(node.loc.keyword, message: MSG_EXPLICIT) do |corrector|
+            corrector.insert_after(node.loc.keyword, ' StandardError')
           end
         end
       end

data/lib/rubocop/cop/style/return_nil.rb

@@ -28,8 +28,9 @@ module RuboCop
       #   def foo(arg)
       #     return nil if arg
       #   end
-      class ReturnNil < Cop
+      class ReturnNil < Base
         include ConfigurableEnforcedStyle
+        extend AutoCorrector
 
         RETURN_MSG = 'Use `return` instead of `return nil`.'
         RETURN_NIL_MSG = 'Use `return nil` instead of `return`.'
@@ -54,12 +55,11 @@ module RuboCop
             return nil if chained_send?(send_node)
           end
 
-          add_offense(node) unless correct_style?(node)
-        end
+          return if correct_style?(node)
 
-        def autocorrect(node)
-          lambda do |corrector|
+          add_offense(node) do |corrector|
             corrected = style == :return ? 'return' : 'return nil'
+
             corrector.replace(node, corrected)
           end
         end