rubocop 1.53.1 → 1.90.0

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

@@ -5,6 +5,8 @@ module RuboCop
     module Style
       # Checks for multiple expressions placed on the same line.
       # It also checks for lines terminated with a semicolon.
+      # In idiomatic Ruby, each expression should be on its own line
+      # for readability.
       #
       # This cop has `AllowAsExpressionSeparator` configuration option.
       # It allows `;` to separate several expressions on the same line.
@@ -62,9 +64,6 @@ module RuboCop
         private
 
         def check_for_line_terminator_or_opener
-          # Make the obvious check first
-          return unless processed_source.raw_source.include?(';')
-
           each_semicolon do |line, column, token_before_semicolon|
             register_semicolon(line, column, false, token_before_semicolon)
           end
@@ -72,10 +71,11 @@ module RuboCop
 
         def each_semicolon
           tokens_for_lines.each do |line, tokens|
-            semicolon_pos = semicolon_position(tokens)
+            next unless (semicolon_pos = semicolon_position(tokens))
+
             after_expr_pos = semicolon_pos == -1 ? -2 : semicolon_pos
 
-            yield line, tokens[semicolon_pos].column, tokens[after_expr_pos] if semicolon_pos
+            yield line, tokens[semicolon_pos].column, tokens[after_expr_pos]
           end
         end
 
@@ -83,6 +83,7 @@ module RuboCop
           processed_source.tokens.group_by(&:line)
         end
 
+        # rubocop:disable-next Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def semicolon_position(tokens)
           if tokens.last.semicolon?
             -1
@@ -93,6 +94,8 @@ module RuboCop
           elsif exist_semicolon_after_left_curly_brace?(tokens) ||
                 exist_semicolon_after_left_string_interpolation_brace?(tokens)
             2
+          elsif exist_semicolon_after_left_lambda_curly_brace?(tokens)
+            3
           elsif exist_semicolon_before_right_string_interpolation_brace?(tokens)
             -4
           end
@@ -106,6 +109,10 @@ module RuboCop
           tokens[1]&.left_curly_brace? && tokens[2]&.semicolon?
         end
 
+        def exist_semicolon_after_left_lambda_curly_brace?(tokens)
+          tokens[2]&.type == :tLAMBEG && tokens[3]&.semicolon?
+        end
+
         def exist_semicolon_before_right_string_interpolation_brace?(tokens)
           tokens[-3]&.type == :tSTRING_DEND && tokens[-4]&.semicolon?
         end
@@ -114,43 +121,63 @@ module RuboCop
           tokens[1]&.type == :tSTRING_DBEG && tokens[2]&.semicolon?
         end
 
+        # rubocop:disable-next Metrics/AbcSize, Metrics/MethodLength
         def register_semicolon(line, column, after_expression, token_before_semicolon = nil)
           range = source_range(processed_source.buffer, line, column)
 
           add_offense(range) do |corrector|
             if after_expression
-              corrector.replace(range, "\n")
+              replace_semicolon_with_line_break(corrector, range)
             else
               # Prevents becoming one range instance with subsequent line when endless range
               # without parentheses.
               # See: https://github.com/rubocop/rubocop/issues/10791
               if token_before_semicolon&.regexp_dots?
-                range_node = find_range_node(token_before_semicolon)
-                corrector.wrap(range_node, '(', ')') if range_node
+                node = find_node(range_nodes, token_before_semicolon)
+              elsif token_before_semicolon&.type == :tLABEL
+                node = find_node(value_omission_pair_nodes, token_before_semicolon).parent
+                space = node.parent.loc.selector.end.join(node.source_range.begin)
+                corrector.remove(space)
               end
 
+              corrector.wrap(node, '(', ')') if node
               corrector.remove(range)
             end
           end
         end
 
+        def replace_semicolon_with_line_break(corrector, range)
+          # Replacing the semicolon with a newline would move the rest of the
+          # line into the body of a heredoc opened earlier on that line.
+          return if heredoc_opened_before_semicolon?(range)
+
+          corrector.replace(range, "\n")
+        end
+
+        def heredoc_opened_before_semicolon?(semicolon_range)
+          processed_source.ast.each_descendant(:any_str).select(&:heredoc?).any? do |heredoc|
+            heredoc.first_line == semicolon_range.line &&
+              heredoc.source_range.end_pos <= semicolon_range.begin_pos
+          end
+        end
+
         def expressions_per_line(exprs)
           # create a map matching lines to the number of expressions on them
-          exprs_lines = exprs.map(&:first_line)
+          exprs_lines = exprs.map(&:last_line)
           exprs_lines.group_by(&:itself)
         end
 
         def find_semicolon_positions(line)
-          # Scan for all the semicolons on the line
-          semicolons = processed_source[line - 1].enum_for(:scan, ';')
-          semicolons.each do
-            yield Regexp.last_match.begin(0)
+          # Scan for all the semicolon tokens on the line. Iterating tokens rather
+          # than the raw source skips `;` characters inside string/regexp literals.
+          processed_source.tokens.each do |token|
+            yield token.column if token.line == line && token.semicolon?
           end
         end
 
-        def find_range_node(token_before_semicolon)
-          range_nodes.detect do |range_node|
-            range_node.source_range.contains?(token_before_semicolon.pos)
+        def find_node(nodes, token_before_semicolon)
+          nodes.detect do |node|
+            node.source_range.overlaps?(token_before_semicolon.pos)
           end
         end
 
@@ -159,7 +186,16 @@ module RuboCop
 
           ast = processed_source.ast
           @range_nodes = ast.range_type? ? [ast] : []
-          @range_nodes.concat(ast.each_descendant(:irange, :erange).to_a)
+          @range_nodes.concat(ast.each_descendant(:range).to_a)
+        end
+
+        def value_omission_pair_nodes
+          if instance_variable_defined?(:@value_omission_pair_nodes)
+            return @value_omission_pair_nodes
+          end
+
+          ast = processed_source.ast
+          @value_omission_pair_nodes = ast.each_descendant(:pair).to_a.select(&:value_omission?)
         end
       end
     end

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

@@ -7,12 +7,12 @@ module RuboCop
       #
       # @example
       #   # bad
-      #   Foo.send(:bar)
-      #   quuz.send(:fred)
+      #   Foo.send(bar)
+      #   quuz.send(fred)
       #
       #   # good
-      #   Foo.__send__(:bar)
-      #   quuz.public_send(:fred)
+      #   Foo.__send__(bar)
+      #   quuz.public_send(fred)
       class Send < Base
         MSG = 'Prefer `Object#__send__` or `Object#public_send` to `send`.'
         RESTRICT_ON_SEND = %i[send].freeze

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

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Detects the use of the `public_send` method with a literal method name argument.
+      # Since the `send` method can be used to call private methods, by default,
+      # only the `public_send` method is detected.
+      #
+      # NOTE: Writer methods with names ending in `=` are always permitted because their
+      # behavior differs as follows:
+      #
+      # [source,ruby]
+      # ----
+      # def foo=(foo)
+      #   @foo = foo
+      #   42
+      # end
+      #
+      # self.foo = 1   # => 1
+      # send(:foo=, 1) # => 42
+      # ----
+      #
+      # @safety
+      #   This cop is not safe because it can incorrectly detect based on the receiver.
+      #   Additionally, when `AllowSend` is set to `true`, it cannot determine whether
+      #   the `send` method being detected is calling a private method.
+      #
+      # @example
+      #   # bad
+      #   obj.public_send(:method_name)
+      #   obj.public_send('method_name')
+      #
+      #   # good
+      #   obj.method_name
+      #
+      # @example AllowSend: true (default)
+      #   # good
+      #   obj.send(:method_name)
+      #   obj.send('method_name')
+      #   obj.__send__(:method_name)
+      #   obj.__send__('method_name')
+      #
+      # @example AllowSend: false
+      #   # bad
+      #   obj.send(:method_name)
+      #   obj.send('method_name')
+      #   obj.__send__(:method_name)
+      #   obj.__send__('method_name')
+      #
+      #   # good
+      #   obj.method_name
+      #
+      class SendWithLiteralMethodName < Base
+        extend AutoCorrector
+
+        MSG = 'Use `%<method_name>s` method call directly instead.'
+        RESTRICT_ON_SEND = %i[public_send send __send__].freeze
+        STATIC_METHOD_NAME_NODE_TYPES = %i[sym str].freeze
+        METHOD_NAME_PATTERN = /\A[a-zA-Z_][a-zA-Z0-9_]*[!?]?\z/.freeze
+        RESERVED_WORDS = %i[
+          BEGIN END alias and begin break case class def defined? do else elsif end ensure
+          false for if in module next nil not or redo rescue retry return self super then true
+          undef unless until when while yield
+        ].freeze
+
+        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        def on_send(node)
+          return if allow_send? && !node.method?(:public_send)
+          return unless (first_argument = node.first_argument)
+          return unless first_argument.type?(*STATIC_METHOD_NAME_NODE_TYPES)
+
+          offense_range = offense_range(node)
+          method_name = first_argument.value
+          return if !METHOD_NAME_PATTERN.match?(method_name) || RESERVED_WORDS.include?(method_name)
+
+          add_offense(offense_range, message: format(MSG, method_name: method_name)) do |corrector|
+            if node.arguments.one?
+              corrector.replace(offense_range, method_name)
+            else
+              corrector.replace(node.loc.selector, method_name)
+              corrector.remove(removal_argument_range(first_argument, node.arguments[1]))
+            end
+          end
+        end
+        alias on_csend on_send
+        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
+        private
+
+        def allow_send?
+          !!cop_config['AllowSend']
+        end
+
+        def offense_range(node)
+          node.loc.selector.join(node.source_range.end)
+        end
+
+        def removal_argument_range(first_argument, second_argument)
+          first_argument.source_range.begin.join(second_argument.source_range.begin)
+        end
+      end
+    end
+  end
+end

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

@@ -122,10 +122,9 @@ module RuboCop
         def on_rescue(node)
           return unless style == :semantic
 
-          begin_node, *rescue_nodes, _else_node = *node
-          check_scope(:raise, begin_node)
+          check_scope(:raise, node.body)
 
-          rescue_nodes.each do |rescue_node|
+          node.resbody_branches.each do |rescue_node|
             check_scope(:fail, rescue_node)
             allow(:raise, rescue_node)
           end

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

@@ -3,8 +3,11 @@
 module RuboCop
   module Cop
     module Style
-      # Sometimes using dig method ends up with just a single
-      # argument. In such cases, dig should be replaced with [].
+      # Sometimes using `dig` method ends up with just a single
+      # argument. In such cases, dig should be replaced with `[]`.
+      #
+      # Since replacing `hash&.dig(:key)` with `hash[:key]` could potentially lead to error,
+      # calls to the `dig` method using safe navigation will be ignored.
       #
       # @safety
       #   This cop is unsafe because it cannot be guaranteed that the receiver
@@ -30,21 +33,19 @@ module RuboCop
       #
       class SingleArgumentDig < Base
         extend AutoCorrector
+        include DigHelp
 
         MSG = 'Use `%<receiver>s[%<argument>s]` instead of `%<original>s`.'
         RESTRICT_ON_SEND = %i[dig].freeze
-
-        # @!method single_argument_dig?(node)
-        def_node_matcher :single_argument_dig?, <<~PATTERN
-          (send _ :dig $!splat)
-        PATTERN
+        IGNORED_ARGUMENT_TYPES = %i[block_pass forwarded_restarg forwarded_args hash].freeze
 
         def on_send(node)
           return unless node.receiver
 
           expression = single_argument_dig?(node)
           return unless expression
-          return if expression.forwarded_args_type?
+          return if IGNORED_ARGUMENT_TYPES.include?(expression.type)
+          return if ignore_dig_chain?(node)
 
           receiver = node.receiver.source
           argument = expression.source
@@ -59,6 +60,13 @@ module RuboCop
 
           ignore_node(node)
         end
+
+        private
+
+        def ignore_dig_chain?(node)
+          dig_chain_enabled? &&
+            (dig?(node.receiver) || dig?(node.parent))
+        end
       end
     end
   end

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

@@ -10,7 +10,7 @@ module RuboCop
       # parameters.
       #
       # Configuration option: Methods
-      # Should be set to use this cop. Array of hashes, where each key is the
+      # Should be set to use this cop. `Array` of hashes, where each key is the
       # method name and value - array of argument names.
       #
       # @example Methods: [{reduce: %w[a b]}]
@@ -33,7 +33,7 @@ module RuboCop
 
         MSG = 'Name `%<method>s` block params `|%<params>s|`.'
 
-        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler, InternalAffairs/ItblockHandler
           return unless node.single_line?
 
           return unless eligible_method?(node)
@@ -89,7 +89,7 @@ module RuboCop
         end
 
         def method_names
-          methods.map { |method| method_name(method).to_sym }
+          @method_names ||= methods.map { |method| method_name(method).to_sym }.freeze
         end
 
         def method_name(method)

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

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for single-line `do`...`end` block.
+      #
+      # In practice a single line `do`...`end` is autocorrected when `EnforcedStyle: semantic`
+      # is configured for `Style/BlockDelimiters`. The autocorrection maintains the
+      # `do` ... `end` syntax to preserve semantics and does not change it to `{`...`}` block.
+      #
+      # NOTE: If `InspectBlocks` is set to `true` for `Layout/RedundantLineBreak`, blocks will
+      # be autocorrected to be on a single line if possible. This cop respects that configuration
+      # by not registering an offense if it would subsequently cause a
+      # `Layout/RedundantLineBreak` offense.
+      #
+      # @example
+      #
+      #   # bad
+      #   foo do |arg| bar(arg) end
+      #
+      #   # good
+      #   foo do |arg|
+      #     bar(arg)
+      #   end
+      #
+      #   # bad
+      #   ->(arg) do bar(arg) end
+      #
+      #   # good
+      #   ->(arg) { bar(arg) }
+      #
+      class SingleLineDoEndBlock < Base
+        extend AutoCorrector
+        include CheckSingleLineSuitability
+
+        MSG = 'Prefer multiline `do`...`end` block.'
+
+        # rubocop:disable-next Metrics/AbcSize
+        def on_block(node)
+          return if node.multiline? || node.braces?
+          return if single_line_blocks_preferred? && suitable_as_single_line?(node)
+
+          add_offense(node) do |corrector|
+            corrector.insert_after(do_line(node), "\n")
+
+            if (heredoc = trailing_heredoc(node.body))
+              # The heredoc body extends past the `end` on the source, so the
+              # `end` has to be moved after it rather than before, which would
+              # otherwise move it into the heredoc body and break the syntax.
+              corrector.remove(node.loc.end)
+              corrector.insert_after(heredoc.loc.heredoc_end, "\nend")
+            else
+              corrector.insert_before(node.loc.end, "\n")
+            end
+          end
+        end
+        alias on_numblock on_block
+        alias on_itblock on_block
+
+        private
+
+        # Returns the heredoc opened on the block's line whose body extends the
+        # furthest down, whether it is the block body itself or nested within it.
+        def trailing_heredoc(node_body)
+          return unless node_body
+
+          heredocs = [node_body, *node_body.each_descendant].select do |node|
+            node.respond_to?(:heredoc?) && node.heredoc?
+          end
+
+          heredocs.max_by { |heredoc| heredoc.loc.heredoc_end.line }
+        end
+
+        def do_line(node)
+          if node.type?(:numblock, :itblock) ||
+             node.arguments.children.empty? || node.send_node.lambda_literal?
+            node.loc.begin
+          else
+            node.arguments
+          end
+        end
+
+        def single_line_blocks_preferred?
+          @config.for_enabled_cop('Layout/RedundantLineBreak')['InspectBlocks']
+        end
+      end
+    end
+  end
+end

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

@@ -4,13 +4,15 @@ module RuboCop
   module Cop
     module Style
       # Checks for single-line method definitions that contain a body.
-      # It will accept single-line methods with no body.
+      # Single-line methods with a body are harder to read and debug
+      # than their multi-line equivalents. It will accept single-line
+      # methods with no body.
       #
       # 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
@@ -65,10 +67,10 @@ module RuboCop
           return false if target_ruby_version < 3.0
           return false if disallow_endless_method_style?
           return false unless body_node
-          return false if body_node.parent.assignment_method? ||
+          return false if body_node.basic_conditional? || body_node.parent.assignment_method? ||
                           NOT_SUPPORTED_ENDLESS_METHOD_BODY_TYPES.include?(body_node.type)
 
-          !(body_node.begin_type? || body_node.kwbegin_type?)
+          !body_node.type?(:begin, :kwbegin)
         end
 
         def correct_to_multiline(corrector, node)
@@ -86,10 +88,10 @@ module RuboCop
         end
 
         def correct_to_endless(corrector, node)
-          self_receiver = node.self_receiver? ? 'self.' : ''
+          receiver = "#{node.receiver.source}." if node.receiver
           arguments = node.arguments.any? ? node.arguments.source : '()'
           body_source = method_body_source(node.body)
-          replacement = "def #{self_receiver}#{node.method_name}#{arguments} = #{body_source}"
+          replacement = "def #{receiver}#{node.method_name}#{arguments} = #{body_source}"
 
           corrector.replace(node, replacement)
         end
@@ -130,14 +132,16 @@ module RuboCop
         end
 
         def require_parentheses?(method_body)
-          method_body.send_type? && !method_body.arguments.empty? && !method_body.comparison_method?
+          return false unless method_body.send_type?
+          return false if method_body.arithmetic_operation?
+
+          !method_body.arguments.empty? && !method_body.comparison_method?
         end
 
         def disallow_endless_method_style?
-          endless_method_config = config.for_cop('Style/EndlessMethod')
-          return true unless endless_method_config['Enabled']
+          return true unless config.cop_enabled?('Style/EndlessMethod')
 
-          endless_method_config['EnforcedStyle'] == 'disallow'
+          config.for_cop('Style/EndlessMethod')['EnforcedStyle'] == 'disallow'
         end
       end
     end

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

@@ -3,8 +3,9 @@
 module RuboCop
   module Cop
     module Style
-      # Checks that arrays are sliced with endless ranges instead of
-      # `ary[start..-1]` on Ruby 2.6+.
+      # Checks that arrays are not sliced with the redundant `ary[0..-1]`, replacing it with `ary`,
+      # and ensures arrays are sliced with endless ranges instead of `ary[start..-1]` on Ruby 2.6+,
+      # and with beginless ranges instead of `ary[nil..end]` on Ruby 2.7+.
       #
       # @safety
       #   This cop is unsafe because `x..-1` and `x..` are only guaranteed to
@@ -21,30 +22,124 @@ module RuboCop
       #
       # @example
       #   # bad
-      #   items[1..-1]
+      #   items[0..-1]
+      #   items[0..nil]
+      #   items[0...nil]
       #
       #   # good
-      #   items[1..]
+      #   items
+      #
+      #   # bad
+      #   items[1..-1]   # Ruby 2.6+
+      #   items[1..nil]  # Ruby 2.6+
+      #
+      #   # good
+      #   items[1..]     # Ruby 2.6+
+      #
+      #   # bad
+      #   items[nil..42] # Ruby 2.7+
+      #
+      #   # good
+      #   items[..42]    # Ruby 2.7+
+      #   items[0..42]   # Ruby 2.7+
+      #
       class SlicingWithRange < Base
         extend AutoCorrector
         extend TargetRubyVersion
 
         minimum_target_ruby_version 2.6
 
-        MSG = 'Prefer ary[n..] over ary[n..-1].'
+        MSG = 'Prefer `%<prefer>s` over `%<current>s`.'
+        MSG_USELESS_RANGE = 'Remove the useless `%<prefer>s`.'
         RESTRICT_ON_SEND = %i[[]].freeze
 
+        # @!method range_from_zero_till_minus_one?(node)
+        def_node_matcher :range_from_zero_till_minus_one?, <<~PATTERN
+          {
+            (irange (int 0) {(int -1) nil})
+            (erange (int 0) nil)
+          }
+        PATTERN
+
         # @!method range_till_minus_one?(node)
-        def_node_matcher :range_till_minus_one?, '(irange !nil? (int -1))'
+        def_node_matcher :range_till_minus_one?, <<~PATTERN
+          {
+            (irange !nil? {(int -1) nil})
+            (erange !nil? nil)
+          }
+        PATTERN
+
+        # @!method range_from_zero?(node)
+        def_node_matcher :range_from_zero?, <<~PATTERN
+          (irange nil !nil?)
+        PATTERN
 
         def on_send(node)
-          return unless node.arguments.count == 1
-          return unless range_till_minus_one?(node.arguments.first)
+          return unless node.arguments.one?
+
+          range_node = node.first_argument
+          offense_range = find_offense_range(node)
+          return unless (message, removal_range =
+                           offense_message_with_removal_range(node, range_node, offense_range))
+
+          # Changing the range to beginningless or endless when unparenthesized
+          # changes the semantics of the code, and thus will not be considered
+          # an offense.
+          return if removal_range != offense_range && unparenthesized_call?(node)
+
+          add_offense(offense_range, message: message) do |corrector|
+            corrector.remove(removal_range)
+          end
+        end
+        alias on_csend on_send
+
+        private
+
+        def unparenthesized_call?(node)
+          node.loc.dot && !node.parenthesized?
+        end
 
-          add_offense(node.first_argument) do |corrector|
-            corrector.remove(node.first_argument.end)
+        def find_offense_range(node)
+          if node.loc.dot
+            node.loc.dot.join(node.source_range.end)
+          else
+            node.loc.selector
           end
         end
+
+        def offense_message_with_removal_range(node, range_node, offense_range)
+          if range_from_zero_till_minus_one?(range_node)
+            [format(MSG_USELESS_RANGE, prefer: offense_range.source), offense_range]
+          elsif range_till_minus_one?(range_node)
+            [
+              offense_message_for_partial_range(node, endless(range_node), offense_range),
+              range_node.end
+            ]
+          elsif range_from_zero?(range_node) && target_ruby_version >= 2.7
+            [
+              offense_message_for_partial_range(node, beginless(range_node), offense_range),
+              range_node.begin
+            ]
+          end
+        end
+
+        def offense_message_for_partial_range(node, prefer, offense_range)
+          current = node.loc.dot ? arguments_source(node) : offense_range.source
+          prefer = "[#{prefer}]" unless node.loc.dot
+          format(MSG, prefer: prefer, current: current)
+        end
+
+        def endless(range_node)
+          "#{range_node.begin.source}#{range_node.loc.operator.source}"
+        end
+
+        def beginless(range_node)
+          "#{range_node.loc.operator.source}#{range_node.end.source}"
+        end
+
+        def arguments_source(node)
+          node.first_argument.source_range.join(node.last_argument.source_range.end).source
+        end
       end
     end
   end