rubocop 0.89.1 → 0.93.0

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
           {
@@ -74,8 +75,6 @@ module RuboCop
         MATCHER
 
         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))
@@ -84,37 +83,21 @@ module RuboCop
             return
           end
 
-          add_offense(ancestor,
-                      location: offense_range(sort_node, ancestor),
-                      message: message(ancestor,
-                                       sorter,
-                                       accessor))
-        end
-
-        def autocorrect(node)
-          sort_node, sorter, accessor = redundant_sort?(node)
+          message = message(ancestor, sorter, accessor)
 
-          lambda do |corrector|
-            # 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))
-            )
+          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

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

@@ -49,6 +49,10 @@ module RuboCop
       #   foo && foo < bar
       #   foo < bar if foo
       #
+      #   # When checking `foo&.empty?` in a conditional, `foo` being `nil` will actually
+      #   # do the opposite of what the author intends.
+      #   foo && foo.empty?
+      #
       #   # This could start returning `nil` as well as the return of the method
       #   foo.nil? || foo.bar
       #   !foo || foo.bar
@@ -58,9 +62,10 @@ module RuboCop
       #   foo.baz = bar if foo
       #   foo.baz + bar if foo
       #   foo.bar > 2 if foo
-      class SafeNavigation < Cop
+      class SafeNavigation < Base
         include NilMethods
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Use safe navigation (`&.`) instead of checking if an object ' \
               'exists before calling the method.'
@@ -103,30 +108,31 @@ module RuboCop
           # chain greater than 2
           return if chain_size(method_chain, method) > 1
           return if unsafe_method_used?(method_chain, method)
+          return if method_chain.method?(:empty?)
 
-          add_offense(node)
+          add_offense(node) do |corrector|
+            autocorrect(corrector, node)
+          end
         end
 
         def use_var_only_in_unless_modifier?(node, variable)
           node.if_type? && node.unless? && !method_called?(variable)
         end
 
-        def autocorrect(node)
+        private
+
+        def autocorrect(corrector, node)
           body = node.node_parts[1]
           method_call = method_call(node)
 
-          lambda do |corrector|
-            corrector.remove(begin_range(node, body))
-            corrector.remove(end_range(node, body))
-            corrector.insert_before(method_call.loc.dot, '&')
-            handle_comments(corrector, node, method_call)
+          corrector.remove(begin_range(node, body))
+          corrector.remove(end_range(node, body))
+          corrector.insert_before(method_call.loc.dot, '&')
+          handle_comments(corrector, node, method_call)
 
-            add_safe_nav_to_all_methods_in_chain(corrector, method_call, body)
-          end
+          add_safe_nav_to_all_methods_in_chain(corrector, method_call, body)
         end
 
-        private
-
         def handle_comments(corrector, node, method_call)
           comments = comments(node)
           return if comments.empty?

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

@@ -27,30 +27,28 @@ module RuboCop
       #   [1, 2, 3].shuffle[1..3]    # sample(3) might return a longer Array
       #   [1, 2, 3].shuffle[foo, bar]
       #   [1, 2, 3].shuffle(random: Random.new)
-      class Sample < Cop
+      class Sample < Base
+        extend AutoCorrector
+
         MSG = 'Use `%<correct>s` instead of `%<incorrect>s`.'
+        RESTRICT_ON_SEND = %i[first last [] at slice].freeze
 
         def_node_matcher :sample_candidate?, <<~PATTERN
-          (send $(send _ :shuffle $...) ${:first :last :[] :at :slice} $...)
+          (send $(send _ :shuffle $...) ${:#{RESTRICT_ON_SEND.join(' :')}} $...)
         PATTERN
 
         def on_send(node)
-          sample_candidate?(node) do |shuffle, shuffle_arg, method, method_args|
+          sample_candidate?(node) do |shuffle_node, shuffle_arg, method, method_args|
             return unless offensive?(method, method_args)
 
-            range = source_range(shuffle, node)
+            range = source_range(shuffle_node, node)
             message = message(shuffle_arg, method, method_args, range)
-            add_offense(node, location: range, message: message)
-          end
-        end
-
-        def autocorrect(node)
-          shuffle_node, shuffle_arg, method, method_args =
-            sample_candidate?(node)
 
-          lambda do |corrector|
-            corrector.replace(source_range(shuffle_node, node),
-                              correction(shuffle_arg, method, method_args))
+            add_offense(range, message: message) do |corrector|
+              corrector.replace(
+                source_range(shuffle_node, node), correction(shuffle_arg, method, method_args)
+              )
+            end
           end
         end
 

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

@@ -12,7 +12,9 @@ module RuboCop
       #
       #   # good
       #   x += 1
-      class SelfAssignment < Cop
+      class SelfAssignment < Base
+        extend AutoCorrector
+
         MSG = 'Use self-assignment shorthand `%<method>s=`.'
         OPS = %i[+ - * ** / | &].freeze
 
@@ -32,16 +34,6 @@ module RuboCop
           check(node, :cvar)
         end
 
-        def autocorrect(node)
-          _var_name, rhs = *node
-
-          if rhs.send_type?
-            autocorrect_send_node(node, rhs)
-          elsif %i[and or].include?(rhs.type)
-            autocorrect_boolean_node(node, rhs)
-          end
-        end
-
         private
 
         def check(node, var_type)
@@ -62,7 +54,9 @@ module RuboCop
           target_node = s(var_type, var_name)
           return unless receiver == target_node
 
-          add_offense(node, message: format(MSG, method: method_name))
+          add_offense(node, message: format(MSG, method: method_name)) do |corrector|
+            autocorrect(corrector, node)
+          end
         end
 
         def check_boolean_node(node, rhs, var_name, var_type)
@@ -72,24 +66,34 @@ module RuboCop
           return unless first_operand == target_node
 
           operator = rhs.loc.operator.source
-          add_offense(node, message: format(MSG, method: operator))
+          add_offense(node, message: format(MSG, method: operator)) do |corrector|
+            autocorrect(corrector, node)
+          end
         end
 
-        def autocorrect_send_node(node, rhs)
+        def autocorrect(corrector, node)
+          _var_name, rhs = *node
+
+          if rhs.send_type?
+            autocorrect_send_node(corrector, node, rhs)
+          elsif %i[and or].include?(rhs.type)
+            autocorrect_boolean_node(corrector, node, rhs)
+          end
+        end
+
+        def autocorrect_send_node(corrector, node, rhs)
           _receiver, method_name, args = *rhs
-          apply_autocorrect(node, rhs, method_name.to_s, args)
+          apply_autocorrect(corrector, node, rhs, method_name.to_s, args)
         end
 
-        def autocorrect_boolean_node(node, rhs)
+        def autocorrect_boolean_node(corrector, node, rhs)
           _first_operand, second_operand = *rhs
-          apply_autocorrect(node, rhs, rhs.loc.operator.source, second_operand)
+          apply_autocorrect(corrector, node, rhs, rhs.loc.operator.source, second_operand)
         end
 
-        def apply_autocorrect(node, rhs, operator, new_rhs)
-          lambda do |corrector|
-            corrector.insert_before(node.loc.operator, operator)
-            corrector.replace(rhs, new_rhs.source)
-          end
+        def apply_autocorrect(corrector, node, rhs, operator, new_rhs)
+          corrector.insert_before(node.loc.operator, operator)
+          corrector.replace(rhs, new_rhs.source)
         end
       end
     end