rubocop 1.68.0 → 1.69.0

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

@@ -33,24 +33,20 @@ module RuboCop
           branch.begin_type? ? Array(branch).last : branch
         end
 
-        # rubocop:disable Metrics/AbcSize
         def lhs(node)
           case node.type
           when :send
             lhs_for_send(node)
-          when :op_asgn
-            "#{node.children[0].source} #{node.children[1]}= "
-          when :and_asgn, :or_asgn
-            "#{node.children[0].source} #{node.loc.operator.source} "
+          when :op_asgn, :and_asgn, :or_asgn
+            "#{node.assignment_node.source} #{node.operator}= "
           when :casgn
             lhs_for_casgn(node)
           when *ConditionalAssignment::VARIABLE_ASSIGNMENT_TYPES
-            "#{node.children[0]} = "
+            "#{node.name} = "
           else
             node.source
           end
         end
-        # rubocop:enable Metrics/AbcSize
 
         def indent(cop, source)
           conf = cop.config.for_cop(END_ALIGNMENT)
@@ -94,11 +90,12 @@ module RuboCop
         end
 
         def lhs_for_casgn(node)
-          namespace = node.children[0]
-          if namespace.nil? || namespace.cbase_type?
-            "#{namespace&.source}#{node.children[1]} = "
+          if node.namespace.nil?
+            "#{node.name} = "
+          elsif node.namespace.cbase_type?
+            "::#{node.name} = "
           else
-            "#{namespace.source}::#{node.children[1]} = "
+            "#{node.namespace.const_name}::#{node.name} = "
           end
         end
 
@@ -210,7 +207,6 @@ module RuboCop
       class ConditionalAssignment < Base
         include ConditionalAssignmentHelper
         include ConfigurableEnforcedStyle
-        include IgnoredNode
         extend AutoCorrector
 
         MSG = 'Use the return of the conditional for variable assignment and comparison.'
@@ -317,12 +313,14 @@ module RuboCop
         end
 
         def assignment_node(node)
-          *_variable, assignment = *node
+          assignment = node.send_type? ? node.last_argument : node.expression
 
           # ignore pseudo-assignments without rhs in for nodes
           return if node.parent&.for_type?
 
-          assignment, = *assignment if assignment.begin_type? && assignment.children.one?
+          if assignment.begin_type? && assignment.children.one?
+            assignment = assignment.children.first
+          end
 
           assignment
         end
@@ -338,7 +336,7 @@ module RuboCop
         end
 
         def move_assignment_inside_condition(corrector, node)
-          *_assignment, condition = *node
+          condition = node.send_type? ? node.last_argument : node.expression
 
           if ternary_condition?(condition)
             TernaryCorrector.move_assignment_inside_condition(corrector, node)
@@ -459,7 +457,7 @@ module RuboCop
         end
 
         def assignment(node)
-          *_, condition = *node
+          condition = node.send_type? ? node.last_argument : node.expression
 
           node.source_range.begin.join(condition.source_range.begin)
         end
@@ -506,7 +504,7 @@ module RuboCop
           end
 
           def move_assignment_inside_condition(corrector, node)
-            *_var, rhs = *node
+            rhs = node.send_type? ? node.last_argument : node.expression
             if_branch, else_branch = extract_branches(node)
             assignment = assignment(node)
 
@@ -537,8 +535,8 @@ module RuboCop
           end
 
           def extract_branches(node)
-            *_var, rhs = *node
-            condition, = *rhs if rhs.begin_type? && rhs.children.one?
+            rhs = node.send_type? ? node.last_argument : node.expression
+            condition = rhs.children.first if rhs.begin_type? && rhs.children.one?
             _condition, if_branch, else_branch = *(condition || rhs)
 
             [if_branch, else_branch]
@@ -567,7 +565,7 @@ module RuboCop
 
           def move_assignment_inside_condition(corrector, node)
             column = node.source_range.column
-            *_var, condition = *node
+            condition = node.send_type? ? node.last_argument : node.expression
             assignment = assignment(node)
 
             corrector.remove(assignment)
@@ -618,7 +616,7 @@ module RuboCop
 
           def move_assignment_inside_condition(corrector, node)
             column = node.source_range.column
-            *_var, condition = *node
+            condition = node.send_type? ? node.last_argument : node.expression
             assignment = assignment(node)
 
             corrector.remove(assignment)

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

@@ -53,8 +53,7 @@ module RuboCop
           return if visibility_declaration?(node)
           return if ignore_modules? && module?(node)
 
-          message = message(node)
-          add_offense(node, message: message)
+          add_offense(node, message: format(MSG, constant_name: node.name))
         end
 
         private
@@ -64,13 +63,7 @@ module RuboCop
         end
 
         def module?(node)
-          node.children.last.class_constructor?
-        end
-
-        def message(node)
-          _namespace, constant_name, _value = *node
-
-          format(MSG, constant_name: constant_name)
+          node.expression.class_constructor?
         end
 
         def class_or_module_scope?(node)
@@ -85,10 +78,8 @@ module RuboCop
         end
 
         def visibility_declaration?(node)
-          _namespace, constant_name, _value = *node
-
           node.parent.each_child_node(:send).any? do |child|
-            visibility_declaration_for?(child, constant_name)
+            visibility_declaration_for?(child, node.name)
           end
         end
 

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

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Check for chained `dig` calls that can be collapsed into a single `dig`.
+      #
+      # @safety
+      #   This cop is unsafe because it cannot be guaranteed that the receiver
+      #   is an `Enumerable` or does not have a nonstandard implementation
+      #   of `dig`.
+      #
+      # @example
+      #   # bad
+      #   x.dig(:foo).dig(:bar).dig(:baz)
+      #   x.dig(:foo, :bar).dig(:baz)
+      #   x.dig(:foo, :bar)&.dig(:baz)
+      #
+      #   # good
+      #   x.dig(:foo, :bar, :baz)
+      #
+      #   # good - `dig`s cannot be combined
+      #   x.dig(:foo).bar.dig(:baz)
+      #
+      class DigChain < Base
+        extend AutoCorrector
+        include RangeHelp
+        include CommentsHelp
+        include DigHelp
+
+        MSG = 'Use `%<replacement>s` instead of chaining.'
+        RESTRICT_ON_SEND = %i[dig].freeze
+
+        def on_send(node)
+          return if ignored_node?(node)
+          return unless node.loc.dot
+          return unless dig?(node)
+
+          range, arguments = inspect_chain(node)
+          return if invalid_arguments?(arguments)
+          return unless range
+
+          register_offense(node, range, arguments)
+        end
+        alias on_csend on_send
+
+        private
+
+        # Walk up the method chain while the receiver is `dig` with arguments.
+        def inspect_chain(node)
+          arguments = node.arguments.dup
+          end_pos = node.source_range.end_pos
+
+          while dig?((node = node.receiver))
+            begin_pos = node.loc.dot ? node.loc.dot.begin_pos + 1 : 0
+            arguments.unshift(*node.arguments)
+            ignore_node(node)
+          end
+
+          return unless begin_pos
+
+          [range_between(begin_pos, end_pos), arguments]
+        end
+
+        def invalid_arguments?(arguments)
+          # If any of the arguments are arguments forwarding (`...`), it can only be the
+          # first argument, or else the resulting code will have a syntax error.
+
+          return false unless arguments&.any?
+
+          forwarded_args_index = arguments.index(&:forwarded_args_type?)
+          forwarded_args_index && forwarded_args_index < (arguments.size - 1)
+        end
+
+        def register_offense(node, range, arguments)
+          arguments = arguments.map(&:source).join(', ')
+          replacement = "dig(#{arguments})"
+
+          add_offense(range, message: format(MSG, replacement: replacement)) do |corrector|
+            corrector.replace(range, replacement)
+
+            comments_in_range(node).reverse_each do |comment|
+              corrector.insert_before(node, "#{comment.source}\n")
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Use `File::NULL` instead of hardcoding the null device (`/dev/null` on Unix-like
+      # OSes, `NUL` or `NUL:` on Windows), so that code is platform independent.
+      # Only looks for full string matches, substrings within a longer string are not
+      # considered.
+      #
+      # NOTE: Uses inside arrays and hashes are ignored.
+      #
+      # @safety
+      #   It is possible for a string value to be changed if code is being run
+      #   on multiple platforms and was previously hardcoded to a specific null device.
+      #
+      #   For example, the following string will change on Windows when changed to
+      #   `File::NULL`:
+      #
+      #   [source,ruby]
+      #   ----
+      #   path = "/dev/null"
+      #   ----
+      #
+      # @example
+      #   # bad
+      #   '/dev/null'
+      #   'NUL'
+      #   'NUL:'
+      #
+      #   # good
+      #   File::NULL
+      #
+      #   # ok - inside an array
+      #   null_devices = %w[/dev/null nul]
+      #
+      #   # ok - inside a hash
+      #   { unix: "/dev/null", windows: "nul" }
+      class FileNull < Base
+        extend AutoCorrector
+
+        REGEXP = %r{\A(/dev/null|NUL:?)\z}i.freeze
+        MSG = 'Use `File::NULL` instead of `%<source>s`.'
+
+        def on_str(node)
+          value = node.value
+
+          return if invalid_string?(value)
+          return if acceptable?(node)
+          return unless REGEXP.match?(value)
+
+          add_offense(node, message: format(MSG, source: value)) do |corrector|
+            corrector.replace(node, 'File::NULL')
+          end
+        end
+
+        private
+
+        def invalid_string?(value)
+          value.empty? || !value.valid_encoding?
+        end
+
+        def acceptable?(node)
+          # Using a hardcoded null device is acceptable when inside an array or
+          # inside a hash to ensure behavior doesn't change.
+          return false unless node.parent
+
+          node.parent.type?(:array, :pair)
+        end
+      end
+    end
+  end
+end

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)

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

@@ -6,8 +6,8 @@ module RuboCop
       # 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 a shorter and simpler code.
+      # Providing arguments directly is more performant than using `merge`, and
+      # also leads to shorter and simpler code.
       #
       # @example
       #   # bad

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/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)