rubocop 1.92.0 → 1.92.2

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

@@ -9,6 +9,11 @@ module RuboCop
       # example, mistranslating an array of literals to percent string notation)
       # rather than meant to be part of the resulting strings.
       #
+      # When a quoted string contains whitespace, `%w` splits it into separate values,
+      # so removing the quotes would not restore the intended string.
+      # Such an array is corrected to an array literal instead, as long as its content
+      # reads as one with only string elements.
+      #
       # @safety
       #   The cop is unsafe because the correction changes the values in the array
       #   and that might have been done purposely.
@@ -26,6 +31,12 @@ module RuboCop
       #
       #   # good
       #   %w(foo bar)
+      #
+      #   # bad - the quoted strings are split at whitespace
+      #   %w('foo bar', 'baz')
+      #
+      #   # good
+      #   ['foo bar', 'baz']
       class PercentStringArray < Base
         include PercentLiteral
         extend AutoCorrector
@@ -36,27 +47,69 @@ module RuboCop
 
         MSG = "Within `%w`/`%W`, quotes and ',' are unnecessary and may be " \
               'unwanted in the resulting strings.'
+        MSG_SPLIT_STRING = 'Within `%w`/`%W`, quoted strings are split at whitespace; ' \
+                           'use an array literal instead.'
 
         def on_array(node)
           process(node, '%w', '%W')
         end
 
         def on_percent_literal(node)
-          return unless contains_quotes_or_commas?(node)
+          if split_quoted_string?(node)
+            register_split_quoted_string(node)
+          elsif contains_quotes_or_commas?(node)
+            register_quotes_or_commas(node)
+          end
+        end
 
-          add_offense(node) do |corrector|
-            node.each_value do |value|
-              range = value.source_range
+        private
 
-              match = range.source.match(TRAILING_QUOTE)
-              corrector.remove_trailing(range, match[0].length) if match
+        def split_quoted_string?(node)
+          sources = node.values.map { |value| value.source.delete_suffix(',') }
 
-              corrector.remove_leading(range, 1) if LEADING_QUOTE.match?(range.source)
-            end
+          sources.each_with_index.any? do |source, index|
+            next false unless (quote = unclosed_quote(source))
+
+            sources.drop(index + 1).any? { |rest| closing_quote?(rest, quote) }
           end
         end
 
-        private
+        def unclosed_quote(source)
+          quote = source[0]
+          return unless LEADING_QUOTE.match?(quote)
+
+          quote if source.length > 1 && !source.end_with?(quote)
+        end
+
+        def closing_quote?(source, quote)
+          source.end_with?(quote) && (source.length == 1 || !source.start_with?(quote))
+        end
+
+        def register_split_quoted_string(node)
+          add_offense(node, message: MSG_SPLIT_STRING) do |corrector|
+            next unless (array_literal = array_literal_source(node))
+
+            corrector.replace(node, array_literal)
+          end
+        end
+
+        def array_literal_source(node)
+          content = range_between(node.loc.begin.end_pos, node.loc.end.begin_pos).source
+          array_literal = "[#{content}]"
+
+          array_literal if string_array?(parse(array_literal))
+        end
+
+        def string_array?(processed_source)
+          return false unless processed_source.valid_syntax? && processed_source.comments.empty?
+          return false unless (array = processed_source.ast).array_type?
+
+          array.children.all? { |child| quoted_string?(child) }
+        end
+
+        def quoted_string?(node)
+          node.type?(:str, :dstr) && node.loc?(:begin)
+        end
 
         def contains_quotes_or_commas?(node)
           node.values.any? do |value|
@@ -68,6 +121,19 @@ module RuboCop
             QUOTES_AND_COMMAS.any? { |pat| literal.match?(pat) }
           end
         end
+
+        def register_quotes_or_commas(node)
+          add_offense(node) do |corrector|
+            node.each_value do |value|
+              range = value.source_range
+
+              match = range.source.match(TRAILING_QUOTE)
+              corrector.remove_trailing(range, match[0].length) if match
+
+              corrector.remove_leading(range, 1) if LEADING_QUOTE.match?(range.source)
+            end
+          end
+        end
       end
     end
   end

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

@@ -146,8 +146,8 @@ module RuboCop
             comment = directive_comment(line_range)
             next if skip_directive?(comment)
 
-            next_range = line_ranges[line_range_index + 1]
-            redundant = find_redundant_directive(cop, comment, line_range, next_range)
+            following_ranges = line_ranges[(line_range_index + 1)..]
+            redundant = find_redundant_directive(cop, comment, line_range, following_ranges)
             yield comment, redundant if redundant
           end
         end
@@ -191,14 +191,33 @@ module RuboCop
           directive.push? || directive.pop? || directive.next?
         end
 
-        def find_redundant_directive(cop, comment, line_range, next_range)
-          if all_disabled?(comment)
-            find_redundant_all(line_range, next_range)
-          elsif department_disabled?(cop, comment)
-            find_redundant_department(cop, line_range)
+        def find_redundant_directive(cop, comment, line_range, following_ranges)
+          return find_redundant_all(line_range, following_ranges.first) if all_disabled?(comment)
+
+          range = line_range_through_repeated_disables(cop, line_range, following_ranges)
+          if department_disabled?(cop, comment)
+            find_redundant_department(cop, range)
           else
-            find_redundant_cop(cop, line_range)
+            find_redundant_cop(cop, range)
+          end
+        end
+
+        def line_range_through_repeated_disables(cop, line_range, following_ranges)
+          last_range = line_range
+          following_ranges.each do |range|
+            break unless followed_ranges?(last_range, range) && repeated_disable?(cop, range)
+
+            last_range = range
           end
+
+          line_range.begin..last_range.end
+        end
+
+        def repeated_disable?(cop, range)
+          comment = directive_comment(range)
+          return false if comment.nil? || skip_directive?(comment)
+
+          !all_disabled?(comment) && !department_disabled?(cop, comment)
         end
 
         # rubocop:disable-next Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity

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

@@ -118,10 +118,7 @@ module RuboCop
         def redundant_splat_expansion(node)
           literal_expansion(node) do |expanded_item|
             if expanded_item.send_type?
-              return if array_new_inside_array_literal?(expanded_item)
-
-              grandparent = node.parent.parent
-              return if grandparent && !ASSIGNMENT_TYPES.include?(grandparent.type)
+              return unless redundant_array_new_splat?(node, expanded_item)
             # An empty array/percent literal (`*[]`, `*%w()`, ...) expands to nothing, so
             # removing the splat would produce invalid or semantically different code.
             elsif expanded_item.array_type? && expanded_item.children.empty?
@@ -132,6 +129,16 @@ module RuboCop
           end
         end
 
+        # A splatted `Array.new` passed as a method argument provides the arguments,
+        # so the splat is only redundant directly inside an array.
+        def redundant_array_new_splat?(node, array_new_node)
+          return false unless node.parent.array_type?
+          return false if array_new_inside_array_literal?(array_new_node)
+
+          grandparent = node.parent.parent
+          !grandparent || ASSIGNMENT_TYPES.include?(grandparent.type)
+        end
+
         def array_new_inside_array_literal?(array_new_node)
           return false unless array_new?(array_new_node)
 

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

@@ -60,7 +60,7 @@ module RuboCop
 
             rest_operands = grouped_operands[begin_of_rest_operands..]
             rest_operands.each do |operand|
-              next if already_appropriate_call?(operand, dot_op)
+              next unless correction_needed?(operand, dot_op, grouped_operands)
 
               register_offense(operand, dot_op)
             end
@@ -100,12 +100,58 @@ module RuboCop
           end
         end
 
+        def correction_needed?(operand, dot_op, grouped_operands)
+          return false if already_appropriate_call?(operand, dot_op)
+
+          dot_op == '&.' || receiver_guaranteed?(operand, grouped_operands)
+        end
+
         def already_appropriate_call?(operand, dot_op)
           return true if operand.safe_navigation? && dot_op == '&.'
 
           (operand.dot? || operand.operator_method?) && dot_op == '.'
         end
 
+        def receiver_guaranteed?(operand, grouped_operands)
+          grouped_operands.take_while { |guard| !guard.equal?(operand) }.any? do |guard|
+            guaranteed_by?(guard, operand)
+          end
+        end
+
+        def guaranteed_by?(guard, operand)
+          return false unless (path = logical_path(guard, operand))
+
+          truthiness = path.last.first.and_type? ? :truthy : :falsey
+          path[0...-1].reverse_each do |node, child|
+            return false unless (truthiness = child_truthiness(node, child, truthiness))
+          end
+
+          !guard.csend_type? || truthiness == :truthy
+        end
+
+        def logical_path(guard, operand)
+          path = []
+          child = guard
+
+          guard.each_ancestor do |node|
+            unless node.begin_type?
+              return nil unless node.operator_keyword?
+
+              path << [node, child]
+            end
+            return path if operand.each_ancestor.any? { |ancestor| ancestor.equal?(node) }
+
+            child = node
+          end
+        end
+
+        def child_truthiness(node, child, truthiness)
+          deciding = node.and_type? ? :truthy : :falsey
+          return truthiness == deciding ? deciding : :unknown if node.lhs.equal?(child)
+
+          deciding if truthiness == deciding
+        end
+
         def register_offense(operand, dot_operator)
           offense_range = operand.operator_method? ? operand : operand.loc.dot
           message = dot_operator == '.' ? USE_DOT_MSG : USE_SAFE_NAVIGATION_MSG

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

@@ -185,6 +185,7 @@ module RuboCop
             ignore_node(key)
 
             next if requires_quotes?(key)
+            next if key.parent.value_omission?
             next if properly_quoted?(key.source, %("#{key.value}"))
 
             correction = %("#{key.value}")

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

@@ -35,15 +35,13 @@ module RuboCop
         ASSIGNMENT_TYPES = %i[lvasgn ivasgn cvasgn gvasgn].freeze
 
         def on_def(node)
-          return unless node.body
+          return if !node.body || node.void_context?
 
           last_expr = last_expression(node.body)
           return unless setter_call_to_local_variable?(last_expr)
 
-          tracker = MethodVariableTracker.new(node.body)
           receiver, = *last_expr
-          variable_name, = *receiver
-          return unless tracker.contain_local_object?(variable_name)
+          return unless contain_local_object?(node.body, receiver)
 
           loc_name = receiver.loc.name
 
@@ -66,6 +64,11 @@ module RuboCop
           expression.is_a?(Array) ? expression.last : expression
         end
 
+        def contain_local_object?(body, receiver)
+          variable_name, = *receiver
+          MethodVariableTracker.new(body).contain_local_object?(variable_name)
+        end
+
         # This class tracks variable assignments in a method body
         # and if a variable contains object passed as argument at the end of
         # the method.

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

@@ -76,11 +76,7 @@ module RuboCop
       def extract_first_element_over_column_limit(node, elements, max)
         line = node.first_line
 
-        # If a `send` or `csend` node is not parenthesized, don't move the first element, because it
-        # can result in changed behavior or a syntax error.
-        if node.call_type? && !node.parenthesized? && !first_argument_is_heredoc?(node)
-          elements = elements.drop(1)
-        end
+        elements = elements.drop(1) unless first_element_movable?(node)
 
         i = 0
         i += 1 while within_column_limit?(elements[i], max, line)
@@ -93,7 +89,12 @@ module RuboCop
       end
 
       # @api private
-      def first_argument_is_heredoc?(node)
+      # If a method call or definition is not parenthesized, the first element cannot be moved,
+      # because it can result in changed behavior or a syntax error.
+      def first_element_movable?(node)
+        return !node.arguments.loc.begin.nil? if node.any_def_type?
+        return true if !node.call_type? || node.parenthesized?
+
         node.first_argument.respond_to?(:heredoc?) && node.first_argument.heredoc?
       end
 

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

@@ -5,6 +5,8 @@ module RuboCop
     # Checks for code on multiple lines that could be rewritten on a single line
     # without changing semantics or exceeding the `Max` parameter of `Layout/LineLength`.
     module CheckSingleLineSuitability
+      include LineLengthHelp
+
       def suitable_as_single_line?(node)
         !too_long?(node) &&
           !comment_within?(node) &&
@@ -21,7 +23,7 @@ module RuboCop
         return false unless max_line_length
 
         lines = processed_source.lines[(line_range.begin - 1)...line_range.end]
-        to_single_line(lines.join("\n")).length > max_line_length
+        line_length(to_single_line(lines.join("\n"))) > max_line_length
       end
 
       def to_single_line(source)

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

@@ -66,7 +66,7 @@ module RuboCop
       # the line at which the parent node ends.
       # rubocop:disable-next Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
       def find_end_line(node)
-        if node.if_type?
+        if node.if_type? && !node.modifier_form?
           if node.else?
             node.loc.else.line
           elsif node.ternary?

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

@@ -45,12 +45,44 @@ module RuboCop
 
       def command_disallowed_in_endless_body?(body)
         return true if body.assignment? && command_call?(assigned_value(body))
+        return true if body_disallowed_in_argument?(body)
+        return true if negated_command_call?(body)
 
         body.each_node(:any_block).any? do |block|
           block.keywords? && command_call?(block.send_node)
         end
       end
 
+      def body_disallowed_in_argument?(body)
+        command_body_in_argument?(body) || do_end_block_body_in_command_argument?(body)
+      end
+
+      # `private def foo = bar baz` parses only on Ruby 4.0+, and only as the sole argument.
+      def command_body_in_argument?(body)
+        return false unless command_call?(body)
+
+        call = argument_receiving_call(body.parent)
+        return false if call.nil?
+
+        target_ruby_version < 4.0 || !call.arguments.one?
+      end
+
+      def argument_receiving_call(def_node)
+        call = def_node.parent
+        return unless call&.call_type?
+
+        call if call.arguments.any? { |argument| argument.equal?(def_node) }
+      end
+
+      def do_end_block_body_in_command_argument?(body)
+        call = argument_receiving_call(body.parent)
+        return false if call.nil? || call.parenthesized?
+
+        body.each_node(:any_block).any? do |block|
+          block.keywords? && !block.send_node.lambda_literal?
+        end
+      end
+
       def assigned_value(node)
         while node.assignment? || node.rescue_type?
           node = node.rescue_type? ? node.body : node.children.last
@@ -64,6 +96,10 @@ module RuboCop
 
         node.arguments? && !node.parenthesized? && !node.operator_method? && !node.setter_method?
       end
+
+      def negated_command_call?(node)
+        node.send_type? && node.prefix_bang? && command_call?(node.receiver)
+      end
     end
   end
 end

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

@@ -55,13 +55,21 @@ module RuboCop
       # Common functionality for checking alignment of hash values.
       module ValueAlignment
         def checkable_layout?(node)
-          !node.pairs_on_same_line? && !node.mixed_delimiters? && alignable_values?(node)
+          !node.pairs_on_same_line? && !node.mixed_delimiters? && alignable_values?(node) &&
+            !pair_after_kwsplat_on_same_line?(node)
         end
 
+        # With several enforced styles, deltas are computed even for a hash this style
+        # can't check. A pair that doesn't begin its line can't be moved without
+        # deleting whatever precedes it, so it's left alone.
         def deltas(first_pair, current_pair)
+          return {} unless current_pair.equal?(first_pair) ||
+                           Util.begins_its_line?(current_pair.source_range)
+
           key_delta = key_delta(first_pair, current_pair)
-          separator_delta = separator_delta(first_pair, current_pair, key_delta)
-          value_delta = value_delta(first_pair, current_pair) - key_delta - separator_delta
+          shift = separator_shift(current_pair, key_delta)
+          separator_delta = separator_delta(first_pair, current_pair, shift)
+          value_delta = value_delta(first_pair, current_pair) - shift - separator_delta
 
           { key: key_delta, separator: separator_delta, value: value_delta }
         end
@@ -78,9 +86,22 @@ module RuboCop
           pair.value && pair.key.last_line != pair.value.first_line
         end
 
-        def separator_delta(first_pair, current_pair, key_delta)
+        def pair_after_kwsplat_on_same_line?(node)
+          first_pair = node.pairs.first
+
+          node.children.each_cons(2).any? do |previous, current|
+            current.pair_type? && !current.equal?(first_pair) &&
+              previous.last_line == current.first_line
+          end
+        end
+
+        def separator_shift(current_pair, key_delta)
+          current_pair.key.multiline? ? 0 : key_delta
+        end
+
+        def separator_delta(first_pair, current_pair, shift)
           if current_pair.hash_rocket?
-            hash_rocket_delta(first_pair, current_pair) - key_delta
+            hash_rocket_delta(first_pair, current_pair) - shift
           else
             0
           end

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

@@ -7,6 +7,8 @@ module RuboCop
       include LineLengthHelp
       include AllowedPattern
 
+      SPACE_INSIDE_PARENS_STYLES = %w[space compact].freeze
+
       private
 
       def single_line_as_modifier?(node)
@@ -42,7 +44,10 @@ module RuboCop
       def modifier_fits_on_single_line?(node)
         return true unless max_line_length
 
-        line_length(line_in_modifier_form(node)) <= max_line_length
+        length = line_length(line_in_modifier_form(node))
+        length += 2 if parenthesize?(node) && space_inside_parens?
+
+        length <= max_line_length
       end
 
       def line_in_modifier_form(node)
@@ -52,6 +57,14 @@ module RuboCop
         "#{code_before}#{to_modifier_form(node)}#{code_after(node)}"
       end
 
+      def space_inside_parens?
+        return false unless config.cop_enabled?('Layout/SpaceInsideParens')
+
+        style = config.for_cop('Layout/SpaceInsideParens')['EnforcedStyle']
+
+        SPACE_INSIDE_PARENS_STYLES.include?(style)
+      end
+
       # Whether an existing line is acceptable to `Layout/LineLength`,
       # exemptions (the cop disabled at that line, an allowed pattern, an
       # allowed cop directive, an allowed URI) included. Only for judging
@@ -98,7 +111,7 @@ module RuboCop
 
       # rubocop:disable-next Metrics/AbcSize
       def if_body_source(if_body)
-        if if_body.call_type? && !if_body.method?(:[]=) && omitted_value_in_last_hash_arg?(if_body)
+        if unparenthesized_call_with_omitted_value?(if_body)
           "#{method_source(if_body)}(#{if_body.arguments.map(&:source).join(', ')})"
         elsif (value = wrapped_value(if_body))
           prefix = if_body.source_range.begin.join(value.source_range.begin).source
@@ -110,7 +123,8 @@ module RuboCop
         end
       end
 
-      def omitted_value_in_last_hash_arg?(if_body)
+      def unparenthesized_call_with_omitted_value?(if_body)
+        return false if !if_body.call_type? || if_body.method?(:[]=) || if_body.parenthesized?
         return false unless (last_argument = if_body.last_argument)
 
         last_argument.hash_type? && last_argument.pairs.last&.value_omission?

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

@@ -163,7 +163,7 @@ module RuboCop
 
       def put_comma(items, kind)
         last_item = items.last
-        return if last_item.block_pass_type?
+        return if last_item.type?(:block_pass, :forwarded_args)
 
         range = autocorrect_range(last_item)
         msg = format(MSG, command: 'Put a', unit: format(kind, article: 'a multiline'))

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

@@ -63,9 +63,10 @@ module RuboCop
         (send nil? VISIBILITY_SCOPES def)
       PATTERN
 
+      # A modifier applies to every symbol it is given, not only to a sole argument.
       # @!method visibility_inline_on_method_name?(node, method_name:)
       def_node_matcher :visibility_inline_on_method_name?, <<~PATTERN
-        (send nil? VISIBILITY_SCOPES (sym %method_name))
+        (send nil? VISIBILITY_SCOPES <(sym %method_name) ...>)
       PATTERN
     end
   end

data/lib/rubocop/cop/naming/rescued_exceptions_variable_name.rb

@@ -128,7 +128,7 @@ module RuboCop
             if child_node.lvar_type?
               parent_node = child_node.parent
               if parent_node.respond_to?(:value_omission?) && parent_node.value_omission?
-                corrector.insert_after(parent_node.loc.operator, " #{preferred_name}")
+                corrector.replace(parent_node.loc.operator, ": #{preferred_name}")
               else
                 corrector.replace(child_node, preferred_name)
               end

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

@@ -132,10 +132,11 @@ module RuboCop
       #     private alias_method :qux, :foo
       #
       #   end
-      class AccessModifierDeclarations < Base
+      class AccessModifierDeclarations < Base # rubocop:disable Metrics/ClassLength
         extend AutoCorrector
 
         include ConfigurableEnforcedStyle
+        include EndlessMethodBodyHelp
         include RangeHelp
 
         GROUP_STYLE_MESSAGE = [
@@ -169,6 +170,10 @@ module RuboCop
             (send nil? :alias_method _ _))
         PATTERN
 
+        def self.autocorrect_incompatible_with
+          [Style::EndlessMethod, Style::SingleLineMethods]
+        end
+
         def on_send(node)
           return if allowed?(node)
 
@@ -248,10 +253,33 @@ module RuboCop
 
             access_modifier_is_inlined?(node) && !right_siblings_same_inline_method?(node)
           else
-            access_modifier_is_not_inlined?(node) && select_grouped_def_nodes(node).any?
+            access_modifier_is_not_inlined?(node) && inlinable?(select_grouped_def_nodes(node))
           end
         end
 
+        def inlinable?(def_nodes)
+          return false if def_nodes.empty?
+
+          def_nodes.none? { |def_node| def_node.endless? && body_unsafe_to_inline?(def_node.body) }
+        end
+
+        def body_unsafe_to_inline?(body)
+          return true if body.each_node(:any_block).any? { |block| do_end_block?(block) }
+
+          target_ruby_version < 4.0 && command_body?(body)
+        end
+
+        def do_end_block?(block)
+          block.keywords? && !block.send_node.lambda_literal?
+        end
+
+        def command_body?(body)
+          body = body.body while body.rescue_type?
+          return true if body.send_type? && body.prefix_not? && !body.parenthesized?
+
+          command_call?(body)
+        end
+
         def correctable_group_offense?(node)
           return false unless group_style?
           return false if allowed?(node)