rubocop 1.54.1 → 1.64.1

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

@@ -31,7 +31,7 @@ module RuboCop
       #     do_something?
       #   end
       #
-      # @example AllowedMethod: ['foo?']
+      # @example AllowedMethods: ['foo?']
       #   # good
       #   def foo?
       #     return if condition
@@ -39,7 +39,7 @@ module RuboCop
       #     do_something?
       #   end
       #
-      # @example AllowedPattern: [/foo/]
+      # @example AllowedPatterns: [/foo/]
       #   # good
       #   def foo?
       #     return if condition
@@ -52,7 +52,7 @@ module RuboCop
         include AllowedMethods
         include AllowedPattern
 
-        MSG = 'Use `return false` instead of `%<prefer>s` in the predicate method.'
+        MSG = 'Return `false` instead of `nil` in predicate methods.'
 
         # @!method return_nil?(node)
         def_node_matcher :return_nil?, <<~PATTERN
@@ -65,16 +65,30 @@ module RuboCop
           return unless (body = node.body)
 
           body.each_descendant(:return) do |return_node|
-            next unless return_nil?(return_node)
+            register_offense(return_node, 'return false') if return_nil?(return_node)
+          end
 
-            message = format(MSG, prefer: return_node.source)
+          return unless (nil_node = nil_node_at_the_end_of_method_body(body))
 
-            add_offense(return_node, message: message) do |corrector|
-              corrector.replace(return_node, 'return false')
-            end
-          end
+          register_offense(nil_node, 'false')
         end
         alias on_defs on_def
+
+        private
+
+        def nil_node_at_the_end_of_method_body(body)
+          return body if body.nil_type?
+          return unless body.begin_type?
+          return unless (last_child = body.children.last)
+
+          last_child if last_child.is_a?(AST::Node) && last_child.nil_type?
+        end
+
+        def register_offense(offense_node, replacement)
+          add_offense(offense_node) do |corrector|
+            corrector.replace(offense_node, replacement)
+          end
+        end
       end
     end
   end

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

@@ -35,7 +35,7 @@ module RuboCop
 
         # @!method sample_candidate?(node)
         def_node_matcher :sample_candidate?, <<~PATTERN
-          (send $(send _ :shuffle $...) ${:#{RESTRICT_ON_SEND.join(' :')}} $...)
+          (call $(call _ :shuffle $...) ${:#{RESTRICT_ON_SEND.join(' :')}} $...)
         PATTERN
 
         def on_send(node)
@@ -52,6 +52,7 @@ module RuboCop
             end
           end
         end
+        alias on_csend on_send
 
         private
 
@@ -109,9 +110,7 @@ module RuboCop
         # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         def source_range(shuffle_node, node)
-          Parser::Source::Range.new(shuffle_node.source_range.source_buffer,
-                                    shuffle_node.loc.selector.begin_pos,
-                                    node.source_range.end_pos)
+          shuffle_node.loc.selector.join(node.source_range.end)
         end
 
         def message(shuffle_arg, method, method_args, range)

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

@@ -55,8 +55,8 @@ module RuboCop
         # @!method regexp_match?(node)
         def_node_matcher :regexp_match?, <<~PATTERN
           {
-            (block send (args (arg $_)) ${(send _ %REGEXP_METHODS _) match-with-lvasgn})
-            (numblock send $1 ${(send _ %REGEXP_METHODS _) match-with-lvasgn})
+            (block call (args (arg $_)) ${(send _ %REGEXP_METHODS _) match-with-lvasgn})
+            (numblock call $1 ${(send _ %REGEXP_METHODS _) match-with-lvasgn})
           }
         PATTERN
 
@@ -64,9 +64,9 @@ module RuboCop
         # @!method creates_hash?(node)
         def_node_matcher :creates_hash?, <<~PATTERN
           {
-            (send (const _ :Hash) {:new :[]} ...)
-            (block (send (const _ :Hash) :new ...) ...)
-            (send _ { :to_h :to_hash } ...)
+            (call (const _ :Hash) {:new :[]} ...)
+            (block (call (const _ :Hash) :new ...) ...)
+            (call _ { :to_h :to_hash } ...)
           }
         PATTERN
 
@@ -100,6 +100,7 @@ module RuboCop
           register_offense(node, block_node, regexp, replacement)
         end
         # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        alias on_csend on_send
 
         private
 
@@ -146,7 +147,7 @@ module RuboCop
           return node.child_nodes.first if node.match_with_lvasgn_type?
 
           if node.receiver.lvar_type? &&
-             (block.numblock_type? || node.receiver.source == block.arguments.first.source)
+             (block.numblock_type? || node.receiver.source == block.first_argument.source)
             node.first_argument
           elsif node.first_argument.lvar_type?
             node.receiver

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

@@ -16,7 +16,7 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Use self-assignment shorthand `%<method>s=`.'
-        OPS = %i[+ - * ** / | &].freeze
+        OPS = %i[+ - * ** / % ^ << >> | &].freeze
 
         def self.autocorrect_incompatible_with
           [Layout::SpaceAroundOperators]

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

@@ -62,9 +62,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
@@ -83,6 +80,7 @@ module RuboCop
           processed_source.tokens.group_by(&:line)
         end
 
+        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def semicolon_position(tokens)
           if tokens.last.semicolon?
             -1
@@ -93,10 +91,13 @@ 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
         end
+        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         def exist_semicolon_before_right_curly_brace?(tokens)
           tokens[-2]&.right_curly_brace? && tokens[-3]&.semicolon?
@@ -106,6 +107,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

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,90 @@
+# 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.
+      #
+      # @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 STATIC_METHOD_NAME_NODE_TYPES.include?(first_argument.type)
+
+          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
+        # 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/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
@@ -33,6 +36,7 @@ module RuboCop
 
         MSG = 'Use `%<receiver>s[%<argument>s]` instead of `%<original>s`.'
         RESTRICT_ON_SEND = %i[dig].freeze
+        IGNORED_ARGUMENT_TYPES = %i[block_pass forwarded_restarg forwarded_args hash].freeze
 
         # @!method single_argument_dig?(node)
         def_node_matcher :single_argument_dig?, <<~PATTERN
@@ -44,7 +48,7 @@ module RuboCop
 
           expression = single_argument_dig?(node)
           return unless expression
-          return if expression.forwarded_args_type?
+          return if IGNORED_ARGUMENT_TYPES.include?(expression.type)
 
           receiver = node.receiver.source
           argument = expression.source

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

@@ -0,0 +1,67 @@
+# 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`
+      # in `Style/BlockDelimiters`. The autocorrection maintains the `do` ... `end` syntax to
+      # preserve semantics and does not change it to `{`...`}` block.
+      #
+      # @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
+
+        MSG = 'Prefer multiline `do`...`end` block.'
+
+        # rubocop:disable Metrics/AbcSize
+        def on_block(node)
+          return if !node.single_line? || node.braces?
+
+          add_offense(node) do |corrector|
+            corrector.insert_after(do_line(node), "\n")
+
+            node_body = node.body
+
+            if node_body.respond_to?(:heredoc?) && node_body.heredoc?
+              corrector.remove(node.loc.end)
+              corrector.insert_after(node_body.loc.heredoc_end, "\nend")
+            else
+              corrector.insert_before(node.loc.end, "\n")
+            end
+          end
+        end
+        # rubocop:enable Metrics/AbcSize
+        alias on_numblock on_block
+
+        private
+
+        def do_line(node)
+          if node.numblock_type? || node.arguments.children.empty? || node.send_node.lambda_literal?
+            node.loc.begin
+          else
+            node.arguments
+          end
+        end
+
+        def x(corrector, node); end
+      end
+    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,29 +22,94 @@ 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?
 
-          add_offense(node.first_argument) do |corrector|
-            corrector.remove(node.first_argument.end)
+          range_node = node.first_argument
+          selector = node.loc.selector
+          unless (message, removal_range = offense_message_with_removal_range(range_node, selector))
+            return
           end
+
+          add_offense(selector, message: message) do |corrector|
+            corrector.remove(removal_range)
+          end
+        end
+
+        private
+
+        def offense_message_with_removal_range(range_node, selector)
+          if range_from_zero_till_minus_one?(range_node)
+            [format(MSG_USELESS_RANGE, prefer: selector.source), selector]
+          elsif range_till_minus_one?(range_node)
+            [
+              format(MSG, prefer: endless(range_node), current: selector.source), range_node.end
+            ]
+          elsif range_from_zero?(range_node) && target_ruby_version >= 2.7
+            [
+              format(MSG, prefer: beginless(range_node), current: selector.source), range_node.begin
+            ]
+          end
+        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
       end
     end

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

@@ -173,7 +173,9 @@ module RuboCop
         end
 
         def correct_for_comment(corrector, node, if_branch)
-          comments = processed_source.ast_with_comments[if_branch]
+          comments = processed_source.ast_with_comments[if_branch].select do |comment|
+            comment.loc.line < if_branch.condition.first_line
+          end
           comment_text = comments.map(&:text).join("\n") << "\n"
 
           corrector.insert_before(node.loc.keyword, comment_text) unless comments.empty?

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

@@ -58,9 +58,8 @@ module RuboCop
       #
       # @example EnforcedStyle: use_builtin_english_names
       #
-      # Like `use_perl_names` but allows builtin global vars.
-      #
       #   # good
+      #   # Like `use_perl_names` but allows builtin global vars.
       #   puts $LOAD_PATH
       #   puts $LOADED_FEATURES
       #   puts $PROGRAM_NAME

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

@@ -35,6 +35,7 @@ module RuboCop
             corrector.replace(range, 'chars')
           end
         end
+        alias on_csend on_send
       end
     end
   end

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

@@ -3,22 +3,42 @@
 module RuboCop
   module Cop
     module Style
-      # Checks that quotes inside the string interpolation
+      # Checks that quotes inside string, symbol, and regexp interpolations
       # match the configured preference.
       #
       # @example EnforcedStyle: single_quotes (default)
       #   # bad
-      #   result = "Tests #{success ? "PASS" : "FAIL"}"
+      #   string = "Tests #{success ? "PASS" : "FAIL"}"
+      #   symbol = :"Tests #{success ? "PASS" : "FAIL"}"
+      #   heredoc = <<~TEXT
+      #     Tests #{success ? "PASS" : "FAIL"}
+      #   TEXT
+      #   regexp = /Tests #{success ? "PASS" : "FAIL"}/
       #
       #   # good
-      #   result = "Tests #{success ? 'PASS' : 'FAIL'}"
+      #   string = "Tests #{success ? 'PASS' : 'FAIL'}"
+      #   symbol = :"Tests #{success ? 'PASS' : 'FAIL'}"
+      #   heredoc = <<~TEXT
+      #     Tests #{success ? 'PASS' : 'FAIL'}
+      #   TEXT
+      #   regexp = /Tests #{success ? 'PASS' : 'FAIL'}/
       #
       # @example EnforcedStyle: double_quotes
       #   # bad
-      #   result = "Tests #{success ? 'PASS' : 'FAIL'}"
+      #   string = "Tests #{success ? 'PASS' : 'FAIL'}"
+      #   symbol = :"Tests #{success ? 'PASS' : 'FAIL'}"
+      #   heredoc = <<~TEXT
+      #     Tests #{success ? 'PASS' : 'FAIL'}
+      #   TEXT
+      #   regexp = /Tests #{success ? 'PASS' : 'FAIL'}/
       #
       #   # good
-      #   result = "Tests #{success ? "PASS" : "FAIL"}"
+      #   string = "Tests #{success ? "PASS" : "FAIL"}"
+      #   symbol = :"Tests #{success ? "PASS" : "FAIL"}"
+      #   heredoc = <<~TEXT
+      #     Tests #{success ? "PASS" : "FAIL"}
+      #   TEXT
+      #   regexp = /Tests #{success ? "PASS" : "FAIL"}/
       class StringLiteralsInInterpolation < Base
         include ConfigurableEnforcedStyle
         include StringLiteralsHelp
@@ -29,6 +49,11 @@ module RuboCop
           StringLiteralCorrector.correct(corrector, node, style)
         end
 
+        # Cop classes that include the StringHelp module usually ignore regexp
+        # nodes. Not so for this cop, which is why we override the on_regexp
+        # definition with an empty one.
+        def on_regexp(node); end
+
         private
 
         def message(_node)

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

@@ -22,20 +22,23 @@ module RuboCop
 
         # @!method lstrip_rstrip(node)
         def_node_matcher :lstrip_rstrip, <<~PATTERN
-          {(send $(send _ $:rstrip) $:lstrip)
-           (send $(send _ $:lstrip) $:rstrip)}
+          {
+            (call $(call _ :rstrip) :lstrip)
+            (call $(call _ :lstrip) :rstrip)
+          }
         PATTERN
 
         def on_send(node)
-          lstrip_rstrip(node) do |first_send, method_one, method_two|
+          lstrip_rstrip(node) do |first_send|
             range = range_between(first_send.loc.selector.begin_pos, node.source_range.end_pos)
-            message = format(MSG, methods: "#{method_one}.#{method_two}")
+            message = format(MSG, methods: range.source)
 
             add_offense(range, message: message) do |corrector|
               corrector.replace(range, 'strip')
             end
           end
         end
+        alias on_csend on_send
       end
     end
   end