rubocop 0.72.0 → 0.76.0

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/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
@@ -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)
 
@@ -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)

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

@@ -53,7 +53,7 @@ module RuboCop
         ALTERNATIVE_PROTECTED = '`protected` inside a `class << self` ' \
                                 'block'
 
-        def_node_search :private_class_methods, <<-PATTERN
+        def_node_search :private_class_methods, <<~PATTERN
           (send nil? :private_class_method $...)
         PATTERN
 

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

@@ -55,7 +55,7 @@ module RuboCop
           SystemExit
         ].freeze
 
-        def_node_matcher :class_new_call?, <<-PATTERN
+        def_node_matcher :class_new_call?, <<~PATTERN
           (send
             (const {cbase nil?} :Class) :new
             $(const {cbase nil?} _))

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

@@ -17,21 +17,20 @@ module RuboCop
       #
       #   "result is 10"
       class LiteralInInterpolation < Cop
+        include Interpolation
         include RangeHelp
         include PercentLiteral
 
         MSG = 'Literal interpolation detected.'
         COMPOSITE = %i[array hash pair irange erange].freeze
 
-        def on_dstr(node)
-          node.each_child_node(:begin) do |begin_node|
-            final_node = begin_node.children.last
-            next unless final_node
-            next if special_keyword?(final_node)
-            next unless prints_as_self?(final_node)
+        def on_interpolation(begin_node)
+          final_node = begin_node.children.last
+          return unless final_node
+          return if special_keyword?(final_node)
+          return unless prints_as_self?(final_node)
 
-            add_offense(final_node)
-          end
+          add_offense(final_node)
         end
 
         def autocorrect(node)

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

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-# rubocop:disable Lint/UnneededCopDisableDirective
+# rubocop:disable Lint/RedundantCopDisableDirective
 module RuboCop
   module Cop
     module Lint
@@ -81,4 +81,4 @@ module RuboCop
     end
   end
 end
-# rubocop:enable Lint/UnneededCopDisableDirective, Layout/SpaceAroundOperators
+# rubocop:enable Lint/RedundantCopDisableDirective, Layout/SpaceAroundOperators

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

@@ -24,7 +24,7 @@ module RuboCop
       class MultipleCompare < Cop
         MSG = 'Use the `&&` operator to compare multiple values.'
 
-        def_node_matcher :multiple_compare?, <<-PATTERN
+        def_node_matcher :multiple_compare?, <<~PATTERN
           (send (send _ {:< :> :<= :>=} $_) {:< :> :<= :>=} _)
         PATTERN
 

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

@@ -87,15 +87,15 @@ module RuboCop
             class_or_module_or_struct_new_call?(child)
         end
 
-        def_node_matcher :eval_call?, <<-PATTERN
+        def_node_matcher :eval_call?, <<~PATTERN
           (block (send _ {:instance_eval :class_eval :module_eval} ...) ...)
         PATTERN
 
-        def_node_matcher :exec_call?, <<-PATTERN
+        def_node_matcher :exec_call?, <<~PATTERN
           (block (send _ {:instance_exec :class_exec :module_exec} ...) ...)
         PATTERN
 
-        def_node_matcher :class_or_module_or_struct_new_call?, <<-PATTERN
+        def_node_matcher :class_or_module_or_struct_new_call?, <<~PATTERN
           (block (send (const nil? {:Class :Module :Struct}) :new ...) ...)
         PATTERN
       end