rubocop 0.78.0 → 1.13.0

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

@@ -27,6 +27,12 @@ module RuboCop
         Parser::Source::Range.new(source_buffer, begin_pos, end_pos)
       end
 
+      # A range containing only the contents of a literal with delimiters (e.g. in
+      # `%i{1 2 3}` this will be the range covering `1 2 3` only).
+      def contents_range(node)
+        range_between(node.loc.begin.end_pos, node.loc.end.begin_pos)
+      end
+
       def range_between(start_pos, end_pos)
         Parser::Source::Range.new(processed_source.buffer, start_pos, end_pos)
       end
@@ -46,19 +52,17 @@ 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
 
         go_left, go_right = directions(side)
 
         begin_pos = range.begin_pos
-        if go_left
-          begin_pos =
-            final_pos(src, begin_pos, -1, newlines, whitespace)
-        end
+        begin_pos = final_pos(src, begin_pos, -1, continuations, newlines, whitespace) if go_left
         end_pos = range.end_pos
-        end_pos = final_pos(src, end_pos, 1, newlines, whitespace) if go_right
+        end_pos = final_pos(src, end_pos, 1, continuations, newlines, whitespace) if go_right
         Parser::Source::Range.new(buffer, begin_pos, end_pos)
       end
 
@@ -69,9 +73,7 @@ module RuboCop
         end_offset = last_line.length - range.last_column
         end_offset += 1 if include_final_newline
 
-        range
-          .adjust(begin_pos: -range.column, end_pos: end_offset)
-          .intersect(buffer.source_range)
+        range.adjust(begin_pos: -range.column, end_pos: end_offset).intersect(buffer.source_range)
       end
 
       def column_offset_between(base_range, range)
@@ -85,8 +87,7 @@ module RuboCop
       # line, in which case 1 is subtracted from the column value. This gives
       # the column as it appears when viewing the file in an editor.
       def effective_column(range)
-        if range.line == 1 &&
-           @processed_source.raw_source.codepoints.first == BYTE_ORDER_MARK
+        if range.line == 1 && @processed_source.raw_source.codepoints.first == BYTE_ORDER_MARK
           range.column - 1
         else
           range.column
@@ -101,15 +102,25 @@ 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 && src[pos + offset] =~ regexp
+        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

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

@@ -8,6 +8,7 @@ module RuboCop
 
       private
 
+      # @!method rational_literal?(node)
       def_node_matcher :rational_literal?, <<~PATTERN
         (send
           (int _) :/

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

@@ -4,18 +4,24 @@ module RuboCop
   module Cop
     # Common functionality for checking `rescue` nodes.
     module RescueNode
-      def investigate(processed_source)
-        @modifier_locations = processed_source
-                              .tokens
-                              .select(&:rescue_modifier?)
-                              .map(&:pos)
+      def on_new_investigation
+        @modifier_locations = processed_source.tokens.select(&:rescue_modifier?).map(&:pos)
       end
 
       private
 
       def rescue_modifier?(node)
-        node&.resbody_type? &&
-          @modifier_locations.include?(node.loc.keyword)
+        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

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

@@ -10,10 +10,14 @@ module RuboCop
 
       private
 
+      # @!method empty_condition?(node)
       def_node_matcher :empty_condition?, '(begin)'
+
+      # @!method setter_method?(node)
       def_node_matcher :setter_method?, '[(send ...) setter_method?]'
-      def_node_matcher :safe_assignment?,
-                       '(begin {equals_asgn? #setter_method?})'
+
+      # @!method safe_assignment?(node)
+      def_node_matcher :safe_assignment?, '(begin {equals_asgn? #setter_method?})'
 
       def safe_assignment_allowed?
         cop_config['AllowSafeAssignment']

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
 
@@ -27,13 +28,11 @@ module RuboCop
       end
 
       def space_missing?(token1, token2)
-        token1.line == token2.line &&
-          token2.column == token1.column + offset
+        token1.line == token2.line && token2.column == token1.column + offset
       end
 
       def space_required_before?(token)
-        !(allowed_type?(token) ||
-          (token.right_curly_brace? && space_forbidden_before_rcurly?))
+        !(allowed_type?(token) || (token.right_curly_brace? && space_forbidden_before_rcurly?))
       end
 
       def allowed_type?(token)

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
 
@@ -24,8 +25,7 @@ module RuboCop
           next unless space_missing?(token1, token2)
           next if space_required_after?(token1)
 
-          pos_before_punctuation = range_between(token1.end_pos,
-                                                 token2.begin_pos)
+          pos_before_punctuation = range_between(token1.end_pos, token2.begin_pos)
 
           yield token2, pos_before_punctuation
         end

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

@@ -4,6 +4,8 @@ module RuboCop
   module Cop
     # Common functionality for modifier cops.
     module StatementModifier
+      include LineLengthHelp
+
       private
 
       def single_line_as_modifier?(node)
@@ -15,16 +17,17 @@ module RuboCop
       end
 
       def non_eligible_node?(node)
-        node.nonempty_line_count > 3 ||
-          !node.modifier_form? &&
-            processed_source.commented?(node.loc.end)
+        node.modifier_form? ||
+          node.nonempty_line_count > 3 ||
+          processed_source.line_with_comment?(node.loc.last_line) ||
+          (first_line_comment(node) && code_after(node))
       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)
@@ -34,21 +37,46 @@ module RuboCop
       def modifier_fits_on_single_line?(node)
         return true unless max_line_length
 
-        modifier_length = length_in_modifier_form(node, node.condition,
-                                                  node.body.source_length)
+        length_in_modifier_form(node) <= max_line_length
+      end
 
-        modifier_length <= max_line_length
+      def length_in_modifier_form(node)
+        keyword_element = node.loc.keyword
+        code_before = keyword_element.source_line[0...keyword_element.column]
+        expression = to_modifier_form(node)
+        line_length("#{code_before}#{expression}#{code_after(node)}")
       end
 
-      def length_in_modifier_form(node, cond, body_length)
-        keyword = node.loc.keyword
+      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
 
-        indentation = keyword.column * indentation_multiplier
-        kw_length = keyword.size
-        cond_length = cond.source_range.size
-        space = 1
+      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
 
-        indentation + body_length + space + kw_length + space + cond_length
+      def code_after(node)
+        end_element = node.loc.end
+        code = end_element.source_line[end_element.last_column..-1]
+        code unless code.empty?
+      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
@@ -57,14 +85,9 @@ module RuboCop
         config.for_cop('Layout/LineLength')['Max']
       end
 
-      def indentation_multiplier
-        return 1 if config.for_cop('Layout/Tab')['Enabled']
-
-        default_configuration = RuboCop::ConfigLoader.default_configuration
-        config.for_cop('Layout/Tab')['IndentationWidth'] ||
-          config.for_cop('Layout/IndentationWidth')['Width'] ||
-          default_configuration.for_cop('Layout/Tab')['IndentationWidth'] ||
-          default_configuration.for_cop('Layout/IndentationWidth')['Width']
+      def comment_disables_cop?(comment)
+        regexp_pattern = "# rubocop : (disable|todo) ([^,],)* (all|#{cop_name})"
+        Regexp.new(regexp_pattern.gsub(' ', '\s*')).match?(comment)
       end
     end
   end

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

@@ -14,7 +14,10 @@ module RuboCop
         return if part_of_ignored_node?(node)
 
         if offense?(node)
-          add_offense(node) { opposite_style_detected }
+          add_offense(node) do |corrector|
+            opposite_style_detected
+            autocorrect(corrector, node) if respond_to?(:autocorrect, true)
+          end
         else
           correct_style_detected
         end

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

@@ -15,7 +15,7 @@ module RuboCop
         if style == :single_quotes
           !double_quotes_required?(src)
         else
-          src !~ /" | \\[^'] | \#(@|\{)/x
+          !/" | \\[^'] | \#(@|\{)/x.match?(src)
         end
       end
     end

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

@@ -14,7 +14,7 @@ module RuboCop
       private
 
       def side_space_range(range:, side:)
-        buffer = @processed_source.buffer
+        buffer = processed_source.buffer
         src = buffer.source
 
         begin_pos = range.begin_pos
@@ -30,29 +30,9 @@ 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
+      def on_new_investigation
+        @token_table = nil
+        super
       end
 
       def no_space_offenses(node, # rubocop:disable Metrics/ParameterLists
@@ -87,22 +67,25 @@ module RuboCop
         return false unless token
 
         if side == :left
-          String(token.space_after?) =~ SINGLE_SPACE_REGEXP
+          SINGLE_SPACE_REGEXP.match?(String(token.space_after?))
         else
-          String(token.space_before?) =~ SINGLE_SPACE_REGEXP
+          SINGLE_SPACE_REGEXP.match?(String(token.space_before?))
         end
       end
 
       def reposition(src, pos, step)
         offset = step == -1 ? -1 : 0
-        pos += step while src[pos + offset] =~ SINGLE_SPACE_REGEXP
+        pos += step while SINGLE_SPACE_REGEXP.match?(src[pos + offset])
         pos.negative? ? 0 : pos
       end
 
       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)
@@ -116,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/target_ruby_version.rb

@@ -4,12 +4,16 @@ module RuboCop
   module Cop
     # Common functionality for checking target ruby version.
     module TargetRubyVersion
+      def required_minimum_ruby_version
+        @minimum_target_ruby_version
+      end
+
       def minimum_target_ruby_version(version)
         @minimum_target_ruby_version = version
       end
 
       def support_target_ruby_version?(version)
-        @minimum_target_ruby_version <= version
+        required_minimum_ruby_version <= version
       end
     end
   end

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

@@ -6,8 +6,7 @@ module RuboCop
     module TrailingBody
       def trailing_body?(node)
         body = node.to_a.reverse[0]
-        body && node.multiline? &&
-          body_on_first_line?(node, body)
+        body && node.multiline? && body_on_first_line?(node, body)
       end
 
       def body_on_first_line?(node, body)

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

@@ -23,7 +23,7 @@ module RuboCop
         if comma_offset && !inside_comment?(after_last_item, comma_offset)
           check_comma(node, kind, after_last_item.begin_pos + comma_offset)
         elsif should_have_comma?(style, node)
-          put_comma(node, items, kind)
+          put_comma(items, kind)
         end
       end
 
@@ -31,7 +31,7 @@ module RuboCop
         # If there is any heredoc in items, then match the comma succeeding
         # any whitespace (except newlines), otherwise allow for newlines
         comma_regex = any_heredoc?(items) ? /\A[^\S\n]*,/ : /\A\s*,/
-        range.source =~ comma_regex && range.source.index(',')
+        comma_regex.match?(range.source) && range.source.index(',')
       end
 
       def check_comma(node, kind, comma_pos)
@@ -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.
@@ -97,8 +95,7 @@ module RuboCop
 
         line = node.loc.selector.nil? ? node.loc.line : node.loc.selector.line
 
-        line == node.last_argument.last_line &&
-          node.last_line == node.last_argument.last_line
+        line == node.last_argument.last_line && node.last_line == node.last_argument.last_line
       end
 
       # A single argument with the closing bracket on the same line as the end
@@ -135,30 +132,28 @@ module RuboCop
 
       def avoid_comma(kind, comma_begin_pos, extra_info)
         range = range_between(comma_begin_pos, comma_begin_pos + 1)
-        article = kind =~ /array/ ? 'an' : 'a'
+        article = /array/.match?(kind) ? 'an' : 'a'
         msg = format(
           MSG,
           command: 'Avoid',
           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(node, items, kind)
-        return if avoid_autocorrect?(elements(node))
-
+      def put_comma(items, kind)
         last_item = items.last
         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)
@@ -169,11 +164,6 @@ module RuboCop
         range_between(expr.begin_pos + ix, expr.end_pos)
       end
 
-      # By default, there's no reason to avoid auto-correct.
-      def avoid_autocorrect?(_nodes)
-        false
-      end
-
       def any_heredoc?(items)
         items.any? { |item| heredoc?(item) }
       end
@@ -191,9 +181,7 @@ module RuboCop
         #       ...
         #     SOURCE
         #   })
-        if node.pair_type? || node.hash_type?
-          return heredoc?(node.children.last)
-        end
+        return heredoc?(node.children.last) if node.pair_type? || node.hash_type?
 
         false
       end