rubocop 1.77.0 → 1.79.0

data/lib/rubocop/cop/lint/redundant_safe_navigation.rb

@@ -20,6 +20,15 @@ module RuboCop
       # In the example below, the safe navigation operator (`&.`) is unnecessary
       # because `NilClass` has methods like `respond_to?` and `is_a?`.
       #
+      # The `InferNonNilReceiver` option specifies whether to look into previous code
+      # paths to infer if the receiver can't be nil. This check is unsafe because the receiver
+      # can be redefined between the safe navigation call and previous regular method call.
+      # It does the inference only in the current scope, e.g. within the same method definition etc.
+      #
+      # The `AdditionalNilMethods` option specifies additional custom methods which are
+      # defined on `NilClass`. When `InferNonNilReceiver` is set, they are used to determine
+      # whether the receiver can be nil.
+      #
       # @safety
       #   This cop is unsafe, because autocorrection can change the return type of
       #   the expression. An offending expression that previously could return `nil`
@@ -33,6 +42,20 @@ module RuboCop
       #   CamelCaseConst.do_something
       #
       #   # bad
+      #   foo.to_s&.strip
+      #   foo.to_i&.zero?
+      #   foo.to_f&.zero?
+      #   foo.to_a&.size
+      #   foo.to_h&.size
+      #
+      #   # good
+      #   foo.to_s.strip
+      #   foo.to_i.zero?
+      #   foo.to_f.zero?
+      #   foo.to_a.size
+      #   foo.to_h.size
+      #
+      #   # bad
       #   do_something if attrs&.respond_to?(:[])
       #
       #   # good
@@ -81,17 +104,59 @@ module RuboCop
       #   do_something if attrs.nil_safe_method(:[])
       #   do_something if attrs&.not_nil_safe_method(:[])
       #
+      # @example InferNonNilReceiver: false (default)
+      #   # good
+      #   foo.bar
+      #   foo&.baz
+      #
+      # @example InferNonNilReceiver: true
+      #   # bad
+      #   foo.bar
+      #   foo&.baz # would raise on previous line if `foo` is nil
+      #
+      #   # good
+      #   foo.bar
+      #   foo.baz
+      #
+      #   # bad
+      #   if foo.condition?
+      #     foo&.bar
+      #   end
+      #
+      #   # good
+      #   if foo.condition?
+      #     foo.bar
+      #   end
+      #
+      #   # good (different scopes)
+      #   def method1
+      #     foo.bar
+      #   end
+      #
+      #   def method2
+      #     foo&.bar
+      #   end
+      #
+      # @example AdditionalNilMethods: [present?]
+      #   # good
+      #   foo.present?
+      #   foo&.bar
+      #
       class RedundantSafeNavigation < Base
         include AllowedMethods
         extend AutoCorrector
 
         MSG = 'Redundant safe navigation detected, use `.` instead.'
         MSG_LITERAL = 'Redundant safe navigation with default literal detected.'
+        MSG_NON_NIL = 'Redundant safe navigation on non-nil receiver (detected by analyzing ' \
+                      'previous code/method invocations).'
 
         NIL_SPECIFIC_METHODS = (nil.methods - Object.new.methods).to_set.freeze
 
         SNAKE_CASE = /\A[[:digit:][:upper:]_]+\z/.freeze
 
+        GUARANTEED_INSTANCE_METHODS = %i[to_s to_i to_f to_a to_h].freeze
+
         # @!method respond_to_nil_specific_method?(node)
         def_node_matcher :respond_to_nil_specific_method?, <<~PATTERN
           (csend _ :respond_to? (sym %NIL_SPECIFIC_METHODS))
@@ -111,15 +176,27 @@ module RuboCop
 
         # rubocop:disable Metrics/AbcSize
         def on_csend(node)
+          range = node.loc.dot
+
+          if infer_non_nil_receiver?
+            checker = Lint::Utils::NilReceiverChecker.new(node.receiver, additional_nil_methods)
+
+            if checker.cant_be_nil?
+              add_offense(range, message: MSG_NON_NIL) { |corrector| corrector.replace(range, '.') }
+              return
+            end
+          end
+
           unless assume_receiver_instance_exists?(node.receiver)
-            return unless check?(node) && allowed_method?(node.method_name)
+            return if !guaranteed_instance?(node.receiver) && !check?(node)
             return if respond_to_nil_specific_method?(node)
           end
 
-          range = node.loc.dot
           add_offense(range) { |corrector| corrector.replace(range, '.') }
         end
+        # rubocop:enable Metrics/AbcSize
 
+        # rubocop:disable Metrics/AbcSize
         def on_or(node)
           conversion_with_default?(node) do |send_node|
             range = send_node.loc.dot.begin.join(node.source_range.end)
@@ -142,7 +219,20 @@ module RuboCop
           receiver.self_type? || (receiver.literal? && !receiver.nil_type?)
         end
 
+        def guaranteed_instance?(node)
+          receiver = if node.any_block_type?
+                       node.send_node
+                     else
+                       node
+                     end
+          return false unless receiver.send_type?
+
+          GUARANTEED_INSTANCE_METHODS.include?(receiver.method_name)
+        end
+
         def check?(node)
+          return false unless allowed_method?(node.method_name)
+
           parent = node.parent
           return false unless parent
 
@@ -154,6 +244,15 @@ module RuboCop
         def condition?(parent, node)
           (parent.conditional? || parent.post_condition_loop?) && parent.condition == node
         end
+
+        def infer_non_nil_receiver?
+          cop_config['InferNonNilReceiver']
+        end
+
+        def additional_nil_methods
+          @additional_nil_methods ||=
+            Array(cop_config.fetch('AdditionalNilMethods', []).map(&:to_sym))
+        end
       end
     end
   end

data/lib/rubocop/cop/lint/redundant_type_conversion.rb

@@ -185,9 +185,9 @@ module RuboCop
           (hash (pair (sym :exception) false))
         PATTERN
 
-        # rubocop:disable Metrics/AbcSize
+        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity
         def on_send(node)
-          return if hash_or_set_with_block?(node)
+          return if node.arguments.any? || hash_or_set_with_block?(node)
 
           receiver = find_receiver(node)
           return unless literal_receiver?(node, receiver) ||
@@ -198,10 +198,10 @@ module RuboCop
           message = format(MSG, method: node.method_name)
 
           add_offense(node.loc.selector, message: message) do |corrector|
-            corrector.remove(node.loc.dot.join(node.loc.selector))
+            corrector.remove(node.loc.dot.join(node.loc.end || node.loc.selector))
           end
         end
-        # rubocop:enable Metrics/AbcSize
+        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity
         alias on_csend on_send
 
         private

data/lib/rubocop/cop/lint/require_range_parentheses.rb

@@ -43,7 +43,7 @@ module RuboCop
         def on_irange(node)
           return if node.parent&.begin_type?
           return unless node.begin && node.end
-          return if same_line?(node.begin, node.end)
+          return if same_line?(node.loc.operator, node.end)
 
           message = format(MSG, range: "#{node.begin.source}#{node.loc.operator.source}")
 

data/lib/rubocop/cop/lint/rescue_type.rb

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # Check for arguments to `rescue` that will result in a `TypeError`
+      # Checks for arguments to `rescue` that will result in a `TypeError`
       # if an exception is raised.
       #
       # @example

data/lib/rubocop/cop/lint/useless_numeric_operation.rb

@@ -31,6 +31,7 @@ module RuboCop
       #
       class UselessNumericOperation < Base
         extend AutoCorrector
+
         MSG = 'Do not apply inconsequential numeric operations to variables.'
         RESTRICT_ON_SEND = %i[+ - * / **].freeze
 

data/lib/rubocop/cop/lint/utils/nil_receiver_checker.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      module Utils
+        # Utility class that checks if the receiver can't be nil.
+        class NilReceiverChecker
+          NIL_METHODS = (nil.methods + %i[!]).to_set.freeze
+
+          def initialize(receiver, additional_nil_methods)
+            @receiver = receiver
+            @additional_nil_methods = additional_nil_methods
+            @checked_nodes = {}.compare_by_identity
+          end
+
+          def cant_be_nil?
+            sole_condition_of_parent_if?(@receiver) || _cant_be_nil?(@receiver.parent, @receiver)
+          end
+
+          private
+
+          # rubocop:disable Metrics
+          def _cant_be_nil?(node, receiver)
+            return false unless node
+
+            # For some nodes, we check their parent and then some children for these parents.
+            # This is added to avoid infinite loops.
+            return false if @checked_nodes.key?(node)
+
+            @checked_nodes[node] = true
+
+            case node.type
+            when :def, :class, :module, :sclass
+              return false
+            when :send
+              return non_nil_method?(node.method_name) if node.receiver == receiver
+
+              node.arguments.each do |argument|
+                return true if _cant_be_nil?(argument, receiver)
+              end
+
+              return true if _cant_be_nil?(node.receiver, receiver)
+            when :begin
+              return true if _cant_be_nil?(node.children.first, receiver)
+            when :if, :case
+              return true if _cant_be_nil?(node.condition, receiver)
+            when :and, :or
+              return true if _cant_be_nil?(node.lhs, receiver)
+            when :pair
+              if _cant_be_nil?(node.key, receiver) ||
+                 _cant_be_nil?(node.value, receiver)
+                return true
+              end
+            when :when
+              node.each_condition do |condition|
+                return true if _cant_be_nil?(condition, receiver)
+              end
+            when :lvasgn, :ivasgn, :cvasgn, :gvasgn, :casgn
+              return true if _cant_be_nil?(node.expression, receiver)
+            end
+
+            # Due to how `if/else` are implemented (`elsif` is a child of `if` or another `elsif`),
+            # using left_siblings will not work correctly for them.
+            if !else_branch?(node) || (node.if_type? && !node.elsif?)
+              node.left_siblings.reverse_each do |sibling|
+                next unless sibling.is_a?(AST::Node)
+
+                return true if _cant_be_nil?(sibling, receiver)
+              end
+            end
+
+            if node.parent
+              _cant_be_nil?(node.parent, receiver)
+            else
+              false
+            end
+          end
+          # rubocop:enable Metrics
+
+          def non_nil_method?(method_name)
+            !NIL_METHODS.include?(method_name) && !@additional_nil_methods.include?(method_name)
+          end
+
+          # rubocop:disable Metrics/PerceivedComplexity
+          def sole_condition_of_parent_if?(node)
+            parent = node.parent
+
+            while parent
+              if parent.if_type?
+                if parent.condition == node
+                  return true
+                elsif parent.elsif?
+                  parent = find_top_if(parent)
+                end
+              elsif else_branch?(parent)
+                # Find the top `if` for `else`.
+                parent = parent.parent
+              end
+
+              parent = parent&.parent
+            end
+
+            false
+          end
+          # rubocop:enable Metrics/PerceivedComplexity
+
+          def else_branch?(node)
+            node.parent&.if_type? && node.parent.else_branch == node
+          end
+
+          def find_top_if(node)
+            node = node.parent while node.elsif?
+
+            node
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -39,6 +39,20 @@ module RuboCop
       #   # good
       #   def foo_bar; end
       #
+      #   # bad
+      #   define_method :fooBar do
+      #   end
+      #
+      #   # good
+      #   define_method :foo_bar do
+      #   end
+      #
+      #   # bad
+      #   Struct.new(:fooBar)
+      #
+      #   # good
+      #   Struct.new(:foo_bar)
+      #
       # @example EnforcedStyle: camelCase
       #   # bad
       #   def foo_bar; end
@@ -46,6 +60,20 @@ module RuboCop
       #   # good
       #   def fooBar; end
       #
+      #   # bad
+      #   define_method :foo_bar do
+      #   end
+      #
+      #   # good
+      #   define_method :fooBar do
+      #   end
+      #
+      #   # bad
+      #   Struct.new(:foo_bar)
+      #
+      #   # good
+      #   Struct.new(:fooBar)
+      #
       # @example ForbiddenIdentifiers: ['def', 'super']
       #   # bad
       #   def def; end
@@ -66,13 +94,66 @@ module RuboCop
         MSG = 'Use %<style>s for method names.'
         MSG_FORBIDDEN = '`%<identifier>s` is forbidden, use another method name instead.'
 
+        OPERATOR_METHODS = %i[| ^ & <=> == === =~ > >= < <= << >> + - * /
+                              % ** ~ +@ -@ !@ ~@ [] []= ! != !~ `].to_set.freeze
+
         # @!method sym_name(node)
         def_node_matcher :sym_name, '(sym $_name)'
 
         # @!method str_name(node)
         def_node_matcher :str_name, '(str $_name)'
 
+        # @!method new_struct?(node)
+        def_node_matcher :new_struct?, '(send (const {nil? cbase} :Struct) :new ...)'
+
+        # @!method define_data?(node)
+        def_node_matcher :define_data?, '(send (const {nil? cbase} :Data) :define ...)'
+
         def on_send(node)
+          if node.method?(:define_method) || node.method?(:define_singleton_method)
+            handle_define_method(node)
+          elsif new_struct?(node)
+            handle_new_struct(node)
+          elsif define_data?(node)
+            handle_define_data(node)
+          else
+            handle_attr_accessor(node)
+          end
+        end
+
+        def on_def(node)
+          return if node.operator_method? || matches_allowed_pattern?(node.method_name)
+
+          if forbidden_name?(node.method_name.to_s)
+            register_forbidden_name(node)
+          else
+            check_name(node, node.method_name, node.loc.name)
+          end
+        end
+        alias on_defs on_def
+
+        private
+
+        def handle_define_method(node)
+          return unless node.first_argument&.type?(:str, :sym)
+
+          handle_method_name(node, node.first_argument.value)
+        end
+
+        def handle_new_struct(node)
+          arguments = node.first_argument&.str_type? ? node.arguments[1..] : node.arguments
+          arguments.select { |argument| argument.type?(:sym, :str) }.each do |name|
+            handle_method_name(name, name.value)
+          end
+        end
+
+        def handle_define_data(node)
+          node.arguments.select { |argument| argument.type?(:sym, :str) }.each do |name|
+            handle_method_name(name, name.value)
+          end
+        end
+
+        def handle_attr_accessor(node)
           return unless (attrs = node.attribute_accessor?)
 
           attrs.last.each do |name_item|
@@ -87,45 +168,53 @@ module RuboCop
           end
         end
 
-        def on_def(node)
-          return if node.operator_method? || matches_allowed_pattern?(node.method_name)
+        def handle_method_name(node, name)
+          return if !name || matches_allowed_pattern?(name)
 
-          if forbidden_name?(node.method_name.to_s)
+          if forbidden_name?(name.to_s)
             register_forbidden_name(node)
-          else
-            check_name(node, node.method_name, node.loc.name)
+          elsif !OPERATOR_METHODS.include?(name)
+            check_name(node, name, range_position(node))
           end
         end
-        alias on_defs on_def
-
-        private
 
         def forbidden_name?(name)
           forbidden_identifier?(name) || forbidden_pattern?(name)
         end
 
+        # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
         def register_forbidden_name(node)
           if node.any_def_type?
             name_node = node.loc.name
             method_name = node.method_name
-          else
-            attrs = node.attribute_accessor?
+          elsif node.literal?
+            name_node = node
+            method_name = node.value
+          elsif (attrs = node.attribute_accessor?)
             name_node = attrs.last.last
             method_name = attr_name(name_node)
+          else
+            name_node = node.first_argument
+            method_name = node.first_argument.value
           end
           message = format(MSG_FORBIDDEN, identifier: method_name)
           add_offense(name_node, message: message)
         end
+        # rubocop:enable Metrics/MethodLength, Metrics/AbcSize
 
         def attr_name(name_item)
           sym_name(name_item) || str_name(name_item)
         end
 
         def range_position(node)
-          selector_end_pos = node.loc.selector.end_pos + 1
-          expr_end_pos = node.source_range.end_pos
+          if node.loc.respond_to?(:selector)
+            selector_end_pos = node.loc.selector.end_pos + 1
+            expr_end_pos = node.source_range.end_pos
 
-          range_between(selector_end_pos, expr_end_pos)
+            range_between(selector_end_pos, expr_end_pos)
+          else
+            node.source_range
+          end
         end
 
         def message(style)

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

@@ -26,6 +26,11 @@ module RuboCop
       # guidelines. By default, `call` is allowed. The cop also has `AllowedPatterns`
       # configuration to allow method names by regular expression.
       #
+      # Although returning a call to another predicate method is treated as a boolean value,
+      # certain method names can be known to not return a boolean, despite ending in a `?`
+      # (for example, `Numeric#nonzero?` returns `self` or `nil`). These methods can be
+      # configured using `NonBooleanPredicates`.
+      #
       # The cop can furthermore be configured to allow all bang methods (method names
       # ending with `!`), with `AllowBangMethods: true` (default false).
       #
@@ -164,7 +169,7 @@ module RuboCop
         def unknown_method_call?(value)
           return false unless value.call_type?
 
-          !value.comparison_method? && !value.predicate_method? && !value.negation_method?
+          !method_returning_boolean?(value)
         end
 
         def return_values(node)
@@ -190,7 +195,13 @@ module RuboCop
 
         def boolean_return?(value)
           return true if value.boolean_type?
+
+          method_returning_boolean?(value)
+        end
+
+        def method_returning_boolean?(value)
           return false unless value.call_type?
+          return false if wayward_predicate?(value.method_name)
 
           value.comparison_method? || value.predicate_method? || value.negation_method?
         end
@@ -258,7 +269,10 @@ module RuboCop
             node.body ? [last_value(node.body)] : [s(:nil)]
           else
             # Branches with no value act as an implicit `nil`.
-            node.branches.filter_map { |branch| branch ? last_value(branch) : s(:nil) }
+            branches = node.branches.map { |branch| branch ? last_value(branch) : s(:nil) }
+            # Missing else branches also act as an implicit `nil`.
+            branches.push(s(:nil)) unless node.else_branch
+            branches
           end
         end
 
@@ -275,6 +289,17 @@ module RuboCop
         def allow_bang_methods?
           cop_config.fetch('AllowBangMethods', false)
         end
+
+        # If a method ending in `?` is known to not return a boolean value,
+        # (for example, `Numeric#nonzero?`) it should be treated as a non-boolean
+        # value, despite the method naming.
+        def wayward_predicate?(name)
+          wayward_predicates.include?(name.to_s)
+        end
+
+        def wayward_predicates
+          Array(cop_config.fetch('WaywardPredicates', []))
+        end
       end
     end
   end

data/lib/rubocop/cop/security/eval.rb

@@ -11,13 +11,14 @@ module RuboCop
       #
       #   eval(something)
       #   binding.eval(something)
+      #   Kernel.eval(something)
       class Eval < Base
         MSG = 'The use of `eval` is a serious security risk.'
         RESTRICT_ON_SEND = %i[eval].freeze
 
         # @!method eval?(node)
         def_node_matcher :eval?, <<~PATTERN
-          (send {nil? (send nil? :binding)} :eval $!str ...)
+          (send {nil? (send nil? :binding) (const {cbase nil?} :Kernel)} :eval $!str ...)
         PATTERN
 
         def on_send(node)

data/lib/rubocop/cop/security/open.rb

@@ -34,6 +34,7 @@ module RuboCop
       #   # good (literal strings)
       #   open("foo.text")
       #   URI.open("http://example.com")
+      #   URI.parse(url).open
       class Open < Base
         MSG = 'The use of `%<receiver>sopen` is a serious security risk.'
         RESTRICT_ON_SEND = %i[open].freeze

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

@@ -348,7 +348,7 @@ module RuboCop
         end
 
         def remove_modifier_node_within_begin(corrector, modifier_node, begin_node)
-          def_node = begin_node.children[1]
+          def_node = begin_node.children[begin_node.children.index(modifier_node) + 1]
           range = modifier_node.source_range.begin.join(def_node.source_range.begin)
           corrector.remove(range)
         end

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

@@ -84,7 +84,10 @@ module RuboCop
 
         def autocorrect(corrector, node)
           if (preferred_accessors = preferred_accessors(node))
-            corrector.replace(node, preferred_accessors)
+            corrector.replace(
+              grouped_style? ? node : range_with_trailing_argument_comment(node),
+              preferred_accessors
+            )
           else
             range = range_with_surrounding_space(node.source_range, side: :left)
             corrector.remove(range)
@@ -196,6 +199,15 @@ module RuboCop
             end
           end.join("\n")
         end
+
+        def range_with_trailing_argument_comment(node)
+          comment = processed_source.ast_with_comments[node.last_argument].last
+          if comment
+            add_range(node.source_range, comment.source_range)
+          else
+            node
+          end
+        end
       end
     end
   end