rubocop 0.78.0 → 1.13.0

data/lib/rubocop/cop/lint/redundant_string_coercion.rb

@@ -17,13 +17,14 @@ module RuboCop
       #   # good
       #
       #   "result is #{something}"
-      class RedundantStringCoercion < Cop
+      class RedundantStringCoercion < Base
         include Interpolation
+        extend AutoCorrector
 
         MSG_DEFAULT = 'Redundant use of `Object#to_s` in interpolation.'
-        MSG_SELF = 'Use `self` instead of `Object#to_s` in ' \
-                   'interpolation.'
+        MSG_SELF = 'Use `self` instead of `Object#to_s` in interpolation.'
 
+        # @!method to_s_without_args?(node)
         def_node_matcher :to_s_without_args?, '(send _ :to_s)'
 
         def on_interpolation(begin_node)
@@ -31,14 +32,12 @@ module RuboCop
 
           return unless to_s_without_args?(final_node)
 
-          add_offense(final_node, location: :selector)
-        end
+          message = final_node.receiver ? MSG_DEFAULT : MSG_SELF
 
-        def autocorrect(node)
-          lambda do |corrector|
-            receiver = node.receiver
+          add_offense(final_node.loc.selector, message: message) do |corrector|
+            receiver = final_node.receiver
             corrector.replace(
-              node.source_range,
+              final_node,
               if receiver
                 receiver.source
               else
@@ -47,12 +46,6 @@ module RuboCop
             )
           end
         end
-
-        private
-
-        def message(node)
-          node.receiver ? MSG_DEFAULT : MSG_SELF
-        end
       end
     end
   end

data/lib/rubocop/cop/lint/redundant_with_index.rb

@@ -26,12 +26,14 @@ module RuboCop
       #     v
       #   end
       #
-      class RedundantWithIndex < Cop
+      class RedundantWithIndex < Base
         include RangeHelp
+        extend AutoCorrector
 
         MSG_EACH_WITH_INDEX = 'Use `each` instead of `each_with_index`.'
         MSG_WITH_INDEX = 'Remove redundant `with_index`.'
 
+        # @!method redundant_with_index?(node)
         def_node_matcher :redundant_with_index?, <<~PATTERN
           (block
             $(send
@@ -42,20 +44,16 @@ module RuboCop
         PATTERN
 
         def on_block(node)
-          redundant_with_index?(node) do |send|
-            add_offense(node, location: with_index_range(send))
-          end
-        end
+          return unless (send = redundant_with_index?(node))
+
+          range = with_index_range(send)
 
-        def autocorrect(node)
-          lambda do |corrector|
-            redundant_with_index?(node) do |send|
-              if send.method?(:each_with_index)
-                corrector.replace(send.loc.selector, 'each')
-              else
-                corrector.remove(with_index_range(send))
-                corrector.remove(send.loc.dot)
-              end
+          add_offense(range, message: message(send)) do |corrector|
+            if send.method?(:each_with_index)
+              corrector.replace(send.loc.selector, 'each')
+            else
+              corrector.remove(range)
+              corrector.remove(send.loc.dot)
             end
           end
         end
@@ -71,10 +69,7 @@ module RuboCop
         end
 
         def with_index_range(send)
-          range_between(
-            send.loc.selector.begin_pos,
-            send.loc.expression.end_pos
-          )
+          range_between(send.loc.selector.begin_pos, send.loc.expression.end_pos)
         end
       end
     end

data/lib/rubocop/cop/lint/redundant_with_object.rb

@@ -26,13 +26,15 @@ module RuboCop
       #     v
       #   end
       #
-      class RedundantWithObject < Cop
+      class RedundantWithObject < Base
         include RangeHelp
+        extend AutoCorrector
 
         MSG_EACH_WITH_OBJECT = 'Use `each` instead of `each_with_object`.'
 
         MSG_WITH_OBJECT = 'Remove redundant `with_object`.'
 
+        # @!method redundant_with_object?(node)
         def_node_matcher :redundant_with_object?, <<~PATTERN
           (block
             $(send _ {:each_with_object :with_object}
@@ -43,20 +45,16 @@ module RuboCop
         PATTERN
 
         def on_block(node)
-          redundant_with_object?(node) do |send|
-            add_offense(node, location: with_object_range(send))
-          end
-        end
+          return unless (send = redundant_with_object?(node))
+
+          range = with_object_range(send)
 
-        def autocorrect(node)
-          lambda do |corrector|
-            redundant_with_object?(node) do |send|
-              if send.method?(:each_with_object)
-                corrector.replace(with_object_range(send), 'each')
-              else
-                corrector.remove(with_object_range(send))
-                corrector.remove(send.loc.dot)
-              end
+          add_offense(range, message: message(send)) do |corrector|
+            if send.method?(:each_with_object)
+              corrector.replace(range, 'each')
+            else
+              corrector.remove(range)
+              corrector.remove(send.loc.dot)
             end
           end
         end
@@ -72,10 +70,7 @@ module RuboCop
         end
 
         def with_object_range(send)
-          range_between(
-            send.loc.selector.begin_pos,
-            send.loc.expression.end_pos
-          )
+          range_between(send.loc.selector.begin_pos, send.loc.expression.end_pos)
         end
       end
     end

data/lib/rubocop/cop/lint/regexp_as_condition.rb

@@ -16,12 +16,14 @@ module RuboCop
       #   if /foo/ =~ $_
       #     do_something
       #   end
-      class RegexpAsCondition < Cop
+      class RegexpAsCondition < Base
+        extend AutoCorrector
+
         MSG = 'Do not use regexp literal as a condition.' \
               ' The regexp literal matches `$_` implicitly.'
 
         def on_match_current_line(node)
-          add_offense(node)
+          add_offense(node) { |corrector| corrector.replace(node, "#{node.source} =~ $_") }
         end
       end
     end

data/lib/rubocop/cop/lint/require_parentheses.rb

@@ -27,11 +27,10 @@ module RuboCop
       #   if day.is?(:tuesday) && month == :jan
       #     # ...
       #   end
-      class RequireParentheses < Cop
+      class RequireParentheses < Base
         include RangeHelp
 
-        MSG = 'Use parentheses in the method call to avoid confusion about ' \
-              'precedence.'
+        MSG = 'Use parentheses in the method call to avoid confusion about precedence.'
 
         def on_send(node)
           return if !node.arguments? || node.parenthesized?
@@ -49,10 +48,9 @@ module RuboCop
         def check_ternary(ternary, node)
           return unless ternary.condition.operator_keyword?
 
-          range = range_between(node.source_range.begin_pos,
-                                ternary.condition.source_range.end_pos)
+          range = range_between(node.source_range.begin_pos, ternary.condition.source_range.end_pos)
 
-          add_offense(range, location: range)
+          add_offense(range)
         end
 
         def check_predicate(predicate, node)

data/lib/rubocop/cop/lint/rescue_exception.rb

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for *rescue* blocks targeting the Exception class.
+      # This cop checks for `rescue` blocks targeting the Exception class.
       #
       # @example
       #
@@ -24,9 +24,8 @@ module RuboCop
       #   rescue ArgumentError
       #     handle_exception
       #   end
-      class RescueException < Cop
-        MSG = 'Avoid rescuing the `Exception` class. ' \
-              'Perhaps you meant to rescue `StandardError`?'
+      class RescueException < Base
+        MSG = 'Avoid rescuing the `Exception` class. Perhaps you meant to rescue `StandardError`?'
 
         def on_resbody(node)
           return unless node.children.first

data/lib/rubocop/cop/lint/rescue_type.rb

@@ -34,8 +34,8 @@ module RuboCop
       #   rescue NameError
       #     baz
       #   end
-      class RescueType < Cop
-        include RescueNode
+      class RescueType < Base
+        extend AutoCorrector
 
         MSG = 'Rescuing from `%<invalid_exceptions>s` will raise a ' \
               '`TypeError` instead of catching the actual exception.'
@@ -50,24 +50,20 @@ module RuboCop
           return if invalid_exceptions.empty?
 
           add_offense(
-            node,
-            location: node.loc.keyword.join(rescued.loc.expression),
-            message: format(
-              MSG, invalid_exceptions: invalid_exceptions.map(&:source)
-                                                         .join(', ')
-            )
-          )
+            node.loc.keyword.join(rescued.loc.expression),
+            message: format(MSG, invalid_exceptions: invalid_exceptions.map(&:source).join(', '))
+          ) do |corrector|
+            autocorrect(corrector, node)
+          end
         end
 
-        def autocorrect(node)
+        def autocorrect(corrector, node)
           rescued, _, _body = *node
           range = Parser::Source::Range.new(node.loc.expression.source_buffer,
                                             node.loc.keyword.end_pos,
                                             rescued.loc.expression.end_pos)
 
-          lambda do |corrector|
-            corrector.replace(range, correction(*rescued))
-          end
+          corrector.replace(range, correction(*rescued))
         end
 
         private
@@ -84,9 +80,7 @@ module RuboCop
         end
 
         def invalid_exceptions(exceptions)
-          exceptions.select do |exception|
-            INVALID_TYPES.include?(exception.type)
-          end
+          exceptions.select { |exception| INVALID_TYPES.include?(exception.type) }
         end
       end
     end

data/lib/rubocop/cop/lint/return_in_void_context.rb

@@ -31,7 +31,7 @@ module RuboCop
       #   def foo=(bar)
       #     return
       #   end
-      class ReturnInVoidContext < Cop
+      class ReturnInVoidContext < Base
         MSG = 'Do not return a value in `%<method>s`.'
 
         def on_return(return_node)
@@ -45,9 +45,7 @@ module RuboCop
 
           return unless method_name && void_context_method?(method_name)
 
-          add_offense(return_node,
-                      location: :keyword,
-                      message: format(message, method: method_name))
+          add_offense(return_node.loc.keyword, message: format(message, method: method_name))
         end
 
         private
@@ -65,8 +63,7 @@ module RuboCop
         end
 
         def setter_method?(method_name)
-          method_name.to_s.end_with?('=') &&
-            !AST::Node::COMPARISON_OPERATORS.include?(method_name)
+          method_name.to_s.end_with?('=') && !AST::Node::COMPARISON_OPERATORS.include?(method_name)
         end
       end
     end

data/lib/rubocop/cop/lint/safe_navigation_chain.rb

@@ -23,16 +23,16 @@ module RuboCop
       #
       #   x&.foo&.bar
       #   x&.foo || bar
-      class SafeNavigationChain < Cop
+      class SafeNavigationChain < Base
         include NilMethods
 
-        MSG = 'Do not chain ordinary method call' \
-              ' after safe navigation operator.'
+        MSG = 'Do not chain ordinary method call after safe navigation operator.'
 
+        # @!method bad_method?(node)
         def_node_matcher :bad_method?, <<~PATTERN
           {
             (send $(csend ...) $_ ...)
-            (send $(block (csend ...) ...) $_ ...)
+            (send $({block numblock} (csend ...) ...) $_ ...)
           }
         PATTERN
 
@@ -45,7 +45,7 @@ module RuboCop
               Parser::Source::Range.new(node.source_range.source_buffer,
                                         safe_nav.source_range.end_pos,
                                         method_chain.source_range.end_pos)
-            add_offense(node, location: location)
+            add_offense(location)
           end
         end
 
@@ -53,10 +53,7 @@ module RuboCop
 
         def method_chain(node)
           chain = node
-          while chain.send_type?
-            chain = chain.parent if chain.parent&.call_type?
-            break # FIXME: Unconditional break. Why while "loop" then?
-          end
+          chain = chain.parent if chain.send_type? && chain.parent&.call_type?
           chain
         end
       end

data/lib/rubocop/cop/lint/safe_navigation_consistency.rb

@@ -26,12 +26,12 @@ module RuboCop
       #   # good
       #   foo&.bar && (foobar.baz || foo&.baz)
       #
-      class SafeNavigationConsistency < Cop
+      class SafeNavigationConsistency < Base
         include IgnoredNode
         include NilMethods
+        extend AutoCorrector
 
-        MSG = 'Ensure that safe navigation is used consistently ' \
-          'inside of `&&` and `||`.'
+        MSG = 'Ensure that safe navigation is used consistently inside of `&&` and `||`.'
 
         def on_csend(node)
           return unless node.parent&.operator_keyword?
@@ -45,36 +45,34 @@ module RuboCop
           safe_nav_receiver = node.receiver
 
           method_calls = conditions.select(&:send_type?)
-          unsafe_method_calls =
-            unsafe_method_calls(method_calls, safe_nav_receiver)
+          unsafe_method_calls = unsafe_method_calls(method_calls, safe_nav_receiver)
 
           unsafe_method_calls.each do |unsafe_method_call|
-            location =
-              node.loc.expression.join(unsafe_method_call.loc.expression)
-            add_offense(unsafe_method_call,
-                        location: location)
+            location = location(node, unsafe_method_call)
+
+            add_offense(location) { |corrector| autocorrect(corrector, unsafe_method_call) }
 
             ignore_node(unsafe_method_call)
           end
         end
 
-        def autocorrect(node)
+        private
+
+        def autocorrect(corrector, node)
           return unless node.dot?
 
-          lambda do |corrector|
-            corrector.insert_before(node.loc.dot, '&')
-          end
+          corrector.insert_before(node.loc.dot, '&')
         end
 
-        private
+        def location(node, unsafe_method_call)
+          node.loc.expression.join(unsafe_method_call.loc.expression)
+        end
 
         def top_conditional_ancestor(node)
           parent = node.parent
           unless parent &&
                  (parent.operator_keyword? ||
-                  (parent.begin_type? &&
-                   parent.parent &&
-                   parent.parent.operator_keyword?))
+                  (parent.begin_type? && parent.parent && parent.parent.operator_keyword?))
             return node
           end
 

data/lib/rubocop/cop/lint/safe_navigation_with_empty.rb

@@ -19,10 +19,12 @@ module RuboCop
       #   return if foo && foo.empty?
       #   return unless foo && foo.empty?
       #
-      class SafeNavigationWithEmpty < Cop
-        MSG = 'Avoid calling `empty?` with the safe navigation operator ' \
-          'in conditionals.'
+      class SafeNavigationWithEmpty < Base
+        extend AutoCorrector
 
+        MSG = 'Avoid calling `empty?` with the safe navigation operator in conditionals.'
+
+        # @!method safe_navigation_empty_in_conditional?(node)
         def_node_matcher :safe_navigation_empty_in_conditional?, <<~PATTERN
           (if (csend (send ...) :empty?) ...)
         PATTERN
@@ -30,7 +32,13 @@ module RuboCop
         def on_if(node)
           return unless safe_navigation_empty_in_conditional?(node)
 
-          add_offense(node)
+          condition = node.condition
+
+          add_offense(condition) do |corrector|
+            receiver = condition.receiver.source
+
+            corrector.replace(condition, "#{receiver} && #{receiver}.#{condition.method_name}")
+          end
         end
       end
     end