rubocop 0.52.1 → 0.93.1

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,15 +17,16 @@ module RuboCop
       end
 
       def non_eligible_node?(node)
-        node.nonempty_line_count > 3 ||
-          !node.modifier_form? && commented?(node.loc.end)
+        node.modifier_form? ||
+          node.nonempty_line_count > 3 ||
+          processed_source.line_with_comment?(node.loc.last_line)
       end
 
       def non_eligible_body?(body)
         body.nil? ||
           body.empty_source? ||
           body.begin_type? ||
-          commented?(body.source_range)
+          processed_source.contains_comment?(body.source_range)
       end
 
       def non_eligible_condition?(condition)
@@ -31,30 +34,57 @@ module RuboCop
       end
 
       def modifier_fits_on_single_line?(node)
-        modifier_length = length_in_modifier_form(node, node.condition,
-                                                  node.body.source_length)
+        return true unless max_line_length
 
-        modifier_length <= max_line_length
+        length_in_modifier_form(node) <= max_line_length
       end
 
-      def length_in_modifier_form(node, cond, body_length)
-        indentation = node.loc.keyword.column
-        kw_length = node.loc.keyword.size
-        cond_length = cond.source_range.size
-        space = 1
-        indentation + body_length + space + kw_length + space + cond_length
+      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 max_line_length
-        config.for_cop('Metrics/LineLength')['Max']
+      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 commented?(source)
-        comment_lines.include?(source.line)
+      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
+        return unless config.for_cop('Layout/LineLength')['Enabled']
+
+        config.for_cop('Layout/LineLength')['Max']
       end
 
-      def comment_lines
-        @comment_lines ||= processed_source.comments.map { |c| c.location.line }
+      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_literals_help.rb

@@ -11,10 +11,11 @@ module RuboCop
       def wrong_quotes?(node)
         src = node.source
         return false if src.start_with?('%', '?')
+
         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

@@ -4,59 +4,35 @@ module RuboCop
   module Cop
     # Common functionality for checking and correcting surrounding whitespace.
     module SurroundingSpace
-      NO_SPACE_COMMAND = 'Do not use'.freeze
-      SPACE_COMMAND = 'Use'.freeze
+      include RangeHelp
+
+      NO_SPACE_COMMAND = 'Do not use'
+      SPACE_COMMAND = 'Use'
+
+      SINGLE_SPACE_REGEXP = /[ \t]/.freeze
 
       private
 
       def side_space_range(range:, side:)
-        buffer = @processed_source.buffer
+        buffer = processed_source.buffer
         src = buffer.source
 
         begin_pos = range.begin_pos
         end_pos = range.end_pos
         if side == :left
+          end_pos = begin_pos
           begin_pos = reposition(src, begin_pos, -1)
-          end_pos -= 1
         end
         if side == :right
-          begin_pos += 1
+          begin_pos = end_pos
           end_pos = reposition(src, end_pos, 1)
         end
         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 tokens(node)
-        @tokens ||= {}
-        @tokens[node.object_id] ||= processed_source.tokens.select do |token|
-          token.end_pos <= node.source_range.end_pos &&
-            token.begin_pos >= node.source_range.begin_pos
-        end
+      def on_new_investigation
+        @token_table = nil
+        super
       end
 
       def no_space_offenses(node, # rubocop:disable Metrics/ParameterLists
@@ -69,6 +45,7 @@ module RuboCop
           space_offense(node, left_token, :right, message, NO_SPACE_COMMAND)
         end
         return if !extra_space?(right_token, :right) || end_ok
+
         space_offense(node, right_token, :left, message, NO_SPACE_COMMAND)
       end
 
@@ -82,28 +59,71 @@ module RuboCop
           space_offense(node, left_token, :none, message, SPACE_COMMAND)
         end
         return if extra_space?(right_token, :right) || end_ok
+
         space_offense(node, right_token, :none, message, SPACE_COMMAND)
       end
 
       def extra_space?(token, side)
         return false unless token
+
         if side == :left
-          String(token.space_after?) == ' '
+          SINGLE_SPACE_REGEXP.match?(String(token.space_after?))
         else
-          String(token.space_before?) == ' '
+          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] =~ /[ \t]/
-        pos < 0 ? 0 : pos
+        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)
+        range = range_between(left.begin_pos, right.end_pos)
+        if offending_empty_space?(empty_config, left, right)
+          empty_offense(node, range, message, 'Use one')
+        end
+        return unless offending_empty_no_space?(empty_config, left, right)
+
+        empty_offense(node, range, message, 'Do not use')
+      end
+
+      def empty_offense(node, range, message, 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)
+        left_index = processed_source.tokens.index(left_bracket_token)
+        right_index = processed_source.tokens.index(right_bracket_token)
+        right_index && left_index == right_index - 1
+      end
+
+      def offending_empty_space?(config, left_token, right_token)
+        config == 'space' && !space_between?(left_token, right_token)
+      end
+
+      def offending_empty_no_space?(config, left_token, right_token)
+        config == 'no_space' && !no_space_between?(left_token, right_token)
+      end
+
+      def space_between?(left_bracket_token, right_bracket_token)
+        left_bracket_token.end_pos + 1 == right_bracket_token.begin_pos
+      end
+
+      def no_space_between?(left_bracket_token, right_bracket_token)
+        left_bracket_token.end_pos == right_bracket_token.begin_pos
       end
     end
   end

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common methods shared by TrailingBody cops
+    module TrailingBody
+      def trailing_body?(node)
+        body = node.to_a.reverse[0]
+        body && node.multiline? &&
+          body_on_first_line?(node, body)
+      end
+
+      def body_on_first_line?(node, body)
+        node.source_range.first_line == body.source_range.first_line
+      end
+
+      def first_part_of(body)
+        if body.begin_type?
+          body.children.first.source_range
+        else
+          body.source_range
+        end
+      end
+    end
+  end
+end

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

@@ -6,8 +6,9 @@ module RuboCop
     # Style/TrailingCommaInLiteral
     module TrailingComma
       include ConfigurableEnforcedStyle
+      include RangeHelp
 
-      MSG = '%<command>s comma after the last %<unit>s.'.freeze
+      MSG = '%<command>s comma after the last %<unit>s.'
 
       private
 
@@ -17,24 +18,39 @@ module RuboCop
 
       def check(node, items, kind, begin_pos, end_pos)
         after_last_item = range_between(begin_pos, end_pos)
-
-        return if heredoc?(after_last_item.source)
-
-        comma_offset = after_last_item.source =~ /,/
+        comma_offset = comma_offset(items, after_last_item)
 
         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
 
+      def comma_offset(items, range)
+        # 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*,/
+        comma_regex.match?(range.source) && range.source.index(',')
+      end
+
       def check_comma(node, kind, comma_pos)
         return if should_have_comma?(style, node)
 
         avoid_comma(kind, comma_pos, extra_avoid_comma_info)
       end
 
+      def check_literal(node, kind)
+        return if node.children.empty?
+        # A braceless hash is the last parameter of a method call and will be
+        # checked as such.
+        return unless brackets?(node)
+
+        check(node, node.children, kind,
+              node.children.last.source_range.end_pos,
+              node.loc.end.begin_pos)
+      end
+
       def extra_avoid_comma_info
         case style
         when :comma
@@ -51,21 +67,15 @@ module RuboCop
         when :comma
           multiline?(node) && no_elements_on_same_line?(node)
         when :consistent_comma
-          multiline?(node)
+          multiline?(node) && !method_name_and_arguments_on_same_line?(node)
         else
           false
         end
       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
-      end
-
-      def heredoc?(source_after_last_item)
-        source_after_last_item =~ /\w/
+        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.
@@ -74,33 +84,39 @@ module RuboCop
       end
 
       # Returns true if the round/square/curly brackets of the given node are
-      # on different lines, and each item within is on its own line, and the
+      # on different lines, each item within is on its own line, and the
       # closing bracket is on its own line.
       def multiline?(node)
-        # No need to process anything if the whole node is not multiline
-        # Without the 2nd check, Foo.new({}) is considered multiline, which
-        # it should not be. Essentially, if there are no elements, the
-        # expression can not be multiline.
-        return false unless node.multiline?
+        node.multiline? && !allowed_multiline_argument?(node)
+      end
 
-        items = elements(node).map(&:source_range)
-        return false if items.empty?
-        items << node.loc.begin << node.loc.end
-        (items.map(&:first_line) + items.map(&:last_line)).uniq.size > 1
+      def method_name_and_arguments_on_same_line?(node)
+        return false unless node.call_type?
+
+        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
+      end
+
+      # A single argument with the closing bracket on the same line as the end
+      # of the argument is not considered multiline, even if the argument
+      # itself might span multiple lines.
+      def allowed_multiline_argument?(node)
+        elements(node).one? && !Util.begins_its_line?(node.loc.end)
       end
 
       def elements(node)
-        return node.children unless node.send_type?
+        return node.children unless %i[csend send].include?(node.type)
 
-        _receiver, _method_name, *args = *node
-        args.flat_map do |a|
+        node.arguments.flat_map do |argument|
           # For each argument, if it is a multi-line hash without braces,
           # then promote the hash elements to method arguments
           # for the purpose of determining multi-line-ness.
-          if a.hash_type? && a.multiline? && !a.braces?
-            a.children
+          if argument.hash_type? && argument.multiline? && !argument.braces?
+            argument.children
           else
-            a
+            argument
           end
         end
       end
@@ -111,36 +127,34 @@ module RuboCop
         items.each_cons(2).none? { |a, b| on_same_line?(a, b) }
       end
 
-      def on_same_line?(a, b)
-        a.last_line == b.line
+      def on_same_line?(range1, range2)
+        range1.last_line == range2.line
       end
 
       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)
@@ -151,8 +165,44 @@ 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?(_)
+      def any_heredoc?(items)
+        items.any? { |item| heredoc?(item) }
+      end
+
+      def heredoc?(node)
+        return false unless node.is_a?(RuboCop::AST::Node)
+        return true if node.loc.respond_to?(:heredoc_body)
+
+        return heredoc_send?(node) if node.send_type?
+
+        # handle hash values
+        #
+        #   some_method({
+        #     'auth' => <<-SOURCE
+        #       ...
+        #     SOURCE
+        #   })
+        return heredoc?(node.children.last) if node.pair_type? || node.hash_type?
+
+        false
+      end
+
+      def heredoc_send?(node)
+        # handle heredocs with methods
+        #
+        #   some_method(<<-CODE.strip.chomp)
+        #     ...
+        #   CODE
+        return heredoc?(node.children.first) if node.children.size == 2
+        # handle nested methods
+        #
+        #   some_method(
+        #     another_method(<<-CODE.strip.chomp)
+        #       ...
+        #     CODE
+        #   )
+        return heredoc?(node.children.last) if node.children.size > 2
+
         false
       end
     end