rubocop 1.41.1 → 1.57.1

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

@@ -11,6 +11,8 @@ module RuboCop
       #   File.exists?(some_path)
       #   Dir.exists?(some_path)
       #   iterator?
+      #   attr :name, true
+      #   attr :name, false
       #   ENV.freeze # Calling `Env.freeze` raises `TypeError` since Ruby 2.7.
       #   ENV.clone
       #   ENV.dup # Calling `Env.dup` raises `TypeError` since Ruby 3.1.
@@ -21,6 +23,8 @@ module RuboCop
       #   File.exist?(some_path)
       #   Dir.exist?(some_path)
       #   block_given?
+      #   attr_accessor :name
+      #   attr_reader :name
       #   ENV # `ENV.freeze` cannot prohibit changes to environment variables.
       #   ENV.to_h
       #   ENV.to_h # `ENV.dup` cannot dup `ENV`, use `ENV.to_h` to get a copy of `ENV` as a hash.
@@ -29,138 +33,84 @@ module RuboCop
       class DeprecatedClassMethods < Base
         extend AutoCorrector
 
-        # Inner class to DeprecatedClassMethods.
-        # This class exists to add abstraction and clean naming
-        # to the deprecated objects
-        class DeprecatedClassMethod
-          include RuboCop::AST::Sexp
+        MSG = '`%<current>s` is deprecated in favor of `%<prefer>s`.'
+        RESTRICT_ON_SEND = %i[
+          attr clone dup exists? freeze gethostbyaddr gethostbyname iterator?
+        ].freeze
+
+        PREFERRED_METHODS = {
+          clone: 'to_h',
+          dup: 'to_h',
+          exists?: 'exist?',
+          gethostbyaddr: 'Addrinfo#getnameinfo',
+          gethostbyname: 'Addrinfo#getaddrinfo',
+          iterator?: 'block_given?'
+        }.freeze
 
-          attr_reader :method, :class_constant
+        DIR_ENV_FILE_CONSTANTS = %i[Dir ENV File].freeze
 
-          def initialize(method, class_constant: nil, correctable: true)
-            @method = method
-            @class_constant = class_constant
-            @correctable = correctable
-          end
-
-          def class_nodes
-            @class_nodes ||=
-              if class_constant
-                [
-                  s(:const, nil, class_constant),
-                  s(:const, s(:cbase), class_constant)
-                ]
-              else
-                [nil]
-              end
-          end
+        # @!method deprecated_class_method?(node)
+        def_node_matcher :deprecated_class_method?, <<~PATTERN
+          {
+            (send (const {cbase nil?} {:ENV}) {:clone :dup :freeze})
+            (send (const {cbase nil?} {:File :Dir}) :exists? _)
+            (send (const {cbase nil?} :Socket) {:gethostbyaddr :gethostbyname} ...)
+            (send nil? :attr _ boolean)
+            (send nil? :iterator?)
+          }
+        PATTERN
 
-          def correctable?
-            @correctable
-          end
+        def on_send(node)
+          return unless deprecated_class_method?(node)
 
-          def to_s
-            [class_constant, method].compact.join(delimiter)
-          end
+          offense_range = offense_range(node)
+          prefer = preferred_method(node)
+          message = format(MSG, current: offense_range.source, prefer: prefer)
 
-          private
+          add_offense(offense_range, message: message) do |corrector|
+            next if socket_const?(node.receiver)
 
-          def delimiter
-            CLASS_METHOD_DELIMITER
+            if node.method?(:freeze)
+              corrector.replace(node, 'ENV')
+            else
+              corrector.replace(offense_range, prefer)
+            end
           end
         end
 
-        # Inner class to DeprecatedClassMethods.
-        # This class exists to add abstraction and clean naming
-        # to the replacements for deprecated objects
-        class Replacement
-          attr_reader :method, :class_constant
-
-          def initialize(method, class_constant: nil, instance_method: false)
-            @method = method
-            @class_constant = class_constant
-            @instance_method = instance_method
-          end
-
-          def to_s
-            [class_constant, method].compact.join(delimiter)
-          end
-
-          private
-
-          def delimiter
-            instance_method? ? INSTANCE_METHOD_DELIMITER : CLASS_METHOD_DELIMITER
-          end
+        private
 
-          def instance_method?
-            @instance_method
+        def offense_range(node)
+          if socket_const?(node.receiver) || dir_env_file_const?(node.receiver)
+            node.source_range.begin.join(node.loc.selector.end)
+          elsif node.method?(:attr)
+            node
+          else
+            node.loc.selector
           end
         end
 
-        MSG = '`%<current>s` is deprecated in favor of `%<prefer>s`.'
-
-        DEPRECATED_METHODS_OBJECT = {
-          DeprecatedClassMethod.new(:exists?, class_constant: :File) =>
-            Replacement.new(:exist?, class_constant: :File),
-
-          DeprecatedClassMethod.new(:exists?, class_constant: :Dir) =>
-            Replacement.new(:exist?, class_constant: :Dir),
-
-          DeprecatedClassMethod.new(:iterator?) => Replacement.new(:block_given?),
-
-          DeprecatedClassMethod.new(:freeze, class_constant: :ENV) =>
-            Replacement.new(nil, class_constant: :ENV),
+        def preferred_method(node)
+          if node.method?(:attr)
+            boolean_argument = node.arguments[1].source
+            preferred_attr_method = boolean_argument == 'true' ? 'attr_accessor' : 'attr_reader'
 
-          DeprecatedClassMethod.new(:clone, class_constant: :ENV) =>
-            Replacement.new(:to_h, class_constant: :ENV),
-
-          DeprecatedClassMethod.new(:dup, class_constant: :ENV) =>
-            Replacement.new(:to_h, class_constant: :ENV),
-
-          DeprecatedClassMethod.new(:gethostbyaddr, class_constant: :Socket, correctable: false) =>
-            Replacement.new(:getnameinfo, class_constant: :Addrinfo, instance_method: true),
-
-          DeprecatedClassMethod.new(:gethostbyname, class_constant: :Socket, correctable: false) =>
-            Replacement.new(:getaddrinfo, class_constant: :Addrinfo, instance_method: true)
-        }.freeze
+            "#{preferred_attr_method} #{node.first_argument.source}"
+          elsif dir_env_file_const?(node.receiver)
+            prefer = PREFERRED_METHODS[node.method_name]
 
-        RESTRICT_ON_SEND = DEPRECATED_METHODS_OBJECT.keys.map(&:method).freeze
-
-        CLASS_METHOD_DELIMITER = '.'
-        INSTANCE_METHOD_DELIMITER = '#'
-
-        def on_send(node)
-          check(node) do |deprecated|
-            prefer = replacement(deprecated)
-            message = format(MSG, current: deprecated, prefer: prefer)
-            current_method = node.loc.selector
-
-            add_offense(current_method, message: message) do |corrector|
-              next unless deprecated.correctable?
-
-              if (preferred_method = prefer.method)
-                corrector.replace(current_method, preferred_method)
-              else
-                corrector.remove(node.loc.dot)
-                corrector.remove(current_method)
-              end
-            end
+            prefer ? "#{node.receiver.source}.#{prefer}" : 'ENV'
+          else
+            PREFERRED_METHODS[node.method_name]
           end
         end
 
-        private
-
-        def check(node)
-          DEPRECATED_METHODS_OBJECT.each_key do |deprecated|
-            next unless deprecated.class_nodes.include?(node.receiver)
-            next unless node.method?(deprecated.method)
-
-            yield deprecated
-          end
+        def socket_const?(node)
+          node&.short_name == :Socket
         end
 
-        def replacement(deprecated)
-          DEPRECATED_METHODS_OBJECT[deprecated]
+        def dir_env_file_const?(node)
+          DIR_ENV_FILE_CONSTANTS.include?(node&.short_name)
         end
       end
     end

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

@@ -100,7 +100,7 @@ module RuboCop
         end
 
         def correction_range(node)
-          range_between(node.loc.dot.end_pos, node.loc.expression.end_pos)
+          range_between(node.loc.dot.end_pos, node.source_range.end_pos)
         end
 
         def openssl_class(node)

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

@@ -4,6 +4,7 @@ module RuboCop
   module Cop
     module Lint
       # Checks for duplicated keys in hash literals.
+      # This cop considers both primitive types and constants for the hash keys.
       #
       # This cop mirrors a warning in Ruby 2.2.
       #
@@ -24,7 +25,7 @@ module RuboCop
         MSG = 'Duplicated key in hash literal.'
 
         def on_hash(node)
-          keys = node.keys.select(&:recursive_basic_literal?)
+          keys = node.keys.select { |key| key.recursive_basic_literal? || key.const_type? }
 
           return unless duplicates?(keys)
 

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

@@ -187,7 +187,7 @@ module RuboCop
           if DEF_TYPES.include?(node.type)
             node.loc.keyword.join(node.loc.name)
           else
-            node.loc.expression
+            node.source_range
           end
         end
 
@@ -258,7 +258,7 @@ module RuboCop
         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

@@ -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|
@@ -32,35 +34,57 @@ module RuboCop
           end
         end
 
-        # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
         def each_repeated_character_class_element_loc(node)
           node.parsed_tree&.each_expression do |expr|
             next if skip_expression?(expr)
 
             seen = Set.new
-            enum = expr.expressions.to_enum
-            expression_count = expr.expressions.count
+            group_expressions(node, expr.expressions) do |group|
+              group_source = group.map(&:to_s).join
 
-            expression_count.times do |current_number|
-              current_child = enum.next
-              next if within_interpolation?(node, current_child)
+              yield source_range(group) if seen.include?(group_source)
 
-              current_child_source = current_child.to_s
-              next_child = enum.peek if current_number + 1 < expression_count
+              seen << group_source
+            end
+          end
+        end
 
-              if seen.include?(current_child_source)
-                next if start_with_escaped_zero_number?(current_child_source, next_child.to_s)
+        private
 
-                yield current_child.expression
-              end
+        def group_expressions(node, expressions)
+          # Create a mutable list to simplify state tracking while we iterate.
+          expressions = expressions.to_a
 
-              seen << current_child_source
-            end
+          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
-        # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
 
-        private
+        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
@@ -75,9 +99,12 @@ module RuboCop
           interpolation_locs(node).any? { |il| il.overlaps?(parse_tree_child_loc) }
         end
 
-        def start_with_escaped_zero_number?(current_child, next_child)
-          # Represents escaped code from `"\00"` (`"\u0000"`) to `"\07"` (`"\a"`).
-          current_child == '\\0' && next_child.match?(/[0-7]/)
+        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)
@@ -86,9 +113,7 @@ module RuboCop
           # 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/else_layout.rb

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

@@ -5,7 +5,7 @@ module RuboCop
     module Lint
       # 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.
       #
@@ -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?

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

@@ -72,6 +72,8 @@ module RuboCop
           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
@@ -86,7 +88,7 @@ module RuboCop
 
         def remove_comments(corrector, node)
           comments_in_range(node).each do |comment|
-            range = range_by_whole_lines(comment.loc.expression, include_final_newline: true)
+            range = range_by_whole_lines(comment.source_range, include_final_newline: true)
             corrector.remove(range)
           end
         end
@@ -141,7 +143,7 @@ module RuboCop
           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.loc.expression.end_pos)
+            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.with(end_pos: if_node.loc.end.end_pos)

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

@@ -25,7 +25,7 @@ module RuboCop
         def on_interpolation(begin_node)
           return unless begin_node.children.empty?
 
-          add_offense(begin_node) { |corrector| corrector.remove(begin_node.loc.expression) }
+          add_offense(begin_node) { |corrector| corrector.remove(begin_node) }
         end
       end
     end

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

@@ -3,14 +3,13 @@
 module RuboCop
   module Cop
     module Lint
-      #
-      # This cop emulates the following Ruby warnings in Ruby 2.6.
+      # Emulates the following Ruby warnings in Ruby 2.6.
       #
       # [source,console]
       # ----
-      # % cat example.rb
+      # $ cat example.rb
       # ERB.new('hi', nil, '-', '@output_buffer')
-      # % ruby -rerb example.rb
+      # $ ruby -rerb example.rb
       # example.rb:1: warning: Passing safe_level with the 2nd argument of ERB.new is
       # deprecated. Do not use it, and specify other arguments as keyword arguments.
       # example.rb:1: warning: Passing trim_mode with the 3rd argument of ERB.new is

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

@@ -81,6 +81,10 @@ module RuboCop
 
           return false if num_of_format_args == :unknown
 
+          first_arg = node.first_argument
+          return false if num_of_expected_fields.zero? &&
+                          (first_arg.dstr_type? || first_arg.array_type?)
+
           matched_arguments_count?(num_of_expected_fields, num_of_format_args)
         end
 
@@ -94,8 +98,8 @@ module RuboCop
 
         # @!method called_on_string?(node)
         def_node_matcher :called_on_string?, <<~PATTERN
-          {(send {nil? const_type?} _ (str _) ...)
-           (send (str ...) ...)}
+          {(send {nil? const_type?} _ {str dstr} ...)
+           (send {str dstr} ...)}
         PATTERN
 
         def method_with_format_args?(node)
@@ -143,11 +147,11 @@ module RuboCop
           return false if node.const_receiver? && !node.receiver.loc.name.is?(KERNEL)
           return false unless node.method?(name)
 
-          node.arguments.size > 1 && node.first_argument.str_type?
+          node.arguments.size > 1 && string_type?(node.first_argument)
         end
 
         def expected_fields_count(node)
-          return :unknown unless node.str_type?
+          return :unknown unless string_type?(node)
 
           format_string = RuboCop::Cop::Utils::FormatString.new(node.source)
           return 1 if format_string.named_interpolation?
@@ -172,10 +176,9 @@ module RuboCop
         def percent?(node)
           receiver = node.receiver
 
-          percent = node.method?(:%) &&
-                    (STRING_TYPES.include?(receiver.type) || node.first_argument.array_type?)
+          percent = node.method?(:%) && (string_type?(receiver) || node.first_argument.array_type?)
 
-          return false if percent && STRING_TYPES.include?(receiver.type) && heredoc?(node)
+          return false if percent && string_type?(receiver) && heredoc?(node)
 
           percent
         end
@@ -188,6 +191,10 @@ module RuboCop
           format(MSG, arg_num: num_args_for_format, method: method_name,
                       field_num: num_expected_fields)
         end
+
+        def string_type?(node)
+          STRING_TYPES.include?(node.type)
+        end
       end
     end
   end