rubocop 1.91.0 → 1.92.2

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

@@ -42,6 +42,8 @@ module RuboCop
       #     break if some_condition
       #   end
       class Loop < Base
+        include Alignment
+        include RangeHelp
         extend AutoCorrector
 
         MSG = 'Use `Kernel#loop` with `break` rather than `begin/end/until`(or `while`).'
@@ -62,7 +64,8 @@ module RuboCop
           add_offense(node.loc.keyword) do |corrector|
             corrector.replace(body.loc.begin, 'loop do')
             corrector.remove(keyword_and_condition_range(node))
-            corrector.insert_before(body.loc.end, build_break_line(node))
+
+            insert_break_line(corrector, node, body)
           end
         end
 
@@ -70,9 +73,28 @@ module RuboCop
           node.body.loc.end.end.join(node.source_range.end)
         end
 
+        def insert_break_line(corrector, node, body)
+          if body.single_line?
+            corrector.replace(space_before_end(body), build_break_line(node))
+          else
+            corrector.insert_before(body.loc.end, build_break_line(node))
+          end
+        end
+
+        def space_before_end(body)
+          range = range_with_surrounding_space(range: body.loc.end, side: :left, newlines: false)
+
+          range.with(end_pos: body.loc.end.begin_pos)
+        end
+
         def build_break_line(node)
           conditional_keyword = node.while_post_type? ? 'unless' : 'if'
-          "break #{conditional_keyword} #{node.condition.source}\n#{indent(node)}"
+          break_line = "break #{conditional_keyword} #{node.condition.source}\n#{indent(node)}"
+          return break_line unless node.body.single_line?
+
+          # A single-line `begin ... end` keeps its body and `end` on one line,
+          # so the `break` has to start a line of its own.
+          "\n#{indent(node, offset: configured_indentation_width)}#{break_line}"
         end
       end
     end

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

@@ -116,31 +116,88 @@ module RuboCop
         end
 
         def first_code_token
-          @first_code_token ||= processed_source.sorted_tokens.find { |token| !token.comment? }
+          processed_source.sorted_tokens.find { |token| !token.comment? }
         end
 
         def check_encoding_comment(comment)
+          return unless misplaced_encoding_position?(comment)
+
+          add_offense(comment, message: MSG_ENCODING) do |corrector|
+            correct_encoding_comment(corrector, comment)
+          end
+        end
+
+        def misplaced_encoding_position?(comment)
           line = comment.source_range.line
-          return if line == effective_encoding_line && comment_starts_line?(comment)
+          return false if line == effective_encoding_line && comment_starts_line?(comment)
+
           # Leave `# frozen_string_literal: true` + `# encoding: x` runs at the
           # very top to Lint/OrderedMagicComments, which already reorders them.
-          return if preceded_only_by_magic_comments?(comment)
+          !preceded_only_by_magic_comments?(comment)
+        end
 
-          add_offense(comment, message: MSG_ENCODING) do |corrector|
+        # With an effective encoding comment already in place, moving another
+        # one in would override it. Drop an identical duplicate and leave a
+        # conflicting one for a human to resolve.
+        def correct_encoding_comment(corrector, comment)
+          effective_comment = effective_encoding_comment
+
+          if effective_comment.nil?
             move_comment(corrector, comment, effective_encoding_line)
+          elsif comment_encoding(effective_comment) == comment_encoding(comment)
+            corrector.remove(comment_removal_range(comment))
           end
         end
 
+        def comment_encoding(comment)
+          Encoding.find(MagicComment.parse(comment.text).encoding)
+        rescue ArgumentError
+          nil
+        end
+
         def check_top_block_comment(comment, directive)
           return unless first_code_token
           return unless comment.source_range.begin_pos > first_code_token.begin_pos
 
           message = format(MSG_AFTER_CODE, directive: directive)
           add_offense(comment, message: message) do |corrector|
-            move_comment(corrector, comment, effective_encoding_line)
+            # Both would be inserted at the top, in no reliable order. Leave
+            # this one to the next pass, once the encoding comment is in place.
+            next if encoding_comment_moving_in?
+
+            move_comment(corrector, comment, top_block_insertion_line)
           end
         end
 
+        def encoding_comment_moving_in?
+          return false if effective_encoding_comment
+
+          processed_source.comments.any? do |comment|
+            known_encoding_comment?(comment) && misplaced_encoding_position?(comment)
+          end
+        end
+
+        def effective_encoding_comment
+          processed_source.comments.find do |comment|
+            comment.source_range.line == effective_encoding_line &&
+              comment_starts_line?(comment) &&
+              MagicComment.parse(comment.text).encoding_specified?
+          end
+        end
+
+        def known_encoding_comment?(comment)
+          return false unless magic_comment_shaped?(comment.text)
+
+          magic_comment = MagicComment.parse(comment.text)
+          magic_comment.encoding_specified? && known_encoding?(magic_comment.encoding)
+        end
+
+        # Insert below an effective encoding comment rather than above it,
+        # which would push it off the only lines where Ruby honors it.
+        def top_block_insertion_line
+          effective_encoding_comment ? effective_encoding_line + 1 : effective_encoding_line
+        end
+
         def check_magic_comment_above_shebang
           shebang_comment = processed_source.comments.find do |comment|
             comment.source_range.line > 1 && comment.text.start_with?('#!') &&
@@ -166,12 +223,7 @@ module RuboCop
         end
 
         def move_comment(corrector, comment, target_line)
-          removal_range = if comment_starts_line?(comment)
-                            range_by_whole_lines(comment.source_range, include_final_newline: true)
-                          else
-                            range_with_surrounding_space(comment.source_range, side: :left)
-                          end
-          corrector.remove(removal_range)
+          corrector.remove(comment_removal_range(comment))
           target_range = processed_source.buffer.line_range(target_line)
           if comment.source_range.line < target_line
             corrector.insert_after(target_range, "\n#{comment.text}")
@@ -179,6 +231,14 @@ module RuboCop
             corrector.insert_before(target_range, "#{comment.text}\n")
           end
         end
+
+        def comment_removal_range(comment)
+          if comment_starts_line?(comment)
+            range_by_whole_lines(comment.source_range, include_final_newline: true)
+          else
+            range_with_surrounding_space(comment.source_range, side: :left)
+          end
+        end
       end
     end
   end

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

@@ -62,7 +62,7 @@ module RuboCop
           each_missing_enable do |cop, line_range|
             next if acceptable_range?(cop, line_range)
 
-            comment = processed_source.comment_at_line(line_range.begin)
+            comment = opening_comment(line_range)
 
             add_offense(comment, message: message(cop, comment))
           end
@@ -73,14 +73,29 @@ module RuboCop
         def each_missing_enable
           processed_source.disabled_line_ranges.each do |cop, line_ranges|
             line_ranges.each do |line_range|
-              # A `disable-next` scope closes itself with its statement.
-              next if line_range.respond_to?(:directive) && line_range.directive.disable_next?
+              # A `disable-next` or `next` scope closes itself with its statement.
+              next if statement_scoped?(line_range)
 
               yield cop, line_range
             end
           end
         end
 
+        def statement_scoped?(line_range)
+          directive = line_range.respond_to?(:directive) && line_range.directive
+          directive && (directive.disable_next? || directive.next?)
+        end
+
+        # A disable suspended by `enable-next` or `next +Cop` reopens below the
+        # statement, on a code line, so the comment that opened it has to come
+        # from the range rather than from its first line.
+        def opening_comment(line_range)
+          directive = line_range.respond_to?(:directive) && line_range.directive
+          return directive.comment if directive
+
+          processed_source.comment_at_line(line_range.begin)
+        end
+
         def acceptable_range?(cop, line_range)
           # This has to remain a strict inequality to handle
           # the case when max_range is Float::INFINITY

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

@@ -40,6 +40,7 @@ module RuboCop
         # NestedPercentLiteral violation to be emitted.
         PERCENT_LITERAL_TYPES = PreferredDelimiters::PERCENT_LITERAL_TYPES
         REGEXES = PERCENT_LITERAL_TYPES.map { |percent_literal| /\A#{percent_literal}\W/ }.freeze
+        FORMAT_SEQUENCE = /\A#{RuboCop::Cop::Utils::FormatString::SEQUENCE}\z/.freeze
 
         def on_array(node)
           process(node, *PERCENT_LITERAL_TYPES)
@@ -54,6 +55,8 @@ module RuboCop
         def contains_percent_literals?(node)
           node.each_child_node.any? do |child|
             literal = child.children.first.to_s.scrub
+            next false if literal.match?(FORMAT_SEQUENCE)
+
             REGEXES.any? { |regex| literal.match?(regex) }
           end
         end

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

@@ -132,7 +132,7 @@ module RuboCop
 
         def handle_as_symbol(node)
           to_method_symbol(node) do |receiver, sym_node, to_method|
-            next if receiver.nil? || !node.arguments.one?
+            next if receiver.nil? || !node.arguments.one? || node.operator_method?
 
             message = format(
               MSG,
@@ -140,6 +140,8 @@ module RuboCop
               corrected_method: correct_sym_method(to_method)
             )
             add_offense(node, message: message) do |corrector|
+              next if part_of_ignored_node?(node)
+
               remove_parentheses(corrector, node) if node.parenthesized?
 
               corrector.replace(sym_node, correct_sym_method(to_method))

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

@@ -57,7 +57,7 @@ module RuboCop
           node = node.children.first while node&.begin_type? && node.children.one?
           return false unless node
 
-          keyword_operator?(node) || modifier_expression?(node)
+          keyword_operator?(node) || modifier_expression?(node) || command_call_operand?(node)
         end
 
         def keyword_operator?(node)
@@ -69,6 +69,27 @@ module RuboCop
           node.type?(:if, :while, :until) && node.modifier_form?
         end
 
+        def command_call_operand?(node)
+          if node.assignment? || (node.call_type? && node.assignment_method?)
+            command_call_value?(node.children.last)
+          elsif node.send_type? && node.prefix_bang?
+            command_call_value?(node.receiver)
+          else
+            false
+          end
+        end
+
+        def command_call_value?(node)
+          command_call?(node) || command_call_operand?(node)
+        end
+
+        def command_call?(node)
+          node = node.send_node if node.any_block_type?
+          return false unless node.type?(:call, :super, :yield)
+
+          node.arguments? && !node.parenthesized? && !node.operator_method?
+        end
+
         def chained_calls?(node)
           first_argument = node.first_argument
           first_argument.call_type? && (node.children.last&.children&.count || 0) > 1

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

@@ -110,7 +110,7 @@ module RuboCop
             # A pending cop that is not enabled in this run produces no
             # offenses, so its directives cannot be judged - they typically
             # prepare the code for the moment the cop gets enabled.
-            next if pending_cop_not_run?(cop)
+            next if pending_cop_not_run?(cop) || disabled_by_preview?(cop)
 
             each_already_disabled(cop, line_ranges, &block)
             each_line_range(cop, line_ranges, &block)
@@ -128,6 +128,17 @@ module RuboCop
             !processed_source.registry.enabled_pending_cop?(cop_cfg, config, cop)
         end
 
+        # A cop that only the `Preview` defaults disable runs again as soon as
+        # preview is turned off, so its directives are still needed.
+        def disabled_by_preview?(cop)
+          return false unless preview? && all_cop_names.include?(cop)
+
+          preview_defaults = ConfigLoader.default_configuration[cop]&.fetch('Preview', nil)
+          return false unless preview_defaults.is_a?(Hash) && preview_defaults['Enabled'] == false
+
+          !config.cop_enabled?(cop)
+        end
+
         def each_line_range(cop, line_ranges)
           line_ranges.each_with_index do |line_range, line_range_index|
             next if should_skip_line_range?(cop, line_range)
@@ -135,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
@@ -180,16 +191,35 @@ 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
         def each_already_disabled(cop, line_ranges)
           line_ranges.each_cons(2) do |previous_range, range|

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

@@ -28,6 +28,7 @@ module RuboCop
       #   end
       #
       class RedundantDirGlobSort < Base
+        include RangeHelp
         extend AutoCorrector
         extend TargetRubyVersion
 
@@ -46,8 +47,7 @@ module RuboCop
           selector = node.loc.selector
 
           add_offense(selector) do |corrector|
-            corrector.remove(selector)
-            corrector.remove(node.loc.dot)
+            autocorrect(corrector, node.loc.dot, selector)
           end
         end
 
@@ -67,6 +67,17 @@ module RuboCop
         def sort_with_comparator?(node)
           node.parent&.any_block_type? || node.last_argument&.block_pass_type?
         end
+
+        def autocorrect(corrector, dot, selector)
+          range = dot.join(selector)
+
+          if processed_source.contains_comment?(range)
+            corrector.remove(dot)
+            corrector.remove(selector)
+          else
+            corrector.remove(range_with_surrounding_space(range, side: :left))
+          end
+        end
       end
     end
   end

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/unescaped_bracket_in_regexp.rb

@@ -53,12 +53,22 @@ module RuboCop
           return if node.each_descendant(:dstr).any?
 
           regexp_constructor(node) do |text|
+            next unless verbatim_string?(text)
+
             detect_offenses_in_tree(text, parse_regexp(text.value))
           end
         end
 
         private
 
+        # Offsets into the string's value only point at the right place in the source
+        # when the string has no escape sequences, so anything else is left alone.
+        def verbatim_string?(node)
+          return false unless node.loc?(:begin) && node.loc?(:end)
+
+          node.loc.begin.end.join(node.loc.end.begin).source == node.value
+        end
+
         # When a character class opens with a bare `]` (e.g. `[^]]`), `regexp_parser` parses
         # `[^]` / `[]` as an empty set and reports the closing `]` as a separate literal.
         # Ruby treats that `]` as the end of the class, not as an unescaped bracket,
@@ -97,7 +107,7 @@ module RuboCop
             location = range_at_index(node, expr.ts, pos)
 
             add_offense(location) do |corrector|
-              corrector.replace(location, '\]')
+              corrector.replace(location, escaped_bracket(node))
             end
           end
 
@@ -108,6 +118,13 @@ module RuboCop
           adjustment = index + offset
           node.loc.begin.end.adjust(begin_pos: adjustment, end_pos: adjustment + 1)
         end
+
+        # A double-quoted string turns `\]` into `]`, so its backslash needs escaping too.
+        def escaped_bracket(node)
+          return '\]' if node.regexp_type? || node.single_quoted? || node.percent_literal?(:q)
+
+          '\\\\]'
+        end
       end
     end
   end