rubocop 0.88.0 → 0.91.1

data/lib/rubocop/cop/mixin/line_length_help.rb

@@ -12,9 +12,7 @@ module RuboCop
 
       def directive_on_source_line?(line_index)
         source_line_number = line_index + processed_source.buffer.first_line
-        comment =
-          processed_source.comments
-                          .detect { |e| e.location.line == source_line_number }
+        comment = processed_source.comment_at_line(source_line_number)
 
         return false unless comment
 

data/lib/rubocop/cop/mixin/method_complexity.rb

@@ -2,10 +2,13 @@
 
 module RuboCop
   module Cop
+    # @api private
+    #
     # This module handles measurement and reporting of complexity in methods.
     module MethodComplexity
       include ConfigurableMax
       include IgnoredMethods
+      include Metrics::Utils::RepeatedCsendDiscount
       extend NodePattern::Macros
 
       def on_def(node)
@@ -37,6 +40,7 @@ module RuboCop
         return unless node.body
 
         max = cop_config['Max']
+        reset_repeated_csend
         complexity, abc_vector = complexity(node.body)
 
         return unless complexity > max
@@ -53,8 +57,12 @@ module RuboCop
       end
 
       def complexity(body)
-        body.each_node(*self.class::COUNTED_NODES).reduce(1) do |score, n|
-          score + complexity_score_for(n)
+        body.each_node(:lvasgn, *self.class::COUNTED_NODES).reduce(1) do |score, node|
+          if node.lvasgn_type?
+            reset_on_lvasgn(node)
+            next score
+          end
+          score + complexity_score_for(node)
         end
       end
     end

data/lib/rubocop/cop/mixin/multiline_element_line_breaks.rb

@@ -16,7 +16,9 @@ module RuboCop
         last_seen_line = -1
         children.each do |child|
           if last_seen_line >= child.first_line
-            add_offense(child)
+            add_offense(child) do |corrector|
+              EmptyLineCorrector.insert_before(corrector, child)
+            end
           else
             last_seen_line = child.last_line
           end

data/lib/rubocop/cop/mixin/multiline_literal_brace_layout.rb

@@ -27,8 +27,7 @@ module RuboCop
         last_element_line =
           last_element_range_with_trailing_comma(node).last_line
 
-        last_element_commented =
-          processed_source.comments.any? { |c| c.loc.line == last_element_line }
+        last_element_commented = processed_source.comment_at_line(last_element_line)
 
         last_element_commented && (node.chained? || node.argument?)
       end
@@ -44,30 +43,32 @@ module RuboCop
       def check_new_line(node)
         return unless closing_brace_on_same_line?(node)
 
-        add_offense(node,
-                    location: :end,
-                    message: self.class::ALWAYS_NEW_LINE_MESSAGE)
+        add_offense(node.loc.end, message: self.class::ALWAYS_NEW_LINE_MESSAGE) do |corrector|
+          MultilineLiteralBraceCorrector.correct(corrector, node, processed_source)
+        end
       end
 
       def check_same_line(node)
         return if closing_brace_on_same_line?(node)
 
-        add_offense(node,
-                    location: :end,
-                    message: self.class::ALWAYS_SAME_LINE_MESSAGE)
+        add_offense(node.loc.end, message: self.class::ALWAYS_SAME_LINE_MESSAGE) do |corrector|
+          MultilineLiteralBraceCorrector.correct(corrector, node, processed_source)
+        end
       end
 
       def check_symmetrical(node)
         if opening_brace_on_same_line?(node)
           return if closing_brace_on_same_line?(node)
 
-          add_offense(node, location: :end,
-                            message: self.class::SAME_LINE_MESSAGE)
+          add_offense(node.loc.end, message: self.class::SAME_LINE_MESSAGE) do |corrector|
+            MultilineLiteralBraceCorrector.correct(corrector, node, processed_source)
+          end
         else
           return unless closing_brace_on_same_line?(node)
 
-          add_offense(node, location: :end,
-                            message: self.class::NEW_LINE_MESSAGE)
+          add_offense(node.loc.end, message: self.class::NEW_LINE_MESSAGE) do |corrector|
+            MultilineLiteralBraceCorrector.correct(corrector, node, processed_source)
+          end
         end
       end
 

data/lib/rubocop/cop/mixin/negative_conditional.rb

@@ -15,7 +15,7 @@ module RuboCop
       def_node_matcher :single_negative?, '(send !(send _ :!) :!)'
       def_node_matcher :empty_condition?, '(begin)'
 
-      def check_negative_conditional(node)
+      def check_negative_conditional(node, message:, &block)
         condition = node.condition
 
         return if empty_condition?(condition)
@@ -25,7 +25,7 @@ module RuboCop
         return unless single_negative?(condition)
         return if node.if_type? && node.else?
 
-        add_offense(node)
+        add_offense(node, message: message, &block)
       end
     end
   end

data/lib/rubocop/cop/mixin/percent_array.rb

@@ -28,24 +28,31 @@ module RuboCop
       end
 
       def comments_in_array?(node)
-        comments = processed_source.comments
-        array_range = node.source_range.to_a
-
-        comments.any? do |comment|
-          !(comment.loc.expression.to_a & array_range).empty?
-        end
+        line_span = node.source_range.first_line...node.source_range.last_line
+        processed_source.each_comment_in_lines(line_span).any?
       end
 
       def check_percent_array(node)
         array_style_detected(:percent, node.values.size)
-        add_offense(node) if style == :brackets
+
+        return unless style == :brackets
+
+        add_offense(node) do |corrector|
+          correct_bracketed(corrector, node)
+        end
       end
 
-      def check_bracketed_array(node)
+      def check_bracketed_array(node, literal_prefix)
         return if allowed_bracket_array?(node)
 
         array_style_detected(:brackets, node.values.size)
-        add_offense(node) if style == :percent
+
+        return unless style == :percent
+
+        add_offense(node) do |corrector|
+          percent_literal_corrector = PercentLiteralCorrector.new(@config, @preferred_delimiters)
+          percent_literal_corrector.correct(corrector, node, literal_prefix)
+        end
       end
     end
   end

data/lib/rubocop/cop/mixin/range_help.rb

@@ -46,7 +46,8 @@ module RuboCop
       end
 
       def range_with_surrounding_space(range:, side: :both,
-                                       newlines: true, whitespace: false)
+                                       newlines: true, whitespace: false,
+                                       continuations: false)
         buffer = @processed_source.buffer
         src = buffer.source
 
@@ -55,10 +56,13 @@ module RuboCop
         begin_pos = range.begin_pos
         if go_left
           begin_pos =
-            final_pos(src, begin_pos, -1, newlines, whitespace)
+            final_pos(src, begin_pos, -1, continuations, newlines, whitespace)
         end
         end_pos = range.end_pos
-        end_pos = final_pos(src, end_pos, 1, newlines, whitespace) if go_right
+        if go_right
+          end_pos =
+            final_pos(src, end_pos, 1, continuations, newlines, whitespace)
+        end
         Parser::Source::Range.new(buffer, begin_pos, end_pos)
       end
 
@@ -101,17 +105,27 @@ module RuboCop
         end
       end
 
-      def final_pos(src, pos, increment, newlines, whitespace)
+      # rubocop:disable Metrics/ParameterLists
+      def final_pos(src, pos, increment, continuations, newlines, whitespace)
         pos = move_pos(src, pos, increment, true, /[ \t]/)
+        pos = move_pos_str(src, pos, increment, continuations, "\\\n")
         pos = move_pos(src, pos, increment, newlines, /\n/)
         move_pos(src, pos, increment, whitespace, /\s/)
       end
+      # rubocop:enable Metrics/ParameterLists
 
       def move_pos(src, pos, step, condition, regexp)
         offset = step == -1 ? -1 : 0
         pos += step while condition && regexp.match?(src[pos + offset])
         pos.negative? ? 0 : pos
       end
+
+      def move_pos_str(src, pos, step, condition, needle)
+        size = needle.length
+        offset = step == -1 ? -size : 0
+        pos += size * step while condition && src[pos + offset, size] == needle
+        pos.negative? ? 0 : pos
+      end
     end
   end
 end

data/lib/rubocop/cop/mixin/regexp_literal_help.rb

@@ -27,7 +27,7 @@ module RuboCop
         # part of the pattern source, but need to preserve their width, to allow offsets to
         # correctly line up with the original source: spaces have no effect, and preserve width.
         if child.begin_type?
-          replace_match_with_spaces(source, /.*/) # replace all content
+          replace_match_with_spaces(source, /.*/m) # replace all content
         elsif freespace_mode
           replace_match_with_spaces(source, /(?<!\\)#.*/) # replace any comments
         else

data/lib/rubocop/cop/mixin/rescue_node.rb

@@ -4,7 +4,7 @@ module RuboCop
   module Cop
     # Common functionality for checking `rescue` nodes.
     module RescueNode
-      def investigate(processed_source)
+      def on_new_investigation
         @modifier_locations = processed_source
                               .tokens
                               .select(&:rescue_modifier?)
@@ -17,6 +17,16 @@ module RuboCop
         node&.resbody_type? &&
           @modifier_locations.include?(node.loc.keyword)
       end
+
+      # @deprecated Use ResbodyNode#exceptions instead
+      def rescued_exceptions(resbody)
+        rescue_group, = *resbody
+        if rescue_group
+          rescue_group.values
+        else
+          []
+        end
+      end
     end
   end
 end

data/lib/rubocop/cop/mixin/space_after_punctuation.rb

@@ -7,10 +7,11 @@ module RuboCop
     module SpaceAfterPunctuation
       MSG = 'Space missing after %<token>s.'
 
-      def investigate(processed_source)
+      def on_new_investigation
         each_missing_space(processed_source.tokens) do |token|
-          add_offense(token, location: token.pos,
-                             message: format(MSG, token: kind(token)))
+          add_offense(token.pos, message: format(MSG, token: kind(token))) do |corrector|
+            PunctuationCorrector.add_space(corrector, token)
+          end
         end
       end
 

data/lib/rubocop/cop/mixin/space_before_punctuation.rb

@@ -9,10 +9,11 @@ module RuboCop
 
       MSG = 'Space found before %<token>s.'
 
-      def investigate(processed_source)
+      def on_new_investigation
         each_missing_space(processed_source.tokens) do |token, pos_before|
-          add_offense(pos_before, location: pos_before,
-                                  message: format(MSG, token: kind(token)))
+          add_offense(pos_before, message: format(MSG, token: kind(token))) do |corrector|
+            PunctuationCorrector.remove_space(corrector, pos_before)
+          end
         end
       end
 

data/lib/rubocop/cop/mixin/statement_modifier.rb

@@ -19,14 +19,14 @@ module RuboCop
       def non_eligible_node?(node)
         node.modifier_form? ||
           node.nonempty_line_count > 3 ||
-          processed_source.commented?(node.loc.end)
+          processed_source.line_with_comment?(node.loc.last_line)
       end
 
       def non_eligible_body?(body)
         body.nil? ||
           body.empty_source? ||
           body.begin_type? ||
-          processed_source.commented?(body.source_range)
+          processed_source.contains_comment?(body.source_range)
       end
 
       def non_eligible_condition?(condition)
@@ -36,14 +36,44 @@ module RuboCop
       def modifier_fits_on_single_line?(node)
         return true unless max_line_length
 
-        length_in_modifier_form(node, node.condition) <= max_line_length
+        length_in_modifier_form(node) <= max_line_length
       end
 
-      def length_in_modifier_form(node, cond)
-        keyword = node.loc.keyword
-        indentation = keyword.source_line[/^\s*/]
-        line_length("#{indentation}#{node.body.source} #{keyword.source} " \
-                    "#{cond.source}")
+      def length_in_modifier_form(node)
+        keyword_element = node.loc.keyword
+        end_element = node.loc.end
+        code_before = keyword_element.source_line[0...keyword_element.column]
+        code_after = end_element.source_line[end_element.last_column..-1]
+        expression = to_modifier_form(node)
+        line_length("#{code_before}#{expression}#{code_after}")
+      end
+
+      def to_modifier_form(node)
+        expression = [node.body.source,
+                      node.keyword,
+                      node.condition.source].compact.join(' ')
+        parenthesized = parenthesize?(node) ? "(#{expression})" : expression
+        [parenthesized, first_line_comment(node)].compact.join(' ')
+      end
+
+      def first_line_comment(node)
+        comment = processed_source.find_comment { |c| c.loc.line == node.loc.line }
+        return unless comment
+
+        comment_source = comment.loc.expression.source
+        comment_source unless comment_disables_cop?(comment_source)
+      end
+
+      def parenthesize?(node)
+        # Parenthesize corrected expression if changing to modifier-if form
+        # would change the meaning of the parent expression
+        # (due to the low operator precedence of modifier-if)
+        parent = node.parent
+        return false if parent.nil?
+        return true if parent.assignment? || parent.operator_keyword?
+        return true if %i[array pair].include?(parent.type)
+
+        node.parent.send_type?
       end
 
       def max_line_length
@@ -51,6 +81,11 @@ module RuboCop
 
         config.for_cop('Layout/LineLength')['Max']
       end
+
+      def comment_disables_cop?(comment)
+        regexp_pattern = "# rubocop : (disable|todo) ([^,],)* (all|#{cop_name})"
+        Regexp.new(regexp_pattern.gsub(' ', '\s*')).match?(comment)
+      end
     end
   end
 end

data/lib/rubocop/cop/mixin/surrounding_space.rb

@@ -30,31 +30,6 @@ module RuboCop
         Parser::Source::Range.new(buffer, begin_pos, end_pos)
       end
 
-      def index_of_first_token(node)
-        range = node.source_range
-        token_table[range.line][range.column]
-      end
-
-      def index_of_last_token(node)
-        range = node.source_range
-        table_row = token_table[range.last_line]
-        (0...range.last_column).reverse_each do |c|
-          ix = table_row[c]
-          return ix if ix
-        end
-      end
-
-      def token_table
-        @token_table ||= begin
-          table = {}
-          processed_source.tokens.each_with_index do |t, ix|
-            table[t.line] ||= {}
-            table[t.line][t.column] = ix
-          end
-          table
-        end
-      end
-
       def on_new_investigation
         @token_table = nil
         super
@@ -106,8 +81,11 @@ module RuboCop
 
       def space_offense(node, token, side, message, command)
         range = side_space_range(range: token.pos, side: side)
-        add_offense(node, location: range,
-                          message: format(message, command: command))
+        add_offense(range, message: format(message, command: command)) do |corrector|
+          autocorrect(corrector, node) unless ignored_node?(node)
+
+          ignore_node(node)
+        end
       end
 
       def empty_offenses(node, left, right, message)
@@ -121,8 +99,9 @@ module RuboCop
       end
 
       def empty_offense(node, range, message, command)
-        add_offense(node, location: range,
-                          message: format(message, command: command))
+        add_offense(range, message: format(message, command: command)) do |corrector|
+          autocorrect(corrector, node)
+        end
       end
 
       def empty_brackets?(left_bracket_token, right_bracket_token)

data/lib/rubocop/cop/mixin/trailing_comma.rb

@@ -74,10 +74,8 @@ module RuboCop
       end
 
       def inside_comment?(range, comma_offset)
-        processed_source.comments.any? do |comment|
-          comment_offset = comment.loc.expression.begin_pos - range.begin_pos
-          comment_offset >= 0 && comment_offset < comma_offset
-        end
+        comment = processed_source.comment_at_line(range.line)
+        comment && comment.loc.expression.begin_pos < range.begin_pos + comma_offset
       end
 
       # Returns true if the node has round/square/curly brackets.
@@ -142,7 +140,9 @@ module RuboCop
           unit: format(kind, article: article) + extra_info.to_s
         )
 
-        add_offense(range, location: range, message: msg)
+        add_offense(range, message: msg) do |corrector|
+          PunctuationCorrector.swap_comma(corrector, range)
+        end
       end
 
       def put_comma(items, kind)
@@ -150,13 +150,11 @@ module RuboCop
         return if last_item.block_pass_type?
 
         range = autocorrect_range(last_item)
-        msg = format(
-          MSG,
-          command: 'Put a',
-          unit: format(kind, article: 'a multiline')
-        )
+        msg = format(MSG, command: 'Put a', unit: format(kind, article: 'a multiline'))
 
-        add_offense(range, location: range, message: msg)
+        add_offense(range, message: msg) do |corrector|
+          PunctuationCorrector.swap_comma(corrector, range)
+        end
       end
 
       def autocorrect_range(item)