rubocop 1.54.1 → 1.64.1

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

@@ -7,12 +7,18 @@ module RuboCop
       # scope.
       # The basic idea for this cop was from the warning of `ruby -cw`:
       #
-      #   assigned but unused variable - foo
+      # [source,console]
+      # ----
+      # assigned but unused variable - foo
+      # ----
       #
       # Currently this cop has advanced logic that detects unreferenced
       # reassignments and properly handles varied cases such as branch, loop,
       # rescue, ensure, etc.
       #
+      # NOTE: Given the assignment `foo = 1, bar = 2`, removing unused variables
+      # can lead to a syntax error, so this case is not autocorrected.
+      #
       # @safety
       #   This cop's autocorrection is unsafe because removing assignment from
       #   operator assignment can cause NameError if this assignment has been used to declare
@@ -51,25 +57,24 @@ module RuboCop
           scope.variables.each_value { |variable| check_for_unused_assignments(variable) }
         end
 
+        # rubocop:disable Metrics/AbcSize
         def check_for_unused_assignments(variable)
           return if variable.should_be_unused?
 
           variable.assignments.each do |assignment|
-            next if assignment.used?
+            next if assignment.used? || part_of_ignored_node?(assignment.node)
 
             message = message_for_useless_assignment(assignment)
+            range = offense_range(assignment)
 
-            location = if assignment.regexp_named_capture?
-                         assignment.node.children.first.source_range
-                       else
-                         assignment.node.loc.name
-                       end
-
-            add_offense(location, message: message) do |corrector|
-              autocorrect(corrector, assignment)
+            add_offense(range, message: message) do |corrector|
+              autocorrect(corrector, assignment) unless sequential_assignment?(assignment.node)
             end
+
+            ignore_node(assignment.node) if chained_assignment?(assignment.node)
           end
         end
+        # rubocop:enable Metrics/AbcSize
 
         def message_for_useless_assignment(assignment)
           variable = assignment.variable
@@ -77,6 +82,28 @@ module RuboCop
           format(MSG, variable: variable.name) + message_specification(assignment, variable).to_s
         end
 
+        def offense_range(assignment)
+          if assignment.regexp_named_capture?
+            assignment.node.children.first.source_range
+          else
+            assignment.node.loc.name
+          end
+        end
+
+        def sequential_assignment?(node)
+          if node.lvasgn_type? && node.expression&.array_type? &&
+             node.each_descendant.any?(&:assignment?)
+            return true
+          end
+          return false unless node.parent
+
+          sequential_assignment?(node.parent)
+        end
+
+        def chained_assignment?(node)
+          node.respond_to?(:expression) && node.expression&.lvasgn_type?
+        end
+
         def message_specification(assignment, variable)
           if assignment.multiple_assignment?
             multiple_assignment_message(variable.name)
@@ -96,8 +123,7 @@ module RuboCop
           return_value_node = return_value_node_of_scope(scope)
           return unless assignment.meta_assignment_node.equal?(return_value_node)
 
-          " Use `#{assignment.operator.sub(/=$/, '')}` " \
-            "instead of `#{assignment.operator}`."
+          " Use `#{assignment.operator.delete_suffix('=')}` instead of `#{assignment.operator}`."
         end
 
         def similar_name_message(variable)

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

@@ -4,7 +4,7 @@ module RuboCop
   module Cop
     module Lint
       # Checks for uses of `Integer#times` that will never yield
-      # (when the integer <= 0) or that will only ever yield once
+      # (when the integer ``<= 0``) or that will only ever yield once
       # (`1.times`).
       #
       # @safety
@@ -64,7 +64,7 @@ module RuboCop
             remove_node(corrector, node)
           elsif !proc_name.empty?
             autocorrect_block_pass(corrector, node, proc_name)
-          else
+          elsif node.block_type?
             autocorrect_block(corrector, node)
           end
         end

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

@@ -6,6 +6,16 @@ module RuboCop
       # Checks for operators, variables, literals, lambda, proc and nonmutating
       # methods used in void context.
       #
+      # `each` blocks are allowed to prevent false positives.
+      # For example, the expression inside the `each` block below.
+      # It's not void, especially when the receiver is an `Enumerator`:
+      #
+      # [source,ruby]
+      # ----
+      # enumerator = [1, 2, 3].filter
+      # enumerator.each { |item| item >= 2 } #=> [2, 3]
+      # ----
+      #
       # @example CheckForMethodsWithNoSideEffects: false (default)
       #   # bad
       #   def some_method
@@ -47,6 +57,7 @@ module RuboCop
 
         OP_MSG = 'Operator `%<op>s` used in void context.'
         VAR_MSG = 'Variable `%<var>s` used in void context.'
+        CONST_MSG = 'Constant `%<var>s` used in void context.'
         LIT_MSG = 'Literal `%<lit>s` used in void context.'
         SELF_MSG = '`self` used in void context.'
         EXPRESSION_MSG = '`%<expression>s` used in void context.'
@@ -72,6 +83,7 @@ module RuboCop
           return unless node.body && !node.body.begin_type?
           return unless in_void_context?(node.body)
 
+          check_void_op(node.body) { node.method?(:each) }
           check_expression(node.body)
         end
 
@@ -87,11 +99,18 @@ module RuboCop
         def check_begin(node)
           expressions = *node
           expressions.pop unless in_void_context?(node)
-          expressions.each { |expr| check_expression(expr) }
+          expressions.each do |expr|
+            check_void_op(expr) do
+              block_node = node.each_ancestor(:block).first
+
+              block_node&.method?(:each)
+            end
+
+            check_expression(expr)
+          end
         end
 
         def check_expression(expr)
-          check_void_op(expr)
           check_literal(expr)
           check_var(expr)
           check_self(expr)
@@ -101,8 +120,9 @@ module RuboCop
           check_nonmutating(expr)
         end
 
-        def check_void_op(node)
+        def check_void_op(node, &block)
           return unless node.send_type? && OPERATORS.include?(node.method_name)
+          return if block && yield(node)
 
           add_offense(node.loc.selector,
                       message: format(OP_MSG, op: node.method_name)) do |corrector|
@@ -113,20 +133,23 @@ module RuboCop
         def check_var(node)
           return unless node.variable? || node.const_type?
 
-          if node.const_type? && node.special_keyword?
-            add_offense(node, message: format(VAR_MSG, var: node.source)) do |corrector|
-              autocorrect_void_expression(corrector, node)
-            end
+          if node.const_type?
+            template = node.special_keyword? ? VAR_MSG : CONST_MSG
+
+            offense_range = node
+            message = format(template, var: node.source)
           else
-            add_offense(node.loc.name,
-                        message: format(VAR_MSG, var: node.loc.name.source)) do |corrector|
-              autocorrect_void_expression(corrector, node)
-            end
+            offense_range = node.loc.name
+            message = format(VAR_MSG, var: node.loc.name.source)
+          end
+
+          add_offense(offense_range, message: message) do |corrector|
+            autocorrect_void_expression(corrector, node)
           end
         end
 
         def check_literal(node)
-          return if !node.literal? || node.xstr_type? || node.range_type?
+          return if !entirely_literal?(node) || node.xstr_type? || node.range_type?
 
           add_offense(node, message: format(LIT_MSG, lit: node.source)) do |corrector|
             autocorrect_void_expression(corrector, node)
@@ -199,6 +222,19 @@ module RuboCop
                       end
           corrector.replace(send_node.loc.selector, suggestion)
         end
+
+        def entirely_literal?(node)
+          case node.type
+          when :array
+            node.each_value.all? { |value| entirely_literal?(value) }
+          when :hash
+            return false unless node.each_key.all? { |key| entirely_literal?(key) }
+
+            node.each_value.all? { |value| entirely_literal?(value) }
+          else
+            node.literal?
+          end
+        end
       end
     end
   end

data/lib/rubocop/cop/metrics/abc_size.rb

@@ -10,9 +10,9 @@ module RuboCop
       #
       # Interpreting ABC size:
       #
-      # * <= 17 satisfactory
-      # * 18..30 unsatisfactory
-      # * > 30 dangerous
+      # * ``<= 17`` satisfactory
+      # * `18..30` unsatisfactory
+      # * `>` 30 dangerous
       #
       # You can have repeated "attributes" calls count as a single "branch".
       # For this purpose, attributes are any method with no argument; no attempt

data/lib/rubocop/cop/metrics/block_length.rb

@@ -12,6 +12,7 @@ module RuboCop
       # Available are: 'array', 'hash', 'heredoc', and 'method_call'. Each construct
       # will be counted as one line regardless of its actual size.
       #
+      # NOTE: This cop does not apply for `Struct` definitions.
       #
       # NOTE: The `ExcludedMethods` configuration is deprecated and only kept
       # for backwards compatibility. Please use `AllowedMethods` and `AllowedPatterns`
@@ -40,7 +41,6 @@ module RuboCop
       #     )
       #   end                 # 6 points
       #
-      # NOTE: This cop does not apply for `Struct` definitions.
       class BlockLength < Base
         include CodeLength
         include AllowedMethods

data/lib/rubocop/cop/metrics/class_length.rb

@@ -11,6 +11,8 @@ module RuboCop
       # Available are: 'array', 'hash', 'heredoc', and 'method_call'. Each construct
       # will be counted as one line regardless of its actual size.
       #
+      # NOTE: This cop also applies for `Struct` definitions.
+      #
       # @example CountAsOne: ['array', 'heredoc', 'method_call']
       #
       #   class Foo
@@ -34,15 +36,18 @@ module RuboCop
       #     )
       #   end                 # 6 points
       #
-      #
-      # NOTE: This cop also applies for `Struct` definitions.
       class ClassLength < Base
         include CodeLength
 
         def on_class(node)
           check_code_length(node)
         end
-        alias on_sclass on_class
+
+        def on_sclass(node)
+          return if node.each_ancestor(:class).any?
+
+          on_class(node)
+        end
 
         def on_casgn(node)
           parent = node.parent

data/lib/rubocop/cop/metrics/method_length.rb

@@ -54,7 +54,7 @@ module RuboCop
         alias on_defs on_def
 
         def on_block(node)
-          return unless node.send_node.method?(:define_method)
+          return unless node.method?(:define_method)
 
           check_code_length(node)
         end

data/lib/rubocop/cop/metrics/utils/code_length_calculator.rb

@@ -10,7 +10,7 @@ module RuboCop
           include Util
 
           FOLDABLE_TYPES = %i[array hash heredoc send csend].freeze
-          CLASSLIKE_TYPES = %i[class module sclass].freeze
+          CLASSLIKE_TYPES = %i[class module].freeze
           private_constant :FOLDABLE_TYPES, :CLASSLIKE_TYPES
 
           def initialize(node, processed_source, count_comments: false, foldable_types: [])
@@ -43,16 +43,16 @@ module RuboCop
             types.map do |type|
               case type
               when :array
-                ->(node) { node.array_type? }
+                lambda(&:array_type?)
               when :hash
-                ->(node) { node.hash_type? }
+                lambda(&:hash_type?)
               when :heredoc
                 ->(node) { heredoc_node?(node) }
               when :method_call
-                ->(node) { node.call_type? }
+                lambda(&:call_type?)
               else
-                raise ArgumentError, "Unknown foldable type: #{type.inspect}. " \
-                                     "Valid foldable types are: #{FOLDABLE_TYPES.join(', ')}."
+                raise Warning, "Unknown foldable type: #{type.inspect}. " \
+                               "Valid foldable types are: #{FOLDABLE_TYPES.join(', ')}."
               end
             end
           end
@@ -145,7 +145,7 @@ module RuboCop
 
           def extract_body(node)
             case node.type
-            when :class, :module, :block, :numblock, :def, :defs
+            when :class, :module, :sclass, :block, :numblock, :def, :defs
               node.body
             when :casgn
               _scope, _name, value = *node

data/lib/rubocop/cop/mixin/check_line_breakable.rb

@@ -218,7 +218,7 @@ module RuboCop
 
       # @api private
       def already_on_multiple_lines?(node)
-        return node.first_line != node.arguments.last.last_line if node.def_type?
+        return node.first_line != node.last_argument.last_line if node.def_type?
 
         !node.single_line?
       end

data/lib/rubocop/cop/mixin/code_length.rb

@@ -36,7 +36,7 @@ module RuboCop
         length = calculator.calculate
         return if length <= max_length
 
-        location = node.casgn_type? ? node.loc.name : node.source_range
+        location = location(node)
 
         add_offense(location, message: message(length, max_length)) { self.max = length }
       end
@@ -54,6 +54,17 @@ module RuboCop
           foldable_types: count_as_one
         )
       end
+
+      def location(node)
+        return node.loc.name if node.casgn_type?
+
+        if LSP.enabled?
+          end_range = node.loc.respond_to?(:name) ? node.loc.name : node.loc.begin
+          node.source_range.begin.join(end_range)
+        else
+          node.source_range
+        end
+      end
     end
   end
 end

data/lib/rubocop/cop/mixin/comments_help.rb

@@ -62,25 +62,29 @@ module RuboCop
       # Returns the end line of a node, which might be a comment and not part of the AST
       # End line is considered either the line at which another node starts, or
       # the line at which the parent node ends.
-      # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity, Lint/DuplicateBranch
+      # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
       def find_end_line(node)
-        if node.if_type? && node.else?
-          node.loc.else.line
-        elsif node.if_type? && node.ternary?
-          node.else_branch.loc.line
-        elsif node.if_type? && node.elsif?
-          node.each_ancestor(:if).find(&:if?).loc.end.line
+        if node.if_type?
+          if node.else?
+            node.loc.else.line
+          elsif node.ternary?
+            node.else_branch.loc.line
+          elsif node.elsif?
+            node.each_ancestor(:if).find(&:if?).loc.end.line
+          end
         elsif node.block_type? || node.numblock_type?
           node.loc.end.line
         elsif (next_sibling = node.right_sibling) && next_sibling.is_a?(AST::Node)
           next_sibling.loc.line
         elsif (parent = node.parent)
-          parent.loc.respond_to?(:end) && parent.loc.end ? parent.loc.end.line : parent.loc.line
-        else
-          node.loc.end.line
-        end
+          if parent.loc.respond_to?(:end) && parent.loc.end
+            parent.loc.end.line
+          else
+            parent.loc.line
+          end
+        end || node.loc.end.line
       end
-      # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity, Lint/DuplicateBranch
+      # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
     end
   end
 end

data/lib/rubocop/cop/mixin/configurable_formatting.rb

@@ -18,6 +18,7 @@ module RuboCop
         alternative_styles.each do |alternative|
           return unexpected_style_detected(alternative) if valid_name?(node, name, alternative)
         end
+        unrecognized_style_detected
       end
 
       def valid_name?(node, name, given_style = style)

data/lib/rubocop/cop/mixin/def_node.rb

@@ -19,7 +19,7 @@ module RuboCop
 
       # @!method non_public_modifier?(node)
       def_node_matcher :non_public_modifier?, <<~PATTERN
-        (send nil? {:private :protected} ({def defs} ...))
+        (send nil? {:private :protected :private_class_method} ({def defs} ...))
       PATTERN
     end
   end

data/lib/rubocop/cop/mixin/hash_shorthand_syntax.rb

@@ -48,29 +48,33 @@ module RuboCop
 
       def register_offense(node, message, replacement) # rubocop:disable Metrics/AbcSize
         add_offense(node.value, message: message) do |corrector|
-          if (def_node = def_node_that_require_parentheses(node))
-            last_argument = def_node.last_argument
-            if last_argument.nil? || !last_argument.hash_type?
-              next corrector.replace(node, replacement)
-            end
-
-            white_spaces = range_between(def_node.selector.end_pos,
-                                         def_node.first_argument.source_range.begin_pos)
-            corrector.replace(white_spaces, '(')
-            corrector.insert_after(last_argument, ')') if node == last_argument.pairs.last
-          end
           corrector.replace(node, replacement)
+
+          next unless (def_node = def_node_that_require_parentheses(node))
+
+          last_argument = def_node.last_argument
+          if last_argument.nil? || !last_argument.hash_type?
+            next corrector.replace(node, replacement)
+          end
+
+          white_spaces = range_between(def_node.selector.end_pos,
+                                       def_node.first_argument.source_range.begin_pos)
+          next if node.parent.braces?
+
+          corrector.replace(white_spaces, '(')
+          corrector.insert_after(last_argument, ')') if node == last_argument.pairs.last
         end
       end
 
       def ignore_mixed_hash_shorthand_syntax?(hash_node)
-        target_ruby_version <= 3.0 || enforced_shorthand_syntax != 'consistent' ||
+        target_ruby_version <= 3.0 ||
+          !%w[consistent either_consistent].include?(enforced_shorthand_syntax) ||
           !hash_node.hash_type?
       end
 
       def ignore_hash_shorthand_syntax?(pair_node)
         target_ruby_version <= 3.0 || enforced_shorthand_syntax == 'either' ||
-          enforced_shorthand_syntax == 'consistent' ||
+          %w[consistent either_consistent].include?(enforced_shorthand_syntax) ||
           !pair_node.parent.hash_type?
       end
 
@@ -169,6 +173,11 @@ module RuboCop
         hash_value_type_breakdown[:value_needed]&.any?
       end
 
+      def ignore_explicit_omissible_hash_shorthand_syntax?(hash_value_type_breakdown)
+        hash_value_type_breakdown.keys == [:value_omittable] &&
+          enforced_shorthand_syntax == 'either_consistent'
+      end
+
       def each_omitted_value_pair(hash_value_type_breakdown, &block)
         hash_value_type_breakdown[:value_omitted]&.each(&block)
       end
@@ -195,6 +204,7 @@ module RuboCop
 
       def no_mixed_shorthand_syntax_check(hash_value_type_breakdown)
         return if hash_with_values_that_cant_be_omitted?(hash_value_type_breakdown)
+        return if ignore_explicit_omissible_hash_shorthand_syntax?(hash_value_type_breakdown)
 
         each_omittable_value_pair(hash_value_type_breakdown) do |pair_node|
           hash_key_source = pair_node.key.source

data/lib/rubocop/cop/mixin/method_complexity.rb

@@ -49,13 +49,13 @@ module RuboCop
 
         return unless complexity > max
 
-        msg = format(self.class::MSG,
-                     method: method_name,
-                     complexity: complexity,
-                     abc_vector: abc_vector,
-                     max: max)
+        msg = format(
+          self.class::MSG,
+          method: method_name, complexity: complexity, abc_vector: abc_vector, max: max
+        )
+        location = location(node)
 
-        add_offense(node, message: msg) { self.max = complexity.ceil }
+        add_offense(location, message: msg) { self.max = complexity.ceil }
       end
 
       def complexity(body)
@@ -69,6 +69,15 @@ module RuboCop
         end
         score
       end
+
+      def location(node)
+        if LSP.enabled?
+          end_range = node.loc.respond_to?(:name) ? node.loc.name : node.loc.begin
+          node.source_range.begin.join(end_range)
+        else
+          node.source_range
+        end
+      end
     end
   end
 end

data/lib/rubocop/cop/mixin/multiline_expression_indentation.rb

@@ -20,16 +20,17 @@ module RuboCop
         range = offending_range(node, lhs, rhs, style)
         check(range, node, lhs, rhs)
       end
+      alias on_csend on_send
 
       private
 
-      # In a chain of method calls, we regard the top send node as the base
+      # In a chain of method calls, we regard the top call node as the base
       # for indentation of all lines following the first. For example:
       # a.
       #   b c { block }.            <-- b is indented relative to a
       #   d                         <-- d is indented relative to a
       def left_hand_side(lhs)
-        while lhs.parent&.send_type? && lhs.parent.loc.dot && !lhs.parent.assignment_method?
+        while lhs.parent&.call_type? && lhs.parent.loc.dot && !lhs.parent.assignment_method?
           lhs = lhs.parent
         end
         lhs
@@ -188,7 +189,7 @@ module RuboCop
         case node.type
         when :casgn   then _scope, _lhs, rhs = *node
         when :op_asgn then _lhs, _op, rhs = *node
-        when :send    then rhs = node.last_argument
+        when :send, :csend then rhs = node.last_argument
         else               _lhs, rhs = *node
         end
         rhs

data/lib/rubocop/cop/mixin/preceding_following_alignment.rb

@@ -75,21 +75,19 @@ module RuboCop
       end
 
       def aligned_token?(range, line)
-        aligned_words?(range, line) ||
-          aligned_char?(range, line) ||
-          aligned_assignment?(range, line)
+        aligned_words?(range, line) || aligned_assignment?(range, line)
       end
 
       def aligned_operator?(range, line)
-        (aligned_identical?(range, line) || aligned_assignment?(range, line))
+        aligned_identical?(range, line) || aligned_assignment?(range, line)
       end
 
       def aligned_words?(range, line)
-        /\s\S/.match?(line[range.column - 1, 2])
-      end
+        left_edge = range.column
+        return true if /\s\S/.match?(line[left_edge - 1, 2])
 
-      def aligned_char?(range, line)
-        line[range.column] == range.source[0]
+        token = range.source
+        token == line[left_edge, token.length]
       end
 
       def aligned_assignment?(range, line)

data/lib/rubocop/cop/mixin/safe_assignment.rb

@@ -14,7 +14,7 @@ module RuboCop
       def_node_matcher :empty_condition?, '(begin)'
 
       # @!method setter_method?(node)
-      def_node_matcher :setter_method?, '[(send ...) setter_method?]'
+      def_node_matcher :setter_method?, '[(call ...) setter_method?]'
 
       # @!method safe_assignment?(node)
       def_node_matcher :safe_assignment?, '(begin {equals_asgn? #setter_method?})'

data/lib/rubocop/cop/mixin/space_before_punctuation.rb

@@ -36,7 +36,7 @@ module RuboCop
       end
 
       def space_required_after?(token)
-        token.left_curly_brace? && space_required_after_lcurly?
+        (token.left_curly_brace? || token.type == :tLAMBEG) && space_required_after_lcurly?
       end
 
       def space_required_after_lcurly?

data/lib/rubocop/cop/mixin/string_help.rb

@@ -30,8 +30,10 @@ module RuboCop
       private
 
       def inside_interpolation?(node)
-        # A :begin node inside a :dstr node is an interpolation.
-        node.ancestors.drop_while { |a| !a.begin_type? }.any?(&:dstr_type?)
+        # A :begin node inside a :dstr, :dsym, or :regexp node is an interpolation.
+        node.ancestors
+            .drop_while { |a| !a.begin_type? }
+            .any? { |a| a.dstr_type? || a.dsym_type? || a.regexp_type? }
       end
     end
   end

data/lib/rubocop/cop/mixin/trailing_comma.rb

@@ -106,7 +106,7 @@ module RuboCop
       end
 
       def elements(node)
-        return node.children unless %i[csend send].include?(node.type)
+        return node.children unless node.call_type?
 
         node.arguments.flat_map do |argument|
           # For each argument, if it is a multi-line hash without braces,