rubocop 0.89.0 → 0.89.1

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

@@ -19,7 +19,7 @@ module RuboCop
       #   FOO = 2
       #   foo = 2
       #   $stdin.read
-      class GlobalVars < Cop
+      class GlobalVars < Base
         MSG = 'Do not introduce global variables.'
 
         # built-in global variables and their English aliases
@@ -72,7 +72,7 @@ module RuboCop
         def check(node)
           global_var, = *node
 
-          add_offense(node, location: :name) unless allowed_var?(global_var)
+          add_offense(node.loc.name) unless allowed_var?(global_var)
         end
       end
     end

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

@@ -46,7 +46,7 @@ module RuboCop
       #   # good
       #   foo || raise('exception') if something
       #   ok
-      class GuardClause < Cop
+      class GuardClause < Base
         include MinBodyLength
         include StatementModifier
 
@@ -105,9 +105,8 @@ module RuboCop
             example = "#{conditional_keyword} #{condition.source}; " \
                       "#{scope_exiting_keyword}; end"
           end
-          add_offense(node,
-                      location: :keyword,
-                      message: format(MSG, example: example))
+
+          add_offense(node.loc.keyword, message: format(MSG, example: example))
         end
 
         def guard_clause_source(guard_clause)

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

@@ -40,7 +40,7 @@ module RuboCop
           parent = node.parent
           return false unless parent
 
-          parent.array_type? && parent.values.last == node
+          parent.array_type? && parent.children.last.equal?(node)
         end
 
         def check_braces(node)

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

@@ -17,8 +17,9 @@ module RuboCop
       #   # good
       #   hash.each_key { |k| p k }
       #   hash.each_value { |v| p v }
-      class HashEachMethods < Cop
+      class HashEachMethods < Base
         include Lint::UnusedArgument
+        extend AutoCorrector
 
         MSG = 'Use `%<prefer>s` instead of `%<current>s`.'
 
@@ -30,12 +31,6 @@ module RuboCop
           register_kv_offense(node)
         end
 
-        def autocorrect(node)
-          lambda do |corrector|
-            correct_key_value_each(node, corrector)
-          end
-        end
-
         private
 
         def register_kv_offense(node)
@@ -45,7 +40,9 @@ module RuboCop
             msg = format(message, prefer: "each_#{method[0..-2]}",
                                   current: "#{method}.each")
 
-            add_offense(target, location: kv_range(target), message: msg)
+            add_offense(kv_range(target), message: msg) do |corrector|
+              correct_key_value_each(target, corrector)
+            end
           end
         end
 

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

@@ -62,7 +62,6 @@ module RuboCop
         MSG_NO_MIXED_KEYS = "Don't mix styles in the same hash."
         MSG_HASH_ROCKETS = 'Use hash rockets syntax.'
 
-        # rubocop:disable Metrics/PerceivedComplexity, Metrics/AbcSize
         def on_hash(node)
           pairs = node.pairs
 
@@ -78,7 +77,6 @@ module RuboCop
             ruby19_check(pairs)
           end
         end
-        # rubocop:enable Metrics/PerceivedComplexity, Metrics/AbcSize
 
         def ruby19_check(pairs)
           check(pairs, '=>', MSG_19) if sym_indices?(pairs)

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

@@ -23,9 +23,10 @@ module RuboCop
       #   # good
       #   {a: 1, b: 2}.transform_keys { |k| foo(k) }
       #   {a: 1, b: 2}.transform_keys { |k| k.to_s }
-      class HashTransformKeys < Cop
-        extend TargetRubyVersion
+      class HashTransformKeys < Base
         include HashTransformMethod
+        extend TargetRubyVersion
+        extend AutoCorrector
 
         minimum_target_ruby_version 2.5
 

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

@@ -23,8 +23,9 @@ module RuboCop
       #   # good
       #   {a: 1, b: 2}.transform_values { |v| foo(v) }
       #   {a: 1, b: 2}.transform_values { |v| v * v }
-      class HashTransformValues < Cop
+      class HashTransformValues < Base
         include HashTransformMethod
+        extend AutoCorrector
 
         def_node_matcher :on_bad_each_with_object, <<~PATTERN
           (block

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

@@ -62,7 +62,7 @@ module RuboCop
       #     do_x
       #     do_z
       #   end
-      class IdenticalConditionalBranches < Cop
+      class IdenticalConditionalBranches < Base
         MSG = 'Move `%<source>s` out of the conditional.'
 
         def on_if(node)

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

@@ -58,7 +58,7 @@ module RuboCop
       #     action_b
       #   end
       #
-      class IfInsideElse < Cop
+      class IfInsideElse < Base
         MSG = 'Convert `if` nested inside `else` to `elsif`.'
 
         def on_if(node)
@@ -69,7 +69,7 @@ module RuboCop
           return unless else_branch&.if_type? && else_branch&.if?
           return if allow_if_modifier_in_else_branch?(else_branch)
 
-          add_offense(else_branch, location: :keyword)
+          add_offense(else_branch.loc.keyword)
         end
 
         private

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

@@ -30,10 +30,11 @@ module RuboCop
       #   if long_condition
       #     do_something_in_a_method_with_a_long_name(arg)
       #   end
-      class IfUnlessModifier < Cop
+      class IfUnlessModifier < Base
         include StatementModifier
         include LineLengthHelp
         include IgnoredPattern
+        extend AutoCorrector
 
         MSG_USE_MODIFIER = 'Favor modifier `%<keyword>s` usage when having a ' \
                            'single-line body. Another good alternative is ' \
@@ -49,22 +50,22 @@ module RuboCop
                 end
           return unless msg
 
-          add_offense(node,
-                      location: :keyword,
-                      message: format(msg, keyword: node.keyword))
+          add_offense(node.loc.keyword, message: format(msg, keyword: node.keyword)) do |corrector|
+            autocorrect(corrector, node)
+          end
         end
 
-        def autocorrect(node)
+        private
+
+        def autocorrect(corrector, node)
           replacement = if node.modifier_form?
                           to_normal_form(node)
                         else
                           to_modifier_form(node)
                         end
-          ->(corrector) { corrector.replace(node, replacement) }
+          corrector.replace(node, replacement)
         end
 
-        private
-
         def too_long_due_to_modifier?(node)
           node.modifier_form? && too_long_single_line?(node) &&
             !another_statement_on_same_line?(node)
@@ -158,10 +159,7 @@ module RuboCop
         end
 
         def first_line_comment(node)
-          comment =
-            processed_source.find_comment { |c| c.loc.line == node.loc.line }
-
-          comment ? comment.loc.expression.source : nil
+          processed_source.comment_at_line(node.loc.line)&.text
         end
       end
     end

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

@@ -22,20 +22,16 @@ module RuboCop
       #  if running?
       #    tired? ? 'stop' : 'go faster'
       #  end
-      class IfUnlessModifierOfIfUnless < Cop
+      class IfUnlessModifierOfIfUnless < Base
         include StatementModifier
+        extend AutoCorrector
 
         MSG = 'Avoid modifier `%<keyword>s` after another conditional.'
 
         def on_if(node)
           return unless node.modifier_form? && node.body.if_type?
 
-          add_offense(node, location: :keyword,
-                            message: format(MSG, keyword: node.keyword))
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
+          add_offense(node.loc.keyword, message: format(MSG, keyword: node.keyword)) do |corrector|
             keyword = node.if? ? 'if' : 'unless'
 
             corrector.replace(node, <<~RUBY.chop)

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

@@ -13,8 +13,9 @@ module RuboCop
       #   # good
       #   result = some_condition ? something : another_thing
       #
-      class IfWithSemicolon < Cop
+      class IfWithSemicolon < Base
         include OnNormalIfUnless
+        extend AutoCorrector
 
         MSG = 'Do not use if x; Use the ternary operator instead.'
 
@@ -24,11 +25,7 @@ module RuboCop
           beginning = node.loc.begin
           return unless beginning&.is?(';')
 
-          add_offense(node)
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
+          add_offense(node) do |corrector|
             corrector.replace(node, correct_to_ternary(node))
           end
         end

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

@@ -14,7 +14,7 @@ module RuboCop
       #
       #   # good
       #   raise ArgumentError, 'Error message here'
-      class ImplicitRuntimeError < Cop
+      class ImplicitRuntimeError < Base
         MSG = 'Use `%<method>s` with an explicit exception class and message,' \
               ' rather than just a message.'
 

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

@@ -15,13 +15,15 @@ module RuboCop
       #   loop do
       #     work
       #   end
-      class InfiniteLoop < Cop
+      class InfiniteLoop < Base
+        extend AutoCorrector
+
         LEADING_SPACE = /\A(\s*)/.freeze
 
         MSG = 'Use `Kernel#loop` for infinite loops.'
 
-        def join_force?(force_class)
-          force_class == VariableForce
+        def self.joining_forces
+          VariableForce
         end
 
         def after_leaving_scope(scope, _variable_table)
@@ -40,16 +42,6 @@ module RuboCop
         alias on_while_post on_while
         alias on_until_post on_until
 
-        def autocorrect(node)
-          if node.while_post_type? || node.until_post_type?
-            replace_begin_end_with_modifier(node)
-          elsif node.modifier_form?
-            replace_source(node.source_range, modifier_replacement(node))
-          else
-            replace_source(non_modifier_range(node), 'loop do')
-          end
-        end
-
         private
 
         def while_or_until(node)
@@ -66,7 +58,19 @@ module RuboCop
             referenced_after_loop?(var, range)
           end
 
-          add_offense(node, location: :keyword)
+          add_offense(node.loc.keyword) do |corrector|
+            autocorrect(corrector, node)
+          end
+        end
+
+        def autocorrect(corrector, node)
+          if node.while_post_type? || node.until_post_type?
+            replace_begin_end_with_modifier(corrector, node)
+          elsif node.modifier_form?
+            replace_source(corrector, node.source_range, modifier_replacement(node))
+          else
+            replace_source(corrector, non_modifier_range(node), 'loop do')
+          end
         end
 
         def assigned_inside_loop?(var, range)
@@ -83,17 +87,13 @@ module RuboCop
           var.references.any? { |r| r.node.source_range.begin_pos > e }
         end
 
-        def replace_begin_end_with_modifier(node)
-          lambda do |corrector|
-            corrector.replace(node.body.loc.begin, 'loop do')
-            corrector.remove(node.body.loc.end.end.join(node.source_range.end))
-          end
+        def replace_begin_end_with_modifier(corrector, node)
+          corrector.replace(node.body.loc.begin, 'loop do')
+          corrector.remove(node.body.loc.end.end.join(node.source_range.end))
         end
 
-        def replace_source(range, replacement)
-          lambda do |corrector|
-            corrector.replace(range, replacement)
-          end
+        def replace_source(corrector, range, replacement)
+          corrector.replace(range, replacement)
         end
 
         def modifier_replacement(node)

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

@@ -17,11 +17,11 @@ module RuboCop
       #   foo.each do |f|
       #     f.bar # Trailing inline comment
       #   end
-      class InlineComment < Cop
+      class InlineComment < Base
         MSG = 'Avoid trailing inline comments.'
 
-        def investigate(processed_source)
-          processed_source.each_comment do |comment|
+        def on_new_investigation
+          processed_source.comments.each do |comment|
             next if comment_line?(processed_source[comment.loc.line - 1]) ||
                     comment.text.match?(/\A# rubocop:(enable|disable)/)
 

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

@@ -33,9 +33,10 @@ module RuboCop
       #     next if f.zero?
       #     f != 1
       #   end
-      class InverseMethods < Cop
+      class InverseMethods < Base
         include IgnoredNode
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Use `%<inverse>s` instead of inverting `%<method>s`.'
         CLASS_COMPARISON_METHODS = %i[<= >= < >].freeze
@@ -70,9 +71,9 @@ module RuboCop
             return if part_of_ignored_node?(node)
             return if possible_class_hierarchy_check?(lhs, rhs, method)
 
-            add_offense(node,
-                        message: format(MSG, method: method,
-                                             inverse: inverse_methods[method]))
+            add_offense(node, message: message(method, inverse_methods[method])) do |corrector|
+              correct_inverse_method(corrector, node)
+            end
           end
         end
 
@@ -86,40 +87,28 @@ module RuboCop
             # offense, such as `y.reject { |key, _value| !(key =~ /c\d/) }`,
             # can cause auto-correction to apply improper corrections.
             ignore_node(block)
-            add_offense(node,
-                        message: format(MSG, method: method,
-                                             inverse: inverse_blocks[method]))
+            add_offense(node, message: message(method, inverse_blocks[method])) do |corrector|
+              correct_inverse_block(corrector, node)
+            end
           end
         end
 
-        def autocorrect(node)
-          if node.block_type?
-            correct_inverse_block(node)
-          elsif node.send_type?
-            correct_inverse_method(node)
-          end
-        end
+        private
 
-        def correct_inverse_method(node)
+        def correct_inverse_method(corrector, node)
           method_call, _lhs, method, _rhs = inverse_candidate?(node)
           return unless method_call && method
 
-          lambda do |corrector|
-            corrector.remove(not_to_receiver(node, method_call))
-            corrector.replace(method_call.loc.selector,
-                              inverse_methods[method].to_s)
-            remove_end_parenthesis(corrector, node, method, method_call)
-          end
+          corrector.remove(not_to_receiver(node, method_call))
+          corrector.replace(method_call.loc.selector, inverse_methods[method].to_s)
+          remove_end_parenthesis(corrector, node, method, method_call)
         end
 
-        def correct_inverse_block(node)
+        def correct_inverse_block(corrector, node)
           method_call, method, block = inverse_block?(node)
 
-          lambda do |corrector|
-            corrector.replace(method_call.loc.selector,
-                              inverse_blocks[method].to_s)
-            correct_inverse_selector(block, corrector)
-          end
+          corrector.replace(method_call.loc.selector, inverse_blocks[method].to_s)
+          correct_inverse_selector(block, corrector)
         end
 
         def correct_inverse_selector(block, corrector)
@@ -139,8 +128,6 @@ module RuboCop
           end
         end
 
-        private
-
         def inverse_methods
           @inverse_methods ||= cop_config['InverseMethods']
                                .merge(cop_config['InverseMethods'].invert)
@@ -190,6 +177,10 @@ module RuboCop
 
           corrector.remove(end_parentheses(node, method_call))
         end
+
+        def message(method, inverse)
+          format(MSG, method: method, inverse: inverse)
+        end
       end
     end
   end