rubocop 1.67.0 → 1.69.0

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

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for usage of `File.open` in append mode with empty block.
+      #
+      # Such a usage only creates a new file, but it doesn't update
+      # timestamps for an existing file, which might have been the intention.
+      #
+      # For example, for an existing file `foo.txt`:
+      #
+      #   ruby -e "puts File.mtime('foo.txt')"
+      #   # 2024-11-26 12:17:23 +0100
+      #
+      #   ruby -e "File.open('foo.txt', 'a') {}"
+      #
+      #   ruby -e "puts File.mtime('foo.txt')"
+      #   # 2024-11-26 12:17:23 +0100 -> unchanged
+      #
+      # If the intention was to update timestamps, `FileUtils.touch('foo.txt')`
+      # should be used instead.
+      #
+      # @safety
+      #   Autocorrection is unsafe for this cop because unlike `File.open`,
+      #   `FileUtils.touch` updates an existing file's timestamps.
+      #
+      # @example
+      #   # bad
+      #   File.open(filename, 'a') {}
+      #   File.open(filename, 'a+') {}
+      #
+      #   # good
+      #   FileUtils.touch(filename)
+      #
+      class FileTouch < Base
+        extend AutoCorrector
+
+        MSG = 'Use `FileUtils.touch(%<argument>s)` instead of `File.open` in ' \
+              'append mode with empty block.'
+
+        RESTRICT_ON_SEND = %i[open].freeze
+
+        APPEND_FILE_MODES = %w[a a+ ab a+b at a+t].to_set.freeze
+
+        # @!method file_open?(node)
+        def_node_matcher :file_open?, <<~PATTERN
+          (send
+            (const {nil? cbase} :File) :open
+            $(...)
+            (str %APPEND_FILE_MODES))
+        PATTERN
+
+        def on_send(node)
+          filename = file_open?(node)
+          parent = node.parent
+
+          return unless filename
+          return unless parent && empty_block?(parent)
+
+          message = format(MSG, argument: filename.source)
+          add_offense(parent, message: message) do |corrector|
+            corrector.replace(parent, "FileUtils.touch(#{filename.source})")
+          end
+        end
+
+        private
+
+        def empty_block?(node)
+          node.block_type? && !node.body
+        end
+      end
+    end
+  end
+end

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

@@ -44,7 +44,6 @@ module RuboCop
       #
       class For < Base
         include ConfigurableEnforcedStyle
-        include RangeHelp
         extend AutoCorrector
 
         EACH_LENGTH = 'each'.length

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

@@ -70,9 +70,7 @@ module RuboCop
         end
 
         def check(node)
-          global_var, = *node
-
-          add_offense(node.loc.name) unless allowed_var?(global_var)
+          add_offense(node.loc.name) unless allowed_var?(node.name)
         end
       end
     end

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

@@ -264,7 +264,7 @@ module RuboCop
 
         def and_or_guard_clause?(guard_clause)
           parent = guard_clause.parent
-          parent.and_type? || parent.or_type?
+          parent.operator_keyword?
         end
 
         def too_long_for_single_line?(node, example)
@@ -283,7 +283,8 @@ module RuboCop
         end
 
         def accepted_if?(node, ending)
-          return true if node.modifier_form? || node.ternary? || node.elsif_conditional?
+          return true if node.modifier_form? || node.ternary? || node.elsif_conditional? ||
+                         assigned_lvar_used_in_if_branch?(node)
 
           if ending
             node.else?
@@ -292,6 +293,18 @@ module RuboCop
           end
         end
 
+        def assigned_lvar_used_in_if_branch?(node)
+          return false unless (if_branch = node.if_branch)
+
+          assigned_lvars_in_condition = node.condition.each_descendant(:lvasgn).map do |lvasgn|
+            lvar_name, = *lvasgn
+            lvar_name.to_s
+          end
+          used_lvars_in_branch = if_branch.each_descendant(:lvar).map(&:source) || []
+
+          (assigned_lvars_in_condition & used_lvars_in_branch).any?
+        end
+
         def remove_whole_lines(corrector, range)
           corrector.remove(range_by_whole_lines(range, include_final_newline: true))
         end

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

@@ -111,8 +111,7 @@ module RuboCop
         end
 
         def requires_parens?(node)
-          (node.call_type? && node.arguments.any? && !node.parenthesized?) ||
-            node.or_type? || node.and_type?
+          (node.call_type? && node.arguments.any? && !node.parenthesized?) || node.operator_keyword?
         end
 
         def multi_argument(node)

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

@@ -59,7 +59,6 @@ module RuboCop
       #   end
       #
       class IfInsideElse < Base
-        include IgnoredNode
         include RangeHelp
         extend AutoCorrector
 

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

@@ -155,8 +155,7 @@ module RuboCop
         end
 
         def require_parentheses?(condition)
-          condition.and_type? || condition.or_type? ||
-            (condition.send_type? && condition.comparison_method?)
+          condition.operator_keyword? || (condition.send_type? && condition.comparison_method?)
         end
       end
     end

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

@@ -23,6 +23,7 @@ module RuboCop
 
         def on_normal_if_unless(node)
           return if node.parent&.if_type?
+          return if part_of_ignored_node?(node)
 
           beginning = node.loc.begin
           return unless beginning&.is?(';')
@@ -32,13 +33,14 @@ module RuboCop
           add_offense(node, message: message) do |corrector|
             autocorrect(corrector, node)
           end
+
+          ignore_node(node)
         end
 
         private
 
-        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def message(node)
-          template = if node.if_branch&.begin_type?
+          template = if require_newline?(node)
                        MSG_NEWLINE
                      elsif node.else_branch&.if_type? || node.else_branch&.begin_type? ||
                            use_block_in_branches?(node)
@@ -49,20 +51,27 @@ module RuboCop
 
           format(template, expr: node.condition.source)
         end
-        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         def autocorrect(corrector, node)
-          if node.branches.compact.any?(&:begin_type?) || use_block_in_branches?(node)
+          if require_newline?(node) || use_block_in_branches?(node)
             corrector.replace(node.loc.begin, "\n")
           else
             corrector.replace(node, replacement(node))
           end
         end
 
+        def require_newline?(node)
+          node.branches.compact.any?(&:begin_type?) || use_return_with_argument?(node)
+        end
+
         def use_block_in_branches?(node)
           node.branches.compact.any? { |branch| branch.block_type? || branch.numblock_type? }
         end
 
+        def use_return_with_argument?(node)
+          node.if_branch&.return_type? && node.if_branch&.arguments&.any?
+        end
+
         def replacement(node)
           return correct_elsif(node) if node.else_branch&.if_type?
 
@@ -111,7 +120,7 @@ module RuboCop
         end
 
         def require_argument_parentheses?(node)
-          return false unless node.call_type?
+          return false if !node.call_type? || node.arithmetic_operation?
 
           !node.parenthesized? && node.arguments.any? && !node.method?(:[]) && !node.method?(:[]=)
         end

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

@@ -41,7 +41,6 @@ module RuboCop
       #     f != 1
       #   end
       class InverseMethods < Base
-        include IgnoredNode
         include RangeHelp
         extend AutoCorrector
 

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

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # When passing an existing hash as keyword arguments, provide additional arguments
+      # directly rather than using `merge`.
+      #
+      # Providing arguments directly is more performant than using `merge`, and
+      # also leads to shorter and simpler code.
+      #
+      # @example
+      #   # bad
+      #   some_method(**opts.merge(foo: true))
+      #   some_method(**opts.merge(other_opts))
+      #
+      #   # good
+      #   some_method(**opts, foo: true)
+      #   some_method(**opts, **other_opts)
+      #
+      class KeywordArgumentsMerging < Base
+        extend AutoCorrector
+
+        MSG = 'Provide additional arguments directly rather than using `merge`.'
+
+        # @!method merge_kwargs?(node)
+        def_node_matcher :merge_kwargs?, <<~PATTERN
+          (send _ _
+            ...
+            (hash
+              (kwsplat
+                $(send $_ :merge $...))
+              ...))
+        PATTERN
+
+        def on_kwsplat(node)
+          return unless (ancestor = node.parent&.parent)
+
+          merge_kwargs?(ancestor) do |merge_node, hash_node, other_hash_node|
+            add_offense(merge_node) do |corrector|
+              autocorrect(corrector, node, hash_node, other_hash_node)
+            end
+          end
+        end
+
+        private
+
+        def autocorrect(corrector, kwsplat_node, hash_node, other_hash_node)
+          other_hash_node_replacement =
+            other_hash_node.map do |node|
+              if node.hash_type?
+                if node.braces?
+                  node.source[1...-1]
+                else
+                  node.source
+                end
+              else
+                "**#{node.source}"
+              end
+            end.join(', ')
+
+          corrector.replace(kwsplat_node, "**#{hash_node.source}, #{other_hash_node_replacement}")
+        end
+      end
+    end
+  end
+end

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

@@ -20,7 +20,6 @@ module RuboCop
       #  lambda.(x, y)
       class LambdaCall < Base
         include ConfigurableEnforcedStyle
-        include IgnoredNode
         extend AutoCorrector
 
         MSG = 'Prefer the use of `%<prefer>s` over `%<current>s`.'

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

@@ -63,12 +63,17 @@ module RuboCop
 
         MSG = 'Use `%<new_method_name>s` instead of `each` to map elements into an array.'
 
+        # @!method suitable_argument_node?(node)
+        def_node_matcher :suitable_argument_node?, <<-PATTERN
+          !{splat forwarded-restarg forwarded-args (hash (forwarded-kwrestarg)) (block-pass nil?)}
+        PATTERN
+
         # @!method each_block_with_push?(node)
         def_node_matcher :each_block_with_push?, <<-PATTERN
           [
             ^({begin kwbegin block} ...)
             ({block numblock} (send !{nil? self} :each) _
-              (send (lvar _) {:<< :push :append} {send lvar begin}))
+              (send (lvar _) {:<< :push :append} #suitable_argument_node?))
           ]
         PATTERN
 

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

@@ -203,7 +203,7 @@ module RuboCop
           end
 
           def logical_operator?(node)
-            (node.and_type? || node.or_type?) && node.logical_operator?
+            node.operator_keyword? && node.logical_operator?
           end
 
           def hash_literal?(node)

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

@@ -71,9 +71,11 @@ module RuboCop
           return false if node.receiver
 
           any_assignment?(node) do |asgn_node|
-            next variable_in_mass_assignment?(node.method_name, asgn_node) if asgn_node.masgn_type?
-
-            asgn_node.loc.name.source == node.method_name.to_s
+            if asgn_node.masgn_type?
+              variable_in_mass_assignment?(node.method_name, asgn_node)
+            else
+              asgn_node.loc.name.source == node.method_name.to_s
+            end
           end
         end
 
@@ -98,20 +100,14 @@ module RuboCop
             # `obj.method ||= value` parses as (or-asgn (send ...) ...)
             # which IS an `asgn_node`. Similarly, `obj.method += value` parses
             # as (op-asgn (send ...) ...), which is also an `asgn_node`.
-            if asgn_node.shorthand_asgn?
-              asgn_node, _value = *asgn_node
-              next if asgn_node.send_type?
-            end
+            next if asgn_node.shorthand_asgn? && asgn_node.lhs.send_type?
 
             yield asgn_node
           end
         end
 
         def variable_in_mass_assignment?(variable_name, node)
-          mlhs_node, _mrhs_node = *node
-          var_nodes = *mlhs_node
-
-          var_nodes.any? { |n| n.to_a.first == variable_name }
+          node.assignments.any? { |n| n.name == variable_name }
         end
 
         def offense_range(node)

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

@@ -6,19 +6,49 @@ module RuboCop
       # Checks for the presence of `method_missing` without also
       # defining `respond_to_missing?`.
       #
+      # Not defining `respond_to_missing?` will cause metaprogramming
+      # methods like `respond_to?` to behave unexpectedly:
+      #
+      # [source,ruby]
+      # ----
+      # class StringDelegator
+      #   def initialize(string)
+      #     @string = string
+      #   end
+      #
+      #   def method_missing(name, *args)
+      #     @string.send(name, *args)
+      #   end
+      # end
+      #
+      # delegator = StringDelegator.new("foo")
+      # # Claims to not respond to `upcase`.
+      # delegator.respond_to?(:upcase) # => false
+      # # But you can call it.
+      # delegator.upcase # => FOO
+      # ----
+      #
       # @example
       #   # bad
       #   def method_missing(name, *args)
-      #     # ...
+      #     if @delegate.respond_to?(name)
+      #       @delegate.send(name, *args)
+      #     else
+      #       super
+      #     end
       #   end
       #
       #   # good
       #   def respond_to_missing?(name, include_private)
-      #     # ...
+      #     @delegate.respond_to?(name) || super
       #   end
       #
       #   def method_missing(name, *args)
-      #     # ...
+      #     if @delegate.respond_to?(name)
+      #       @delegate.send(name, *args)
+      #     else
+      #       super
+      #     end
       #   end
       #
       class MissingRespondToMissing < Base

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

@@ -39,7 +39,7 @@ module RuboCop
         BRACES_MSG = 'Wrap multiline memoization blocks in `(` and `)`.'
 
         def on_or_asgn(node)
-          _lhs, rhs = *node
+          rhs = node.expression
 
           return unless bad_rhs?(rhs)
 

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

@@ -55,25 +55,19 @@ module RuboCop
         MSG = 'Avoid comparing a variable with multiple items ' \
               'in a conditional, use `Array#include?` instead.'
 
-        def on_new_investigation
-          reset_comparison
-        end
-
         def on_or(node)
           root_of_or_node = root_of_or_node(node)
-
           return unless node == root_of_or_node
-          return unless nested_variable_comparison?(root_of_or_node)
-          return if @allowed_method_comparison
-          return if @compared_elements.size < comparisons_threshold
+          return unless nested_comparison?(node)
+
+          return unless (variable, values = find_offending_var(node))
+          return if values.size < comparisons_threshold
 
           add_offense(node) do |corrector|
-            elements = @compared_elements.join(', ')
-            prefer_method = "[#{elements}].include?(#{variables_in_node(node).first})"
+            elements = values.map(&:source).join(', ')
+            prefer_method = "[#{elements}].include?(#{variable_name(variable)})"
 
             corrector.replace(node, prefer_method)
-
-            reset_comparison
           end
         end
 
@@ -92,32 +86,25 @@ module RuboCop
           (send $_ :== $lvar)
         PATTERN
 
-        def nested_variable_comparison?(node)
-          return false unless nested_comparison?(node)
-
-          variables_in_node(node).count == 1
-        end
-
-        def variables_in_node(node)
+        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        def find_offending_var(node, variables = Set.new, values = [])
           if node.or_type?
-            node.node_parts.flat_map { |node_part| variables_in_node(node_part) }.uniq
-          else
-            variables_in_simple_node(node)
-          end
-        end
+            find_offending_var(node.lhs, variables, values)
+            find_offending_var(node.rhs, variables, values)
+          elsif simple_double_comparison?(node)
+            return
+          elsif (var, obj = simple_comparison?(node))
+            return if allow_method_comparison? && obj.send_type?
 
-        def variables_in_simple_node(node)
-          simple_double_comparison?(node) do |var1, var2|
-            return [variable_name(var1), variable_name(var2)]
-          end
-          if (var, obj = simple_comparison_lhs?(node)) || (obj, var = simple_comparison_rhs?(node))
-            @allowed_method_comparison = true if allow_method_comparison? && obj.send_type?
-            @compared_elements << obj.source
-            return [variable_name(var)]
+            variables << var
+            return if variables.size > 1
+
+            values << obj
           end
 
-          []
+          [variables.first, values] if variables.any?
         end
+        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         def variable_name(node)
           node.children[0]
@@ -132,7 +119,14 @@ module RuboCop
         end
 
         def comparison?(node)
-          simple_comparison_lhs?(node) || simple_comparison_rhs?(node) || nested_comparison?(node)
+          simple_comparison?(node) || nested_comparison?(node)
+        end
+
+        def simple_comparison?(node)
+          if (var, obj = simple_comparison_lhs?(node)) ||
+             (obj, var = simple_comparison_rhs?(node))
+            [var, obj]
+          end
         end
 
         def root_of_or_node(or_node)
@@ -145,11 +139,6 @@ module RuboCop
           end
         end
 
-        def reset_comparison
-          @compared_elements = []
-          @allowed_method_comparison = false
-        end
-
         def allow_method_comparison?
           cop_config.fetch('AllowMethodComparison', true)
         end

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

@@ -125,15 +125,14 @@ module RuboCop
         MSG = 'Freeze mutable objects assigned to constants.'
 
         def on_casgn(node)
-          _scope, _const_name, value = *node
-          if value.nil? # This is only the case for `CONST += ...` or similarg66
+          if node.expression.nil? # This is only the case for `CONST += ...` or similarg66
             parent = node.parent
             return unless parent.or_asgn_type? # We only care about `CONST ||= ...`
 
-            value = parent.children.last
+            on_assignment(parent.children.last)
+          else
+            on_assignment(node.expression)
           end
-
-          on_assignment(value)
         end
 
         private

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

@@ -46,10 +46,12 @@ module RuboCop
           @corrected_nodes = nil
         end
 
+        # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity
         def on_if(node)
           return unless if_else?(node)
           return unless (condition = unwrap_begin_nodes(node.condition))
           return if double_negation?(condition) || !negated_condition?(condition)
+          return unless condition.arguments.size < 2
 
           message = message(node)
           add_offense(node, message: message) do |corrector|
@@ -62,6 +64,7 @@ module RuboCop
             end
           end
         end
+        # rubocop:enable Metrics/AbcSize,Metrics/CyclomaticComplexity
 
         private
 
@@ -92,13 +95,12 @@ module RuboCop
         end
 
         def correct_negated_condition(corrector, node)
-          receiver, method_name, rhs = *node
           replacement =
             if node.negation_method?
-              receiver.source
+              node.receiver.source
             else
-              inverted_method = method_name.to_s.sub('!', '=')
-              "#{receiver.source} #{inverted_method} #{rhs.source}"
+              inverted_method = node.method_name.to_s.sub('!', '=')
+              "#{node.receiver.source} #{inverted_method} #{node.first_argument.source}"
             end
 
           corrector.replace(node, replacement)

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

@@ -18,7 +18,6 @@ module RuboCop
       class NestedTernaryOperator < Base
         extend AutoCorrector
         include RangeHelp
-        include IgnoredNode
 
         MSG = 'Ternary operators must not be nested. Prefer `if` or `else` constructs instead.'
 
@@ -45,9 +44,11 @@ module RuboCop
         end
 
         def remove_parentheses(source)
-          return source unless source.start_with?('(')
-
-          source.delete_prefix('(').delete_suffix(')')
+          if source.start_with?('(') && source.end_with?(')')
+            source.delete_prefix('(').delete_suffix(')')
+          else
+            source
+          end
         end
 
         def replace_loc_and_whitespace(corrector, range, replacement)

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

@@ -52,7 +52,7 @@ module RuboCop
         end
 
         def requires_parens?(child)
-          child.and_type? || child.or_type? ||
+          child.operator_keyword? ||
             (child.send_type? && child.binary_operation?) ||
             (child.if_type? && child.ternary?)
         end