rubocop 1.67.0 → 1.77.0

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

@@ -4,9 +4,10 @@ module RuboCop
   module Cop
     # Methods that calculate and return Parser::Source::Ranges
     module RangeHelp
-      private
-
       BYTE_ORDER_MARK = 0xfeff # The Unicode codepoint
+      NOT_GIVEN = Module.new
+
+      private
 
       def source_range(source_buffer, line_number, column, length = 1)
         if column.is_a?(Range)
@@ -33,6 +34,18 @@ module RuboCop
         range_between(node.loc.begin.end_pos, node.loc.end.begin_pos)
       end
 
+      # A range containing the first to the last argument
+      # of a method call or method definition.
+      # def foo(a, b:)
+      #         ^^^^^
+      # bar(1, 2, 3, &blk)
+      #     ^^^^^^^^^^^^^
+      # baz { |x, y:, z:| }
+      #        ^^^^^^^^^
+      def arguments_range(node)
+        node.first_argument.source_range.join(node.last_argument.source_range)
+      end
+
       def range_between(start_pos, end_pos)
         Parser::Source::Range.new(processed_source.buffer, start_pos, end_pos)
       end
@@ -51,12 +64,10 @@ module RuboCop
         Parser::Source::Range.new(buffer, begin_pos, end_pos)
       end
 
-      NOT_GIVEN = Module.new
       def range_with_surrounding_space(range_positional = NOT_GIVEN, # rubocop:disable Metrics/ParameterLists
                                        range: NOT_GIVEN, side: :both, newlines: true,
                                        whitespace: false, continuations: false,
                                        buffer: @processed_source.buffer)
-
         range = range_positional unless range_positional == NOT_GIVEN
 
         src = buffer.source

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

@@ -36,7 +36,7 @@ module RuboCop
       end
 
       def space_required_after?(token)
-        (token.left_curly_brace? || token.type == :tLAMBEG) && space_required_after_lcurly?
+        token.left_curly_brace? && space_required_after_lcurly?
       end
 
       def space_required_after_lcurly?

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

@@ -55,14 +55,19 @@ module RuboCop
       end
 
       def if_body_source(if_body)
-        if if_body.call_type? &&
-           if_body.last_argument&.hash_type? && if_body.last_argument.pairs.last&.value_omission?
+        if if_body.call_type? && !if_body.method?(:[]=) && omitted_value_in_last_hash_arg?(if_body)
           "#{method_source(if_body)}(#{if_body.arguments.map(&:source).join(', ')})"
         else
           if_body.source
         end
       end
 
+      def omitted_value_in_last_hash_arg?(if_body)
+        return false unless (last_argument = if_body.last_argument)
+
+        last_argument.hash_type? && last_argument.pairs.last&.value_omission?
+      end
+
       def method_source(if_body)
         end_range = if_body.implicit_call? ? if_body.loc.dot.end : if_body.loc.selector
 
@@ -96,7 +101,7 @@ module RuboCop
       end
 
       def max_line_length
-        return unless config.for_cop('Layout/LineLength')['Enabled']
+        return unless config.cop_enabled?('Layout/LineLength')
 
         config.for_cop('Layout/LineLength')['Max']
       end

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

@@ -10,7 +10,7 @@ module RuboCop
       def on_str(node)
         # Constants like __FILE__ are handled as strings,
         # but don't respond to begin.
-        return unless node.loc.respond_to?(:begin) && node.loc.begin
+        return unless node.loc?(:begin)
         return if part_of_ignored_node?(node)
 
         if offense?(node)
@@ -33,7 +33,7 @@ module RuboCop
         # A :begin node inside a :dstr, :dsym, or :regexp node is an interpolation.
         node.ancestors
             .drop_while { |a| !a.begin_type? }
-            .any? { |a| a.dstr_type? || a.dsym_type? || a.regexp_type? }
+            .any? { |a| a.type?(:dstr, :dsym, :regexp) }
       end
     end
   end

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

@@ -26,7 +26,7 @@ module RuboCop
       end
 
       def string_literals_config
-        config.for_cop('Style/StringLiterals')
+        config.for_enabled_cop('Style/StringLiterals')
       end
     end
   end

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

@@ -8,12 +8,28 @@ module RuboCop
         @minimum_target_ruby_version
       end
 
+      def required_maximum_ruby_version
+        @maximum_target_ruby_version
+      end
+
       def minimum_target_ruby_version(version)
         @minimum_target_ruby_version = version
       end
 
+      def maximum_target_ruby_version(version)
+        @maximum_target_ruby_version = version
+      end
+
       def support_target_ruby_version?(version)
-        required_minimum_ruby_version <= version
+        # By default, no minimum or maximum versions of ruby are required
+        # to run any cop. In order to do a simple numerical comparison of
+        # the requested version against any requirements, we use 0 and
+        # Infinity as the default values to indicate no minimum (0) and no
+        # maximum (Infinity).
+        min = required_minimum_ruby_version || 0
+        max = required_maximum_ruby_version || Float::INFINITY
+
+        version.between?(min, max)
       end
     end
   end

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

@@ -2,8 +2,9 @@
 
 module RuboCop
   module Cop
-    # Common methods shared by Style/TrailingCommaInArguments and
-    # Style/TrailingCommaInLiteral
+    # Common methods shared by Style/TrailingCommaInArguments,
+    # Style/TrailingCommaInArrayLiteral and Style/TrailingCommaInHashLiteral
+    # rubocop:disable Metrics/ModuleLength
     module TrailingComma
       include ConfigurableEnforcedStyle
       include RangeHelp
@@ -57,6 +58,8 @@ module RuboCop
           ', unless each item is on its own line'
         when :consistent_comma
           ', unless items are split onto multiple lines'
+        when :diff_comma
+          ', unless that item immediately precedes a newline'
         else
           ''
         end
@@ -68,6 +71,8 @@ module RuboCop
           multiline?(node) && no_elements_on_same_line?(node)
         when :consistent_comma
           multiline?(node) && !method_name_and_arguments_on_same_line?(node)
+        when :diff_comma
+          multiline?(node) && last_item_precedes_newline?(node)
         else
           false
         end
@@ -102,7 +107,7 @@ module RuboCop
       # of the argument is not considered multiline, even if the argument
       # itself might span multiple lines.
       def allowed_multiline_argument?(node)
-        elements(node).one? && !Util.begins_its_line?(node.loc.end)
+        elements(node).one? && !Util.begins_its_line?(node_end_location(node))
       end
 
       def elements(node)
@@ -122,14 +127,24 @@ module RuboCop
 
       def no_elements_on_same_line?(node)
         items = elements(node).map(&:source_range)
-        items << node.loc.end
+        items << node_end_location(node)
         items.each_cons(2).none? { |a, b| on_same_line?(a, b) }
       end
 
+      def node_end_location(node)
+        node.loc.end || node.source_range.end.adjust(begin_pos: -1)
+      end
+
       def on_same_line?(range1, range2)
         range1.last_line == range2.line
       end
 
+      def last_item_precedes_newline?(node)
+        after_last_item = node.children.last.source_range.end.join(node.loc.end.begin)
+
+        after_last_item.source.start_with?(/,?\s*(#.*)?\n/)
+      end
+
       def avoid_comma(kind, comma_begin_pos, extra_info)
         range = range_between(comma_begin_pos, comma_begin_pos + 1)
         article = kind.include?('array') ? 'an' : 'a'
@@ -181,7 +196,7 @@ module RuboCop
         #       ...
         #     SOURCE
         #   })
-        return heredoc?(node.children.last) if node.pair_type? || node.hash_type?
+        return heredoc?(node.children.last) if node.type?(:pair, :hash)
 
         false
       end
@@ -205,5 +220,6 @@ module RuboCop
         false
       end
     end
+    # rubocop:enable Metrics/ModuleLength
   end
 end

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

@@ -3,13 +3,13 @@
 module RuboCop
   module Cop
     module Naming
-      # Makes sure that accessor methods are named properly. Applies
-      # to both instance and class methods.
+      # Avoid prefixing accessor method names with `get_` or `set_`.
+      # Applies to both instance and class methods.
       #
-      # NOTE: Offenses are only registered for methods with the expected
-      # arity. Getters (`get_attribute`) must have no arguments to be
-      # registered, and setters (`set_attribute(value)`) must have exactly
-      # one.
+      # NOTE: Method names starting with `get_` or `set_` only register an offense
+      # when the methods match the expected arity for getters and setters respectively.
+      # Getters (`get_attribute`) must have no arguments to be registered,
+      # and setters (`set_attribute(value)`) must have exactly one.
       #
       # @example
       #   # bad

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

@@ -13,6 +13,20 @@ module RuboCop
       # The default variable name is `block`. If the name is already in use, it will not be
       # autocorrected.
       #
+      # [NOTE]
+      # ====
+      # Because of a bug in Ruby 3.3.0, when a block is referenced inside of another block,
+      # no offense will be registered until Ruby 3.4:
+      #
+      # [source,ruby]
+      # ----
+      # def foo(&block)
+      #   # Using an anonymous block would be a syntax error on Ruby 3.3.0
+      #   block_method { bar(&block) }
+      # end
+      # ----
+      # ====
+      #
       # @example EnforcedStyle: anonymous (default)
       #
       #   # bad
@@ -48,7 +62,7 @@ module RuboCop
         MSG = 'Use %<style>s block forwarding.'
 
         def self.autocorrect_incompatible_with
-          [Lint::AmbiguousOperator, Style::ArgumentsForwarding]
+          [Lint::AmbiguousOperator, Style::ArgumentsForwarding, Style::ExplicitBlockArgument]
         end
 
         def on_def(node)
@@ -90,21 +104,11 @@ module RuboCop
           last_argument.source == block_pass_node.source
         end
 
-        # Prevents the following syntax error:
-        #
-        # # foo.rb
-        # def foo(&)
-        #   block_method do
-        #     bar(&)
-        #   end
-        # end
-        #
-        # $ ruby -vc foo.rb
-        # ruby 3.3.0 (2023-12-25 revision 5124f9ac75) [x86_64-darwin22]
-        # foo.rb: foo.rb:4: anonymous block parameter is also used within block (SyntaxError)
-        #
+        # Ruby 3.3.0 had a bug where accessing an anonymous block argument inside of a block
+        # was a syntax error in unambiguous cases: https://bugs.ruby-lang.org/issues/20090
+        # We disallow this also for earlier Ruby versions so that code is forwards compatible.
         def invalidates_syntax?(block_pass_node)
-          block_pass_node.each_ancestor(:block, :numblock).any?
+          target_ruby_version <= 3.3 && block_pass_node.each_ancestor(:any_block).any?
         end
 
         def use_kwarg_in_method_definition?(node)
@@ -138,7 +142,7 @@ module RuboCop
         def use_block_argument_as_local_variable?(node, last_argument)
           return false if node.body.nil?
 
-          node.body.each_descendant(:lvar, :lvasgn).any? do |lvar|
+          node.body.each_node(:lvar, :lvasgn).any? do |lvar|
             !lvar.parent.block_pass_type? && lvar.node_parts[0].to_s == last_argument
           end
         end

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

@@ -31,12 +31,11 @@ module RuboCop
         PATTERN
 
         def on_casgn(node)
-          if node.parent&.or_asgn_type?
-            lhs, value = *node.parent
-            _scope, const_name = *lhs
-          else
-            _scope, const_name, value = *node
-          end
+          value = if node.parent&.or_asgn_type?
+                    node.parent.expression
+                  else
+                    node.expression
+                  end
 
           # We cannot know the result of method calls like
           # NewClass = something_that_returns_a_class
@@ -46,7 +45,7 @@ module RuboCop
           # SomeClass = Class.new(...)
           # SomeClass = Struct.new(...)
           return if allowed_assignment?(value)
-          return if SNAKE_CASE.match?(const_name)
+          return if SNAKE_CASE.match?(node.name)
 
           add_offense(node.loc.name)
         end

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

@@ -37,8 +37,6 @@ module RuboCop
       #
       #   anything/using_snake_case.rake
       class FileName < Base
-        include RangeHelp
-
         MSG_SNAKE_CASE = 'The name of this source file (`%<basename>s`) should use snake_case.'
         MSG_NO_DEFINITION = '`%<basename>s` should define a class or module called `%<namespace>s`.'
         MSG_REGEX = '`%<basename>s` should match `%<regex>s`.'
@@ -154,7 +152,7 @@ module RuboCop
 
             const_namespace, const_name = *const
             next if name != const_name && !match_acronym?(name, const_name)
-            next unless namespace.empty? || match_namespace(child, const_namespace, namespace)
+            next unless namespace.empty? || namespace_matches?(child, const_namespace, namespace)
 
             return node
           end
@@ -171,7 +169,7 @@ module RuboCop
           s(:const, namespace, name) if name
         end
 
-        def match_namespace(node, namespace, expected)
+        def namespace_matches?(node, namespace, expected)
           match_partial = partial_matcher!(expected)
 
           match_partial.call(namespace)

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

@@ -155,6 +155,7 @@ module RuboCop
         UNDERSCORE_REQUIRED = 'Memoized variable `%<var>s` does not start ' \
                               'with `_`. Use `@%<suggested_var>s` instead.'
         DYNAMIC_DEFINE_METHODS = %i[define_method define_singleton_method].to_set.freeze
+        INITIALIZE_METHODS = %i[initialize initialize_clone initialize_copy initialize_dup].freeze
 
         # @!method method_definition?(node)
         def_node_matcher :method_definition?, <<~PATTERN
@@ -168,7 +169,7 @@ module RuboCop
         # rubocop:disable Metrics/AbcSize
         # rubocop:disable Metrics/MethodLength
         def on_or_asgn(node)
-          lhs, _value = *node
+          lhs = node.lhs
           return unless lhs.ivasgn_type?
 
           method_node, method_name = find_definition(node)
@@ -181,8 +182,8 @@ module RuboCop
 
           suggested_var = suggested_var(method_name)
           msg = format(
-            message(lhs.children.first.to_s),
-            var: lhs.children.first.to_s,
+            message(lhs.name),
+            var: lhs.name,
             suggested_var: suggested_var,
             method: method_name
           )
@@ -209,14 +210,13 @@ module RuboCop
           method_node, method_name = find_definition(node)
           return false unless method_node
 
-          var_name = arg.children.first
-          defined_memoized?(method_node.body, var_name) do |defined_ivar, return_ivar, ivar_assign|
+          defined_memoized?(method_node.body, arg.name) do |defined_ivar, return_ivar, ivar_assign|
             return false if matches?(method_name, ivar_assign)
 
             suggested_var = suggested_var(method_name)
             msg = format(
-              message(var_name.to_s),
-              var: var_name.to_s,
+              message(arg.name),
+              var: arg.name,
               suggested_var: suggested_var,
               method: method_name
             )
@@ -242,7 +242,7 @@ module RuboCop
         def find_definition(node)
           # Methods can be defined in a `def` or `defs`,
           # or dynamically via a `block` node.
-          node.each_ancestor(:def, :defs, :block).each do |ancestor|
+          node.each_ancestor(:any_def, :block).each do |ancestor|
             method_node, method_name = method_definition?(ancestor)
             return [method_node, method_name] if method_node
           end
@@ -251,11 +251,10 @@ module RuboCop
         end
 
         def matches?(method_name, ivar_assign)
-          return true if ivar_assign.nil? || method_name == :initialize
+          return true if ivar_assign.nil? || INITIALIZE_METHODS.include?(method_name)
 
-          method_name = method_name.to_s.delete('!?')
-          variable = ivar_assign.children.first
-          variable_name = variable.to_s.sub('@', '')
+          method_name = method_name.to_s.delete('!?=')
+          variable_name = ivar_assign.name.to_s.sub('@', '')
 
           variable_name_candidates(method_name).include?(variable_name)
         end
@@ -269,7 +268,7 @@ module RuboCop
         end
 
         def suggested_var(method_name)
-          suggestion = method_name.to_s.delete('!?')
+          suggestion = method_name.to_s.delete('!?=')
 
           style == :required ? "_#{suggestion}" : suggestion
         end

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

@@ -6,14 +6,31 @@ module RuboCop
       # Makes sure that all methods use the configured style,
       # snake_case or camelCase, for their names.
       #
-      # This cop has `AllowedPatterns` configuration option.
+      # Method names matching patterns are always allowed.
       #
-      #   Naming/MethodName:
-      #     AllowedPatterns:
-      #       - '\AonSelectionBulkChange\z'
-      #       - '\AonSelectionCleared\z'
+      # The cop can be configured with `AllowedPatterns` to allow certain regexp patterns:
       #
-      # Method names matching patterns are always allowed.
+      # [source,yaml]
+      # ----
+      # Naming/MethodName:
+      #   AllowedPatterns:
+      #     - '\AonSelectionBulkChange\z'
+      #     - '\AonSelectionCleared\z'
+      # ----
+      #
+      # As well, you can also forbid specific method names or regexp patterns
+      # using `ForbiddenIdentifiers` or `ForbiddenPatterns`:
+      #
+      # [source,yaml]
+      # ----
+      # Naming/MethodName:
+      #   ForbiddenIdentifiers:
+      #     - 'def'
+      #     - 'super'
+      #   ForbiddenPatterns:
+      #     - '_v1\z'
+      #     - '_gen1\z'
+      # ----
       #
       # @example EnforcedStyle: snake_case (default)
       #   # bad
@@ -28,12 +45,26 @@ module RuboCop
       #
       #   # good
       #   def fooBar; end
+      #
+      # @example ForbiddenIdentifiers: ['def', 'super']
+      #   # bad
+      #   def def; end
+      #   def super; end
+      #
+      # @example ForbiddenPatterns: ['_v1\z', '_gen1\z']
+      #   # bad
+      #   def release_v1; end
+      #   def api_gen1; end
+      #
       class MethodName < Base
         include ConfigurableNaming
         include AllowedPattern
         include RangeHelp
+        include ForbiddenIdentifiers
+        include ForbiddenPattern
 
         MSG = 'Use %<style>s for method names.'
+        MSG_FORBIDDEN = '`%<identifier>s` is forbidden, use another method name instead.'
 
         # @!method sym_name(node)
         def_node_matcher :sym_name, '(sym $_name)'
@@ -48,19 +79,44 @@ module RuboCop
             name = attr_name(name_item)
             next if !name || matches_allowed_pattern?(name)
 
-            check_name(node, name, range_position(node))
+            if forbidden_name?(name.to_s)
+              register_forbidden_name(node)
+            else
+              check_name(node, name, range_position(node))
+            end
           end
         end
 
         def on_def(node)
           return if node.operator_method? || matches_allowed_pattern?(node.method_name)
 
-          check_name(node, node.method_name, node.loc.name)
+          if forbidden_name?(node.method_name.to_s)
+            register_forbidden_name(node)
+          else
+            check_name(node, node.method_name, node.loc.name)
+          end
         end
         alias on_defs on_def
 
         private
 
+        def forbidden_name?(name)
+          forbidden_identifier?(name) || forbidden_pattern?(name)
+        end
+
+        def register_forbidden_name(node)
+          if node.any_def_type?
+            name_node = node.loc.name
+            method_name = node.method_name
+          else
+            attrs = node.attribute_accessor?
+            name_node = attrs.last.last
+            method_name = attr_name(name_node)
+          end
+          message = format(MSG_FORBIDDEN, identifier: method_name)
+          add_offense(name_node, message: message)
+        end
+
         def attr_name(name_item)
           sym_name(name_item) || str_name(name_item)
         end