rubocop 0.70.0 → 0.75.0

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)

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
 
@@ -130,7 +137,8 @@ module RuboCop
           args_delimiter = node.arguments.loc.begin # Can be ( | or nil.
 
           check_left_brace(inner, node.loc.begin, args_delimiter)
-          check_right_brace(inner, node.loc.end, node.single_line?)
+          check_right_brace(inner, node.loc.begin, node.loc.end,
+                            node.single_line?)
         end
 
         def check_left_brace(inner, left_brace, args_delimiter)
@@ -141,15 +149,26 @@ module RuboCop
           end
         end
 
-        def check_right_brace(inner, right_brace, single_line)
+        def check_right_brace(inner, left_brace, right_brace, single_line)
           if single_line && inner =~ /\S$/
             no_space(right_brace.begin_pos, right_brace.end_pos,
                      'Space missing inside }.')
           else
+            return if multiline_block?(left_brace, right_brace) &&
+                      aligned_braces?(left_brace, right_brace)
+
             space_inside_right_brace(right_brace)
           end
         end
 
+        def multiline_block?(left_brace, right_brace)
+          left_brace.first_line != right_brace.first_line
+        end
+
+        def aligned_braces?(left_brace, right_brace)
+          left_brace.first_line == right_brace.last_column
+        end
+
         def no_space_inside_left_brace(left_brace, args_delimiter)
           if pipe?(args_delimiter)
             if left_brace.end_pos == args_delimiter.begin_pos &&

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/tab.rb

@@ -30,16 +30,13 @@ module RuboCop
           str_ranges = string_literal_ranges(processed_source.ast)
 
           processed_source.lines.each.with_index(1) do |line, lineno|
-            match = line.match(/^([^\t]*)\t+/)
+            match = line.match(/\t+/)
             next unless match
 
-            prefix = match.captures[0]
-            col = prefix.length
-            next if in_string_literal?(str_ranges, lineno, col)
-
             range = source_range(processed_source.buffer,
                                  lineno,
-                                 col...match.end(0))
+                                 match.begin(0)...match.end(0))
+            next if in_string_literal?(str_ranges, range)
 
             add_offense(range, location: range)
           end
@@ -54,16 +51,9 @@ module RuboCop
 
         private
 
-        # rubocop:disable Metrics/CyclomaticComplexity
-        def in_string_literal?(ranges, line, col)
-          ranges.any? do |range|
-            (range.line == line && range.column <= col) ||
-              (range.line < line && line < range.last_line) ||
-              (range.line != line && range.last_line == line &&
-               range.last_column >= col)
-          end
+        def in_string_literal?(ranges, tabs_range)
+          ranges.any? { |range| range.contains?(tabs_range) }
         end
-        # rubocop:enable Metrics/CyclomaticComplexity
 
         def string_literal_ranges(ast)
           # which lines start inside a string literal?
@@ -72,13 +62,11 @@ module RuboCop
           ast.each_node(:str, :dstr).each_with_object(Set.new) do |str, ranges|
             loc = str.location
 
-            range = if str.heredoc?
-                      loc.heredoc_body
-                    else
-                      loc.expression
-                    end
-
-            ranges << range
+            if str.heredoc?
+              ranges << loc.heredoc_body
+            elsif loc.respond_to?(:begin) && loc.begin
+              ranges << loc.expression
+            end
           end
         end
       end

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/big_decimal_new.rb

@@ -18,7 +18,7 @@ module RuboCop
         MSG = '`%<double_colon>sBigDecimal.new()` is deprecated. ' \
               'Use `%<double_colon>sBigDecimal()` instead.'
 
-        def_node_matcher :big_decimal_new, <<-PATTERN
+        def_node_matcher :big_decimal_new, <<~PATTERN
           (send
             (const ${nil? cbase} :BigDecimal) :new ...)
         PATTERN

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

@@ -35,15 +35,15 @@ module RuboCop
       class Debugger < Cop
         MSG = 'Remove debugger entry point `%<source>s`.'
 
-        def_node_matcher :kernel?, <<-PATTERN
+        def_node_matcher :kernel?, <<~PATTERN
           {
             (const nil? :Kernel)
             (const (cbase) :Kernel)
           }
         PATTERN
 
-        def_node_matcher :debugger_call?, <<-PATTERN
-          {(send {nil? #kernel?} {:debugger :byebug} ...)
+        def_node_matcher :debugger_call?, <<~PATTERN
+          {(send {nil? #kernel?} {:debugger :byebug :remote_byebug} ...)
            (send (send {#kernel? nil?} :binding)
              {:pry :remote_pry :pry_remote} ...)
            (send (const {nil? (cbase)} :Pry) :rescue ...)
@@ -52,12 +52,10 @@ module RuboCop
                       :save_screenshot} ...)}
         PATTERN
 
-        def_node_matcher :binding_irb_call?, <<-PATTERN
+        def_node_matcher :binding_irb_call?, <<~PATTERN
           (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/duplicate_methods.rb

@@ -79,7 +79,7 @@ module RuboCop
           end
         end
 
-        def_node_matcher :method_alias?, <<-PATTERN
+        def_node_matcher :method_alias?, <<~PATTERN
           (alias (sym $_name) sym)
         PATTERN
 
@@ -91,11 +91,11 @@ module RuboCop
           found_instance_method(node, name)
         end
 
-        def_node_matcher :alias_method?, <<-PATTERN
+        def_node_matcher :alias_method?, <<~PATTERN
           (send nil? :alias_method (sym $_name) _)
         PATTERN
 
-        def_node_matcher :attr?, <<-PATTERN
+        def_node_matcher :attr?, <<~PATTERN
           (send nil? ${:attr_reader :attr_writer :attr_accessor :attr} $...)
         PATTERN
 

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

@@ -24,7 +24,7 @@ module RuboCop
       class EachWithObjectArgument < Cop
         MSG = 'The argument to each_with_object can not be immutable.'
 
-        def_node_matcher :each_with_object?, <<-PATTERN
+        def_node_matcher :each_with_object?, <<~PATTERN
           ({send csend} _ :each_with_object $_)
         PATTERN
 

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
 
@@ -76,7 +77,7 @@ module RuboCop
           '`ERB.new(str, eoutvar: %<arg_value>s)` instead.'
         ].freeze
 
-        def_node_matcher :erb_new_with_non_keyword_arguments, <<-PATTERN
+        def_node_matcher :erb_new_with_non_keyword_arguments, <<~PATTERN
           (send
             (const {nil? cbase} :ERB) :new $...)
         PATTERN
@@ -97,10 +98,65 @@ module RuboCop
           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)
+          overridden_kwargs = kwargs.dup
+
+          if node.arguments[2]
+            overridden_kwargs[0] = "trim_mode: #{node.arguments[2].source}"
+          end
+
+          if node.arguments[3] && !node.arguments[3].hash_type?
+            overridden_kwargs[1] = "eoutvar: #{node.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)
 
@@ -61,7 +55,7 @@ module RuboCop
           end
         end
 
-        def_node_matcher :called_on_string?, <<-PATTERN
+        def_node_matcher :called_on_string?, <<~PATTERN
           {(send {nil? const_type?} _ (str _) ...)
            (send (str ...) ...)}
         PATTERN
@@ -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)