rubocop 0.89.0 → 0.92.0

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

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

@@ -27,11 +27,12 @@ module RuboCop
       #
       #   # bad
       #   %w[foo bar baz]
-      class WordArray < Cop
+      class WordArray < Base
         include ArrayMinSize
         include ArraySyntax
         include ConfigurableEnforcedStyle
         include PercentArray
+        extend AutoCorrector
 
         PERCENT_MSG = 'Use `%w` or `%W` for an array of words.'
         ARRAY_MSG = 'Use `[]` for an array of words.'
@@ -44,31 +45,14 @@ module RuboCop
           if bracketed_array_of?(:str, node)
             return if complex_content?(node.values)
 
-            check_bracketed_array(node)
+            check_bracketed_array(node, 'w')
           elsif node.percent_literal?(:string)
             check_percent_array(node)
           end
         end
 
-        def autocorrect(node)
-          if style == :percent
-            PercentLiteralCorrector
-              .new(@config, @preferred_delimiters)
-              .correct(node, 'w')
-          else
-            correct_bracketed(node)
-          end
-        end
-
         private
 
-        def check_bracketed_array(node)
-          return if allowed_bracket_array?(node)
-
-          array_style_detected(:brackets, node.values.size)
-          add_offense(node) if style == :percent
-        end
-
         def complex_content?(strings)
           strings.any? do |s|
             string = s.str_content.dup.force_encoding(::Encoding::UTF_8)
@@ -81,7 +65,7 @@ module RuboCop
           Regexp.new(cop_config['WordRegex'])
         end
 
-        def correct_bracketed(node)
+        def correct_bracketed(corrector, node)
           words = node.children.map do |word|
             if word.dstr_type?
               string_literal = to_string_literal(word.source)
@@ -92,9 +76,7 @@ module RuboCop
             end
           end
 
-          lambda do |corrector|
-            corrector.replace(node, "[#{words.join(', ')}]")
-          end
+          corrector.replace(node, "[#{words.join(', ')}]")
         end
       end
     end

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

@@ -52,9 +52,10 @@ module RuboCop
       #   # good
       #   99 == foo
       #   "bar" != foo
-      class YodaCondition < Cop
+      class YodaCondition < Base
         include ConfigurableEnforcedStyle
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Reverse the order of the operands `%<source>s`.'
 
@@ -80,11 +81,7 @@ module RuboCop
           return if equality_only? && non_equality_operator?(node) ||
                     file_constant_equal_program_name?(node)
 
-          valid_yoda?(node) || add_offense(node)
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
+          valid_yoda?(node) || add_offense(node) do |corrector|
             corrector.replace(actual_code_range(node), corrected_code(node))
           end
         end
@@ -157,15 +154,7 @@ module RuboCop
         def interpolation?(node)
           return true if node.dstr_type?
 
-          # TODO: Use `RegexpNode#interpolation?` when the following is released.
-          # https://github.com/rubocop-hq/rubocop-ast/pull/18
-          if node.regexp_type?
-            return true if node.children.any? do |child|
-              child.respond_to?(:begin_type?) && child.begin_type?
-            end
-          end
-
-          false
+          node.regexp_type? && node.interpolation?
         end
       end
     end

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

@@ -25,29 +25,23 @@ module RuboCop
       #   !{a: 1, b: 2}.empty?
       #   !string.empty?
       #   !hash.empty?
-      class ZeroLengthPredicate < Cop
+      class ZeroLengthPredicate < Base
+        extend AutoCorrector
+
         ZERO_MSG = 'Use `empty?` instead of `%<lhs>s %<opr>s %<rhs>s`.'
         NONZERO_MSG = 'Use `!empty?` instead of ' \
                       '`%<lhs>s %<opr>s %<rhs>s`.'
 
-        LENGTH_METHODS = %i[size length].freeze
+        RESTRICT_ON_SEND = %i[size length].freeze
 
         def on_send(node)
           check_zero_length_predicate(node)
           check_nonzero_length_predicate(node)
         end
 
-        def autocorrect(node)
-          lambda do |corrector|
-            corrector.replace(node, replacement(node))
-          end
-        end
-
         private
 
         def check_zero_length_predicate(node)
-          return unless LENGTH_METHODS.include?(node.method_name)
-
           zero_length_predicate = zero_length_predicate(node.parent)
           return unless zero_length_predicate
 
@@ -56,14 +50,13 @@ module RuboCop
           return if non_polymorphic_collection?(node.parent)
 
           add_offense(
-            node.parent,
-            message: format(ZERO_MSG, lhs: lhs, opr: opr, rhs: rhs)
-          )
+            node.parent, message: format(ZERO_MSG, lhs: lhs, opr: opr, rhs: rhs)
+          ) do |corrector|
+            corrector.replace(node.parent, replacement(node.parent))
+          end
         end
 
         def check_nonzero_length_predicate(node)
-          return unless LENGTH_METHODS.include?(node.method_name)
-
           nonzero_length_predicate = nonzero_length_predicate(node.parent)
           return unless nonzero_length_predicate
 
@@ -72,9 +65,10 @@ module RuboCop
           return if non_polymorphic_collection?(node.parent)
 
           add_offense(
-            node.parent,
-            message: format(NONZERO_MSG, lhs: lhs, opr: opr, rhs: rhs)
-          )
+            node.parent, message: format(NONZERO_MSG, lhs: lhs, opr: opr, rhs: rhs)
+          ) do |corrector|
+            corrector.replace(node.parent, replacement(node.parent))
+          end
         end
 
         def_node_matcher :zero_length_predicate, <<~PATTERN

data/lib/rubocop/cop/team.rb

@@ -117,6 +117,7 @@ module RuboCop
       def autocorrect(processed_source, report)
         @updated_source_file = false
         return unless autocorrect?
+        return if report.processed_source.parser_error
 
         new_source = autocorrect_report(report)
 

data/lib/rubocop/cop/util.rb

@@ -5,7 +5,6 @@ module RuboCop
     # This module contains a collection of useful utility methods.
     module Util
       include PathUtil
-      include TokensUtil
 
       # Match literal regex characters, not including anchors, character
       # classes, alternatives, groups, repetitions, references, etc
@@ -14,10 +13,12 @@ module RuboCop
 
       module_function
 
+      # This is a bad API
       def comment_line?(line_source)
         /^\s*#/.match?(line_source)
       end
 
+      # @deprecated Use `ProcessedSource#line_with_comment?`, `contains_comment?` or similar
       def comment_lines?(node)
         processed_source[line_range(node)].any? { |line| comment_line?(line) }
       end

data/lib/rubocop/cop/utils/format_string.rb

@@ -111,11 +111,9 @@ module RuboCop
         private
 
         def parse
-          @source.to_enum(:scan, SEQUENCE).map do
-            FormatSequence.new(
-              Regexp.last_match
-            )
-          end
+          matches = []
+          @source.scan(SEQUENCE) { matches << FormatSequence.new(Regexp.last_match) }
+          matches
         end
 
         def mixed_formats?

data/lib/rubocop/cop/variable_force.rb

@@ -22,6 +22,8 @@ module RuboCop
     #
     #     def after_declaring_variable(variable, variable_table)
     #     end
+    #
+    # @api private
     class VariableForce < Force # rubocop:disable Metrics/ClassLength
       VARIABLE_ASSIGNMENT_TYPE = :lvasgn
       REGEXP_NAMED_CAPTURE_TYPE = :match_with_lvasgn

data/lib/rubocop/cops_documentation_generator.rb

@@ -1,7 +1,9 @@
 # frozen_string_literal: true
 
 # Class for generating documentation of all cops departments
+# @api private
 class CopsDocumentationGenerator # rubocop:disable Metrics/ClassLength
+  include ::RuboCop::Cop::Documentation
   # This class will only generate documentation for cops that belong to one of
   # the departments given in the `departments` array. E.g. if we only wanted
   # documentation for Lint cops:
@@ -10,7 +12,7 @@ class CopsDocumentationGenerator # rubocop:disable Metrics/ClassLength
   #
   def initialize(departments: [])
     @departments = departments.map(&:to_sym).sort!
-    @cops = RuboCop::Cop::Cop.registry
+    @cops = RuboCop::Cop::Registry.global
     @config = RuboCop::ConfigLoader.default_configuration
   end
 
@@ -210,7 +212,7 @@ class CopsDocumentationGenerator # rubocop:disable Metrics/ClassLength
     selected_cops.each do |cop|
       content << print_cop_with_doc(cop)
     end
-    file_name = "#{Dir.pwd}/docs/modules/ROOT/pages/cops_#{department.downcase}.adoc"
+    file_name = "#{Dir.pwd}/docs/modules/ROOT/pages/#{department_to_basename(department)}.adoc"
     File.open(file_name, 'w') do |file|
       puts "* generated #{file_name}"
       file.write("#{content.strip}\n")
@@ -243,7 +245,7 @@ class CopsDocumentationGenerator # rubocop:disable Metrics/ClassLength
 
   def table_of_content_for_department(department)
     type_title = department[0].upcase + department[1..-1]
-    filename = "cops_#{department.downcase}.adoc"
+    filename = "#{department_to_basename(department)}.adoc"
     content = +"=== Department xref:#{filename}[#{type_title}]\n\n"
     cops_of_department(department).each do |cop|
       anchor = cop.cop_name.sub('/', '').downcase