rubocop 0.88.0 → 0.89.1

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,23 +11,20 @@ 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.'
 
         def on_send(node)
-          return if ineligible_node?(node)
           return unless !node.arguments? && node.parenthesized?
+          return if ineligible_node?(node)
           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?`.'
 
@@ -36,9 +36,16 @@ module RuboCop
         private
 
         def implements_respond_to_missing?(node)
-          node.parent.each_child_node(node.type).any? do |sibling|
-            sibling.method?(:respond_to_missing?)
+          return false unless (grand_parent = node.parent.parent)
+
+          grand_parent.each_descendant(node.type) do |descendant|
+            return true if descendant.method?(:respond_to_missing?)
+
+            child = descendant.children.first
+            return true if child.respond_to?(:method?) && child.method?(:respond_to_missing?)
           end
+
+          false
         end
       end
     end

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

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

@@ -40,7 +40,7 @@ module RuboCop
       #   class C
       #     prepend M
       #   end
-      class MixinUsage < Cop
+      class MixinUsage < Base
         MSG = '`%<statement>s` is used at the top level. Use inside `class` ' \
               'or `module`.'
 

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

@@ -71,8 +71,9 @@ module RuboCop
       #
       # These offenses are not safe to auto-correct since there are different
       # implications to each approach.
-      class ModuleFunction < Cop
+      class ModuleFunction < Base
         include ConfigurableEnforcedStyle
+        extend AutoCorrector
 
         MODULE_FUNCTION_MSG =
           'Use `module_function` instead of `extend self`.'
@@ -89,18 +90,14 @@ module RuboCop
           return unless node.body&.begin_type?
 
           each_wrong_style(node.body.children) do |child_node|
-            add_offense(child_node)
-          end
-        end
-
-        def autocorrect(node)
-          return if style == :forbidden
+            add_offense(child_node) do |corrector|
+              next if style == :forbidden
 
-          lambda do |corrector|
-            if extend_self_node?(node)
-              corrector.replace(node, 'module_function')
-            else
-              corrector.replace(node, 'extend self')
+              if extend_self_node?(child_node)
+                corrector.replace(child_node, 'module_function')
+              else
+                corrector.replace(child_node, 'extend self')
+              end
             end
           end
         end
@@ -139,7 +136,7 @@ module RuboCop
           end
         end
 
-        def message(_node)
+        def message(_range)
           return FORBIDDEN_MSG if style == :forbidden
 
           style == :module_function ? MODULE_FUNCTION_MSG : EXTEND_SELF_MSG

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

@@ -14,9 +14,10 @@ module RuboCop
       #
       #   # good
       #   { result: 'ok' } if cond
-      class MultilineIfModifier < Cop
+      class MultilineIfModifier < Base
         include StatementModifier
         include Alignment
+        extend AutoCorrector
 
         MSG = 'Favor a normal %<keyword>s-statement over a modifier' \
               ' clause in a multiline statement.'
@@ -24,21 +25,13 @@ module RuboCop
         def on_if(node)
           return unless node.modifier_form? && node.body.multiline?
 
-          add_offense(node)
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
+          add_offense(node, message: format(MSG, keyword: node.keyword)) do |corrector|
             corrector.replace(node, to_normal_if(node))
           end
         end
 
         private
 
-        def message(node)
-          format(MSG, keyword: node.keyword)
-        end
-
         def to_normal_if(node)
           indented_body = indented_body(node.body, node)
           condition = "#{node.keyword} #{node.condition.source}"

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

@@ -16,9 +16,10 @@ module RuboCop
       #   if cond then a
       #   elsif cond then b
       #   end
-      class MultilineIfThen < Cop
+      class MultilineIfThen < Base
         include OnNormalIfUnless
         include RangeHelp
+        extend AutoCorrector
 
         NON_MODIFIER_THEN = /then\s*(#.*)?$/.freeze
 
@@ -27,15 +28,8 @@ module RuboCop
         def on_normal_if_unless(node)
           return unless non_modifier_then?(node)
 
-          add_offense(node, location: :begin,
-                            message: format(MSG, keyword: node.keyword))
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
-            corrector.remove(
-              range_with_surrounding_space(range: node.loc.begin, side: :left)
-            )
+          add_offense(node.loc.begin, message: format(MSG, keyword: node.keyword)) do |corrector|
+            corrector.remove(range_with_surrounding_space(range: node.loc.begin, side: :left))
           end
         end
 

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

@@ -30,30 +30,32 @@ module RuboCop
       #     bar
       #     baz
       #   )
-      class MultilineMemoization < Cop
+      class MultilineMemoization < Base
         include ConfigurableEnforcedStyle
+        extend AutoCorrector
 
-        MSG = 'Wrap multiline memoization blocks in `begin` and `end`.'
+        KEYWORD_MSG = 'Wrap multiline memoization blocks in `begin` and `end`.'
+        BRACES_MSG = 'Wrap multiline memoization blocks in `(` and `)`.'
 
         def on_or_asgn(node)
           _lhs, rhs = *node
 
           return unless bad_rhs?(rhs)
 
-          add_offense(rhs, location: node.source_range)
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
+          add_offense(node.source_range) do |corrector|
             if style == :keyword
-              keyword_autocorrect(node, corrector)
+              keyword_autocorrect(rhs, corrector)
             else
-              corrector.replace(node.loc.begin, '(')
-              corrector.replace(node.loc.end, ')')
+              corrector.replace(rhs.loc.begin, '(')
+              corrector.replace(rhs.loc.end, ')')
             end
           end
         end
 
+        def message(_node)
+          style == :braces ? BRACES_MSG : KEYWORD_MSG
+        end
+
         private
 
         def bad_rhs?(rhs)
@@ -77,13 +79,13 @@ module RuboCop
           if node_buf.source[node.loc.begin.end_pos] == "\n"
             'begin'
           else
-            "begin\n" + (' ' * (node.loc.column + indent))
+            "begin\n#{' ' * (node.loc.column + indent)}"
           end
         end
 
         def keyword_end_str(node, node_buf)
           if /[^\s)]/.match?(node_buf.source_line(node.loc.end.line))
-            "\n" + (' ' * node.loc.column) + 'end'
+            "\n#{' ' * node.loc.column}end"
           else
             'end'
           end