rubocop 1.48.1 → 1.62.1

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

@@ -11,6 +11,18 @@ module RuboCop
       # cop. The tab size is configured in the `IndentationWidth` of the
       # `Layout/IndentationStyle` cop.
       #
+      # One-line pattern matching is always allowed. To ensure that there are few cases
+      # where the match variable is not used, and to prevent oversights. The variable `x`
+      # becomes undefined and raises `NameError` when the following example is changed to
+      # the modifier form:
+      #
+      # [source,ruby]
+      # ----
+      # if [42] in [x]
+      #   x # `x` is undefined when using modifier form.
+      # end
+      # ----
+      #
       # NOTE: It is allowed when `defined?` argument has an undefined value,
       # because using the modifier form causes the following incompatibility:
       #
@@ -66,27 +78,26 @@ module RuboCop
         end
 
         def on_if(node)
-          return if defined_nodes(node).any? { |n| defined_argument_is_undefined?(node, n) }
-
-          msg = if single_line_as_modifier?(node) && !named_capture_in_condition?(node)
-                  MSG_USE_MODIFIER
-                elsif too_long_due_to_modifier?(node)
-                  MSG_USE_NORMAL
-                end
-          return unless msg
+          condition = node.condition
+          return if defined_nodes(condition).any? { |n| defined_argument_is_undefined?(node, n) } ||
+                    pattern_matching_nodes(condition).any?
+          return unless (msg = message(node))
 
           add_offense(node.loc.keyword, message: format(msg, keyword: node.keyword)) do |corrector|
+            next if part_of_ignored_node?(node)
+
             autocorrect(corrector, node)
+            ignore_node(node)
           end
         end
 
         private
 
-        def defined_nodes(node)
-          if node.condition.defined_type?
-            [node.condition]
+        def defined_nodes(condition)
+          if condition.defined_type?
+            [condition]
           else
-            node.condition.each_descendant.select(&:defined_type?)
+            condition.each_descendant.select(&:defined_type?)
           end
         end
 
@@ -100,6 +111,24 @@ module RuboCop
           end
         end
 
+        def pattern_matching_nodes(condition)
+          if condition.match_pattern_type? || condition.match_pattern_p_type?
+            [condition]
+          else
+            condition.each_descendant.select do |node|
+              node.match_pattern_type? || node.match_pattern_p_type?
+            end
+          end
+        end
+
+        def message(node)
+          if single_line_as_modifier?(node) && !named_capture_in_condition?(node)
+            MSG_USE_MODIFIER
+          elsif too_long_due_to_modifier?(node)
+            MSG_USE_NORMAL
+          end
+        end
+
         def autocorrect(corrector, node)
           replacement = if node.modifier_form?
                           replacement_for_modifier_form(corrector, node)

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

@@ -47,7 +47,7 @@ module RuboCop
         def correct_elsif(node)
           <<~RUBY.chop
             if #{node.condition.source}
-              #{node.if_branch.source}
+              #{node.if_branch&.source}
             #{build_else_branch(node.else_branch).chop}
             end
           RUBY
@@ -56,7 +56,7 @@ module RuboCop
         def build_else_branch(second_condition)
           result = <<~RUBY
             elsif #{second_condition.condition.source}
-              #{second_condition.if_branch.source}
+              #{second_condition.if_branch&.source}
           RUBY
 
           if second_condition.else_branch

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

@@ -60,25 +60,25 @@ module RuboCop
         # @!method inverse_candidate?(node)
         def_node_matcher :inverse_candidate?, <<~PATTERN
           {
-            (send $(send $(...) $_ $...) :!)
-            (send ({block numblock} $(send $(...) $_) $...) :!)
-            (send (begin $(send $(...) $_ $...)) :!)
+            (send $(call $(...) $_ $...) :!)
+            (send ({block numblock} $(call $(...) $_) $...) :!)
+            (send (begin $(call $(...) $_ $...)) :!)
           }
         PATTERN
 
         # @!method inverse_block?(node)
         def_node_matcher :inverse_block?, <<~PATTERN
-          ({block numblock} $(send (...) $_) ... { $(send ... :!)
+          ({block numblock} $(call (...) $_) ... { $(call ... :!)
                                                    $(send (...) {:!= :!~} ...)
-                                                   (begin ... $(send ... :!))
+                                                   (begin ... $(call ... :!))
                                                    (begin ... $(send (...) {:!= :!~} ...))
                                                  })
         PATTERN
 
         def on_send(node)
-          inverse_candidate?(node) do |_method_call, lhs, method, rhs|
+          inverse_candidate?(node) do |method_call, lhs, method, rhs|
             return unless inverse_methods.key?(method)
-            return if negated?(node)
+            return if negated?(node) || relational_comparison_with_safe_navigation?(method_call)
             return if part_of_ignored_node?(node)
             return if possible_class_hierarchy_check?(lhs, rhs, method)
 
@@ -87,6 +87,7 @@ module RuboCop
             end
           end
         end
+        alias on_csend on_send
 
         def on_block(node)
           inverse_block?(node) do |_method_call, method, block|
@@ -154,16 +155,16 @@ module RuboCop
           node.parent.respond_to?(:method?) && node.parent.method?(:!)
         end
 
+        def relational_comparison_with_safe_navigation?(node)
+          node.csend_type? && CLASS_COMPARISON_METHODS.include?(node.method_name)
+        end
+
         def not_to_receiver(node, method_call)
-          Parser::Source::Range.new(node.source_range.source_buffer,
-                                    node.loc.selector.begin_pos,
-                                    method_call.source_range.begin_pos)
+          node.loc.selector.begin.join(method_call.source_range.begin)
         end
 
         def end_parentheses(node, method_call)
-          Parser::Source::Range.new(node.source_range.source_buffer,
-                                    method_call.source_range.end_pos,
-                                    node.source_range.end_pos)
+          method_call.source_range.end.join(node.source_range.end)
         end
 
         # When comparing classes, `!(Integer < Numeric)` is not the same as

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

@@ -10,12 +10,16 @@ module RuboCop
       # Methods that can be inverted should be defined in `InverseMethods`. Note that
       # the relationship of inverse methods needs to be defined in both directions.
       # For example,
-      #   InverseMethods:
-      #     :!=: :==
-      #     :even?: :odd?
-      #     :odd?: :even?
       #
-      #  will suggest both `even?` and `odd?` to be inverted, but only `!=` (and not `==`).
+      # [source,yaml]
+      # ----
+      # InverseMethods:
+      #   :!=: :==
+      #   :even?: :odd?
+      #   :odd?: :even?
+      # ----
+      #
+      # will suggest both `even?` and `odd?` to be inverted, but only `!=` (and not `==`).
       #
       # @safety
       #   This cop is unsafe because it cannot be guaranteed that the method
@@ -28,12 +32,14 @@ module RuboCop
       #   foo unless x != y
       #   foo unless x >= 10
       #   foo unless x.even?
+      #   foo unless odd?
       #
       #   # good
       #   foo if bar
       #   foo if x == y
       #   foo if x < 10
       #   foo if x.odd?
+      #   foo if even?
       #
       #   # bad (complex condition)
       #   foo unless x != y || x.even?
@@ -47,7 +53,7 @@ module RuboCop
       class InvertibleUnlessCondition < Base
         extend AutoCorrector
 
-        MSG = 'Favor `if` with inverted condition over `unless`.'
+        MSG = 'Prefer `%<prefer>s` over `%<current>s`.'
 
         def on_if(node)
           return unless node.unless?
@@ -55,7 +61,10 @@ module RuboCop
           condition = node.condition
           return unless invertible?(condition)
 
-          add_offense(node) do |corrector|
+          message = format(MSG, prefer: "#{node.inverse_keyword} #{preferred_condition(condition)}",
+                                current: "#{node.keyword} #{condition.source}")
+
+          add_offense(node, message: message) do |corrector|
             corrector.replace(node.loc.keyword, node.inverse_keyword)
             autocorrect(corrector, condition)
           end
@@ -68,7 +77,7 @@ module RuboCop
           when :begin
             invertible?(node.children.first)
           when :send
-            return if inheritance_check?(node)
+            return false if inheritance_check?(node)
 
             node.method?(:!) || inverse_methods.key?(node.method_name)
           when :or, :and
@@ -84,6 +93,43 @@ module RuboCop
             (argument.const_type? && argument.short_name.to_s.upcase != argument.short_name.to_s)
         end
 
+        def preferred_condition(node)
+          case node.type
+          when :begin    then "(#{preferred_condition(node.children.first)})"
+          when :send     then preferred_send_condition(node)
+          when :or, :and then preferred_logical_condition(node)
+          end
+        end
+
+        def preferred_send_condition(node) # rubocop:disable Metrics/CyclomaticComplexity
+          receiver_source = node.receiver&.source
+          return receiver_source if node.method?(:!)
+
+          # receiver may be implicit (self)
+          dotted_receiver_source = receiver_source ? "#{receiver_source}." : ''
+
+          inverse_method_name = inverse_methods[node.method_name]
+          return "#{dotted_receiver_source}#{inverse_method_name}" unless node.arguments?
+
+          argument_list = node.arguments.map(&:source).join(', ')
+          if node.operator_method?
+            return "#{receiver_source} #{inverse_method_name} #{argument_list}"
+          end
+
+          if node.parenthesized?
+            return "#{dotted_receiver_source}#{inverse_method_name}(#{argument_list})"
+          end
+
+          "#{dotted_receiver_source}#{inverse_method_name} #{argument_list}"
+        end
+
+        def preferred_logical_condition(node)
+          preferred_lhs = preferred_condition(node.lhs)
+          preferred_rhs = preferred_condition(node.rhs)
+
+          "#{preferred_lhs} #{node.inverse_operator} #{preferred_rhs}"
+        end
+
         def autocorrect(corrector, node)
           case node.type
           when :begin

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

@@ -69,10 +69,10 @@ module RuboCop
           return unless offending_selector?(node, selector)
 
           add_offense(node.send_node.source_range, message: message(node, selector)) do |corrector|
-            if node.send_node.source == 'lambda'
-              autocorrect_method_to_literal(corrector, node)
-            else
+            if node.send_node.lambda_literal?
               LambdaLiteralToMethodCorrector.new(node).call(corrector)
+            else
+              autocorrect_method_to_literal(corrector, node)
             end
           end
         end

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

@@ -20,6 +20,7 @@ module RuboCop
       #  lambda.(x, y)
       class LambdaCall < Base
         include ConfigurableEnforcedStyle
+        include IgnoredNode
         extend AutoCorrector
 
         MSG = 'Prefer the use of `%<prefer>s` over `%<current>s`.'
@@ -33,8 +34,12 @@ module RuboCop
             current = node.source
 
             add_offense(node, message: format(MSG, prefer: prefer, current: current)) do |corrector|
+              next if part_of_ignored_node?(node)
+
               opposite_style_detected
               corrector.replace(node, prefer)
+
+              ignore_node(node)
             end
           else
             correct_style_detected

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

@@ -44,9 +44,9 @@ module RuboCop
 
         # @!method map_and_compact?(node)
         def_node_matcher :map_and_compact?, <<~RUBY
-          (send
+          (call
             (block
-              (send _ :map)
+              (call _ :map)
               (args
                 $(arg _))
               {
@@ -85,6 +85,7 @@ module RuboCop
             end
           end
         end
+        alias on_csend on_send
 
         private
 
@@ -115,20 +116,17 @@ module RuboCop
         def truthy_branch_for_guard?(node)
           if_node = node.left_sibling
 
-          if if_node.if? || if_node.ternary?
-            if_node.else_branch.nil?
-          elsif if_node.unless?
-            if_node.if_branch.nil?
+          if if_node.if?
+            if_node.if_branch.arguments.any?
+          else
+            if_node.if_branch.arguments.none?
           end
         end
 
         def range(node)
-          buffer = node.source_range.source_buffer
           map_node = node.receiver.send_node
-          begin_pos = map_node.loc.selector.begin_pos
-          end_pos = node.source_range.end_pos
 
-          Parser::Source::Range.new(buffer, begin_pos, end_pos)
+          map_node.loc.selector.join(node.source_range.end)
         end
       end
     end

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

@@ -34,18 +34,25 @@ module RuboCop
 
         minimum_target_ruby_version 2.6
 
-        MSG = 'Pass a block to `to_h` instead of calling `%<method>s.to_h`.'
+        MSG = 'Pass a block to `to_h` instead of calling `%<method>s%<dot>sto_h`.'
         RESTRICT_ON_SEND = %i[to_h].freeze
 
-        # @!method map_to_h?(node)
-        def_node_matcher :map_to_h?, <<~PATTERN
-          $(send (block $(send _ {:map :collect}) ...) :to_h)
+        # @!method map_to_h(node)
+        def_node_matcher :map_to_h, <<~PATTERN
+          {
+            $(call ({block numblock} $(call _ {:map :collect}) ...) :to_h)
+            $(call $(call _ {:map :collect} (block_pass sym)) :to_h)
+          }
         PATTERN
 
+        def self.autocorrect_incompatible_with
+          [Layout::SingleLineBlockChain]
+        end
+
         def on_send(node)
-          return unless (to_h_node, map_node = map_to_h?(node))
+          return unless (to_h_node, map_node = map_to_h(node))
 
-          message = format(MSG, method: map_node.loc.selector.source)
+          message = format(MSG, method: map_node.loc.selector.source, dot: to_h_node.loc.dot.source)
           add_offense(map_node.loc.selector, message: message) do |corrector|
             # If the `to_h` call already has a block, do not autocorrect.
             next if to_h_node.block_node
@@ -53,15 +60,21 @@ module RuboCop
             autocorrect(corrector, to_h_node, map_node)
           end
         end
+        alias on_csend on_send
 
         private
 
+        # rubocop:disable Metrics/AbcSize
         def autocorrect(corrector, to_h, map)
           removal_range = range_between(to_h.loc.dot.begin_pos, to_h.loc.selector.end_pos)
 
           corrector.remove(range_with_surrounding_space(removal_range, side: :left))
+          if (map_dot = map.loc.dot)
+            corrector.replace(map_dot, to_h.loc.dot.source)
+          end
           corrector.replace(map.loc.selector, 'to_h')
         end
+        # rubocop:enable Metrics/AbcSize
       end
     end
   end

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

@@ -32,7 +32,10 @@ module RuboCop
 
         # @!method map_to_set?(node)
         def_node_matcher :map_to_set?, <<~PATTERN
-          $(send (block $(send _ {:map :collect}) ...) :to_set)
+          {
+            $(send ({block numblock} $(send _ {:map :collect}) ...) :to_set)
+            $(send $(send _ {:map :collect} (block_pass sym)) :to_set)
+          }
         PATTERN
 
         def on_send(node)

data/lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb

@@ -50,17 +50,13 @@ module RuboCop
             return false unless (last_argument = node.last_argument)
             return false if !last_argument.hash_type? || !last_argument.pairs.last&.value_omission?
 
-            modifier_form?(node) || exist_next_line_expression?(node)
-          end
-
-          def modifier_form?(node)
-            node.parent.respond_to?(:modifier_form?) && node.parent.modifier_form?
+            node.parent&.conditional? || !last_expression?(node)
           end
 
           # Require hash value omission be enclosed in parentheses to prevent the following issue:
           # https://bugs.ruby-lang.org/issues/18396.
-          def exist_next_line_expression?(node)
-            node.parent&.assignment? ? node.parent.right_sibling : node.right_sibling
+          def last_expression?(node)
+            !(node.parent&.assignment? ? node.parent.right_sibling : node.right_sibling)
           end
 
           def syntax_like_method_call?(node)
@@ -90,6 +86,7 @@ module RuboCop
 
           def legitimate_call_with_parentheses?(node) # rubocop:disable Metrics/PerceivedComplexity
             call_in_literals?(node) ||
+              node.parent&.when_type? ||
               call_with_ambiguous_arguments?(node) ||
               call_in_logical_operators?(node) ||
               call_in_optional_arguments?(node) ||
@@ -102,7 +99,7 @@ module RuboCop
 
           def call_in_literals?(node)
             parent = node.parent&.block_type? ? node.parent.parent : node.parent
-            return unless parent
+            return false unless parent
 
             parent.pair_type? ||
               parent.array_type? ||
@@ -113,7 +110,7 @@ module RuboCop
 
           def call_in_logical_operators?(node)
             parent = node.parent&.block_type? ? node.parent.parent : node.parent
-            return unless parent
+            return false unless parent
 
             logical_operator?(parent) ||
               (parent.send_type? &&
@@ -128,25 +125,39 @@ module RuboCop
             node.parent&.class_type? && node.parent&.single_line?
           end
 
-          def call_with_ambiguous_arguments?(node)
+          def call_with_ambiguous_arguments?(node) # rubocop:disable Metrics/PerceivedComplexity
             call_with_braced_block?(node) ||
+              call_in_argument_with_block?(node) ||
               call_as_argument_or_chain?(node) ||
+              call_in_match_pattern?(node) ||
               hash_literal_in_arguments?(node) ||
               node.descendants.any? do |n|
-                n.forwarded_args_type? || ambiguous_literal?(n) || logical_operator?(n) ||
-                  call_with_braced_block?(n)
+                n.forwarded_args_type? || n.block_type? || n.numblock_type? ||
+                  ambiguous_literal?(n) || logical_operator?(n)
               end
           end
 
           def call_with_braced_block?(node)
-            (node.send_type? || node.super_type?) &&
-              ((node.parent&.block_type? || node.parent&.numblock_type?) && node.parent&.braces?)
+            (node.call_type? || node.super_type?) && node.block_node&.braces?
+          end
+
+          def call_in_argument_with_block?(node)
+            parent = node.parent&.block_type? && node.parent&.parent
+            return false unless parent
+
+            parent.call_type? || parent.super_type? || parent.yield_type?
           end
 
           def call_as_argument_or_chain?(node)
             node.parent &&
-              ((node.parent.send_type? && !assigned_before?(node.parent, node)) ||
-              node.parent.csend_type? || node.parent.super_type? || node.parent.yield_type?)
+              (node.parent.call_type? || node.parent.super_type? || node.parent.yield_type?) &&
+              !assigned_before?(node.parent, node)
+          end
+
+          def call_in_match_pattern?(node)
+            return false unless (parent = node.parent)
+
+            parent.match_pattern_type? || parent.match_pattern_p_type?
           end
 
           def hash_literal_in_arguments?(node)

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

@@ -7,21 +7,19 @@ module RuboCop
       # method calls containing parameters.
       #
       # In the default style (require_parentheses), macro methods are allowed.
-      # Additional methods can be added to the `AllowedMethods`
-      # or `AllowedPatterns` list. These options are
-      # valid only in the default style. Macros can be included by
-      # either setting `IgnoreMacros` to false or adding specific macros to
-      # the `IncludedMacros` list.
+      # Additional methods can be added to the `AllowedMethods` or
+      # `AllowedPatterns` list. These options are valid only in the default
+      # style. Macros can be included by either setting `IgnoreMacros` to false
+      # or adding specific macros to the `IncludedMacros` list.
       #
-      # Precedence of options is all follows:
+      # Precedence of options is as follows:
       #
       # 1. `AllowedMethods`
       # 2. `AllowedPatterns`
       # 3. `IncludedMacros`
       #
-      # eg. If a method is listed in both
-      # `IncludedMacros` and `AllowedMethods`, then the latter takes
-      # precedence (that is, the method is allowed).
+      # If a method is listed in both `IncludedMacros` and `AllowedMethods`,
+      # then the latter takes precedence (that is, the method is allowed).
       #
       # In the alternative style (omit_parentheses), there are three additional
       # options.
@@ -40,14 +38,29 @@ module RuboCop
       #     to `true` allows the presence of parentheses in such a method call
       #     even with arguments.
       #
-      # NOTE: Parentheses are still allowed in cases where omitting them
-      # results in ambiguous or syntactically incorrect code. For example,
-      # parentheses are required around a method with arguments when inside an
-      # endless method definition introduced in Ruby 3.0. Parentheses are also
-      # allowed when forwarding arguments with the triple-dot syntax introduced
-      # in Ruby 2.7 as omitting them starts an endless range.
-      # And Ruby 3.1's hash omission syntax has a case that requires parentheses
-      # because of the following issue: https://bugs.ruby-lang.org/issues/18396.
+      # NOTE: The style of `omit_parentheses` allows parentheses in cases where
+      # omitting them results in ambiguous or syntactically incorrect code.
+      #
+      # Non-exhaustive list of examples:
+      #
+      # - Parentheses are required allowed in method calls with arguments inside
+      #   literals, logical operators, setting default values in position and
+      #   keyword arguments, chaining and more.
+      # - Parentheses are allowed in method calls with arguments inside
+      #   operators to avoid ambiguity.
+      #   triple-dot syntax introduced in Ruby 2.7 as omitting them starts an
+      #   endless range.
+      # - Parentheses are allowed when forwarding arguments with the
+      #   triple-dot syntax introduced in Ruby 2.7 as omitting them starts an
+      #   endless range.
+      # - Parentheses are required in calls with arguments when inside an
+      #   endless method definition introduced in Ruby 3.0.
+      # - Ruby 3.1's hash omission syntax allows parentheses if the method call
+      #   is in conditionals and requires parentheses if the call
+      #   is not the value-returning expression. See
+      #   https://bugs.ruby-lang.org/issues/18396.
+      # - Parentheses are required in anonymous arguments, keyword arguments
+      #   and block passing in Ruby 3.2.
       #
       # @example EnforcedStyle: require_parentheses (default)
       #
@@ -80,34 +93,28 @@ module RuboCop
       #   array.delete e
       #
       #   # bad
-      #   foo.enforce(strict: true)
+      #   action.enforce(strict: true)
       #
       #   # good
-      #   foo.enforce strict: true
+      #   action.enforce strict: true
       #
       #   # good
-      #   # Allows parens for calls that won't produce valid Ruby or be ambiguous.
-      #   model.validate strict(true)
+      #   # Parentheses are allowed for code that can be ambiguous without
+      #   # them.
+      #   action.enforce(condition) || other_condition
       #
       #   # good
-      #   # Allows parens for calls that won't produce valid Ruby or be ambiguous.
+      #   # Parentheses are allowed for calls that won't produce valid Ruby
+      #   # without them.
       #   yield path, File.basename(path)
       #
       #   # good
-      #   # Operators methods calls with parens
-      #   array&.[](index)
-      #
-      #   # good
-      #   # Operators methods without parens, if you prefer
-      #   array.[] index
-      #
-      #   # good
-      #   # Operators methods calls with parens
-      #   array&.[](index)
-      #
-      #   # good
-      #   # Operators methods without parens, if you prefer
-      #   array.[] index
+      #   # Omitting the parentheses in Ruby 3.1 hash omission syntax can lead
+      #   # to ambiguous code. We allow them in conditionals and non-last
+      #   # expressions. See https://bugs.ruby-lang.org/issues/18396
+      #   if meets(criteria:, action:)
+      #     safe_action(action) || dangerous_action(action)
+      #   end
       #
       # @example IgnoreMacros: true (default)
       #
@@ -211,15 +218,13 @@ module RuboCop
           send(style, node) # call require_parentheses or omit_parentheses
         end
         alias on_csend on_send
-        alias on_super on_send
         alias on_yield on_send
 
         private
 
         def args_begin(node)
           loc = node.loc
-          selector =
-            node.super_type? || node.yield_type? ? loc.keyword : loc.selector
+          selector = node.yield_type? ? loc.keyword : loc.selector
 
           resize_by = args_parenthesized?(node) ? 2 : 1
           selector.end.resize(resize_by)
@@ -232,7 +237,7 @@ module RuboCop
         def args_parenthesized?(node)
           return false unless node.arguments.one?
 
-          first_node = node.arguments.first
+          first_node = node.first_argument
           first_node.begin_type? && first_node.parenthesized_call?
         end
       end