rubocop 1.39.0 → 1.42.0

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

@@ -9,13 +9,18 @@ module RuboCop
       # NOTE: This cop does not move the first argument, if you want that to
       # be on a separate line, see `Layout/FirstMethodArgumentLineBreak`.
       #
-      # @example
+      # @example AllowMultilineFinalElement: false (default)
       #
       #   # bad
       #   foo(a, b,
       #     c
       #   )
       #
+      #   # bad
+      #   foo(a, b, {
+      #     foo: "bar",
+      #   })
+      #
       #   # good
       #   foo(
       #     a,
@@ -25,6 +30,46 @@ module RuboCop
       #
       #   # good
       #   foo(a, b, c)
+      #
+      #   # good
+      #   foo(
+      #     a,
+      #     b,
+      #     {
+      #       foo: "bar",
+      #     }
+      #   )
+      #
+      # @example AllowMultilineFinalElement: true
+      #
+      #   # bad
+      #   foo(a, b,
+      #     c
+      #   )
+      #
+      #   # good
+      #   foo(a, b, {
+      #     foo: "bar",
+      #   })
+      #
+      #   # good
+      #   foo(
+      #     a,
+      #     b,
+      #     c
+      #   )
+      #
+      #   # good
+      #   foo(a, b, c)
+      #
+      #   # good
+      #   foo(
+      #     a,
+      #     b,
+      #     {
+      #       foo: "bar",
+      #     }
+      #   )
       class MultilineMethodArgumentLineBreaks < Base
         include MultilineElementLineBreaks
         extend AutoCorrector
@@ -45,7 +90,13 @@ module RuboCop
           last_arg = args.last
           args = args[0...-1] + last_arg.children if last_arg&.hash_type? && !last_arg&.braces?
 
-          check_line_breaks(node, args)
+          check_line_breaks(node, args, ignore_last: ignore_last_element?)
+        end
+
+        private
+
+        def ignore_last_element?
+          !!cop_config['AllowMultilineFinalElement']
         end
       end
     end

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

@@ -9,7 +9,7 @@ module RuboCop
       # NOTE: This cop does not move the first argument, if you want that to
       # be on a separate line, see `Layout/FirstMethodParameterLineBreak`.
       #
-      # @example
+      # @example AllowMultilineFinalElement: false (default)
       #
       #   # bad
       #   def foo(a, b,
@@ -17,6 +17,47 @@ module RuboCop
       #   )
       #   end
       #
+      #   # bad
+      #   def foo(a, b = {
+      #     foo: "bar",
+      #   })
+      #   end
+      #
+      #   # good
+      #   def foo(
+      #     a,
+      #     b,
+      #     c
+      #   )
+      #   end
+      #
+      #   # good
+      #   def foo(
+      #     a,
+      #     b = {
+      #       foo: "bar",
+      #     }
+      #   )
+      #   end
+      #
+      #   # good
+      #   def foo(a, b, c)
+      #   end
+      #
+      # @example AllowMultilineFinalElement: true
+      #
+      #   # bad
+      #   def foo(a, b,
+      #     c
+      #   )
+      #   end
+      #
+      #   # good
+      #   def foo(a, b = {
+      #     foo: "bar",
+      #   })
+      #   end
+      #
       #   # good
       #   def foo(
       #     a,
@@ -26,6 +67,15 @@ module RuboCop
       #   end
       #
       #   # good
+      #   def foo(
+      #     a,
+      #     b = {
+      #       foo: "bar",
+      #     }
+      #   )
+      #   end
+      #
+      #   # good
       #   def foo(a, b, c)
       #   end
       class MultilineMethodParameterLineBreaks < Base
@@ -37,7 +87,13 @@ module RuboCop
         def on_def(node)
           return if node.arguments.empty?
 
-          check_line_breaks(node, node.arguments)
+          check_line_breaks(node, node.arguments, ignore_last: ignore_last_element?)
+        end
+
+        private
+
+        def ignore_last_element?
+          !!cop_config['AllowMultilineFinalElement']
         end
       end
     end

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

@@ -84,11 +84,11 @@ module RuboCop
           return true if other_cop_takes_precedence?(node)
 
           !cop_config['InspectBlocks'] && (node.block_type? ||
-                                           node.each_descendant(:block).any?(&:multiline?))
+                                           any_descendant?(node, :block, &:multiline?))
         end
 
         def other_cop_takes_precedence?(node)
-          single_line_block_chain_enabled? && node.each_descendant(:block).any? do |block_node|
+          single_line_block_chain_enabled? && any_descendant?(node, :block) do |block_node|
             block_node.parent.send_type? && block_node.parent.loc.dot && !block_node.multiline?
           end
         end

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

@@ -256,7 +256,7 @@ module RuboCop
           # regular dotted method calls bind more tightly than operators
           # so we need to climb up the AST past them
           node.each_ancestor do |ancestor|
-            return true if ancestor.and_type? || ancestor.or_type?
+            return true if ancestor.and_type? || ancestor.or_type? || ancestor.range_type?
             return false unless ancestor.send_type?
             return true if ancestor.operator_method?
           end

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

@@ -79,7 +79,7 @@ module RuboCop
         def ends_in_end?(processed_source)
           buffer = processed_source.buffer
 
-          return true if buffer.source.strip.start_with?('__END__')
+          return true if buffer.source.match?(/\s*__END__/)
           return false if processed_source.tokens.empty?
 
           extra = buffer.source[processed_source.tokens.last.end_pos..]

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

@@ -47,7 +47,6 @@ module RuboCop
         MSG = 'Trailing whitespace detected.'
 
         def on_new_investigation
-          @heredocs = extract_heredocs(processed_source.ast)
           processed_source.lines.each_with_index do |line, index|
             next unless line.end_with?(' ', "\t")
 
@@ -102,17 +101,25 @@ module RuboCop
         end
 
         def find_heredoc(line_number)
-          @heredocs.each { |node, r| return node if r.include?(line_number) }
+          heredocs.each { |node, r| return node if r.include?(line_number) }
           nil
         end
 
+        def heredocs
+          @heredocs ||= extract_heredocs(processed_source.ast)
+        end
+
         def extract_heredocs(ast)
           return [] unless ast
 
-          ast.each_node(:str, :dstr, :xstr).select(&:heredoc?).map do |node|
+          heredocs = []
+          ast.each_node(:str, :dstr, :xstr) do |node|
+            next unless node.heredoc?
+
             body = node.location.heredoc_body
-            [node, body.first_line...body.last_line]
+            heredocs << [node, body.first_line...body.last_line]
           end
+          heredocs
         end
 
         def offense_range(lineno, line)

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

@@ -63,7 +63,7 @@ module RuboCop
           return unless node.arguments?
 
           return unless ambiguous_block_association?(node)
-          return if node.parenthesized? || node.last_argument.lambda? || node.last_argument.proc? ||
+          return if node.parenthesized? || node.last_argument.lambda_or_proc? ||
                     allowed_method_pattern?(node)
 
           message = message(node)

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

@@ -11,6 +11,10 @@ module RuboCop
       # an assignment to indicate "I know I'm using an assignment
       # as a condition. It's not a mistake."
       #
+      # @safety
+      #   This cop's autocorrection is unsafe because it assumes that
+      #   the author meant to use an assignment result as a condition.
+      #
       # @example
       #   # bad
       #   if some_var = true
@@ -35,6 +39,8 @@ module RuboCop
       #   end
       #
       class AssignmentInCondition < Base
+        extend AutoCorrector
+
         include SafeAssignment
 
         MSG_WITH_SAFE_ASSIGNMENT_ALLOWED =
@@ -53,7 +59,11 @@ module RuboCop
             next :skip_children if skip_children?(asgn_node)
             next if allowed_construct?(asgn_node)
 
-            add_offense(asgn_node.loc.operator)
+            add_offense(asgn_node.loc.operator) do |corrector|
+              next unless safe_assignment_allowed?
+
+              corrector.wrap(asgn_node, '(', ')')
+            end
           end
         end
         alias on_while on_if

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

@@ -16,6 +16,10 @@ module RuboCop
       # using the same name a namespace and a class. To avoid too many unnecessary
       # offenses, Enable this cop with `Only: [The, Constant, Names, Causing, Issues]`
       #
+      # NOTE: `Style/RedundantConstantBase` cop is disabled if this cop is enabled to prevent
+      # conflicting rules. Because it respects user configurations that want to enable
+      # this cop which is disabled by default.
+      #
       # @example
       #   # By default checks every constant
       #

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

@@ -96,8 +96,10 @@ module RuboCop
         end
 
         def debugger_method?(send_node)
+          method_name = send_node.method_name
+
           debugger_methods.any? do |method|
-            next unless method[:method_name] == send_node.method_name
+            next unless method[:method_name] == method_name
 
             if method[:receiver].nil?
               send_node.receiver.nil?

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

@@ -14,7 +14,8 @@ module RuboCop
       #       Alternative: 'alternative_value'
       #       DeprecatedVersion: 'deprecated_version'
       #
-      # By default, `NIL`, `TRUE`, `FALSE` and `Random::DEFAULT` are configured.
+      # By default, `NIL`, `TRUE`, `FALSE`, `Net::HTTPServerException, `Random::DEFAULT`,
+      # `Struct::Group`, and `Struct::Passwd` are configured.
       #
       # @example
       #
@@ -22,13 +23,19 @@ module RuboCop
       #   NIL
       #   TRUE
       #   FALSE
+      #   Net::HTTPServerException
       #   Random::DEFAULT # Return value of Ruby 2 is `Random` instance, Ruby 3.0 is `Random` class.
+      #   Struct::Group
+      #   Struct::Passwd
       #
       #   # good
       #   nil
       #   true
       #   false
+      #   Net::HTTPClientException
       #   Random.new # `::DEFAULT` has been deprecated in Ruby 3, `.new` is compatible with Ruby 2.
+      #   Etc::Group
+      #   Etc::Passwd
       #
       class DeprecatedConstants < Base
         extend AutoCorrector

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

@@ -84,8 +84,6 @@ module RuboCop
       #   end
       #
       class DuplicateBranch < Base
-        include RescueNode
-
         MSG = 'Duplicate branch body detected.'
 
         def on_branching_statement(node)

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

@@ -57,19 +57,20 @@ module RuboCop
         def initialize(config = nil, options = nil)
           super
           @definitions = {}
+          @scopes = Hash.new { |hash, key| hash[key] = [] }
         end
 
         def on_def(node)
           # if a method definition is inside an if, it is very likely
           # that a different definition is used depending on platform, etc.
-          return if node.ancestors.any?(&:if_type?)
+          return if node.each_ancestor.any?(&:if_type?)
           return if possible_dsl?(node)
 
           found_instance_method(node, node.method_name)
         end
 
         def on_defs(node)
-          return if node.ancestors.any?(&:if_type?)
+          return if node.each_ancestor.any?(&:if_type?)
           return if possible_dsl?(node)
 
           if node.receiver.const_type?
@@ -157,16 +158,18 @@ module RuboCop
 
         def found_method(node, method_name)
           key = method_key(node, method_name)
+          scope = node.each_ancestor(:rescue, :ensure).first&.type
 
           if @definitions.key?(key)
-            loc = if DEF_TYPES.include?(node.type)
-                    node.loc.keyword.join(node.loc.name)
-                  else
-                    node.loc.expression
-                  end
+            if scope && !@scopes[scope].include?(key)
+              @definitions[key] = node
+              @scopes[scope] << key
+              return
+            end
+
             message = message_for_dup(node, method_name, key)
 
-            add_offense(loc, message: message)
+            add_offense(location(node), message: message)
           else
             @definitions[key] = node
           end
@@ -180,6 +183,14 @@ module RuboCop
           end
         end
 
+        def location(node)
+          if DEF_TYPES.include?(node.type)
+            node.loc.keyword.join(node.loc.name)
+          else
+            node.loc.expression
+          end
+        end
+
         def on_attr(node, attr_name, args)
           case attr_name
           when :attr

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

@@ -65,7 +65,7 @@ module RuboCop
 
         def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
           return if node.body
-          return if allow_empty_lambdas? && lambda_or_proc?(node)
+          return if allow_empty_lambdas? && node.lambda_or_proc?
           return if cop_config['AllowComments'] && allow_comment?(node)
 
           add_offense(node)
@@ -88,10 +88,6 @@ module RuboCop
           regexp_pattern = "# rubocop : (disable|todo) ([^,],)* (all|#{cop_name})"
           Regexp.new(regexp_pattern.gsub(' ', '\s*')).match?(comment)
         end
-
-        def lambda_or_proc?(node)
-          node.lambda? || node.proc?
-        end
       end
     end
   end

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

@@ -68,7 +68,7 @@ module RuboCop
         MSG = 'Avoid `%<keyword>s` branches without a body.'
 
         def on_if(node)
-          return if node.body
+          return if node.body || same_line?(node.loc.begin, node.loc.end)
           return if cop_config['AllowComments'] && contains_comments?(node)
 
           add_offense(node, message: format(MSG, keyword: node.keyword)) do |corrector|

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

@@ -6,9 +6,10 @@ module RuboCop
       # Checks for interpolation in a single quoted string.
       #
       # @safety
-      #   This cop is generally safe, but is marked as unsafe because
-      #   it is possible to actually intentionally have text inside
-      #   `#{...}` in a single quoted string.
+      #   This cop's autocorrection is unsafe because although it always replaces single quotes as
+      #   if it were miswritten double quotes, it is not always the case. For example,
+      #   `'#{foo} bar'` would be replaced by `"#{foo} bar"`, so the replaced code would evaluate
+      #   the expression `foo`.
       #
       # @example
       #

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

@@ -44,7 +44,6 @@ module RuboCop
       class NonAtomicFileOperation < Base
         extend AutoCorrector
         include Alignment
-        include RangeHelp
 
         MSG_REMOVE_FILE_EXIST_CHECK = 'Remove unnecessary existence check ' \
                                       '`%<receiver>s.%<method_name>s`.'
@@ -101,10 +100,11 @@ module RuboCop
         def register_offense(node, exist_node)
           add_offense(node, message: message_change_force_method(node)) unless force_method?(node)
 
-          range = range_between(node.parent.loc.keyword.begin_pos,
-                                exist_node.loc.expression.end_pos)
+          parent = node.parent
+          range = parent.loc.keyword.begin.join(parent.condition.source_range.end)
+
           add_offense(range, message: message_remove_file_exist_check(exist_node)) do |corrector|
-            autocorrect(corrector, node, range) unless node.parent.elsif?
+            autocorrect(corrector, node, range) unless parent.elsif?
           end
         end
 
@@ -120,7 +120,12 @@ module RuboCop
         def autocorrect(corrector, node, range)
           corrector.remove(range)
           autocorrect_replace_method(corrector, node)
-          corrector.remove(node.parent.loc.end) if node.parent.multiline?
+
+          if node.parent.modifier_form?
+            corrector.remove(node.source_range.end.join(node.parent.loc.keyword.begin))
+          else
+            corrector.remove(node.parent.loc.end)
+          end
         end
 
         def autocorrect_replace_method(corrector, node)

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

@@ -68,6 +68,12 @@ module RuboCop
           @valid_ref = regexp_conditions.map { |condition| check_regexp(condition) }.compact.max
         end
 
+        def on_in_pattern(node)
+          regexp_patterns = patterns(node).select(&:regexp_type?)
+
+          @valid_ref = regexp_patterns.map { |pattern| check_regexp(pattern) }.compact.max
+        end
+
         def on_nth_ref(node)
           backref, = *node
           return if @valid_ref.nil? || backref <= @valid_ref
@@ -84,6 +90,19 @@ module RuboCop
 
         private
 
+        def patterns(pattern_node)
+          pattern = pattern_node.node_parts[0]
+
+          case pattern.type
+          when :array_pattern, :match_alt
+            pattern.children
+          when :match_as
+            patterns(pattern)
+          else
+            [pattern]
+          end
+        end
+
         def check_regexp(node)
           return if node.interpolation?
 

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

@@ -40,11 +40,16 @@ module RuboCop
           unless node.arguments.one? && first_argument_starts_with_left_parenthesis?(node)
             return true
           end
+          return true if first_argument_block_type?(node.first_argument)
 
           node.operator_method? || node.setter_method? || chained_calls?(node) ||
             valid_first_argument?(node.first_argument)
         end
 
+        def first_argument_block_type?(first_arg)
+          first_arg.block_type? || first_arg.numblock_type?
+        end
+
         def valid_first_argument?(first_arg)
           first_arg.operator_keyword? || first_arg.hash_type? || ternary_expression?(first_arg)
         end

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

@@ -128,23 +128,35 @@ module RuboCop
           end
         end
 
+        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def each_already_disabled(cop, line_ranges)
           line_ranges.each_cons(2) do |previous_range, range|
             next if ignore_offense?(range)
-            next unless followed_ranges?(previous_range, range)
-
             # If a cop is disabled in a range that begins on the same line as
             # the end of the previous range, it means that the cop was
             # already disabled by an earlier comment. So it's redundant
             # whether there are offenses or not.
+            next unless followed_ranges?(previous_range, range)
+
             comment = processed_source.comment_at_line(range.begin)
 
+            next unless comment
             # Comments disabling all cops don't count since it's reasonable
             # to disable a few select cops first and then all cops further
             # down in the code.
-            yield comment, cop if comment && !all_disabled?(comment)
+            next if all_disabled?(comment)
+
+            redundant =
+              if department_disabled?(cop, comment)
+                find_redundant_department(cop, range)
+              else
+                cop
+              end
+
+            yield comment, redundant if redundant
           end
         end
+        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         def find_redundant_cop(cop, range)
           cop_offenses = offenses_to_check.select { |offense| offense.cop_name == cop }

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

@@ -42,7 +42,7 @@ module RuboCop
         MSG = 'Unnecessary enabling of %<cop>s.'
 
         def on_new_investigation
-          return if processed_source.blank?
+          return if processed_source.blank? || !processed_source.raw_source.include?('enable')
 
           offenses = processed_source.comment_config.extra_enabled_comments
           offenses.each { |comment, cop_names| register_offense(comment, cop_names) }

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

@@ -17,13 +17,19 @@ module RuboCop
       #     do_something
       #   end
       class RegexpAsCondition < Base
+        include IgnoredNode
         extend AutoCorrector
 
         MSG = 'Do not use regexp literal as a condition. ' \
               'The regexp literal matches `$_` implicitly.'
 
         def on_match_current_line(node)
+          return if node.ancestors.none?(&:conditional?)
+          return if part_of_ignored_node?(node)
+
           add_offense(node) { |corrector| corrector.replace(node, "#{node.source} =~ $_") }
+
+          ignore_node(node)
         end
       end
     end

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

@@ -46,7 +46,9 @@ module RuboCop
         private
 
         def check_ternary(ternary, node)
-          return if node.method?(:[]) || !ternary.condition.operator_keyword?
+          if node.method?(:[]) || node.assignment_method? || !ternary.condition.operator_keyword?
+            return
+          end
 
           range = range_between(node.source_range.begin_pos, ternary.condition.source_range.end_pos)