rubocop 1.72.2 → 1.73.0

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

@@ -4,6 +4,7 @@ module RuboCop
   module Cop
     # 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
@@ -130,6 +135,12 @@ module RuboCop
         range1.last_line == range2.line
       end
 
+      def last_item_precedes_newline?(node)
+        after_last_item =
+          range_between(node.children.last.source_range.end_pos, node.loc.end.begin_pos)
+        after_last_item.source =~ /\A,?\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'
@@ -205,5 +216,6 @@ module RuboCop
         false
       end
     end
+    # rubocop:enable Metrics/ModuleLength
   end
 end

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

@@ -3,8 +3,15 @@
 module RuboCop
   module Cop
     module Naming
-      # Makes sure that all variables use the configured style,
-      # snake_case or camelCase, for their names.
+      # Checks that the configured style (snake_case or camelCase) is used for all variable names.
+      # This includes local variables, instance variables, class variables, method arguments
+      # (positional, keyword, rest or block), and block arguments.
+      #
+      # The cop can also be configured to forbid using specific names for variables, using
+      # `ForbiddenIdentifiers` or `ForbiddenPatterns`. In addition to the above, this applies
+      # to global variables as well.
+      #
+      # Method definitions and method calls are not affected by this cop.
       #
       # @example EnforcedStyle: snake_case (default)
       #   # bad
@@ -26,7 +33,21 @@ module RuboCop
       #
       # @example AllowedPatterns: ['_v\d+\z']
       #   # good (with EnforcedStyle: camelCase)
-      #   :release_v1
+      #   release_v1 = true
+      #
+      # @example ForbiddenIdentifiers: ['fooBar']
+      #   # bad (in all cases)
+      #   fooBar = 1
+      #   @fooBar = 1
+      #   @@fooBar = 1
+      #   $fooBar = 1
+      #
+      # @example ForbiddenPatterns: ['_v\d+\z']
+      #   # bad (in all cases)
+      #   release_v1 = true
+      #   @release_v1 = true
+      #   @@release_v1 = true
+      #   $release_v1 = true
       #
       class VariableName < Base
         include AllowedIdentifiers
@@ -34,16 +55,21 @@ module RuboCop
         include AllowedPattern
 
         MSG = 'Use %<style>s for variable names.'
+        MSG_FORBIDDEN = '`%<identifier>s` is forbidden, use another name instead.'
 
         def valid_name?(node, name, given_style = style)
           super || matches_allowed_pattern?(name)
         end
 
         def on_lvasgn(node)
-          return unless node.name
-          return if allowed_identifier?(node.name)
+          return unless (name = node.name)
+          return if allowed_identifier?(name)
 
-          check_name(node, node.name, node.loc.name)
+          if forbidden_name?(name)
+            register_forbidden_name(node)
+          else
+            check_name(node, name, node.loc.name)
+          end
         end
         alias on_ivasgn    on_lvasgn
         alias on_cvasgn    on_lvasgn
@@ -56,11 +82,43 @@ module RuboCop
         alias on_blockarg  on_lvasgn
         alias on_lvar      on_lvasgn
 
+        # Only forbidden names are checked for global variable assignment
+        def on_gvasgn(node)
+          return unless (name = node.name)
+          return unless forbidden_name?(name)
+
+          register_forbidden_name(node)
+        end
+
         private
 
         def message(style)
           format(MSG, style: style)
         end
+
+        def forbidden_identifiers
+          cop_config.fetch('ForbiddenIdentifiers', [])
+        end
+
+        def forbidden_patterns
+          cop_config.fetch('ForbiddenPatterns', [])
+        end
+
+        def matches_forbidden_pattern?(name)
+          forbidden_patterns.any? { |pattern| Regexp.new(pattern).match?(name) }
+        end
+
+        def forbidden_name?(name)
+          name = name.to_s.delete(SIGILS)
+
+          (forbidden_identifiers.any? && forbidden_identifiers.include?(name)) ||
+            (forbidden_patterns.any? && matches_forbidden_pattern?(name))
+        end
+
+        def register_forbidden_name(node)
+          message = format(MSG_FORBIDDEN, identifier: node.name)
+          add_offense(node.loc.name, message: message)
+        end
       end
     end
   end

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

@@ -139,12 +139,16 @@ module RuboCop
           style == :separated
         end
 
+        def groupable_sibling_accessor?(node, sibling)
+          sibling.attribute_accessor? &&
+            sibling.method?(node.method_name) &&
+            node_visibility(sibling) == node_visibility(node) &&
+            groupable_accessor?(sibling) && !previous_line_comment?(sibling)
+        end
+
         def groupable_sibling_accessors(send_node)
           send_node.parent.each_child_node(:send).select do |sibling|
-            sibling.attribute_accessor? &&
-              sibling.method?(send_node.method_name) &&
-              node_visibility(sibling) == node_visibility(send_node) &&
-              groupable_accessor?(sibling) && !previous_line_comment?(sibling)
+            groupable_sibling_accessor?(send_node, sibling)
           end
         end
 
@@ -155,13 +159,23 @@ module RuboCop
 
         def preferred_accessors(node)
           if grouped_style?
+            return if skip_for_grouping?(node)
+
             accessors = groupable_sibling_accessors(node)
-            group_accessors(node, accessors) if node.loc == accessors.first.loc
+            if node.loc == accessors.first.loc || skip_for_grouping?(accessors.first)
+              group_accessors(node, accessors)
+            end
           else
             separate_accessors(node)
           end
         end
 
+        # Group after constants
+        def skip_for_grouping?(node)
+          node.right_siblings.any?(&:casgn_type?) &&
+            node.right_siblings.any? { |n| n.send_type? && groupable_sibling_accessor?(node, n) }
+        end
+
         def group_accessors(node, accessors)
           accessor_names = accessors.flat_map { |accessor| accessor.arguments.map(&:source) }.uniq
 

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

@@ -5,8 +5,11 @@ module RuboCop
     module Style
       # Checks for endless methods.
       #
-      # It can enforce either the use of endless methods definitions
-      # for single-lined method bodies, or disallow endless methods.
+      # It can enforce endless method definitions whenever possible or with single line methods.
+      # It can also disallow multiline endless method definitions or all endless definitions.
+      #
+      # `require_single_line` style enforces endless method definitions for single line methods.
+      # `require_always` style enforces endless method definitions for single statement methods.
       #
       # Other method definition types are not considered by this cop.
       #
@@ -15,36 +18,116 @@ module RuboCop
       # * allow_single_line (default) - only single line endless method definitions are allowed.
       # * allow_always - all endless method definitions are allowed.
       # * disallow - all endless method definitions are disallowed.
+      # * require_single_line - endless method definitions are required for single line methods.
+      # * require_always - all endless method definitions are required.
       #
       # NOTE: Incorrect endless method definitions will always be
       # corrected to a multi-line definition.
       #
       # @example EnforcedStyle: allow_single_line (default)
+      #   # bad, multi-line endless method
+      #   def my_method = x.foo
+      #                    .bar
+      #                    .baz
+      #
       #   # good
-      #   def my_method() = x
+      #   def my_method
+      #     x
+      #   end
       #
-      #   # bad, multi-line endless method
-      #   def my_method() = x.foo
-      #                      .bar
-      #                      .baz
+      #   # good
+      #   def my_method = x
+      #
+      #   # good
+      #   def my_method
+      #     x.foo
+      #      .bar
+      #      .baz
+      #   end
       #
       # @example EnforcedStyle: allow_always
       #   # good
-      #   def my_method() = x
+      #   def my_method
+      #     x
+      #   end
       #
       #   # good
-      #   def my_method() = x.foo
-      #                      .bar
-      #                      .baz
+      #   def my_method = x
+      #
+      #   # good
+      #   def my_method = x.foo
+      #                    .bar
+      #                    .baz
+      #
+      #   # good
+      #   def my_method
+      #     x.foo
+      #      .bar
+      #      .baz
+      #   end
       #
       # @example EnforcedStyle: disallow
       #   # bad
-      #   def my_method() = x
+      #   def my_method = x
+      #
+      #   # bad
+      #   def my_method = x.foo
+      #                    .bar
+      #                    .baz
+      #
+      #   # good
+      #   def my_method
+      #     x
+      #   end
+      #
+      #   # good
+      #   def my_method
+      #     x.foo
+      #      .bar
+      #      .baz
+      #   end
+      #
+      # @example EnforcedStyle: require_single_line
+      #   # bad
+      #   def my_method
+      #     x
+      #   end
+      #
+      #   # bad
+      #   def my_method = x.foo
+      #                    .bar
+      #                    .baz
+      #
+      #   # good
+      #   def my_method = x
+      #
+      #   # good
+      #   def my_method
+      #     x.foo
+      #      .bar
+      #      .baz
+      #   end
+      #
+      # @example EnforcedStyle: require_always
+      #   # bad
+      #   def my_method
+      #     x
+      #   end
       #
       #   # bad
-      #   def my_method() = x.foo
-      #                      .bar
-      #                      .baz
+      #   def my_method
+      #     x.foo
+      #      .bar
+      #      .baz
+      #   end
+      #
+      #   # good
+      #   def my_method = x
+      #
+      #   # good
+      #   def my_method = x.foo
+      #                    .bar
+      #                    .baz
       #
       class EndlessMethod < Base
         include ConfigurableEnforcedStyle
@@ -57,12 +140,21 @@ module RuboCop
         CORRECTION_STYLES = %w[multiline single_line].freeze
         MSG = 'Avoid endless method definitions.'
         MSG_MULTI_LINE = 'Avoid endless method definitions with multiple lines.'
+        MSG_REQUIRE_SINGLE = 'Use endless method definitions for single line methods.'
+        MSG_REQUIRE_ALWAYS = 'Use endless method definitions.'
 
         def on_def(node)
-          if style == :disallow
-            handle_disallow_style(node)
-          else
+          return if node.assignment_method?
+
+          case style
+          when :allow_single_line, :allow_always
             handle_allow_style(node)
+          when :disallow
+            handle_disallow_style(node)
+          when :require_single_line
+            handle_require_single_line_style(node)
+          when :require_always
+            handle_require_always_style(node)
           end
         end
 
@@ -77,11 +169,64 @@ module RuboCop
           end
         end
 
+        def handle_require_single_line_style(node)
+          if node.endless? && !node.single_line?
+            add_offense(node, message: MSG_MULTI_LINE) do |corrector|
+              correct_to_multiline(corrector, node)
+            end
+          elsif !node.endless? && can_be_made_endless?(node) && node.body.single_line?
+            return if too_long_when_made_endless?(node)
+
+            add_offense(node, message: MSG_REQUIRE_SINGLE) do |corrector|
+              corrector.replace(node, endless_replacement(node))
+            end
+          end
+        end
+
+        def handle_require_always_style(node)
+          return if node.endless? || !can_be_made_endless?(node)
+          return if too_long_when_made_endless?(node)
+
+          add_offense(node, message: MSG_REQUIRE_ALWAYS) do |corrector|
+            corrector.replace(node, endless_replacement(node))
+          end
+        end
+
         def handle_disallow_style(node)
           return unless node.endless?
 
           add_offense(node) { |corrector| correct_to_multiline(corrector, node) }
         end
+
+        def correct_to_multiline(corrector, node)
+          replacement = <<~RUBY.strip
+            def #{node.method_name}#{arguments(node)}
+              #{node.body.source}
+            end
+          RUBY
+
+          corrector.replace(node, replacement)
+        end
+
+        def endless_replacement(node)
+          <<~RUBY.strip
+            def #{node.method_name}#{arguments(node)} = #{node.body.source}
+          RUBY
+        end
+
+        def arguments(node, missing = '')
+          node.arguments.any? ? node.arguments.source : missing
+        end
+
+        def can_be_made_endless?(node)
+          node.body && !node.body.begin_type? && !node.body.kwbegin_type?
+        end
+
+        def too_long_when_made_endless?(node)
+          return false unless config.cop_enabled?('Layout/LineLength')
+
+          endless_replacement(node).length > config.for_cop('Layout/LineLength')['Max']
+        end
       end
     end
   end

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

@@ -36,7 +36,7 @@ module RuboCop
         include RangeHelp
         extend AutoCorrector
 
-        MSG = 'Use `\\` instead of `+` or `<<` to concatenate those strings.'
+        MSG = 'Use `\\` instead of `%<operator>s` to concatenate multiline strings.'
         CONCAT_TOKEN_TYPES = %i[tPLUS tLSHFT].freeze
         SIMPLE_STRING_TOKEN_TYPE = :tSTRING
         COMPLEX_STRING_BEGIN_TOKEN = :tSTRING_BEG
@@ -61,14 +61,20 @@ module RuboCop
           successor = tokens[index + 2]
 
           return unless eligible_token_set?(predecessor, operator, successor)
-
           return if same_line?(operator, successor)
 
           next_successor = token_after_last_string(successor, index)
-
           return unless eligible_next_successor?(next_successor)
 
-          add_offense(operator.pos) { |corrector| autocorrect(corrector, operator.pos) }
+          register_offense(operator)
+        end
+
+        def register_offense(operator)
+          message = format(MSG, operator: operator.text)
+
+          add_offense(operator.pos, message: message) do |corrector|
+            autocorrect(corrector, operator.pos)
+          end
         end
 
         def autocorrect(corrector, operator_range)

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

@@ -41,7 +41,7 @@ module RuboCop
           return if ignored_node?(node)
 
           return unless (receiver = node.receiver)
-          return unless receiver.any_block_type? && receiver.loc.end.is?('end')
+          return unless receiver.any_block_type? && receiver.keywords?
 
           range = range_between(receiver.loc.end.begin_pos, node.source_range.end_pos)
 

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

@@ -42,6 +42,22 @@ module RuboCop
       #     c
       #   end
       #
+      #   # bad
+      #   a.nil? ? true : a
+      #
+      #   # good
+      #   a.nil? || a
+      #
+      #   # bad
+      #   if a.nil?
+      #     true
+      #   else
+      #     a
+      #   end
+      #
+      #   # good
+      #   a.nil? || a
+      #
       class RedundantCondition < Base
         include CommentsHelp
         include RangeHelp
@@ -128,6 +144,16 @@ module RuboCop
           #   end
           return true if condition == if_branch
 
+          # e.g.
+          #   a.nil? ? true : a
+          # or
+          #   if a.nil?
+          #     true
+          #   else
+          #     a
+          #   end
+          return true if if_branch_is_true_type_and_else_is_not?(node)
+
           # e.g.
           #   if foo
           #     @value = foo
@@ -146,6 +172,12 @@ module RuboCop
             !use_hash_key_access?(if_branch)
         end
 
+        def if_branch_is_true_type_and_else_is_not?(node)
+          return false unless node.ternary? || node.if?
+
+          node.if_branch&.true_type? && node.else_branch && !node.else_branch.true_type?
+        end
+
         def branches_have_assignment?(node)
           _condition, if_branch, else_branch = *node # rubocop:disable InternalAffairs/NodeDestructuring
 
@@ -194,6 +226,8 @@ module RuboCop
             argument_source = if_branch.first_argument.source
 
             "#{if_branch.receiver.source} #{if_branch.method_name} (#{argument_source}"
+          elsif if_branch.true_type?
+            if_branch.parent.condition.source
           else
             if_branch.source
           end

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

@@ -47,7 +47,7 @@ module RuboCop
       class RedundantFormat < Base
         extend AutoCorrector
 
-        MSG = 'Redundant `%<method_name>s` can be removed.'
+        MSG = 'Use `%<prefer>s` directly instead of `%<method_name>s`.'
 
         RESTRICT_ON_SEND = %i[format sprintf].to_set.freeze
         ACCEPTABLE_LITERAL_TYPES = %i[str dstr sym dsym numeric boolean nil].freeze
@@ -72,10 +72,20 @@ module RuboCop
           (pair (sym %1) $_)
         PATTERN
 
+        # @!method splatted_arguments?(node)
+        def_node_matcher :splatted_arguments?, <<~PATTERN
+          (send _ %RESTRICT_ON_SEND <{
+            splat
+            (hash <kwsplat ...>)
+          } ...>)
+        PATTERN
+
         def on_send(node)
           format_without_additional_args?(node) do |value|
-            add_offense(node, message: message(node)) do |corrector|
-              corrector.replace(node, value.source)
+            replacement = value.source
+
+            add_offense(node, message: message(node, replacement)) do |corrector|
+              corrector.replace(node, replacement)
             end
             return
           end
@@ -85,8 +95,8 @@ module RuboCop
 
         private
 
-        def message(node)
-          format(MSG, method_name: node.method_name)
+        def message(node, prefer)
+          format(MSG, prefer: prefer, method_name: node.method_name)
         end
 
         def detect_unnecessary_fields(node)
@@ -96,7 +106,7 @@ module RuboCop
           arguments = node.arguments[1..]
 
           return unless string && arguments.any?
-          return if arguments.any?(&:splat_type?)
+          return if splatted_arguments?(node)
 
           register_all_fields_literal(node, string, arguments)
         end
@@ -104,9 +114,11 @@ module RuboCop
         def register_all_fields_literal(node, string, arguments)
           return unless all_fields_literal?(string, arguments.dup)
 
-          add_offense(node, message: message(node)) do |corrector|
-            replacement = format(string, *argument_values(arguments))
-            corrector.replace(node, quote(replacement, node))
+          formatted_string = format(string, *argument_values(arguments))
+          replacement = quote(formatted_string, node)
+
+          add_offense(node, message: message(node, replacement)) do |corrector|
+            corrector.replace(node, replacement)
           end
         end
 
@@ -119,7 +131,7 @@ module RuboCop
             next if sequence.percent?
 
             hash = arguments.detect(&:hash_type?)
-            argument = find_argument(sequence, arguments, hash)
+            next unless (argument = find_argument(sequence, arguments, hash))
             next unless matching_argument?(sequence, argument)
 
             count += 1
@@ -160,7 +172,7 @@ module RuboCop
         end
 
         def numeric?(argument)
-          argument&.type?(:numeric, :str) ||
+          argument.type?(:numeric, :str) ||
             rational_number?(argument) ||
             complex_number?(argument)
         end

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

@@ -58,7 +58,7 @@ module RuboCop
         # rubocop:disable Metrics/AbcSize
         def on_lvasgn(node)
           return unless (rhs = node.rhs)
-          return unless rhs.call_type? && method_returning_self?(rhs.method_name)
+          return unless rhs.type?(:any_block, :call) && method_returning_self?(rhs.method_name)
           return unless (receiver = rhs.receiver)
 
           receiver_type = ASSIGNMENT_TYPE_TO_RECEIVER_TYPE[node.type]

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

@@ -8,9 +8,9 @@ module RuboCop
       #
       # Endless methods added in Ruby 3.0 are also accepted by this cop.
       #
-      # If `Style/EndlessMethod` is enabled with `EnforcedStyle: allow_single_line` or
-      # `allow_always`, single-line methods will be autocorrected to endless
-      # methods if there is only one statement in the body.
+      # If `Style/EndlessMethod` is enabled with `EnforcedStyle: allow_single_line`, `allow_always`,
+      # `require_single_line`, or `require_always`, single-line methods will be autocorrected
+      # to endless methods if there is only one statement in the body.
       #
       # @example
       #   # bad

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

@@ -128,7 +128,7 @@ module RuboCop
         end
 
         def uncorrectable?(part)
-          part.multiline? || heredoc?(part) || part.each_descendant(:block).any?
+          part.multiline? || heredoc?(part) || part.each_descendant(:any_block).any?
         end
 
         def heredoc?(node)