rubocop 1.65.1 → 1.66.0

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

@@ -51,7 +51,6 @@ module RuboCop
       #   # defined inside a method call.
       #
       #   # bad
-      #   # consistent
       #   array = [
       #     :value
       #   ]
@@ -72,13 +71,11 @@ module RuboCop
       #   # brackets are indented to the same position.
       #
       #   # bad
-      #   # align_brackets
       #   and_now_for_something = [
       #                             :completely_different
       #   ]
       #
       #   # good
-      #   # align_brackets
       #   and_now_for_something = [
       #                             :completely_different
       #                           ]

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

@@ -25,20 +25,20 @@ module RuboCop
       # * `Layout/ArrayAlignment`
       # * `Layout/BlockAlignment`
       # * `Layout/BlockEndNewline`
-      # * `LayoutClosingParenthesisIndentation`
-      # * `LayoutFirstArgumentIndentation`
-      # * `LayoutFirstArrayElementIndentation`
-      # * `LayoutFirstHashElementIndentation`
-      # * `LayoutFirstParameterIndentation`
-      # * `LayoutHashAlignment`
-      # * `LayoutIndentationWidth`
-      # * `LayoutMultilineArrayLineBreaks`
-      # * `LayoutMultilineBlockLayout`
-      # * `LayoutMultilineHashBraceLayout`
-      # * `LayoutMultilineHashKeyLineBreaks`
-      # * `LayoutMultilineMethodArgumentLineBreaks`
-      # * `LayoutMultilineMethodParameterLineBreaks`
-      # * `Layout/ParameterAlignment`
+      # * `Layout/ClosingParenthesisIndentation`
+      # * `Layout/FirstArgumentIndentation`
+      # * `Layout/FirstArrayElementIndentation`
+      # * `Layout/FirstHashElementIndentation`
+      # * `Layout/FirstParameterIndentation`
+      # * `Layout/HashAlignment`
+      # * `Layout/IndentationWidth`
+      # * `Layout/MultilineArrayLineBreaks`
+      # * `Layout/MultilineBlockLayout`
+      # * `Layout/MultilineHashBraceLayout`
+      # * `Layout/MultilineHashKeyLineBreaks`
+      # * `Layout/MultilineMethodArgumentLineBreaks`
+      # * `Layout/MultilineMethodParameterLineBreaks`
+      # * `Layout//ParameterAlignment`
       # * `Style/BlockDelimiters`
       #
       # Together, these cops will pretty print hashes, arrays,

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

@@ -67,19 +67,31 @@ module RuboCop
 
         MSG = 'Avoid `%<keyword>s` branches without a body.'
 
+        # rubocop:disable Metrics/AbcSize
         def on_if(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|
+          range = offense_range(node)
+
+          add_offense(range, message: format(MSG, keyword: node.keyword)) do |corrector|
             next if node.parent&.call_type?
 
             autocorrect(corrector, node)
           end
         end
+        # rubocop:enable Metrics/AbcSize
 
         private
 
+        def offense_range(node)
+          if node.loc.else
+            node.source_range.begin.join(node.loc.else.begin)
+          else
+            node.source_range
+          end
+        end
+
         def autocorrect(corrector, node)
           remove_comments(corrector, node)
           remove_empty_branch(corrector, node)
@@ -93,13 +105,22 @@ module RuboCop
           end
         end
 
+        # rubocop:disable Metrics/AbcSize
         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
+          range = if empty_if_branch?(node) && else_branch?(node)
+                    branch_range(node)
+                  elsif same_line?(node, else_kw_loc = node.loc.else)
+                    node.source_range.begin.join(else_kw_loc.begin)
+                  elsif node.parent&.loc.respond_to?(:end) &&
+                        same_line?(node, end_loc = node.parent.loc.end)
+                    node.source_range.begin.join(end_loc.begin)
+                  else
+                    deletion_range(branch_range(node))
+                  end
+
+          corrector.remove(range)
         end
+        # rubocop:enable Metrics/AbcSize
 
         def correct_other_branches(corrector, node)
           return unless require_other_branches_correction?(node)

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

@@ -66,9 +66,7 @@ module RuboCop
         end
 
         def literal_zero?(node)
-          # TODO: https://github.com/rubocop/rubocop-ast/pull/304 is released,
-          # replace this condition with `node&.numeric_type? && node.value.zero?`.
-          node&.numeric_type? && node.node_parts[0].zero?
+          node&.numeric_type? && node.value.zero?
         end
 
         # rubocop:disable Metrics/PerceivedComplexity

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

@@ -40,9 +40,9 @@ module RuboCop
             end
 
             add_offense(range, message: message) do |corrector|
-              preferred  = "#{lhs_node.source} + #{rhs_node.source}"
+              range = lhs_node.source_range.end.join(rhs_node.source_range.begin)
 
-              corrector.replace(range, preferred)
+              corrector.replace(range, ' + ')
             end
           end
         end
@@ -92,6 +92,8 @@ module RuboCop
         end
 
         def str_content(node)
+          return unless node.respond_to?(:str_type?)
+
           if node.str_type?
             node.children[0]
           else

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

@@ -16,15 +16,14 @@ module RuboCop
       # reassignments and properly handles varied cases such as branch, loop,
       # rescue, ensure, etc.
       #
+      # This cop's autocorrection avoids cases like `a ||= 1` because removing assignment from
+      # operator assignment can cause NameError if this assignment has been used to declare
+      # a local variable. For example, replacing `a ||= 1` with `a || 1` may cause
+      # "undefined local variable or method `a' for main:Object (NameError)".
+      #
       # NOTE: Given the assignment `foo = 1, bar = 2`, removing unused variables
       # can lead to a syntax error, so this case is not autocorrected.
       #
-      # @safety
-      #   This cop's autocorrection is unsafe because removing assignment from
-      #   operator assignment can cause NameError if this assignment has been used to declare
-      #   local variable. For example, replacing `a ||= 1` to `a || 1` may cause
-      #   "undefined local variable or method `a' for main:Object (NameError)".
-      #
       # @example
       #
       #   # bad
@@ -53,24 +52,32 @@ module RuboCop
           scope.variables.each_value { |variable| check_for_unused_assignments(variable) }
         end
 
-        # rubocop:disable Metrics/AbcSize
+        # rubocop:disable Metrics/AbcSize, Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity
         def check_for_unused_assignments(variable)
           return if variable.should_be_unused?
 
           variable.assignments.reverse_each do |assignment|
-            next if assignment.used? || part_of_ignored_node?(assignment.node)
+            assignment_node = assignment.node
+            next if assignment.used? || part_of_ignored_node?(assignment_node)
 
             message = message_for_useless_assignment(assignment)
             range = offense_range(assignment)
 
             add_offense(range, message: message) do |corrector|
-              autocorrect(corrector, assignment) unless sequential_assignment?(assignment.node)
+              # In cases like `x = 1, y = 2`, where removing a variable would cause a syntax error,
+              # and where changing `x ||= 1` to `x = 1` would cause `NameError`,
+              # the autocorrect will be skipped, even if the variable is unused.
+              if sequential_assignment?(assignment_node) || assignment_node.parent&.or_asgn_type?
+                next
+              end
+
+              autocorrect(corrector, assignment)
             end
 
-            ignore_node(assignment.node) if chained_assignment?(assignment.node)
+            ignore_node(assignment_node) if chained_assignment?(assignment_node)
           end
         end
-        # rubocop:enable Metrics/AbcSize
+        # rubocop:enable Metrics/AbcSize, Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity
 
         def message_for_useless_assignment(assignment)
           variable = assignment.variable

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

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Certain numeric operations have no impact, being:
+      # Adding or subtracting 0, multiplying or dividing by 1 or raising to the power of 1.
+      # These are probably leftover from debugging, or are mistakes.
+      #
+      # @example
+      #
+      #   # bad
+      #   x + 0
+      #   x - 0
+      #   x * 1
+      #   x / 1
+      #   x ** 1
+      #
+      #   # good
+      #   x
+      #
+      #   # bad
+      #   x += 0
+      #   x -= 0
+      #   x *= 1
+      #   x /= 1
+      #   x **= 1
+      #
+      #   # good
+      #   x = x
+      #
+      class UselessNumericOperation < Base
+        extend AutoCorrector
+        MSG = 'Do not apply inconsequential numeric operations to variables.'
+        RESTRICT_ON_SEND = %i[+ - * / **].freeze
+
+        # @!method useless_operation?(node)
+        def_node_matcher :useless_operation?, '(send (send nil? $_) $_ (int $_))'
+
+        # @!method useless_abbreviated_assignment?(node)
+        def_node_matcher :useless_abbreviated_assignment?, '(op-asgn (lvasgn $_) $_ (int $_))'
+
+        def on_send(node)
+          return unless useless_operation?(node)
+
+          variable, operation, number = useless_operation?(node)
+          return unless useless?(operation, number)
+
+          add_offense(node) do |corrector|
+            corrector.replace(node, variable)
+          end
+        end
+
+        def on_op_asgn(node)
+          return unless useless_abbreviated_assignment?(node)
+
+          variable, operation, number = useless_abbreviated_assignment?(node)
+          return unless useless?(operation, number)
+
+          add_offense(node) do |corrector|
+            corrector.replace(node, "#{variable} = #{variable}")
+          end
+        end
+
+        private
+
+        def useless?(operation, number)
+          if number.zero?
+            true if %i[+ -].include?(operation)
+          elsif number == 1
+            true if %i[* / **].include?(operation)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -66,7 +66,6 @@ module RuboCop
         BINARY_OPERATORS = %i[* / % + - == === != < > <= >= <=>].freeze
         UNARY_OPERATORS = %i[+@ -@ ~ !].freeze
         OPERATORS = (BINARY_OPERATORS + UNARY_OPERATORS).freeze
-        VOID_CONTEXT_TYPES = %i[def for block].freeze
         NONMUTATING_METHODS_WITH_BANG_VERSION = %i[capitalize chomp chop compact
                                                    delete_prefix delete_suffix downcase
                                                    encode flatten gsub lstrip merge next
@@ -86,7 +85,6 @@ module RuboCop
           check_void_op(node.body) { node.method?(:each) }
           check_expression(node.body)
         end
-
         alias on_numblock on_block
 
         def on_begin(node)
@@ -94,6 +92,10 @@ module RuboCop
         end
         alias on_kwbegin on_begin
 
+        def on_ensure(node)
+          check_ensure(node)
+        end
+
         private
 
         def check_begin(node)
@@ -193,12 +195,24 @@ module RuboCop
           end
         end
 
+        def check_ensure(node)
+          return unless (body = node.body)
+          # NOTE: the `begin` node case is already handled via `on_begin`
+          return if body.begin_type?
+
+          check_void_op(body) do
+            block_node = node.each_ancestor(:block).first
+            block_node&.method?(:each)
+          end
+
+          check_expression(body)
+        end
+
         def in_void_context?(node)
           parent = node.parent
-
           return false unless parent && parent.children.last == node
 
-          VOID_CONTEXT_TYPES.include?(parent.type) && parent.void_context?
+          parent.respond_to?(:void_context?) && parent.void_context?
         end
 
         def autocorrect_void_op(corrector, node)
@@ -231,15 +245,23 @@ module RuboCop
         def entirely_literal?(node)
           case node.type
           when :array
-            node.each_value.all? { |value| entirely_literal?(value) }
+            all_values_entirely_literal?(node)
           when :hash
-            return false unless node.each_key.all? { |key| entirely_literal?(key) }
-
-            node.each_value.all? { |value| entirely_literal?(value) }
+            all_keys_entirely_literal?(node) && all_values_entirely_literal?(node)
+          when :send, :csend
+            node.method?(:freeze) && node.receiver && entirely_literal?(node.receiver)
           else
             node.literal?
           end
         end
+
+        def all_keys_entirely_literal?(node)
+          node.each_key.all? { |key| entirely_literal?(key) }
+        end
+
+        def all_values_entirely_literal?(node)
+          node.each_value.all? { |value| entirely_literal?(value) }
+        end
       end
     end
   end

data/lib/rubocop/cop/metrics/block_length.rb

@@ -9,8 +9,9 @@ module RuboCop
       # The cop can be configured to ignore blocks passed to certain methods.
       #
       # You can set constructs you want to fold with `CountAsOne`.
-      # Available are: 'array', 'hash', 'heredoc', and 'method_call'. Each construct
-      # will be counted as one line regardless of its actual size.
+      #
+      # Available are: 'array', 'hash', 'heredoc', and 'method_call'.
+      # Each construct will be counted as one line regardless of its actual size.
       #
       # NOTE: This cop does not apply for `Struct` definitions.
       #
@@ -18,7 +19,7 @@ module RuboCop
       # for backwards compatibility. Please use `AllowedMethods` and `AllowedPatterns`
       # instead. By default, there are no methods to allowed.
       #
-      # @example CountAsOne: ['array', 'heredoc', 'method_call']
+      # @example CountAsOne: ['array', 'hash', 'heredoc', 'method_call']
       #
       #   something do
       #     array = [         # +1
@@ -26,7 +27,7 @@ module RuboCop
       #       2
       #     ]
       #
-      #     hash = {          # +3
+      #     hash = {          # +1
       #       key: 'value'
       #     }
       #
@@ -39,7 +40,7 @@ module RuboCop
       #       1,
       #       2
       #     )
-      #   end                 # 6 points
+      #   end                 # 4 points
       #
       class BlockLength < Base
         include CodeLength

data/lib/rubocop/cop/metrics/class_length.rb

@@ -8,12 +8,13 @@ module RuboCop
       # The maximum allowed length is configurable.
       #
       # You can set constructs you want to fold with `CountAsOne`.
-      # Available are: 'array', 'hash', 'heredoc', and 'method_call'. Each construct
-      # will be counted as one line regardless of its actual size.
+      #
+      # Available are: 'array', 'hash', 'heredoc', and 'method_call'.
+      # Each construct will be counted as one line regardless of its actual size.
       #
       # NOTE: This cop also applies for `Struct` definitions.
       #
-      # @example CountAsOne: ['array', 'heredoc', 'method_call']
+      # @example CountAsOne: ['array', 'hash', 'heredoc', 'method_call']
       #
       #   class Foo
       #     ARRAY = [         # +1
@@ -21,7 +22,7 @@ module RuboCop
       #       2
       #     ]
       #
-      #     HASH = {          # +3
+      #     HASH = {          # +1
       #       key: 'value'
       #     }
       #
@@ -34,7 +35,7 @@ module RuboCop
       #       1,
       #       2
       #     )
-      #   end                 # 6 points
+      #   end                 # 4 points
       #
       class ClassLength < Base
         include CodeLength

data/lib/rubocop/cop/metrics/method_length.rb

@@ -8,15 +8,16 @@ module RuboCop
       # The maximum allowed length is configurable.
       #
       # You can set constructs you want to fold with `CountAsOne`.
-      # Available are: 'array', 'hash', 'heredoc', and 'method_call'. Each construct
-      # will be counted as one line regardless of its actual size.
+      #
+      # Available are: 'array', 'hash', 'heredoc', and 'method_call'.
+      # Each construct will be counted as one line regardless of its actual size.
       #
       # NOTE: The `ExcludedMethods` and `IgnoredMethods` configuration is
       # deprecated and only kept for backwards compatibility.
       # Please use `AllowedMethods` and `AllowedPatterns` instead.
       # By default, there are no methods to allowed.
       #
-      # @example CountAsOne: ['array', 'heredoc', 'method_call']
+      # @example CountAsOne: ['array', 'hash', 'heredoc', 'method_call']
       #
       #   def m
       #     array = [       # +1
@@ -24,7 +25,7 @@ module RuboCop
       #       2
       #     ]
       #
-      #     hash = {        # +3
+      #     hash = {        # +1
       #       key: 'value'
       #     }
       #
@@ -37,7 +38,7 @@ module RuboCop
       #       1,
       #       2
       #     )
-      #   end               # 6 points
+      #   end               # 4 points
       #
       class MethodLength < Base
         include CodeLength

data/lib/rubocop/cop/metrics/module_length.rb

@@ -8,10 +8,11 @@ module RuboCop
       # The maximum allowed length is configurable.
       #
       # You can set constructs you want to fold with `CountAsOne`.
-      # Available are: 'array', 'hash', 'heredoc', and 'method_call'. Each construct
-      # will be counted as one line regardless of its actual size.
       #
-      # @example CountAsOne: ['array', 'heredoc', 'method_call']
+      # Available are: 'array', 'hash', 'heredoc', and 'method_call'.
+      # Each construct will be counted as one line regardless of its actual size.
+      #
+      # @example CountAsOne: ['array', 'hash', 'heredoc', 'method_call']
       #
       #   module M
       #     ARRAY = [         # +1
@@ -19,7 +20,7 @@ module RuboCop
       #       2
       #     ]
       #
-      #     HASH = {          # +3
+      #     HASH = {          # +1
       #       key: 'value'
       #     }
       #
@@ -32,7 +33,7 @@ module RuboCop
       #       1,
       #       2
       #     )
-      #   end                 # 6 points
+      #   end                 # 4 points
       #
       class ModuleLength < Base
         include CodeLength

data/lib/rubocop/cop/mixin/annotation_comment.rb

@@ -4,8 +4,6 @@ module RuboCop
   module Cop
     # Representation of an annotation comment in source code (eg. `# TODO: blah blah blah`).
     class AnnotationComment
-      extend Forwardable
-
       attr_reader :comment, :margin, :keyword, :colon, :space, :note
 
       # @param [Parser::Source::Comment] comment

data/lib/rubocop/cop/mixin/frozen_string_literal.rb

@@ -20,7 +20,7 @@ module RuboCop
 
       def frozen_string_literal?(node)
         frozen_string = if target_ruby_version >= 3.0
-                          uninterpolated_string?(node) || frozen_heredoc?(node)
+                          uninterpolated_string?(node) || uninterpolated_heredoc?(node)
                         else
                           FROZEN_STRING_LITERAL_TYPES_RUBY27.include?(node.type)
                         end
@@ -32,29 +32,39 @@ module RuboCop
         node.str_type? || (node.dstr_type? && node.each_descendant(:begin).none?)
       end
 
-      def frozen_heredoc?(node)
+      def uninterpolated_heredoc?(node)
         return false unless node.dstr_type? && node.heredoc?
 
         node.children.all?(&:str_type?)
       end
+      alias frozen_heredoc? uninterpolated_heredoc?
 
       def frozen_string_literals_enabled?
         ruby_version = processed_source.ruby_version
         return false unless ruby_version
 
+        # Check if a magic string literal comment specifies what to do
+        magic_comments = leading_comment_lines.filter_map { |line| MagicComment.parse(line) }
+        if (literal_magic_comment = magic_comments.find(&:frozen_string_literal_specified?))
+          return literal_magic_comment.frozen_string_literal?
+        end
+
         # TODO: Ruby officially abandon making frozen string literals default
         # for Ruby 3.0.
         # https://bugs.ruby-lang.org/issues/11473#note-53
-        # Whether frozen string literals will be the default after Ruby 3.0
-        # or not is still unclear as of January 2019.
+        # Whether frozen string literals will be the default after Ruby 4.0
+        # or not is still unclear as of July 2024.
         # It may be necessary to add this code in the future.
         #
-        #   return true if ruby_version >= 3.1
+        #   return ruby_version >= 4.0 if string_literals_frozen_by_default?.nil?
         #
-        # And the above `ruby_version >= 3.1` is undecided whether it will be
-        # Ruby 3.1, 3.2, 4.0 or others.
-        # See https://bugs.ruby-lang.org/issues/8976#note-41 for details.
-        leading_comment_lines.any? { |line| MagicComment.parse(line).frozen_string_literal? }
+        # And the above `ruby_version >= 4.0` is undecided whether it will be
+        # Ruby 4.0 or others.
+        # See https://bugs.ruby-lang.org/issues/20205 for details.
+        # For now, offer a configuration value to override behavior is using RUBYOPT.
+        return false if string_literals_frozen_by_default?.nil?
+
+        string_literals_frozen_by_default?
       end
 
       def frozen_string_literals_disabled?

data/lib/rubocop/cop/mixin/line_length_help.rb

@@ -91,8 +91,13 @@ module RuboCop
       end
 
       def uri_regexp
-        @uri_regexp ||=
-          URI::DEFAULT_PARSER.make_regexp(config.for_cop('Layout/LineLength')['URISchemes'])
+        @uri_regexp ||= begin
+          # Ruby 3.4 changes the default parser to RFC3986 which warns on make_regexp.
+          # Additionally, the RFC2396_PARSER alias is only available on 3.4 for now.
+          # Extra info at https://github.com/ruby/uri/issues/118
+          parser = defined?(URI::RFC2396_PARSER) ? URI::RFC2396_PARSER : URI::DEFAULT_PARSER
+          parser.make_regexp(config.for_cop('Layout/LineLength')['URISchemes'])
+        end
       end
 
       def valid_uri?(uri_ish_string)

data/lib/rubocop/cop/mixin/string_literals_help.rb

@@ -16,6 +16,18 @@ module RuboCop
           !/" | \\[^'\\] | \#[@{$]/x.match?(src)
         end
       end
+
+      def preferred_string_literal
+        enforce_double_quotes? ? '""' : "''"
+      end
+
+      def enforce_double_quotes?
+        string_literals_config['EnforcedStyle'] == 'double_quotes'
+      end
+
+      def string_literals_config
+        config.for_cop('Style/StringLiterals')
+      end
     end
   end
 end

data/lib/rubocop/cop/naming/accessor_method_name.rb

@@ -40,6 +40,7 @@ module RuboCop
         MSG_WRITER = 'Do not prefix writer method names with `set_`.'
 
         def on_def(node)
+          return unless proper_attribute_name?(node)
           return unless bad_reader_name?(node) || bad_writer_name?(node)
 
           message = message(node)
@@ -58,6 +59,10 @@ module RuboCop
           end
         end
 
+        def proper_attribute_name?(node)
+          !node.method_name.to_s.end_with?('!', '?', '=')
+        end
+
         def bad_reader_name?(node)
           node.method_name.to_s.start_with?('get_') && !node.arguments?
         end

data/lib/rubocop/cop/naming/predicate_name.rb

@@ -70,7 +70,7 @@ module RuboCop
       #   def_node_matcher(:is_even) { |value| }
       #
       #   # good
-      #   # def_node_matcher(:even?) { |value| }
+      #   def_node_matcher(:even?) { |value| }
       #
       class PredicateName < Base
         include AllowedMethods

data/lib/rubocop/cop/style/alias.rb

@@ -80,7 +80,7 @@ module RuboCop
         def alias_method_possible?(node)
           scope_type(node) != :instance_eval &&
             node.children.none?(&:gvar_type?) &&
-            node&.parent&.type != :def
+            node.each_ancestor(:def).none?
         end
 
         def add_offense_for_args(node, &block)