rubocop 1.67.0 → 1.75.5

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
 
@@ -110,7 +107,7 @@ module RuboCop
           parent = node.parent
           return true unless parent
 
-          !(parent.mlhs_type? || parent.resbody_type?)
+          !parent.type?(:mlhs, :resbody)
         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.'
@@ -313,22 +309,25 @@ module RuboCop
         end
 
         def allowed_single_line?(branches)
-          single_line_conditions_only? && branches.any?(&:begin_type?)
+          single_line_conditions_only? && branches.compact.any?(&:begin_type?)
         end
 
         def assignment_node(node)
-          *_variable, assignment = *node
+          assignment = node.send_type? ? node.last_argument : node.expression
+          return unless assignment
 
           # 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
 
         def move_assignment_outside_condition(corrector, node)
-          if node.case_type? || node.case_match_type?
+          if node.type?(:case, :case_match)
             CaseCorrector.correct(corrector, self, node)
           elsif node.ternary?
             TernaryCorrector.correct(corrector, node)
@@ -338,11 +337,11 @@ 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)
-          elsif condition.case_type? || condition.case_match_type?
+          elsif condition.type?(:case, :case_match)
             CaseCorrector.move_assignment_inside_condition(corrector, node)
           elsif condition.if_type?
             IfCorrector.move_assignment_inside_condition(corrector, node)
@@ -438,17 +437,28 @@ module RuboCop
       # Helper module to provide common methods to ConditionalAssignment
       # correctors
       module ConditionalCorrectorHelper
+        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity
         def remove_whitespace_in_branches(corrector, branch, condition, column)
           branch.each_node do |child|
             next if child.source_range.nil?
+            next if child.parent.dstr_type?
 
             white_space = white_space_range(child, column)
             corrector.remove(white_space) if white_space.source.strip.empty?
           end
 
-          [condition.loc.else, condition.loc.end].each do |loc|
-            corrector.remove_preceding(loc, loc.column - column)
+          if condition.loc.else && !same_line?(condition.else_branch, condition)
+            corrector.remove_preceding(condition.loc.else, condition.loc.else.column - column)
           end
+
+          return unless condition.loc.end && !same_line?(condition.loc.end, condition)
+
+          corrector.remove_preceding(condition.loc.end, condition.loc.end.column - column)
+        end
+        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity
+
+        def same_line?(node1, node2)
+          RuboCop::Cop::Util.same_line?(node1, node2)
         end
 
         def white_space_range(node, column)
@@ -459,7 +469,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 +516,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 +547,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 +577,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)
@@ -595,6 +605,8 @@ module RuboCop
 
             return unless (branch_else = branch.parent.loc.else)
 
+            return if same_line?(branch_else, condition)
+
             corrector.remove_preceding(branch_else, branch_else.column - column)
           end
         end
@@ -618,7 +630,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,89 @@
+# 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 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_range = node.source_range.end
+
+          while dig?(node = node.receiver)
+            begin_range = node.loc.selector
+            arguments.unshift(*node.arguments)
+            ignore_node(node)
+          end
+
+          return unless begin_range
+
+          [begin_range.join(end_range), 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/documentation.rb

@@ -186,7 +186,7 @@ module RuboCop
         def qualify_const(node)
           return if node.nil?
 
-          if node.cbase_type? || node.self_type? || node.call_type? || node.variable?
+          if node.type?(:cbase, :self, :call) || node.variable?
             node.source
           else
             [qualify_const(node.namespace), node.short_name].compact

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

@@ -93,7 +93,7 @@ module RuboCop
 
           if conditional_node
             double_negative_condition_return_value?(node, last_child, conditional_node)
-          elsif last_child.pair_type? || last_child.hash_type? || last_child.parent.array_type?
+          elsif last_child.type?(:pair, :hash) || last_child.parent.array_type?
             false
           else
             last_child.last_line <= node.last_line
@@ -102,14 +102,14 @@ module RuboCop
 
         def find_def_node_from_ascendant(node)
           return unless (parent = node.parent)
-          return parent if parent.def_type? || parent.defs_type?
+          return parent if parent.any_def_type?
           return node.parent.child_nodes.first if define_method?(parent)
 
           find_def_node_from_ascendant(node.parent)
         end
 
         def define_method?(node)
-          return false unless node.block_type?
+          return false unless node.any_block_type?
 
           child = node.child_nodes.first
           return false unless child.send_type?
@@ -147,7 +147,7 @@ module RuboCop
         def find_parent_not_enumerable(node)
           return unless (parent = node.parent)
 
-          if parent.pair_type? || parent.hash_type? || parent.array_type?
+          if parent.type?(:pair, :hash, :array)
             find_parent_not_enumerable(parent)
           else
             parent

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

@@ -4,7 +4,7 @@ module RuboCop
   module Cop
     module Style
       # Checks for loops which iterate a constant number of times,
-      # using a Range literal and `#each`. This can be done more readably using
+      # using a `Range` literal and `#each`. This can be done more readably using
       # `Integer#times`.
       #
       # This check only applies if the block takes no parameters.
@@ -53,8 +53,7 @@ module RuboCop
           (block
             (call
               (begin
-                (${irange erange}
-                  (int $_) (int $_)))
+                ($range (int $_) (int $_)))
               :each)
             (args ...)
             ...)
@@ -65,8 +64,7 @@ module RuboCop
           (block
             (call
               (begin
-                ({irange erange}
-                  (int 0) (int _)))
+                (range (int 0) (int _)))
               :each)
             (args ...)
             ...)
@@ -77,8 +75,7 @@ module RuboCop
           (block
             (call
               (begin
-                ({irange erange}
-                  (int _) (int _)))
+                (range (int _) (int _)))
               :each)
             (args)
             ...)

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

@@ -58,7 +58,7 @@ module RuboCop
 
         # @!method each_with_object_block_candidate?(node)
         def_node_matcher :each_with_object_block_candidate?, <<~PATTERN
-          (block $(call _ {:inject :reduce} _) $_ $_)
+          (block $(call _ {:inject :reduce} _) $(args _ _) $_)
         PATTERN
 
         # @!method each_with_object_numblock_candidate?(node)
@@ -71,8 +71,7 @@ module RuboCop
 
           first_arg, second_arg = *node.arguments
 
-          corrector.replace(first_arg, second_arg.source)
-          corrector.replace(second_arg, first_arg.source)
+          corrector.swap(first_arg, second_arg)
 
           if return_value_occupies_whole_line?(return_value)
             corrector.remove(whole_line_expression(return_value))

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

@@ -131,6 +131,8 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Redundant `else`-clause.'
+        NIL_STYLES = %i[nil both].freeze
+        EMPTY_STYLES = %i[empty both].freeze
 
         def on_normal_if_unless(node)
           check(node)
@@ -150,11 +152,11 @@ module RuboCop
         end
 
         def nil_style?
-          style == :nil || style == :both
+          NIL_STYLES.include?(style)
         end
 
         def empty_style?
-          style == :empty || style == :both
+          EMPTY_STYLES.include?(style)
         end
 
         def empty_check(node)

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

@@ -6,6 +6,10 @@ module RuboCop
       # Checks for the use of a method, the result of which
       # would be a literal, like an empty array, hash, or string.
       #
+      # NOTE: When frozen string literals are enabled, `String.new`
+      # isn't corrected to an empty string since the former is
+      # mutable and the latter would be frozen.
+      #
       # @example
       #   # bad
       #   a = Array.new
@@ -136,7 +140,7 @@ module RuboCop
         def frozen_strings?
           return true if frozen_string_literals_enabled?
 
-          frozen_string_cop_enabled = config.for_cop('Style/FrozenStringLiteralComment')['Enabled']
+          frozen_string_cop_enabled = config.cop_enabled?('Style/FrozenStringLiteralComment')
           frozen_string_cop_enabled &&
             !frozen_string_literals_disabled? &&
             string_literals_frozen_by_default?.nil?

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

@@ -109,7 +109,7 @@ module RuboCop
         end
 
         def max_line_length
-          return unless config.for_cop('Layout/LineLength')['Enabled']
+          return unless config.cop_enabled?('Layout/LineLength')
 
           config.for_cop('Layout/LineLength')['Max']
         end