rubocop 0.73.0 → 0.77.0

data/lib/rubocop/cop/layout/space_in_lambda_literal.rb

@@ -48,9 +48,7 @@ module RuboCop
             if style == :require_space
               corrector.insert_before(children[1].source_range, ' ')
             else
-              space_range = range_between(children[0].source_range.end_pos,
-                                          children[1].source_range.begin_pos)
-              corrector.remove(space_range)
+              corrector.remove(space_after_arrow(lambda_node))
             end
           end
         end
@@ -62,10 +60,14 @@ module RuboCop
         end
 
         def space_after_arrow?(lambda_node)
-          arrow = lambda_node.parent.children[0]
-          parentheses = lambda_node.parent.children[1]
-          (parentheses.source_range.begin_pos - arrow.source_range.end_pos)
-            .positive?
+          !space_after_arrow(lambda_node).empty?
+        end
+
+        def space_after_arrow(lambda_node)
+          arrow = lambda_node.parent.children[0].source_range
+          parentheses = lambda_node.parent.children[1].source_range
+
+          arrow.end.join(parentheses.begin)
         end
 
         def range_of_offense(node)

data/lib/rubocop/cop/layout/space_inside_array_literal_brackets.rb

@@ -132,7 +132,7 @@ module RuboCop
           line, col = line_and_column_for(token)
           return true if col == -1
 
-          processed_source.lines[line][0..col].delete(' ').empty?
+          processed_source.lines[line][0..col] !~ /\S/
         end
 
         def index_for(node, token)
@@ -210,18 +210,21 @@ module RuboCop
 
         def compact_corrections(corrector, node, left, right)
           if qualifies_for_compact?(node, left, side: :left)
-            range = side_space_range(range: left.pos, side: :right)
-            corrector.remove(range)
+            compact(corrector, left, :right)
           elsif !left.space_after?
             corrector.insert_after(left.pos, ' ')
           end
           if qualifies_for_compact?(node, right)
-            range = side_space_range(range: right.pos, side: :left)
-            corrector.remove(range)
+            compact(corrector, right, :left)
           elsif !right.space_before?
             corrector.insert_before(right.pos, ' ')
           end
         end
+
+        def compact(corrector, bracket, side)
+          range = side_space_range(range: bracket.pos, side: side)
+          corrector.remove(range)
+        end
       end
     end
   end

data/lib/rubocop/cop/layout/space_inside_block_braces.rb

@@ -84,6 +84,13 @@ module RuboCop
         def on_block(node)
           return if node.keywords?
 
+          # Do not register an offense for multi-line empty braces. That means
+          # preventing auto-correction to single-line empty braces. It will
+          # conflict with auto-correction by `Layout/SpaceInsideBlockBraces` cop
+          # if auto-corrected to a single-line empty braces.
+          # See: https://github.com/rubocop-hq/rubocop/issues/7363
+          return if node.body.nil? && node.multiline?
+
           left_brace = node.loc.begin
           right_brace = node.loc.end
 

data/lib/rubocop/cop/layout/space_inside_parens.rb

@@ -72,7 +72,7 @@ module RuboCop
             # If the second token is a comment, that means that a line break
             # follows, and that the rules for space inside don't apply.
             next if token2.comment?
-            next unless token2.line == token1.line && token1.space_after?
+            next unless same_line?(token1, token2) && token1.space_after?
 
             yield range_between(token1.end_pos, token2.begin_pos)
           end
@@ -82,17 +82,18 @@ module RuboCop
           tokens.each_cons(2) do |token1, token2|
             next if can_be_ignored?(token1, token2)
 
-            next unless token2.line == token1.line && !token1.space_after?
-
             if token1.left_parens?
               yield range_between(token2.begin_pos, token2.begin_pos + 1)
-
             elsif token2.right_parens?
               yield range_between(token2.begin_pos, token2.end_pos)
             end
           end
         end
 
+        def same_line?(token1, token2)
+          token1.line == token2.line
+        end
+
         def parens?(token1, token2)
           token1.left_parens? || token2.right_parens?
         end
@@ -104,8 +105,7 @@ module RuboCop
           # follows, and that the rules for space inside don't apply.
           return true if token2.comment?
 
-          # Ignore empty parens. # TODO: Could be configurable.
-          return true if token1.left_parens? && token2.right_parens?
+          return true unless same_line?(token1, token2) && !token1.space_after?
         end
       end
     end

data/lib/rubocop/cop/layout/space_inside_string_interpolation.rb

@@ -19,61 +19,45 @@ module RuboCop
       #   # good
       #      var = "This is the #{ space } example"
       class SpaceInsideStringInterpolation < Cop
+        include Interpolation
+        include SurroundingSpace
         include ConfigurableEnforcedStyle
         include RangeHelp
 
         NO_SPACE_MSG = 'Space inside string interpolation detected.'
-        SPACE_MSG = 'Missing space around string interpolation detected.'
+        SPACE_MSG = 'Missing space inside string interpolation detected.'
 
-        def on_dstr(node)
-          each_style_violation(node) do |final_node|
-            add_offense(final_node)
-          end
-        end
+        def on_interpolation(begin_node)
+          return if begin_node.multiline?
 
-        def autocorrect(node)
-          new_source = style == :no_space ? node.source : " #{node.source} "
-          lambda do |corrector|
-            corrector.replace(
-              range_with_surrounding_space(range: node.source_range),
-              new_source
-            )
+          delims = delimiters(begin_node)
+          return if empty_brackets?(*delims)
+
+          if style == :no_space
+            no_space_offenses(begin_node, *delims, NO_SPACE_MSG)
+          else
+            space_offenses(begin_node, *delims, SPACE_MSG)
           end
         end
 
-        private
-
-        def each_style_violation(node)
-          node.each_child_node(:begin) do |begin_node|
-            final_node = begin_node.children.last
-            next unless final_node
+        def autocorrect(begin_node)
+          lambda do |corrector|
+            delims = delimiters(begin_node)
 
-            if style == :no_space && space_on_any_side?(final_node)
-              yield final_node
-            elsif style == :space && !space_on_each_side?(final_node)
-              yield final_node
+            if style == :no_space
+              SpaceCorrector.remove_space(processed_source, corrector, *delims)
+            else
+              SpaceCorrector.add_space(processed_source, corrector, *delims)
             end
           end
         end
 
-        def message(_node)
-          style == :no_space ? NO_SPACE_MSG : SPACE_MSG
-        end
-
-        def space_on_any_side?(node)
-          interp = node.source_range
-          interp_with_surrounding_space =
-            range_with_surrounding_space(range: interp)
-
-          interp_with_surrounding_space != interp
-        end
-
-        def space_on_each_side?(node)
-          interp = node.source_range
-          interp_with_surrounding_space =
-            range_with_surrounding_space(range: interp)
+        private
 
-          interp_with_surrounding_space.source == " #{interp.source} "
+        def delimiters(begin_node)
+          left = processed_source.tokens[index_of_first_token(begin_node)]
+          right = processed_source.tokens[index_of_last_token(begin_node)]
+          [left, right]
         end
       end
     end

data/lib/rubocop/cop/layout/{trailing_blank_lines.rb → trailing_empty_lines.rb}

@@ -37,7 +37,7 @@ module RuboCop
       #   class Foo; end
       #   # EOF
       #
-      class TrailingBlankLines < Cop
+      class TrailingEmptyLines < Cop
         include ConfigurableEnforcedStyle
         include RangeHelp
 

data/lib/rubocop/cop/layout/trailing_whitespace.rb

@@ -14,6 +14,20 @@ module RuboCop
       #   # good
       #   x = 0
       #
+      # @example AllowInHeredoc: false (default)
+      #   # The line in this example contains spaces after the 0.
+      #   # bad
+      #   code = <<~RUBY
+      #     x = 0
+      #   RUBY
+      #
+      # @example AllowInHeredoc: true
+      #   # The line in this example contains spaces after the 0.
+      #   # good
+      #   code = <<~RUBY
+      #     x = 0
+      #   RUBY
+      #
       class TrailingWhitespace < Cop
         include RangeHelp
 
@@ -22,11 +36,13 @@ module RuboCop
         def investigate(processed_source)
           heredoc_ranges = extract_heredoc_ranges(processed_source.ast)
           processed_source.lines.each_with_index do |line, index|
+            lineno = index + 1
+
             next unless line.end_with?(' ', "\t")
-            next if skip_heredoc? && inside_heredoc?(heredoc_ranges, index + 1)
+            next if skip_heredoc? && inside_heredoc?(heredoc_ranges, lineno)
 
             range = source_range(processed_source.buffer,
-                                 index + 1,
+                                 lineno,
                                  (line.rstrip.length)...(line.length))
 
             add_offense(range, location: range)

data/lib/rubocop/cop/lint/assignment_in_condition.rb

@@ -6,21 +6,34 @@ module RuboCop
       # This cop checks for assignments in the conditions of
       # if/while/until.
       #
-      # @example
+      # `AllowSafeAssignment` option for safe assignment.
+      # By safe assignment we mean putting parentheses around
+      # an assignment to indicate "I know I'm using an assignment
+      # as a condition. It's not a mistake."
       #
+      # @example
       #   # bad
-      #
       #   if some_var = true
       #     do_something
       #   end
       #
-      # @example
+      #   # good
+      #   if some_var == true
+      #     do_something
+      #   end
       #
+      # @example AllowSafeAssignment: true (default)
       #   # good
+      #   if (some_var = true)
+      #     do_something
+      #   end
       #
-      #   if some_var == true
+      # @example AllowSafeAssignment: false
+      #   # bad
+      #   if (some_var = true)
       #     do_something
       #   end
+      #
       class AssignmentInCondition < Cop
         include SafeAssignment
 

data/lib/rubocop/cop/lint/debugger.rb

@@ -43,7 +43,7 @@ module RuboCop
         PATTERN
 
         def_node_matcher :debugger_call?, <<~PATTERN
-          {(send {nil? #kernel?} {:debugger :byebug} ...)
+          {(send {nil? #kernel?} {:debugger :byebug :remote_byebug} ...)
            (send (send {#kernel? nil?} :binding)
              {:pry :remote_pry :pry_remote} ...)
            (send (const {nil? (cbase)} :Pry) :rescue ...)
@@ -56,8 +56,6 @@ module RuboCop
           (send (send {#kernel? nil?} :binding) :irb ...)
         PATTERN
 
-        def_node_matcher :pry_rescue?, '(send (const nil? :Pry) :rescue ...)'
-
         def on_send(node)
           return unless debugger_call?(node) || binding_irb?(node)
 

data/lib/rubocop/cop/lint/disjunctive_assignment_in_constructor.rb

@@ -33,7 +33,7 @@ module RuboCop
 
         # @param [DefNode] node a constructor definition
         def check(node)
-          return unless node.method_name == :initialize
+          return unless node.method?(:initialize)
 
           check_body(node.body)
         end

data/lib/rubocop/cop/lint/{duplicated_key.rb → duplicate_hash_key.rb}

@@ -18,7 +18,7 @@ module RuboCop
       #   # good
       #
       #   hash = { food: 'apple', other_food: 'orange' }
-      class DuplicatedKey < Cop
+      class DuplicateHashKey < Cop
         include Duplication
 
         MSG = 'Duplicated key in hash literal.'

data/lib/rubocop/cop/lint/empty_interpolation.rb

@@ -17,12 +17,12 @@ module RuboCop
       #
       #   "result is #{some_result}"
       class EmptyInterpolation < Cop
+        include Interpolation
+
         MSG = 'Empty interpolation detected.'
 
-        def on_dstr(node)
-          node.each_child_node(:begin) do |begin_node|
-            add_offense(begin_node) if begin_node.children.empty?
-          end
+        def on_interpolation(begin_node)
+          add_offense(begin_node) if begin_node.children.empty?
         end
 
         def autocorrect(node)

data/lib/rubocop/cop/lint/erb_new_arguments.rb

@@ -61,6 +61,7 @@ module RuboCop
       #
       class ErbNewArguments < Cop
         extend TargetRubyVersion
+        include RangeHelp
 
         minimum_target_ruby_version 2.6
 
@@ -85,22 +86,78 @@ module RuboCop
           erb_new_with_non_keyword_arguments(node) do |arguments|
             return if correct_arguments?(arguments)
 
-            1.upto(3) do |i|
-              next if !arguments[i] || arguments[i].hash_type?
+            arguments[1..3].each_with_index do |argument, i|
+              next if !argument || argument.hash_type?
 
-              message = format(MESSAGES[i - 1], arg_value: arguments[i].source)
+              message = format(MESSAGES[i], arg_value: argument.source)
 
               add_offense(
-                node, location: arguments[i].source_range, message: message
+                node, location: argument.source_range, message: message
               )
             end
           end
         end
 
+        def autocorrect(node)
+          str_arg = node.arguments[0].source
+
+          kwargs = build_kwargs(node)
+          overridden_kwargs = override_by_legacy_args(kwargs, node)
+
+          good_arguments = [
+            str_arg, overridden_kwargs
+          ].flatten.compact.join(', ')
+
+          lambda do |corrector|
+            corrector.replace(arguments_range(node), good_arguments)
+          end
+        end
+
+        private
+
         def correct_arguments?(arguments)
           arguments.size == 1 ||
             arguments.size == 2 && arguments[1].hash_type?
         end
+
+        def build_kwargs(node)
+          return [nil, nil] unless node.arguments.last.hash_type?
+
+          trim_mode_arg, eoutvar_arg = nil
+
+          node.arguments.last.pairs.each do |pair|
+            case pair.key.source
+            when 'trim_mode'
+              trim_mode_arg = "trim_mode: #{pair.value.source}"
+            when 'eoutvar'
+              eoutvar_arg = "eoutvar: #{pair.value.source}"
+            end
+          end
+
+          [trim_mode_arg, eoutvar_arg]
+        end
+
+        def override_by_legacy_args(kwargs, node)
+          arguments = node.arguments
+          overridden_kwargs = kwargs.dup
+
+          if arguments[2]
+            overridden_kwargs[0] = "trim_mode: #{arguments[2].source}"
+          end
+
+          if arguments[3] && !arguments[3].hash_type?
+            overridden_kwargs[1] = "eoutvar: #{arguments[3].source}"
+          end
+
+          overridden_kwargs
+        end
+
+        def arguments_range(node)
+          arguments = node.arguments
+
+          range_between(arguments.first.source_range.begin_pos,
+                        arguments.last.source_range.end_pos)
+        end
       end
     end
   end

data/lib/rubocop/cop/lint/format_parameter_mismatch.rb

@@ -22,16 +22,10 @@ module RuboCop
         # http://rubular.com/r/CvpbxkcTzy
         MSG = "Number of arguments (%<arg_num>i) to `%<method>s` doesn't " \
               'match the number of fields (%<field_num>i).'
-        FIELD_REGEX =
-          /(%(([\s#+-0\*]*)(\d*)?(\.\d+)?[bBdiouxXeEfgGaAcps]|%))/.freeze
-        NAMED_FIELD_REGEX = /%\{[_a-zA-Z][_a-zA-Z]+\}/.freeze
+
         KERNEL = 'Kernel'
         SHOVEL = '<<'
-        PERCENT = '%'
-        PERCENT_PERCENT = '%%'
-        DIGIT_DOLLAR_FLAG = /%(\d+)\$/.freeze
         STRING_TYPES = %i[str dstr].freeze
-        NAMED_INTERPOLATION = /%(?:<\w+>|\{\w+\})/.freeze
 
         def on_send(node)
           return unless offending_node?(node)
@@ -44,7 +38,7 @@ module RuboCop
         def offending_node?(node)
           return false unless called_on_string?(node)
           return false unless method_with_format_args?(node)
-          return false if named_mode?(node) || splat_args?(node)
+          return false if splat_args?(node)
 
           num_of_format_args, num_of_expected_fields = count_matches(node)
 
@@ -70,16 +64,6 @@ module RuboCop
           sprintf?(node) || format?(node) || percent?(node)
         end
 
-        def named_mode?(node)
-          relevant_node = if sprintf?(node) || format?(node)
-                            node.first_argument
-                          elsif percent?(node)
-                            node.receiver
-                          end
-
-          !relevant_node.source.scan(NAMED_FIELD_REGEX).empty?
-        end
-
         def splat_args?(node)
           return false if percent?(node)
 
@@ -127,27 +111,17 @@ module RuboCop
 
         def expected_fields_count(node)
           return :unknown unless node.str_type?
-          return 1 if node.source =~ NAMED_INTERPOLATION
 
-          max_digit_dollar_num = max_digit_dollar_num(node)
-          return max_digit_dollar_num if max_digit_dollar_num&.nonzero?
+          format_string = RuboCop::Cop::Utils::FormatString.new(node.source)
+          return 1 if format_string.named_interpolation?
 
-          node
-            .source
-            .scan(FIELD_REGEX)
-            .reject { |x| x.first == PERCENT_PERCENT }
-            .reduce(0) { |acc, elem| acc + arguments_count(elem[2]) }
-        end
-
-        def max_digit_dollar_num(node)
-          node.source.scan(DIGIT_DOLLAR_FLAG).map do |digit_dollar_num|
-            digit_dollar_num.first.to_i
-          end.max
-        end
+          max_digit_dollar_num = format_string.max_digit_dollar_num
+          return max_digit_dollar_num if max_digit_dollar_num&.nonzero?
 
-        # number of arguments required for the format sequence
-        def arguments_count(format)
-          format.scan('*').count + 1
+          format_string
+            .format_sequences
+            .reject(&:percent?)
+            .reduce(0) { |acc, seq| acc + seq.arity }
         end
 
         def format?(node)