rubocop 1.24.1 → 1.64.1

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

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks that there are no repeated patterns used in `in` keywords.
+      #
+      # @example
+      #
+      #   # bad
+      #   case x
+      #   in 'first'
+      #     do_something
+      #   in 'first'
+      #     do_something_else
+      #   end
+      #
+      #   # good
+      #   case x
+      #   in 'first'
+      #     do_something
+      #   in 'second'
+      #     do_something_else
+      #   end
+      #
+      #   # bad - repeated alternate patterns with the same conditions don't depend on the order
+      #   case x
+      #   in foo | bar
+      #     first_method
+      #   in bar | foo
+      #     second_method
+      #   end
+      #
+      #   # good
+      #   case x
+      #   in foo | bar
+      #     first_method
+      #   in bar | baz
+      #     second_method
+      #   end
+      #
+      #   # bad - repeated hash patterns with the same conditions don't depend on the order
+      #   case x
+      #   in foo: a, bar: b
+      #     first_method
+      #   in bar: b, foo: a
+      #     second_method
+      #   end
+      #
+      #   # good
+      #   case x
+      #   in foo: a, bar: b
+      #     first_method
+      #   in bar: b, baz: c
+      #     second_method
+      #   end
+      #
+      #   # bad - repeated array patterns with elements in the same order
+      #   case x
+      #   in [foo, bar]
+      #     first_method
+      #   in [foo, bar]
+      #     second_method
+      #   end
+      #
+      #   # good
+      #   case x
+      #   in [foo, bar]
+      #     first_method
+      #   in [bar, foo]
+      #     second_method
+      #   end
+      #
+      #   # bad - repeated the same patterns and guard conditions
+      #   case x
+      #   in foo if bar
+      #     first_method
+      #   in foo if bar
+      #     second_method
+      #   end
+      #
+      #   # good
+      #   case x
+      #   in foo if bar
+      #     first_method
+      #   in foo if baz
+      #     second_method
+      #   end
+      #
+      class DuplicateMatchPattern < Base
+        extend TargetRubyVersion
+
+        MSG = 'Duplicate `in` pattern detected.'
+
+        minimum_target_ruby_version 2.7
+
+        def on_case_match(case_node)
+          case_node.in_pattern_branches.each_with_object(Set.new) do |in_pattern_node, previous|
+            pattern = in_pattern_node.pattern
+            next if previous.add?(pattern_identity(pattern))
+
+            add_offense(pattern)
+          end
+        end
+
+        private
+
+        def pattern_identity(pattern)
+          pattern_source = if pattern.hash_pattern_type? || pattern.match_alt_type?
+                             pattern.children.map(&:source).sort.to_s
+                           else
+                             pattern.source
+                           end
+
+          return pattern_source unless (guard = pattern.parent.children[1])
+
+          pattern_source + guard.source
+        end
+      end
+    end
+  end
+end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for duplicated instance (or singleton) method
+      # Checks for duplicated instance (or singleton) method
       # definitions.
       #
       # @example
@@ -51,25 +51,26 @@ module RuboCop
       #   alias bar foo
       class DuplicateMethods < Base
         MSG = 'Method `%<method>s` is defined at both %<defined>s and %<current>s.'
-
         RESTRICT_ON_SEND = %i[alias_method attr_reader attr_writer attr_accessor attr].freeze
+        DEF_TYPES = %i[def defs].freeze
 
         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?
@@ -127,13 +128,13 @@ module RuboCop
           found_method(node, "#{enclosing}.#{name}")
         end
 
-        def message_for_dup(node, method_name)
-          format(MSG, method: method_name, defined: source_location(@definitions[method_name]),
+        def message_for_dup(node, method_name, key)
+          format(MSG, method: method_name, defined: source_location(@definitions[key]),
                       current: source_location(node))
         end
 
         def found_instance_method(node, name)
-          return unless (scope = node.parent_module_name)
+          return found_sclass_method(node, name) unless (scope = node.parent_module_name)
 
           # Humanize the scope
           scope = scope.sub(
@@ -145,19 +146,48 @@ module RuboCop
           found_method(node, "#{scope}#{name}")
         end
 
+        def found_sclass_method(node, name)
+          singleton_ancestor = node.each_ancestor.find(&:sclass_type?)
+          return unless singleton_ancestor
+
+          singleton_receiver_node = singleton_ancestor.children[0]
+          return unless singleton_receiver_node.send_type?
+
+          found_method(node, "#{singleton_receiver_node.method_name}.#{name}")
+        end
+
         def found_method(node, method_name)
-          if @definitions.key?(method_name)
-            loc = case node.type
-                  when :def, :defs
-                    node.loc.keyword.join(node.loc.name)
-                  else
-                    node.loc.expression
-                  end
-            message = message_for_dup(node, method_name)
-
-            add_offense(loc, message: message)
+          key = method_key(node, method_name)
+          scope = node.each_ancestor(:rescue, :ensure).first&.type
+
+          if @definitions.key?(key)
+            if scope && !@scopes[scope].include?(key)
+              @definitions[key] = node
+              @scopes[scope] << key
+              return
+            end
+
+            message = message_for_dup(node, method_name, key)
+
+            add_offense(location(node), message: message)
+          else
+            @definitions[key] = node
+          end
+        end
+
+        def method_key(node, method_name)
+          if (ancestor_def = node.each_ancestor(*DEF_TYPES).first)
+            "#{ancestor_def.method_name}.#{method_name}"
+          else
+            method_name
+          end
+        end
+
+        def location(node)
+          if DEF_TYPES.include?(node.type)
+            node.loc.keyword.join(node.loc.name)
           else
-            @definitions[method_name] = node
+            node.source_range
           end
         end
 
@@ -223,12 +253,12 @@ module RuboCop
           # Assume that if a method definition is inside any block call which
           # we can't identify, it could be a DSL
           node.each_ancestor(:block).any? do |ancestor|
-            ancestor.method_name != :class_eval && !ancestor.class_constructor?
+            !ancestor.method?(:class_eval) && !ancestor.class_constructor?
           end
         end
 
         def source_location(node)
-          range = node.location.expression
+          range = node.source_range
           path = smart_path(range.source_buffer.name)
           "#{path}:#{range.line}"
         end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for duplicate elements in Regexp character classes.
+      # Checks for duplicate elements in Regexp character classes.
       #
       # @example
       #
@@ -24,6 +24,8 @@ module RuboCop
 
         MSG_REPEATED_ELEMENT = 'Duplicate element inside regexp character class'
 
+        OCTAL_DIGITS_AFTER_ESCAPE = 2
+
         def on_regexp(node)
           each_repeated_character_class_element_loc(node) do |loc|
             add_offense(loc, message: MSG_REPEATED_ELEMENT) do |corrector|
@@ -34,24 +36,60 @@ module RuboCop
 
         def each_repeated_character_class_element_loc(node)
           node.parsed_tree&.each_expression do |expr|
-            next if expr.type != :set || expr.token == :intersection
+            next if skip_expression?(expr)
 
             seen = Set.new
+            group_expressions(node, expr.expressions) do |group|
+              group_source = group.map(&:to_s).join
 
-            expr.expressions.each do |child|
-              next if within_interpolation?(node, child)
-
-              child_source = child.to_s
-
-              yield child.expression if seen.include?(child_source)
+              yield source_range(group) if seen.include?(group_source)
 
-              seen << child_source
+              seen << group_source
             end
           end
         end
 
         private
 
+        def group_expressions(node, expressions)
+          # Create a mutable list to simplify state tracking while we iterate.
+          expressions = expressions.to_a
+
+          until expressions.empty?
+            # With we may need to compose a group of multiple expressions.
+            group = [expressions.shift]
+            next if within_interpolation?(node, group.first)
+
+            # With regexp_parser < 2.7 escaped octal sequences may be up to 3
+            # separate expressions ("\\0", "0", "1").
+            pop_octal_digits(group, expressions) if escaped_octal?(group.first.to_s)
+
+            yield(group)
+          end
+        end
+
+        def pop_octal_digits(current_child, expressions)
+          OCTAL_DIGITS_AFTER_ESCAPE.times do
+            next_child = expressions.first
+            break unless octal?(next_child.to_s)
+
+            current_child << expressions.shift
+          end
+        end
+
+        def source_range(children)
+          return children.first.expression if children.size == 1
+
+          range_between(
+            children.first.expression.begin_pos,
+            children.last.expression.begin_pos + children.last.to_s.length
+          )
+        end
+
+        def skip_expression?(expr)
+          expr.type != :set || expr.token == :intersection
+        end
+
         # Since we blank interpolations with a space for every char of the interpolation, we would
         # mark every space (except the first) as duplicate if we do not skip regexp_parser nodes
         # that are within an interpolation.
@@ -61,15 +99,21 @@ module RuboCop
           interpolation_locs(node).any? { |il| il.overlaps?(parse_tree_child_loc) }
         end
 
+        def escaped_octal?(string)
+          string.length == 2 && string[0] == '\\' && octal?(string[1])
+        end
+
+        def octal?(char)
+          ('0'..'7').cover?(char)
+        end
+
         def interpolation_locs(node)
           @interpolation_locs ||= {}
 
           # Cache by loc, not by regexp content, as content can be repeated in multiple patterns
           key = node.loc
 
-          @interpolation_locs[key] ||= node.children.select(&:begin_type?).map do |interpolation|
-            interpolation.loc.expression
-          end
+          @interpolation_locs[key] ||= node.children.select(&:begin_type?).map(&:source_range)
         end
       end
     end

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

@@ -3,7 +3,11 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for duplicate `require`s and `require_relative`s.
+      # Checks for duplicate ``require``s and ``require_relative``s.
+      #
+      # @safety
+      #   This cop's autocorrection is unsafe because it may break the dependency order
+      #   of `require`.
       #
       # @example
       #   # bad
@@ -20,6 +24,9 @@ module RuboCop
       #   require_relative 'foo'
       #
       class DuplicateRequire < Base
+        include RangeHelp
+        extend AutoCorrector
+
         MSG = 'Duplicate `%<method>s` detected.'
         REQUIRE_METHODS = Set.new(%i[require require_relative]).freeze
         RESTRICT_ON_SEND = REQUIRE_METHODS
@@ -39,7 +46,9 @@ module RuboCop
           return unless require_call?(node)
           return if @required[node.parent].add?("#{node.method_name}#{node.first_argument}")
 
-          add_offense(node, message: format(MSG, method: node.method_name))
+          add_offense(node, message: format(MSG, method: node.method_name)) do |corrector|
+            corrector.remove(range_by_whole_lines(node.source_range, include_final_newline: true))
+          end
         end
       end
     end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks that there are no repeated exceptions
+      # Checks that there are no repeated exceptions
       # used in 'rescue' expressions.
       #
       # @example

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks if each_with_object is called with an immutable
+      # Checks if each_with_object is called with an immutable
       # argument. Since the argument is the object that the given block shall
       # make calls on to build something based on the enumerable that
       # each_with_object iterates over, an immutable argument makes no sense.

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

@@ -3,11 +3,11 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for odd `else` block layout - like
+      # Checks for odd `else` block layout - like
       # having an expression on the same line as the `else` keyword,
       # which is usually a mistake.
       #
-      # Its auto-correction tweaks layout to keep the syntax. So, this auto-correction
+      # Its autocorrection tweaks layout to keep the syntax. So, this autocorrection
       # is compatible correction for bad case syntax, but if your code makes a mistake
       # with `elsif` and `else`, you will have to correct it manually.
       #
@@ -25,7 +25,7 @@ module RuboCop
       #
       #   # good
       #
-      #   # This code is compatible with the bad case. It will be auto-corrected like this.
+      #   # This code is compatible with the bad case. It will be autocorrected like this.
       #   if something
       #     # ...
       #   else
@@ -41,6 +41,7 @@ module RuboCop
       #     do_that
       #   end
       class ElseLayout < Base
+        include Alignment
         include RangeHelp
         extend AutoCorrector
 
@@ -80,13 +81,8 @@ module RuboCop
         def autocorrect(corrector, node, first_else)
           corrector.insert_after(node.loc.else, "\n")
 
-          blank_range = range_between(node.loc.else.end_pos, first_else.loc.expression.begin_pos)
-          indentation = indent(node, offset: indentation_width)
-          corrector.replace(blank_range, indentation)
-        end
-
-        def indentation_width
-          @config.for_cop('Layout/IndentationWidth')['Width'] || 2
+          blank_range = range_between(node.loc.else.end_pos, first_else.source_range.begin_pos)
+          corrector.replace(blank_range, indentation(node))
         end
       end
     end

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

@@ -3,9 +3,9 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for blocks without a body.
+      # Checks for blocks without a body.
       # Such empty blocks are typically an oversight or we should provide a comment
-      # be clearer what we're aiming for.
+      # to clarify what we're aiming for.
       #
       # Empty lambdas and procs are ignored by default.
       #
@@ -63,9 +63,9 @@ module RuboCop
       class EmptyBlock < Base
         MSG = 'Empty block detected.'
 
-        def on_block(node)
+        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)
@@ -77,7 +77,7 @@ module RuboCop
           return false unless processed_source.contains_comment?(node.source_range)
 
           line_comment = processed_source.comment_at_line(node.source_range.line)
-          !line_comment || !comment_disables_cop?(line_comment.loc.expression.source)
+          !line_comment || !comment_disables_cop?(line_comment.source)
         end
 
         def allow_empty_lambdas?
@@ -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_class.rb

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for classes and metaclasses without a body.
+      # Checks for classes and metaclasses without a body.
       # Such empty classes and metaclasses are typically an oversight or we should provide a comment
       # to be clearer what we're aiming for.
       #
@@ -85,7 +85,9 @@ module RuboCop
         private
 
         def body_or_allowed_comment_lines?(node)
-          node.body || (cop_config['AllowComments'] && comment_lines?(node))
+          return true if node.body
+
+          cop_config['AllowComments'] && processed_source.contains_comment?(node.source_range)
         end
       end
     end

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

@@ -3,7 +3,15 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for the presence of `if`, `elsif` and `unless` branches without a body.
+      # Checks for the presence of `if`, `elsif` and `unless` branches without a body.
+      #
+      # NOTE: empty `else` branches are handled by `Style/EmptyElse`.
+      #
+      # @safety
+      #   Autocorrection for this cop is not safe. The conditions for empty branches that
+      #   the autocorrection removes may have side effects, or the logic in subsequent
+      #   branches may change due to the removal of a previous condition.
+      #
       # @example
       #   # bad
       #   if condition
@@ -53,13 +61,115 @@ module RuboCop
       #   end
       #
       class EmptyConditionalBody < Base
+        extend AutoCorrector
+        include CommentsHelp
+        include RangeHelp
+
         MSG = 'Avoid `%<keyword>s` branches without a body.'
 
         def on_if(node)
-          return if node.body
-          return if cop_config['AllowComments'] && comment_lines?(node)
+          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|
+            next if node.parent&.call_type?
+
+            autocorrect(corrector, node)
+          end
+        end
+
+        private
+
+        def autocorrect(corrector, node)
+          remove_comments(corrector, node)
+          remove_empty_branch(corrector, node)
+          correct_other_branches(corrector, node)
+        end
+
+        def remove_comments(corrector, node)
+          comments_in_range(node).each do |comment|
+            range = range_by_whole_lines(comment.source_range, include_final_newline: true)
+            corrector.remove(range)
+          end
+        end
+
+        def remove_empty_branch(corrector, node)
+          if empty_if_branch?(node) && else_branch?(node)
+            corrector.remove(branch_range(node))
+          else
+            corrector.remove(deletion_range(branch_range(node)))
+          end
+        end
+
+        def correct_other_branches(corrector, node)
+          return unless require_other_branches_correction?(node)
+
+          if node.else_branch&.if_type? && !node.else_branch.modifier_form?
+            # Replace an orphaned `elsif` with `if`
+            corrector.replace(node.else_branch.loc.keyword, 'if')
+          else
+            # Flip orphaned `else`
+            corrector.replace(node.loc.else, "#{node.inverse_keyword} #{node.condition.source}")
+          end
+        end
+
+        def require_other_branches_correction?(node)
+          return false unless node.if_type? && node.else?
+          return false if !empty_if_branch?(node) && node.elsif?
+
+          !empty_elsif_branch?(node)
+        end
+
+        def empty_if_branch?(node)
+          return false unless (parent = node.parent)
+          return true unless parent.if_type?
+          return true unless (if_branch = parent.if_branch)
+
+          if_branch.if_type? && !if_branch.body
+        end
+
+        def empty_elsif_branch?(node)
+          return false unless (else_branch = node.else_branch)
+
+          else_branch.if_type? && !else_branch.body
+        end
+
+        def else_branch?(node)
+          node.else_branch && !node.else_branch.if_type?
+        end
+
+        # rubocop:disable Metrics/AbcSize
+        def branch_range(node)
+          if empty_if_branch?(node) && else_branch?(node)
+            node.source_range.with(end_pos: node.loc.else.begin_pos)
+          elsif node.loc.else
+            node.source_range.with(end_pos: node.condition.source_range.end_pos)
+          elsif all_branches_body_missing?(node)
+            if_node = node.ancestors.detect(&:if?)
+            node.source_range.join(if_node.loc.end.end)
+          else
+            node.source_range
+          end
+        end
+        # rubocop:enable Metrics/AbcSize
+
+        def all_branches_body_missing?(node)
+          return false unless node.parent&.if_type?
+
+          node.parent.branches.compact.empty?
+        end
+
+        def deletion_range(range)
+          # Collect a range between the start of the `if` node and the next relevant node,
+          # including final new line.
+          # Based on `RangeHelp#range_by_whole_lines` but allows the `if` to not start
+          # on the first column.
+          buffer = @processed_source.buffer
+
+          last_line = buffer.source_line(range.last_line)
+          end_offset = last_line.length - range.last_column + 1
 
-          add_offense(node, message: format(MSG, keyword: node.keyword))
+          range.adjust(end_pos: end_offset).intersect(buffer.source_range)
         end
       end
     end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for empty `ensure` blocks
+      # Checks for empty `ensure` blocks
       #
       # @example
       #

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for the presence of empty expressions.
+      # Checks for the presence of empty expressions.
       #
       # @example
       #