rubocop 0.78.0 → 1.13.0

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

@@ -0,0 +1,118 @@
+# 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: Remove `Symbol#to_s` after supporting only Ruby >= 2.7.
+          return unless node.method_name.to_s.end_with?('=')
+          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
+
+        # @!method redundant_self_assignment?(node, method_name)
+        def_node_matcher :redundant_self_assignment?, <<~PATTERN
+          (send
+            (self) _
+            (send
+              (send
+                {(self) nil?} %1) #method_returning_self?
+              ...))
+        PATTERN
+
+        # @!method redundant_nonself_assignment?(node, receiver, method_name)
+        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,12 +49,15 @@ 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`.'
+        MSG = 'Use `%<suggestion>s` instead of `%<sorter>s...%<accessor_source>s`.'
 
+        RESTRICT_ON_SEND = %i[sort sort_by].freeze
+
+        # @!method redundant_sort?(node)
         def_node_matcher :redundant_sort?, <<~MATCHER
           {
             (send $(send _ $:sort ...) ${:last :first})
@@ -63,50 +66,43 @@ module RuboCop
             (send $(send _ $:sort_by _) ${:last :first})
             (send $(send _ $:sort_by _) ${:[] :at :slice} {(int 0) (int -1)})
 
-            (send (block $(send _ ${:sort_by :sort}) ...) ${:last :first})
+            (send ({block numblock} $(send _ ${:sort_by :sort}) ...) ${:last :first})
             (send
-              (block $(send _ ${:sort_by :sort}) ...)
+              ({block numblock} $(send _ ${:sort_by :sort}) ...)
               ${:[] :at :slice} {(int 0) (int -1)}
             )
           }
         MATCHER
 
         def on_send(node)
-          redundant_sort?(node) do |sort_node, sorter, accessor|
-            range = range_between(
-              sort_node.loc.selector.begin_pos,
-              node.loc.expression.end_pos
-            )
+          if (sort_node, sorter, accessor = redundant_sort?(node.parent))
+            ancestor = node.parent
+          elsif (sort_node, sorter, accessor = redundant_sort?(node.parent&.parent))
+            ancestor = node.parent.parent
+          else
+            return
+          end
+
+          message = message(ancestor, sorter, accessor)
 
-            add_offense(node,
-                        location: range,
-                        message: message(node,
-                                         sorter,
-                                         accessor))
+          add_offense(offense_range(sort_node, ancestor), message: message) do |corrector|
+            autocorrect(corrector, ancestor, sort_node, sorter, accessor)
           end
         end
 
-        def autocorrect(node)
-          sort_node, sorter, accessor = redundant_sort?(node)
+        private
 
-          lambda do |corrector|
-            # Remove accessor, e.g. `first` or `[-1]`.
-            corrector.remove(
-              range_between(
-                accessor_start(node),
-                node.loc.expression.end_pos
-              )
-            )
+        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
+          # Replace "sort" or "sort_by" with the appropriate min/max method.
+          corrector.replace(sort_node.loc.selector, suggestion(sorter, accessor, arg_value(node)))
         end
 
-        private
+        def offense_range(sort_node, ancestor)
+          range_between(sort_node.loc.selector.begin_pos, ancestor.loc.expression.end_pos)
+        end
 
         def message(node, sorter, accessor)
           accessor_source = range_between(
@@ -115,9 +111,7 @@ module RuboCop
           ).source
 
           format(MSG,
-                 suggestion: suggestion(sorter,
-                                        accessor,
-                                        arg_value(node)),
+                 suggestion: suggestion(sorter, accessor, arg_value(node)),
                  sorter: sorter,
                  accessor_source: accessor_source)
         end
@@ -135,9 +129,10 @@ module RuboCop
         end
 
         def suffix(sorter)
-          if sorter == :sort
+          case sorter
+          when :sort
             ''
-          elsif sorter == :sort_by
+          when :sort_by
             '_by'
           end
         end

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

@@ -15,11 +15,13 @@ 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 }`.'
 
+        # @!method redundant_sort_by(node)
         def_node_matcher :redundant_sort_by, <<~PATTERN
           (block $(send _ :sort_by) (args (arg $_x)) (lvar _x))
         PATTERN
@@ -28,17 +30,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,26 +106,12 @@ 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)
+          style == :slashes && !contains_disallowed_slash?(node) || allowed_mixed_slash?(node)
         end
 
         def allowed_mixed_slash?(node)
-          style == :mixed && node.single_line? &&
-            !contains_disallowed_slash?(node)
+          style == :mixed && node.single_line? && !contains_disallowed_slash?(node)
         end
 
         def allowed_percent_r_literal?(node)
@@ -134,8 +121,7 @@ module RuboCop
         end
 
         def allowed_mixed_percent_r?(node)
-          style == :mixed && node.multiline? ||
-            contains_disallowed_slash?(node)
+          style == :mixed && node.multiline? || contains_disallowed_slash?(node)
         end
 
         def contains_disallowed_slash?(node)
@@ -160,8 +146,7 @@ module RuboCop
         end
 
         def preferred_delimiters
-          config.for_cop('Style/PercentLiteralDelimiters') \
-            ['PreferredDelimiters']['%r'].split(//)
+          config.for_cop('Style/PercentLiteralDelimiters') ['PreferredDelimiters']['%r'].chars
         end
 
         def correct_delimiters(node, corrector)

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

@@ -39,33 +39,60 @@ module RuboCop
       #   rescue SomeException
       #     handle_error
       #   end
-      class RescueModifier < Cop
+      class RescueModifier < Base
         include Alignment
+        include RangeHelp
         include RescueNode
+        extend AutoCorrector
 
         MSG = 'Avoid using `rescue` in its modifier form.'
 
+        def self.autocorrect_incompatible_with
+          [Style::MethodCallWithArgsParentheses]
+        end
+
         def on_resbody(node)
           return unless rescue_modifier?(node)
 
-          add_offense(node.parent)
+          rescue_node = node.parent
+          add_offense(rescue_node) do |corrector|
+            parenthesized = parenthesized?(rescue_node)
+
+            correct_rescue_block(corrector, rescue_node, parenthesized)
+            ParenthesesCorrector.correct(corrector, rescue_node.parent) if parenthesized
+          end
+        end
+
+        private
+
+        def parenthesized?(node)
+          node.parent && parentheses?(node.parent)
         end
 
-        def autocorrect(node)
+        def correct_rescue_block(corrector, 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)
+
+          corrector.remove(range_between(operation.source_range.end_pos, node.source_range.end_pos))
+          corrector.insert_before(operation, "begin\n#{node_indentation}")
+          corrector.insert_after(operation, <<~RESCUE_CLAUSE.chop)
+
+            #{node_offset}rescue
+            #{node_indentation}#{rescue_args.source}
+            #{node_offset}end
+          RESCUE_CLAUSE
+        end
 
-          lambda do |corrector|
-            corrector.replace(node.source_range, correction)
+        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,22 +70,23 @@ 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.'
-        MSG_EXPLICIT = 'Avoid rescuing without specifying ' \
-          'an error class.'
+        MSG_IMPLICIT = 'Omit the error class when rescuing `StandardError` by itself.'
+        MSG_EXPLICIT = 'Avoid rescuing without specifying an error class.'
 
+        # @!method rescue_without_error_class?(node)
         def_node_matcher :rescue_without_error_class?, <<~PATTERN
           (resbody nil? _ _)
         PATTERN
 
+        # @!method rescue_standard_error?(node)
         def_node_matcher :rescue_standard_error?, <<~PATTERN
-          (resbody $(array (const nil? :StandardError)) _ _)
+          (resbody $(array (const {nil? cbase} :StandardError)) _ _)
         PATTERN
 
         def on_resbody(node)
@@ -94,28 +95,29 @@ 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)
-            end
+            rescue_without_error_class?(node) { offense_for_exlicit_enforced_style(node) }
           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