rubocop 0.89.0 → 0.89.1

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

@@ -46,8 +46,9 @@ module RuboCop
       #   f = ->(x) do
       #         x
       #       end
-      class Lambda < Cop
+      class Lambda < Base
         include ConfigurableEnforcedStyle
+        extend AutoCorrector
 
         LITERAL_MESSAGE = 'Use the `-> { ... }` lambda literal syntax for ' \
                           '%<modifier>s lambdas.'
@@ -69,21 +70,15 @@ module RuboCop
 
           return unless offending_selector?(node, selector)
 
-          add_offense(node,
-                      location: node.send_node.source_range,
-                      message: message(node, selector))
-        end
-        alias on_numblock on_block
-
-        def autocorrect(node)
-          if node.send_node.source == 'lambda'
-            lambda do |corrector|
+          add_offense(node.send_node.source_range, message: message(node, selector)) do |corrector|
+            if node.send_node.source == 'lambda'
               autocorrect_method_to_literal(corrector, node)
+            else
+              LambdaLiteralToMethodCorrector.new(node).call(corrector)
             end
-          else
-            LambdaLiteralToMethodCorrector.new(node)
           end
         end
+        alias on_numblock on_block
 
         private
 

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

@@ -18,30 +18,31 @@ module RuboCop
       #
       #  # good
       #  lambda.(x, y)
-      class LambdaCall < Cop
+      class LambdaCall < Base
         include ConfigurableEnforcedStyle
+        extend AutoCorrector
 
         def on_send(node)
           return unless node.receiver && node.method?(:call)
 
-          if offense?(node)
-            add_offense(node) { opposite_style_detected }
+          if offense?(node) && opposite_style_detected
+            add_offense(node) do |corrector|
+              autocorrect(corrector, node)
+            end
           else
             correct_style_detected
           end
         end
 
-        def autocorrect(node)
-          lambda do |corrector|
-            if explicit_style?
-              receiver = node.receiver.source
-              replacement = node.source.sub("#{receiver}.", "#{receiver}.call")
+        def autocorrect(corrector, node)
+          if explicit_style?
+            receiver = node.receiver.source
+            replacement = node.source.sub("#{receiver}.", "#{receiver}.call")
 
-              corrector.replace(node, replacement)
-            else
-              add_parentheses(node, corrector) unless node.parenthesized?
-              corrector.remove(node.loc.selector)
-            end
+            corrector.replace(node, replacement)
+          else
+            add_parentheses(node, corrector) unless node.parenthesized?
+            corrector.remove(node.loc.selector)
           end
         end
 

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

@@ -19,8 +19,9 @@ module RuboCop
       #   some_str = 'ala' \
       #              'bala'
       #
-      class LineEndConcatenation < Cop
+      class LineEndConcatenation < Base
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Use `\\` instead of `+` or `<<` to concatenate ' \
               'those strings.'
@@ -36,25 +37,12 @@ module RuboCop
           [Style::RedundantInterpolation]
         end
 
-        def investigate(processed_source)
+        def on_new_investigation
           processed_source.tokens.each_index do |index|
             check_token_set(index)
           end
         end
 
-        def autocorrect(operator_range)
-          # Include any trailing whitespace so we don't create a syntax error.
-          operator_range = range_with_surrounding_space(range: operator_range,
-                                                        side: :right,
-                                                        newlines: false)
-          one_more_char = operator_range.resize(operator_range.size + 1)
-          # Don't create a double backslash at the end of the line, in case
-          # there already was a backslash after the concatenation operator.
-          operator_range = one_more_char if one_more_char.source.end_with?('\\')
-
-          ->(corrector) { corrector.replace(operator_range, '\\') }
-        end
-
         private
 
         def check_token_set(index)
@@ -68,7 +56,22 @@ module RuboCop
 
           return unless eligible_next_successor?(next_successor)
 
-          add_offense(operator.pos, location: operator.pos)
+          add_offense(operator.pos) do |corrector|
+            autocorrect(corrector, operator.pos)
+          end
+        end
+
+        def autocorrect(corrector, operator_range)
+          # Include any trailing whitespace so we don't create a syntax error.
+          operator_range = range_with_surrounding_space(range: operator_range,
+                                                        side: :right,
+                                                        newlines: false)
+          one_more_char = operator_range.resize(operator_range.size + 1)
+          # Don't create a double backslash at the end of the line, in case
+          # there already was a backslash after the concatenation operator.
+          operator_range = one_more_char if one_more_char.source.end_with?('\\')
+
+          corrector.replace(operator_range, '\\')
         end
 
         def eligible_token_set?(predecessor, operator, successor)

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

@@ -143,10 +143,11 @@ module RuboCop
       #
       #   # good
       #   Array 1
-      class MethodCallWithArgsParentheses < Cop
+      class MethodCallWithArgsParentheses < Base
         include ConfigurableEnforcedStyle
         include IgnoredMethods
         include IgnoredPattern
+        extend AutoCorrector
 
         def initialize(*)
           super

data/lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb

@@ -15,14 +15,7 @@ module RuboCop
             return if allowed_camel_case_method_call?(node)
             return if legitimate_call_with_parentheses?(node)
 
-            add_offense(node, location: node.loc.begin.join(node.loc.end))
-          end
-          alias on_csend on_send
-          alias on_super on_send
-          alias on_yield on_send
-
-          def autocorrect(node)
-            lambda do |corrector|
+            add_offense(offense_range(node)) do |corrector|
               if parentheses_at_the_end_of_multiline_call?(node)
                 corrector.replace(args_begin(node), ' \\')
               else
@@ -31,13 +24,20 @@ module RuboCop
               corrector.remove(node.loc.end)
             end
           end
+          alias on_csend on_send
+          alias on_super on_send
+          alias on_yield on_send
+
+          private
+
+          def offense_range(node)
+            node.loc.begin.join(node.loc.end)
+          end
 
-          def message(_node = nil)
+          def message(_range = nil)
             'Omit parentheses for method calls with arguments.'
           end
 
-          private
-
           def super_call_without_arguments?(node)
             node.super_type? && node.arguments.none?
           end

data/lib/rubocop/cop/style/method_call_with_args_parentheses/require_parentheses.rb

@@ -12,19 +12,15 @@ module RuboCop
             return if eligible_for_parentheses_omission?(node)
             return unless node.arguments? && !node.parenthesized?
 
-            add_offense(node)
-          end
-          alias on_csend on_send
-          alias on_super on_send
-          alias on_yield on_send
-
-          def autocorrect(node)
-            lambda do |corrector|
+            add_offense(node) do |corrector|
               corrector.replace(args_begin(node), '(')
 
               corrector.insert_after(args_end(node), ')') unless args_parenthesized?(node)
             end
           end
+          alias on_csend on_send
+          alias on_super on_send
+          alias on_yield on_send
 
           def message(_node = nil)
             'Use parentheses for method calls with arguments.'

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

@@ -11,8 +11,9 @@ module RuboCop
       #
       #   # good
       #   object.some_method
-      class MethodCallWithoutArgsParentheses < Cop
+      class MethodCallWithoutArgsParentheses < Base
         include IgnoredMethods
+        extend AutoCorrector
 
         MSG = 'Do not use parentheses for method calls with ' \
               'no arguments.'
@@ -23,11 +24,7 @@ module RuboCop
           return if ignored_method?(node.method_name)
           return if same_name_assignment?(node)
 
-          add_offense(node, location: node.loc.begin.join(node.loc.end))
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
+          add_offense(offense_range(node)) do |corrector|
             corrector.remove(node.loc.begin)
             corrector.remove(node.loc.end)
           end
@@ -69,6 +66,10 @@ module RuboCop
 
           var_nodes.any? { |n| n.to_a.first == variable_name }
         end
+
+        def offense_range(node)
+          node.loc.begin.join(node.loc.end)
+        end
       end
     end
   end

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

@@ -12,7 +12,7 @@ module RuboCop
       #   a do
       #     b
       #   end.c
-      class MethodCalledOnDoEndBlock < Cop
+      class MethodCalledOnDoEndBlock < Base
         include RangeHelp
 
         MSG = 'Avoid chaining a method call on a do...end block.'
@@ -37,7 +37,7 @@ module RuboCop
           range = range_between(receiver.loc.end.begin_pos,
                                 node.source_range.end_pos)
 
-          add_offense(nil, location: range)
+          add_offense(range)
         end
         alias on_csend on_send
       end

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

@@ -84,9 +84,10 @@ module RuboCop
       #           last_descriptive_var_name)
       #     do_something
       #   end
-      class MethodDefParentheses < Cop
+      class MethodDefParentheses < Base
         include ConfigurableEnforcedStyle
         include RangeHelp
+        extend AutoCorrector
 
         MSG_PRESENT = 'Use def without parentheses.'
         MSG_MISSING = 'Use def with parentheses when there are ' \
@@ -109,17 +110,6 @@ module RuboCop
         end
         alias on_defs on_def
 
-        def autocorrect(node)
-          lambda do |corrector|
-            if node.args_type?
-              # offense is registered on args node when parentheses are unwanted
-              correct_arguments(node, corrector)
-            else
-              correct_definition(node, corrector)
-            end
-          end
-        end
-
         private
 
         def correct_arguments(arg_node, corrector)
@@ -150,14 +140,19 @@ module RuboCop
         def missing_parentheses(node)
           location = node.arguments.source_range
 
-          add_offense(node, location: location, message: MSG_MISSING) do
-            unexpected_style_detected(:require_no_parentheses)
+          return unless unexpected_style_detected(:require_no_parentheses)
+
+          add_offense(location, message: MSG_MISSING) do |corrector|
+            correct_definition(node, corrector)
           end
         end
 
         def unwanted_parentheses(args)
-          add_offense(args, message: MSG_PRESENT) do
-            unexpected_style_detected(:require_parentheses)
+          return unless unexpected_style_detected(:require_parentheses)
+
+          add_offense(args, message: MSG_PRESENT) do |corrector|
+            # offense is registered on args node when parentheses are unwanted
+            correct_arguments(args, corrector)
           end
         end
       end

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

@@ -14,27 +14,23 @@ module RuboCop
       #   # good
       #   bar = foo.minmax
       #   return foo.minmax
-      class MinMax < Cop
+      class MinMax < Base
+        extend AutoCorrector
+
         MSG = 'Use `%<receiver>s.minmax` instead of `%<offender>s`.'
 
         def on_array(node)
           min_max_candidate(node) do |receiver|
             offender = offending_range(node)
 
-            add_offense(node, location: offender,
-                              message: message(offender, receiver))
-          end
-        end
-        alias on_return on_array
-
-        def autocorrect(node)
-          receiver = node.children.first.receiver
+            add_offense(offender, message: message(offender, receiver)) do |corrector|
+              receiver = node.children.first.receiver
 
-          lambda do |corrector|
-            corrector.replace(offending_range(node),
-                              "#{receiver.source}.minmax")
+              corrector.replace(offending_range(node), "#{receiver.source}.minmax")
+            end
           end
         end
+        alias on_return on_array
 
         private
 

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

@@ -93,7 +93,7 @@ module RuboCop
       #   else
       #     # the content of `else` branch will be determined by Style/EmptyElse
       #   end
-      class MissingElse < Cop
+      class MissingElse < Base
         include OnNormalIfUnless
         include ConfigurableEnforcedStyle
 
@@ -119,20 +119,20 @@ module RuboCop
         private
 
         def check(node)
-          add_offense(node) unless node.else?
+          return if node.else?
+
+          add_offense(node, message: format(message_template, type: node.type))
         end
 
-        def message(node)
-          template = case empty_else_style
-                     when :empty
-                       MSG_NIL
-                     when :nil
-                       MSG_EMPTY
-                     else
-                       MSG
-                     end
-
-          format(template, type: node.type)
+        def message_template
+          case empty_else_style
+          when :empty
+            MSG_NIL
+          when :nil
+            MSG_EMPTY
+          else
+            MSG
+          end
         end
 
         def if_style?

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

@@ -21,7 +21,7 @@ module RuboCop
       #     # ...
       #   end
       #
-      class MissingRespondToMissing < Cop
+      class MissingRespondToMissing < Base
         MSG =
           'When using `method_missing`, define `respond_to_missing?`.'
 

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

@@ -30,8 +30,9 @@ module RuboCop
       #   class Foo
       #     extend Qox, Bar
       #   end
-      class MixinGrouping < Cop
+      class MixinGrouping < Base
         include ConfigurableEnforcedStyle
+        extend AutoCorrector
 
         MIXIN_METHODS = %i[extend include prepend].freeze
         MSG = 'Put `%<mixin>s` mixins in %<suffix>s.'
@@ -47,23 +48,6 @@ module RuboCop
 
         alias on_module on_class
 
-        def autocorrect(node)
-          range = node.loc.expression
-          if separated_style?
-            correction = separate_mixins(node)
-          else
-            mixins = sibling_mixins(node)
-            if node == mixins.first
-              correction = group_mixins(node, mixins)
-            else
-              range = range_to_remove_for_subsequent_mixin(mixins, node)
-              correction = ''
-            end
-          end
-
-          ->(corrector) { corrector.replace(range, correction) }
-        end
-
         private
 
         def range_to_remove_for_subsequent_mixin(mixins, node)
@@ -89,13 +73,33 @@ module RuboCop
         def check_grouped_style(send_node)
           return if sibling_mixins(send_node).size == 1
 
-          add_offense(send_node)
+          message = format(MSG, mixin: send_node.method_name, suffix: 'a single statement')
+
+          add_offense(send_node, message: message) do |corrector|
+            range = send_node.loc.expression
+            mixins = sibling_mixins(send_node)
+            if send_node == mixins.first
+              correction = group_mixins(send_node, mixins)
+            else
+              range = range_to_remove_for_subsequent_mixin(mixins, send_node)
+              correction = ''
+            end
+
+            corrector.replace(range, correction)
+          end
         end
 
         def check_separated_style(send_node)
           return if send_node.arguments.one?
 
-          add_offense(send_node)
+          message = format(MSG, mixin: send_node.method_name, suffix: 'separate statements')
+
+          add_offense(send_node, message: message) do |corrector|
+            range = send_node.loc.expression
+            correction = separate_mixins(send_node)
+
+            corrector.replace(range, correction)
+          end
         end
 
         def sibling_mixins(send_node)
@@ -107,13 +111,6 @@ module RuboCop
           end
         end
 
-        def message(send_node)
-          suffix =
-            separated_style? ? 'separate statements' : 'a single statement'
-
-          format(MSG, mixin: send_node.method_name, suffix: suffix)
-        end
-
         def grouped_style?
           style == :grouped
         end