rubocop 0.87.1 → 0.91.0

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,52 +25,50 @@ 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`.'
 
+        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)
-          zero_length_predicate = zero_length_predicate(node)
-
+          zero_length_predicate = zero_length_predicate(node.parent)
           return unless zero_length_predicate
 
           lhs, opr, rhs = zero_length_predicate
 
-          return if non_polymorphic_collection?(node)
+          return if non_polymorphic_collection?(node.parent)
 
           add_offense(
-            node,
-            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)
-          nonzero_length_predicate = nonzero_length_predicate(node)
-
+          nonzero_length_predicate = nonzero_length_predicate(node.parent)
           return unless nonzero_length_predicate
 
           lhs, opr, rhs = nonzero_length_predicate
 
-          return if non_polymorphic_collection?(node)
+          return if non_polymorphic_collection?(node.parent)
 
           add_offense(
-            node,
-            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

@@ -43,7 +43,7 @@ module RuboCop
         cop_classes = Registry.new(cop_classes.to_a) unless cop_classes.is_a?(Registry)
         only = options.fetch(:only, [])
         safe = options.fetch(:safe, false)
-        cop_classes.enabled(config, only, safe).map do |cop_class|
+        cop_classes.enabled(config, only, only_safe: safe).map do |cop_class|
           cop_class.new(config, options)
         end
       end
@@ -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/tokens_util.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module RuboCop
+  # Common methods and behaviors for dealing with tokens.
+  module TokensUtil
+    module_function
+
+    # rubocop:disable Metrics/AbcSize
+    def tokens(node)
+      @tokens ||= {}
+      return @tokens[node.object_id] if @tokens[node.object_id]
+
+      @tokens[node.object_id] =
+        # The tokens list is always sorted by token position,
+        # except for cases when heredoc is passed as a method argument.
+        # In this case tokens are interleaved by heredoc contents' tokens.
+        # We can try a fast (binary) search, assuming the mentioned cases are rare,
+        # and fallback to linear search if failed.
+        if (tokens = fast_tokens(node))
+          tokens
+        else
+          begin_pos = node.source_range.begin_pos
+          end_pos   = node.source_range.end_pos
+
+          processed_source.tokens.select do |token|
+            token.end_pos <= end_pos && token.begin_pos >= begin_pos
+          end
+        end
+    end
+    # rubocop:enable Metrics/AbcSize
+
+    def index_of_first_token(node)
+      index = fast_index_of_first_token(node)
+      return index if index
+
+      begin_pos = node.source_range.begin_pos
+      processed_source.tokens.index { |token| token.begin_pos == begin_pos }
+    end
+
+    def index_of_last_token(node)
+      index = fast_index_of_last_token(node)
+      return index if index
+
+      end_pos = node.source_range.end_pos
+      processed_source.tokens.index { |token| token.end_pos == end_pos }
+    end
+
+    private
+
+    def fast_index_of_first_token(node)
+      begin_pos = node.source_range.begin_pos
+      tokens = processed_source.tokens
+
+      index = tokens.bsearch_index { |token| token.begin_pos >= begin_pos }
+      index if index && tokens[index].begin_pos == begin_pos
+    end
+
+    def fast_index_of_last_token(node)
+      end_pos = node.source_range.end_pos
+      tokens = processed_source.tokens
+
+      index = tokens.bsearch_index { |token| token.end_pos >= end_pos }
+      index if index && tokens[index].end_pos == end_pos
+    end
+
+    def fast_tokens(node)
+      begin_index = index_of_first_token(node)
+      end_index   = index_of_last_token(node)
+
+      tokens = processed_source.tokens[begin_index..end_index]
+      tokens if sorted_tokens?(tokens)
+    end
+
+    def sorted_tokens?(tokens)
+      prev_begin_pos = -1
+      tokens.each do |token|
+        return false if token.begin_pos < prev_begin_pos
+
+        prev_begin_pos = token.begin_pos
+      end
+      true
+    end
+  end
+end

data/lib/rubocop/cop/util.rb

@@ -5,6 +5,7 @@ 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
@@ -13,10 +14,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
@@ -127,19 +130,6 @@ module RuboCop
           .sub('Style', 'Styles')
       end
 
-      def tokens(node)
-        @tokens ||= {}
-        return @tokens[node.object_id] if @tokens[node.object_id]
-
-        source_range = node.source_range
-        begin_pos = source_range.begin_pos
-        end_pos = source_range.end_pos
-
-        @tokens[node.object_id] = processed_source.tokens.select do |token|
-          token.end_pos <= end_pos && token.begin_pos >= begin_pos
-        end
-      end
-
       private
 
       def compatible_external_encoding_for?(src)

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
@@ -197,7 +199,6 @@ module RuboCop
         regexp.named_captures.keys
       end
 
-      # rubocop:disable Metrics/AbcSize
       def process_variable_operator_assignment(node)
         if LOGICAL_OPERATOR_ASSIGNMENT_TYPES.include?(node.type)
           asgn_node, rhs_node = *node
@@ -232,7 +233,6 @@ module RuboCop
 
         skip_children!
       end
-      # rubocop:enable Metrics/AbcSize
 
       def process_variable_multiple_assignment(node)
         lhs_node, rhs_node = *node