rubocop 0.89.1 → 0.93.0

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

@@ -15,20 +15,17 @@ module RuboCop
       #     extend self
       #   end
       #
-      class TrailingBodyOnModule < Cop
+      class TrailingBodyOnModule < Base
         include Alignment
         include TrailingBody
+        extend AutoCorrector
 
         MSG = 'Place the first line of module body on its own line.'
 
         def on_module(node)
           return unless trailing_body?(node)
 
-          add_offense(node, location: first_part_of(node.to_a.last))
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
+          add_offense(first_part_of(node.to_a.last)) do |corrector|
             LineBreakCorrector.correct_trailing_body(
               configured_width: configured_indentation_width,
               corrector: corrector,

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

@@ -84,8 +84,9 @@ module RuboCop
       #     1,
       #     2
       #   )
-      class TrailingCommaInArguments < Cop
+      class TrailingCommaInArguments < Base
         include TrailingComma
+        extend AutoCorrector
 
         def on_send(node)
           return unless node.arguments? && node.parenthesized?
@@ -96,10 +97,6 @@ module RuboCop
         end
         alias on_csend on_send
 
-        def autocorrect(range)
-          PunctuationCorrector.swap_comma(range)
-        end
-
         def self.autocorrect_incompatible_with
           [Layout::HeredocArgumentClosingParenthesis]
         end

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

@@ -81,18 +81,15 @@ module RuboCop
       #     1,
       #     2
       #   ]
-      class TrailingCommaInArrayLiteral < Cop
+      class TrailingCommaInArrayLiteral < Base
         include TrailingComma
+        extend AutoCorrector
 
         def on_array(node)
           return unless node.square_brackets?
 
           check_literal(node, 'item of %<article>s array')
         end
-
-        def autocorrect(range)
-          PunctuationCorrector.swap_comma(range)
-        end
       end
     end
   end

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

@@ -40,20 +40,21 @@ module RuboCop
       #   add do
       #     foo + bar
       #   end
-      class TrailingCommaInBlockArgs < Cop
+      class TrailingCommaInBlockArgs < Base
+        extend AutoCorrector
+
         MSG = 'Useless trailing comma present in block arguments.'
 
         def on_block(node)
           # lambda literal (`->`) never has block arguments.
           return if node.send_node.lambda_literal?
-
           return unless useless_trailing_comma?(node)
 
-          add_offense(node, location: last_comma(node).pos)
-        end
+          last_comma_pos = last_comma(node).pos
 
-        def autocorrect(node)
-          ->(corrector) { corrector.replace(last_comma(node).pos, '') }
+          add_offense(last_comma_pos) do |corrector|
+            corrector.replace(last_comma_pos, '')
+          end
         end
 
         private
@@ -75,12 +76,13 @@ module RuboCop
         end
 
         def argument_tokens(node)
-          pipes = tokens(node).select { |token| token.type == :tPIPE }
+          tokens = processed_source.tokens_within(node)
+          pipes = tokens.select { |token| token.type == :tPIPE }
           begin_pos, end_pos = pipes.map do |pipe|
-            tokens(node).index(pipe)
+            tokens.index(pipe)
           end
 
-          tokens(node)[begin_pos + 1..end_pos - 1]
+          tokens[begin_pos + 1..end_pos - 1]
         end
       end
     end

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

@@ -84,16 +84,13 @@ module RuboCop
       #     foo: 1,
       #     bar: 2
       #   }
-      class TrailingCommaInHashLiteral < Cop
+      class TrailingCommaInHashLiteral < Base
         include TrailingComma
+        extend AutoCorrector
 
         def on_hash(node)
           check_literal(node, 'item of %<article>s hash')
         end
-
-        def autocorrect(range)
-          PunctuationCorrector.swap_comma(range)
-        end
       end
     end
   end

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

@@ -28,9 +28,10 @@ module RuboCop
       #   # bad
       #   a, b, _something = foo()
       #
-      class TrailingUnderscoreVariable < Cop
+      class TrailingUnderscoreVariable < Base
         include SurroundingSpace
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Do not use trailing `_`s in parallel assignment. ' \
               'Prefer `%<code>s`.'
@@ -44,17 +45,9 @@ module RuboCop
             offset = range.begin_pos - node.source_range.begin_pos
             good_code[offset, range.size] = ''
 
-            add_offense(node,
-                        location: range,
-                        message: format(MSG, code: good_code))
-          end
-        end
-
-        def autocorrect(node)
-          ranges = unneeded_ranges(node)
-
-          lambda do |corrector|
-            ranges.each { |range| corrector.remove(range) if range }
+            add_offense(range, message: format(MSG, code: good_code)) do |corrector|
+              corrector.remove(range)
+            end
           end
         end
 
@@ -75,11 +68,9 @@ module RuboCop
 
             var, = *variable
             var, = *var
-            if allow_named_underscore_variables
-              break offense unless var == :_
-            else
-              break offense unless var.to_s.start_with?(UNDERSCORE)
-            end
+
+            break offense if (allow_named_underscore_variables && var != :_) ||
+                             !var.to_s.start_with?(UNDERSCORE)
 
             variable
           end

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

@@ -27,8 +27,9 @@ module RuboCop
       #   class << self
       #     attr_reader :baz
       #   end
-      class TrivialAccessors < Cop
+      class TrivialAccessors < Base
         include AllowedMethods
+        extend AutoCorrector
 
         MSG = 'Use `attr_%<kind>s` to define trivial %<kind>s methods.'
 
@@ -41,17 +42,6 @@ module RuboCop
         end
         alias on_defs on_def
 
-        def autocorrect(node)
-          parent = node.parent
-          return if parent&.send_type?
-
-          if node.def_type?
-            autocorrect_instance(node)
-          elsif node.defs_type? && node.children.first.self_type?
-            autocorrect_class(node)
-          end
-        end
-
         private
 
         def in_module_or_instance_eval?(node)
@@ -76,9 +66,20 @@ module RuboCop
                  end
           return unless kind
 
-          add_offense(node,
-                      location: :keyword,
-                      message: format(MSG, kind: kind))
+          add_offense(node.loc.keyword, message: format(MSG, kind: kind)) do |corrector|
+            autocorrect(corrector, node)
+          end
+        end
+
+        def autocorrect(corrector, node)
+          parent = node.parent
+          return if parent&.send_type?
+
+          if node.def_type?
+            autocorrect_instance(corrector, node)
+          elsif node.defs_type? && node.children.first.self_type?
+            autocorrect_class(corrector, node)
+          end
         end
 
         def exact_name_match?
@@ -156,31 +157,26 @@ module RuboCop
           "attr_#{kind} :#{method_name.to_s.chomp('=')}"
         end
 
-        def autocorrect_instance(node)
+        def autocorrect_instance(corrector, node)
           kind = trivial_accessor_kind(node)
 
           return unless names_match?(node) && !node.predicate_method? && kind
 
-          lambda do |corrector|
-            corrector.replace(node,
-                              accessor(kind, node.method_name))
-          end
+          corrector.replace(node, accessor(kind, node.method_name))
         end
 
-        def autocorrect_class(node)
+        def autocorrect_class(corrector, node)
           kind = trivial_accessor_kind(node)
 
           return unless names_match?(node) && kind
 
-          lambda do |corrector|
-            indent = ' ' * node.loc.column
-            corrector.replace(
-              node.source_range,
-              ['class << self',
-               "#{indent}  #{accessor(kind, node.method_name)}",
-               "#{indent}end"].join("\n")
-            )
-          end
+          indent = ' ' * node.loc.column
+          corrector.replace(
+            node.source_range,
+            ['class << self',
+             "#{indent}  #{accessor(kind, node.method_name)}",
+             "#{indent}end"].join("\n")
+          )
         end
 
         def top_level_node?(node)

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

@@ -19,8 +19,9 @@ module RuboCop
       #   else
       #     # do a different thing...
       #   end
-      class UnlessElse < Cop
+      class UnlessElse < Base
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Do not use `unless` with `else`. Rewrite these with the ' \
               'positive case first.'
@@ -28,14 +29,10 @@ module RuboCop
         def on_if(node)
           return unless node.unless? && node.else?
 
-          add_offense(node)
-        end
-
-        def autocorrect(node)
-          body_range = range_between_condition_and_else(node, node.condition)
-          else_range = range_between_else_and_end(node)
+          add_offense(node) do |corrector|
+            body_range = range_between_condition_and_else(node, node.condition)
+            else_range = range_between_else_and_end(node)
 
-          lambda do |corrector|
             corrector.replace(node.loc.keyword, 'if')
             corrector.replace(body_range, else_range.source)
             corrector.replace(else_range, body_range.source)

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

@@ -17,9 +17,12 @@ module RuboCop
       #   # good
       #   'foo'.unpack1('h*')
       #
-      class UnpackFirst < Cop
+      class UnpackFirst < Base
+        extend AutoCorrector
+
         MSG = 'Use `%<receiver>s.unpack1(%<format>s)` instead of '\
           '`%<receiver>s.unpack(%<format>s)%<method>s`.'
+        RESTRICT_ON_SEND = %i[first [] slice at].freeze
 
         def_node_matcher :unpack_and_first_element?, <<~PATTERN
           {
@@ -35,13 +38,7 @@ module RuboCop
                              receiver: unpack_call.receiver.source,
                              format: unpack_arg.source,
                              method: range.source)
-            add_offense(node, message: message)
-          end
-        end
-
-        def autocorrect(node)
-          unpack_and_first_element?(node) do |unpack_call, _unpack_arg|
-            lambda do |corrector|
+            add_offense(node, message: message) do |corrector|
               corrector.remove(first_element_range(node, unpack_call))
               corrector.replace(unpack_call.loc.selector, 'unpack1')
             end

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

@@ -15,28 +15,25 @@ module RuboCop
       #   "His name is #{$name}"
       #   /check #{$pattern}/
       #   "Let's go to the #{@store}"
-      class VariableInterpolation < Cop
+      class VariableInterpolation < Base
         include Interpolation
+        extend AutoCorrector
 
         MSG = 'Replace interpolated variable `%<variable>s` ' \
               'with expression `#{%<variable>s}`.'
 
         def on_node_with_interpolations(node)
           var_nodes(node.children).each do |var_node|
-            add_offense(var_node)
-          end
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
-            corrector.replace(node, "{#{node.source}}")
+            add_offense(var_node) do |corrector|
+              corrector.replace(var_node, "{#{var_node.source}}")
+            end
           end
         end
 
         private
 
-        def message(node)
-          format(MSG, variable: node.source)
+        def message(range)
+          format(MSG, variable: range.source)
         end
 
         def var_nodes(nodes)

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

@@ -17,17 +17,15 @@ module RuboCop
       #   when 1 then 'baz'
       #   when 2 then 'bar'
       #   end
-      class WhenThen < Cop
+      class WhenThen < Base
+        extend AutoCorrector
+
         MSG = 'Do not use `when x;`. Use `when x then` instead.'
 
         def on_when(node)
           return if node.multiline? || node.then? || !node.body
 
-          add_offense(node, location: :begin)
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
+          add_offense(node.loc.begin) do |corrector|
             corrector.replace(node.loc.begin, ' then')
           end
         end

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

@@ -28,31 +28,21 @@ module RuboCop
       #   until x.empty?
       #     do_something(x.pop)
       #   end
-      class WhileUntilDo < Cop
+      class WhileUntilDo < Base
+        extend AutoCorrector
+
         MSG = 'Do not use `do` with multi-line `%<keyword>s`.'
 
         def on_while(node)
-          handle(node)
-        end
-
-        def on_until(node)
-          handle(node)
-        end
-
-        def handle(node)
           return unless node.multiline? && node.do?
 
-          add_offense(node, location: :begin,
-                            message: format(MSG, keyword: node.keyword))
-        end
-
-        def autocorrect(node)
-          do_range = node.condition.source_range.end.join(node.loc.begin)
+          add_offense(node.loc.begin, message: format(MSG, keyword: node.keyword)) do |corrector|
+            do_range = node.condition.source_range.end.join(node.loc.begin)
 
-          lambda do |corrector|
             corrector.remove(do_range)
           end
         end
+        alias on_until on_while
       end
     end
   end

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

@@ -24,37 +24,23 @@ module RuboCop
       #
       #   # good
       #   x += 1 until x > 10
-      class WhileUntilModifier < Cop
+      class WhileUntilModifier < Base
         include StatementModifier
+        extend AutoCorrector
 
         MSG = 'Favor modifier `%<keyword>s` usage when ' \
               'having a single-line body.'
 
         def on_while(node)
-          check(node)
-        end
-
-        def on_until(node)
-          check(node)
-        end
+          return unless node.multiline? && single_line_as_modifier?(node)
 
-        def autocorrect(node)
-          oneline = "#{node.body.source} #{node.keyword} " \
-                    "#{node.condition.source}"
+          add_offense(node.loc.keyword, message: format(MSG, keyword: node.keyword)) do |corrector|
+            oneline = "#{node.body.source} #{node.keyword} #{node.condition.source}"
 
-          lambda do |corrector|
             corrector.replace(node, oneline)
           end
         end
-
-        private
-
-        def check(node)
-          return unless node.multiline? && single_line_as_modifier?(node)
-
-          add_offense(node, location: :keyword,
-                            message: format(MSG, keyword: node.keyword))
-        end
+        alias on_until on_while
       end
     end
   end