rubocop 1.59.0 → 1.65.1

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.first_argument)
+          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

@@ -159,7 +159,13 @@ module RuboCop
           node_to_check = condition&.block_type? ? condition.send_node : condition
           return unless wrap_condition?(node_to_check)
 
-          corrector.wrap(condition, '(', ')')
+          if condition.call_type?
+            source = parenthesized_method_arguments(condition)
+
+            corrector.replace(condition, source)
+          else
+            corrector.wrap(condition, '(', ')')
+          end
         end
 
         def correct_for_outer_condition_modify_form_style(corrector, node, if_branch)
@@ -236,7 +242,20 @@ module RuboCop
         end
 
         def replace_condition(condition)
-          wrap_condition?(condition) ? "(#{condition.source})" : condition.source
+          return condition.source unless wrap_condition?(condition)
+
+          if condition.call_type?
+            parenthesized_method_arguments(condition)
+          else
+            "(#{condition.source})"
+          end
+        end
+
+        def parenthesized_method_arguments(node)
+          method_call = node.source_range.begin.join(node.loc.selector.end).source
+          arguments = node.first_argument.source_range.begin.join(node.source_range.end).source
+
+          "#{method_call}(#{arguments})"
         end
 
         def allow_modifier?

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/super_arguments.rb

@@ -0,0 +1,174 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for redundant argument forwarding when calling super with arguments identical to
+      # the method definition.
+      #
+      # Using zero arity `super` within a `define_method` block results in `RuntimeError`:
+      #
+      # [source,ruby]
+      # ----
+      # def m
+      #   define_method(:foo) { super() } # => OK
+      # end
+      #
+      # def m
+      #   define_method(:foo) { super }   # => RuntimeError
+      # end
+      # ----
+      #
+      # Furthermore, any arguments accompanied by a block may potentially be delegating to
+      # `define_method`, therefore, `super` used within these blocks will be allowed.
+      # This approach might result in false negatives, yet ensuring safe detection takes precedence.
+      #
+      # @example
+      #   # bad
+      #   def method(*args, **kwargs)
+      #     super(*args, **kwargs)
+      #   end
+      #
+      #   # good - implicitly passing all arguments
+      #   def method(*args, **kwargs)
+      #     super
+      #   end
+      #
+      #   # good - forwarding a subset of the arguments
+      #   def method(*args, **kwargs)
+      #     super(*args)
+      #   end
+      #
+      #   # good - forwarding no arguments
+      #   def method(*args, **kwargs)
+      #     super()
+      #   end
+      #
+      #   # good - assigning to the block variable before calling super
+      #   def method(&block)
+      #     # Assigning to the block variable would pass the old value to super,
+      #     # under this circumstance the block must be referenced explicitly.
+      #     block ||= proc { 'fallback behavior' }
+      #     super(&block)
+      #   end
+      class SuperArguments < Base
+        extend AutoCorrector
+
+        DEF_TYPES = %i[def defs].freeze
+        ASSIGN_TYPES = %i[or_asgn lvasgn].freeze
+
+        MSG = 'Call `super` without arguments and parentheses when the signature is identical.'
+
+        def on_super(super_node)
+          def_node = super_node.ancestors.find do |node|
+            # When defining dynamic methods, implicitly calling `super` is not possible.
+            # Since there is a possibility of delegation to `define_method`,
+            # `super` used within the block is always allowed.
+            break if node.block_type?
+
+            break node if DEF_TYPES.include?(node.type)
+          end
+          return unless def_node
+          return unless arguments_identical?(def_node, def_node.arguments.argument_list,
+                                             super_node.arguments)
+
+          add_offense(super_node) { |corrector| corrector.replace(super_node, 'super') }
+        end
+
+        private
+
+        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        def arguments_identical?(def_node, def_args, super_args)
+          super_args = preprocess_super_args(super_args)
+          return false if def_args.size != super_args.size
+
+          def_args.zip(super_args).each do |def_arg, super_arg|
+            next if positional_arg_same?(def_arg, super_arg)
+            next if positional_rest_arg_same(def_arg, super_arg)
+            next if keyword_arg_same?(def_arg, super_arg)
+            next if keyword_rest_arg_same?(def_arg, super_arg)
+            next if block_arg_same?(def_node, def_arg, super_arg)
+            next if forward_arg_same?(def_arg, super_arg)
+
+            return false
+          end
+          true
+        end
+        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
+        def positional_arg_same?(def_arg, super_arg)
+          return false unless def_arg.arg_type? || def_arg.optarg_type?
+          return false unless super_arg.lvar_type?
+
+          def_arg.name == super_arg.children.first
+        end
+
+        def positional_rest_arg_same(def_arg, super_arg)
+          return false unless def_arg.restarg_type?
+          # anonymous forwarding
+          return true if def_arg.name.nil? && super_arg.forwarded_restarg_type?
+          return false unless super_arg.splat_type?
+          return false unless (lvar_node = super_arg.children.first).lvar_type?
+
+          def_arg.name == lvar_node.children.first
+        end
+
+        def keyword_arg_same?(def_arg, super_arg)
+          return false unless def_arg.kwarg_type? || def_arg.kwoptarg_type?
+          return false unless (pair_node = super_arg).pair_type?
+          return false unless (sym_node = pair_node.key).sym_type?
+          return false unless (lvar_node = pair_node.value).lvar_type?
+          return false unless sym_node.source == lvar_node.source
+
+          def_arg.name == sym_node.value
+        end
+
+        def keyword_rest_arg_same?(def_arg, super_arg)
+          return false unless def_arg.kwrestarg_type?
+          # anonymous forwarding
+          return true if def_arg.name.nil? && super_arg.forwarded_kwrestarg_type?
+          return false unless super_arg.kwsplat_type?
+          return false unless (lvar_node = super_arg.children.first).lvar_type?
+
+          def_arg.name == lvar_node.children.first
+        end
+
+        def block_arg_same?(def_node, def_arg, super_arg)
+          return false unless def_arg.blockarg_type? && super_arg.block_pass_type?
+          # anonymous forwarding
+          return true if (block_pass_child = super_arg.children.first).nil? && def_arg.name.nil?
+
+          block_arg_name = block_pass_child.children.first
+          def_arg.name == block_arg_name && !block_reassigned?(def_node, block_arg_name)
+        end
+
+        # Reassigning the block argument will still pass along the original block to super
+        # https://bugs.ruby-lang.org/issues/20505
+        def block_reassigned?(def_node, block_arg_name)
+          def_node.each_node(*ASSIGN_TYPES).any? do |assign_node|
+            # TODO: Since `Symbol#name` is supported from Ruby 3.0, the inheritance check for
+            # `AST::Node` can be removed when requiring Ruby 3.0+.
+            lhs = assign_node.node_parts[0]
+            next if lhs.is_a?(AST::Node) && !lhs.respond_to?(:name)
+
+            assign_node.name == block_arg_name
+          end
+        end
+
+        def forward_arg_same?(def_arg, super_arg)
+          def_arg.forward_arg_type? && super_arg.forwarded_args_type?
+        end
+
+        def preprocess_super_args(super_args)
+          super_args.flat_map do |node|
+            if node.hash_type? && !node.braces?
+              node.children
+            else
+              node
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -37,6 +37,42 @@ module RuboCop
       #   # ArgumentError: wrong number of arguments (given 1, expected 0)
       #   ----
       #
+      #   It is also unsafe because `Symbol#to_proc` does not work with
+      #   `protected` methods which would otherwise be accessible.
+      #
+      #   For example:
+      #
+      #   [source,ruby]
+      #   ----
+      #   class Box
+      #     def initialize
+      #       @secret = rand
+      #     end
+      #
+      #     def normal_matches?(*others)
+      #       others.map { |other| other.secret }.any?(secret)
+      #     end
+      #
+      #     def symbol_to_proc_matches?(*others)
+      #       others.map(&:secret).any?(secret)
+      #     end
+      #
+      #     protected
+      #
+      #     attr_reader :secret
+      #   end
+      #
+      #   boxes = [Box.new, Box.new]
+      #   Box.new.normal_matches?(*boxes)
+      #   # => false
+      #   boxes.first.normal_matches?(*boxes)
+      #   # => true
+      #   Box.new.symbol_to_proc_matches?(*boxes)
+      #   # => NoMethodError: protected method `secret' called for #<Box...>
+      #   boxes.first.symbol_to_proc_matches?(*boxes)
+      #   # => NoMethodError: protected method `secret' called for #<Box...>
+      #   ----
+      #
       # @example
       #   # bad
       #   something.map { |s| s.upcase }
@@ -84,6 +120,23 @@ module RuboCop
       #   # good
       #   something.map { |s| s.upcase }
       #
+      # @example AllCops:ActiveSupportExtensionsEnabled: false (default)
+      #   # bad
+      #   ->(x) { x.foo }
+      #   proc { |x| x.foo }
+      #   Proc.new { |x| x.foo }
+      #
+      #   # good
+      #   lambda(&:foo)
+      #   proc(&:foo)
+      #   Proc.new(&:foo)
+      #
+      # @example AllCops:ActiveSupportExtensionsEnabled: true
+      #   # good
+      #   ->(x) { x.foo }
+      #   proc { |x| x.foo }
+      #   Proc.new { |x| x.foo }
+      #
       class SymbolProc < Base
         include CommentsHelp
         include RangeHelp
@@ -93,6 +146,7 @@ module RuboCop
 
         MSG = 'Pass `&:%<method>s` as an argument to `%<block_method>s` instead of a block.'
         SUPER_TYPES = %i[super zsuper].freeze
+        LAMBDA_OR_PROC = %i[lambda proc].freeze
 
         # @!method proc_node?(node)
         def_node_matcher :proc_node?, '(send (const {nil? cbase} :Proc) :new)'
@@ -115,13 +169,12 @@ module RuboCop
         # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def on_block(node)
           symbol_proc?(node) do |dispatch_node, arguments_node, method_name|
-            # TODO: Rails-specific handling that we should probably make
-            # configurable - https://github.com/rubocop/rubocop/issues/1485
-            # we should allow lambdas & procs
-            return if proc_node?(dispatch_node)
+            if active_support_extensions_enabled?
+              return if proc_node?(dispatch_node)
+              return if LAMBDA_OR_PROC.include?(dispatch_node.method_name)
+            end
             return if unsafe_hash_usage?(dispatch_node)
             return if unsafe_array_usage?(dispatch_node)
-            return if %i[lambda proc].include?(dispatch_node.method_name)
             return if allowed_method_name?(dispatch_node.method_name)
             return if allow_if_method_has_argument?(node.send_node)
             return if node.block_type? && destructuring_block_argument?(arguments_node)
@@ -170,6 +223,15 @@ module RuboCop
         end
 
         def autocorrect_without_args(corrector, node)
+          if node.send_node.lambda_literal?
+            if node.send_node.loc.selector.source == '->'
+              corrector.replace(node, "lambda(&:#{node.body.method_name})")
+              return
+            else
+              autocorrect_lambda_block(corrector, node)
+            end
+          end
+
           corrector.replace(block_range_with_space(node), "(&:#{node.body.method_name})")
         end
 
@@ -182,6 +244,14 @@ module RuboCop
           corrector.remove(block_range_with_space(node))
         end
 
+        def autocorrect_lambda_block(corrector, node)
+          send_node_loc = node.send_node.loc
+          corrector.replace(send_node_loc.selector, 'lambda')
+
+          range = range_between(send_node_loc.selector.end_pos, node.loc.begin.end_pos - 2)
+          corrector.remove(range)
+        end
+
         def block_range_with_space(node)
           block_range = range_between(begin_pos_for_replacement(node), node.loc.end.end_pos)
           range_with_surrounding_space(block_range, side: :left)

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

@@ -77,7 +77,7 @@ module RuboCop
 
         # @!method define_method_block?(node)
         def_node_matcher :define_method_block?, <<~PATTERN
-          ({block numblock} (send _ {:define_method} _) ...)
+          ({block numblock} (send _ :define_method _) ...)
         PATTERN
       end
     end

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

@@ -17,8 +17,6 @@ module RuboCop
       #     do_something(x.pop)
       #   end
       #
-      # @example
-      #
       #   # bad
       #   until x.empty? do
       #     do_something(x.pop)

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

@@ -16,7 +16,6 @@ module RuboCop
       #   # good
       #   x += 1 while x < 10
       #
-      # @example
       #   # bad
       #   until x > 10
       #     x += 1

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

@@ -48,14 +48,19 @@ module RuboCop
           check_nonzero_length_comparison(node)
         end
 
+        def on_csend(node)
+          check_zero_length_predicate(node)
+          check_zero_length_comparison(node)
+        end
+
         private
 
         def check_zero_length_predicate(node)
-          return unless (length_method = zero_length_predicate(node.parent))
+          return unless zero_length_predicate?(node.parent)
           return if non_polymorphic_collection?(node.parent)
 
           offense = node.loc.selector.join(node.parent.source_range.end)
-          message = format(ZERO_MSG, current: "#{length_method}.zero?")
+          message = format(ZERO_MSG, current: offense.source)
 
           add_offense(offense, message: message) do |corrector|
             corrector.replace(offense, 'empty?')
@@ -92,44 +97,47 @@ module RuboCop
           end
         end
 
-        # @!method zero_length_predicate(node)
-        def_node_matcher :zero_length_predicate, <<~PATTERN
-          (send (send (...) ${:length :size}) :zero?)
+        # @!method zero_length_predicate?(node)
+        def_node_matcher :zero_length_predicate?, <<~PATTERN
+          (call (call (...) {:length :size}) :zero?)
         PATTERN
 
         # @!method zero_length_comparison(node)
         def_node_matcher :zero_length_comparison, <<~PATTERN
-          {(send (send (...) ${:length :size}) $:== (int $0))
-           (send (int $0) $:== (send (...) ${:length :size}))
-           (send (send (...) ${:length :size}) $:<  (int $1))
-           (send (int $1) $:> (send (...) ${:length :size}))}
+          {(call (call (...) ${:length :size}) $:== (int $0))
+           (call (int $0) $:== (call (...) ${:length :size}))
+           (call (call (...) ${:length :size}) $:<  (int $1))
+           (call (int $1) $:> (call (...) ${:length :size}))}
         PATTERN
 
         # @!method nonzero_length_comparison(node)
         def_node_matcher :nonzero_length_comparison, <<~PATTERN
-          {(send (send (...) ${:length :size}) ${:> :!=} (int $0))
-           (send (int $0) ${:< :!=} (send (...) ${:length :size}))}
+          {(call (call (...) ${:length :size}) ${:> :!=} (int $0))
+           (call (int $0) ${:< :!=} (call (...) ${:length :size}))}
         PATTERN
 
         def replacement(node)
-          receiver = zero_length_receiver(node)
-          return "#{receiver.source}.empty?" if receiver
+          length_node = zero_length_node(node)
+          if length_node&.receiver
+            return "#{length_node.receiver.source}#{length_node.loc.dot.source}empty?"
+          end
 
-          "!#{other_receiver(node).source}.empty?"
+          other_length_node = other_length_node(node)
+          "!#{other_length_node.receiver.source}#{other_length_node.loc.dot.source}empty?"
         end
 
-        # @!method zero_length_receiver(node)
-        def_node_matcher :zero_length_receiver, <<~PATTERN
-          {(send (send $_ _) :== (int 0))
-           (send (int 0) :== (send $_ _))
-           (send (send $_ _) :<  (int 1))
-           (send (int 1) :> (send $_ _))}
+        # @!method zero_length_node(node)
+        def_node_matcher :zero_length_node, <<~PATTERN
+          {(send $(call _ _) :== (int 0))
+           (send (int 0) :== $(call _ _))
+           (send $(call _ _) :<  (int 1))
+           (send (int 1) :> $(call _ _))}
         PATTERN
 
-        # @!method other_receiver(node)
-        def_node_matcher :other_receiver, <<~PATTERN
-          {(send (send $_ _) _ _)
-           (send _ _ (send $_ _))}
+        # @!method other_length_node(node)
+        def_node_matcher :other_length_node, <<~PATTERN
+          {(call $(call _ _) _ _)
+           (call _ _ $(call _ _))}
         PATTERN
 
         # Some collection like objects in the Ruby standard library

data/lib/rubocop/cop/team.rb

@@ -74,6 +74,10 @@ module RuboCop
       # @deprecated. Use investigate
       # @return Array<offenses>
       def inspect_file(processed_source)
+        warn Rainbow(<<~WARNING).yellow, uplevel: 1
+          `inspect_file` is deprecated. Use `investigate` instead.
+        WARNING
+
         investigate(processed_source).offenses
       end
 
@@ -108,6 +112,10 @@ module RuboCop
 
       # @deprecated
       def forces
+        warn Rainbow(<<~WARNING).yellow, uplevel: 1
+          `forces` is deprecated.
+        WARNING
+
         @forces ||= self.class.forces_for(cops)
       end
 
@@ -174,6 +182,9 @@ module RuboCop
       end
 
       def support_target_rails_version?(cop)
+        # In this case, the rails version was already checked by `#excluded_file?`
+        return true if defined?(RuboCop::Rails::TargetRailsVersion::USES_REQUIRES_GEM_API)
+
         return true unless cop.class.respond_to?(:support_target_rails_version?)
 
         cop.class.support_target_rails_version?(cop.target_rails_version)
@@ -237,6 +248,8 @@ module RuboCop
 
           if cause.is_a?(Warning)
             handle_warning(cause, location)
+          elsif cause.is_a?(Force::HookError)
+            handle_error(cause.cause, location, cause.joining_cop)
           else
             handle_error(cause, location, error.cop)
           end

data/lib/rubocop/cop/util.rb

@@ -20,6 +20,10 @@ module RuboCop
 
       # @deprecated Use `ProcessedSource#line_with_comment?`, `contains_comment?` or similar
       def comment_lines?(node)
+        warn Rainbow(<<~WARNING).yellow, uplevel: 1
+          `comment_lines?` is deprecated. Use `ProcessedSource#line_with_comment?`, `contains_comment?` or similar instead.
+        WARNING
+
         processed_source[line_range(node)].any? { |line| comment_line?(line) }
       end
 
@@ -173,7 +177,9 @@ module RuboCop
       def same_line?(node1, node2)
         line1 = line(node1)
         line2 = line(node2)
-        line1 && line2 && line1 == line2
+        return false unless line1 && line2
+
+        line1 == line2
       end
 
       def indent(node, offset: 0)

data/lib/rubocop/cop/utils/regexp_ranges.rb

@@ -88,7 +88,7 @@ module RuboCop
         end
 
         def escaped_octal?(expr)
-          expr.text =~ /^\\[0-7]$/
+          expr.text.valid_encoding? && expr.text =~ /^\\[0-7]$/
         end
 
         def octal_digit?(char)