rubocop 1.91.0 → 1.92.0

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

@@ -98,6 +98,8 @@ module RuboCop
             end
           elsif node.condition.falsey_literal?
             add_offense(node.condition) do |corrector|
+              next if orphans_loop_control_keyword?(node)
+
               corrector.replace(node, node.body.child_nodes.map(&:source).join("\n"))
             end
           end
@@ -127,6 +129,8 @@ module RuboCop
             end
           elsif node.condition.truthy_literal?
             add_offense(node.condition) do |corrector|
+              next if orphans_loop_control_keyword?(node)
+
               corrector.replace(node, node.body.child_nodes.map(&:source).join("\n"))
             end
           end
@@ -175,6 +179,15 @@ module RuboCop
 
         private
 
+        # Unwrapping the body of a loop that runs once would leave a `break`,
+        # `next` or `redo` that belongs to it outside of any loop.
+        def orphans_loop_control_keyword?(node)
+          node.body.each_node(:next, :break, :redo).any? do |control|
+            inner = control.each_ancestor.take_while { |ancestor| !ancestor.equal?(node) }
+            inner.none? { |ancestor| ancestor.any_block_type? || ancestor.loop_keyword? }
+          end
+        end
+
         def void_value_expression?(node)
           node = node.children.last while node&.begin_type?
 
@@ -273,6 +286,8 @@ module RuboCop
                        "#{node.else_branch.source.sub('elsif', 'if')}\nend"
                      elsif node.else? || node.ternary?
                        node.else_branch.source
+                     elsif node.value_used?
+                       'nil'
                      else
                        '' # Equivalent to removing the node
                      end

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

@@ -24,30 +24,16 @@ module RuboCop
         MSG = 'Literal interpolation detected.'
         COMPOSITE = %i[array hash pair irange erange].freeze
 
-        # rubocop:disable-next Metrics/AbcSize
         def on_interpolation(begin_node)
           final_node = begin_node.children.last
           return unless offending?(final_node)
-
-          # %W and %I split the content into words before expansion
-          # treating each interpolation as a word component, so
-          # interpolation should not be removed if the expanded value
-          # contains a space character.
-          expanded_value = autocorrected_value(final_node)
-          expanded_value = handle_special_regexp_chars(begin_node, expanded_value)
-
-          return if in_array_percent_literal?(begin_node) && /\s|\A\z/.match?(expanded_value)
+          return unless (expanded_value = correctable_value(begin_node, final_node))
 
           add_offense(final_node) do |corrector|
             next if final_node.dstr_type? # nested, fixed in next iteration
+            next if follows_literal_interpolation?(begin_node)
 
-            replacement = if final_node.str_type? && !final_node.value.valid_encoding?
-                            final_node.source.delete_prefix('"').delete_suffix('"')
-                          else
-                            expanded_value
-                          end
-
-            corrector.replace(final_node.parent, replacement)
+            corrector.replace(final_node.parent, replacement(final_node, expanded_value))
           end
         end
 
@@ -73,6 +59,22 @@ module RuboCop
           node.array_type? && grandparent.regexp_type?
         end
 
+        def correctable_value(begin_node, final_node)
+          value = autocorrected_value(final_node)
+          value = handle_special_regexp_chars(begin_node, value)
+          return if starts_interpolation_after_hash_sign?(begin_node, value)
+
+          value = escape_trailing_hash_sign(begin_node, value)
+
+          # %W and %I split the content into words before expansion
+          # treating each interpolation as a word component, so
+          # interpolation should not be removed if the expanded value
+          # contains a space character.
+          return if in_array_percent_literal?(begin_node) && /\s|\A\z/.match?(value)
+
+          value
+        end
+
         # rubocop:disable-next Metrics/MethodLength, Metrics/CyclomaticComplexity
         def autocorrected_value(node)
           case node.type
@@ -116,6 +118,17 @@ module RuboCop
           end
         end
 
+        def starts_interpolation_after_hash_sign?(begin_node, value)
+          source = processed_source.buffer.source
+          range = begin_node.source_range
+          # Removing an empty value puts the `#` right before what follows the interpolation.
+          following = "#{value}#{source[range.end_pos]}"
+          return false unless following.start_with?('{', '@', '$')
+          return false unless source[range.begin_pos - 1] == '#'
+
+          unescaped_hash_sign?(source[0...range.begin_pos])
+        end
+
         def autocorrected_value_for_string(node)
           return node.source.delete_prefix('"').delete_suffix('"') unless node.value.valid_encoding?
 
@@ -180,7 +193,9 @@ module RuboCop
         end
 
         def space_literal?(node)
-          node.str_type? && node.value.valid_encoding? && node.value.blank?
+          # `String#blank?` misses Unicode spaces such as U+3000 that
+          # `Layout/TrailingWhitespace` treats as trailing whitespace.
+          node.str_type? && node.value.valid_encoding? && node.value.match?(/\A[[:space:]]*\z/)
         end
 
         def ends_heredoc_line?(node)
@@ -188,7 +203,8 @@ module RuboCop
           return false unless grandparent&.dstr_type? && grandparent.heredoc?
 
           line = processed_source.lines[node.last_line - 1]
-          line.size == node.loc.last_column + 1
+
+          line.size == node.parent.source_range.last_column
         end
 
         def in_array_percent_literal?(node)
@@ -198,6 +214,34 @@ module RuboCop
           grandparent = parent.parent
           grandparent&.array_type? && grandparent.percent_literal?
         end
+
+        def escape_trailing_hash_sign(begin_node, value)
+          following = processed_source.buffer.source[begin_node.source_range.end_pos]
+          return value unless %w[{ @ $].include?(following) && unescaped_hash_sign?(value)
+
+          "#{value.delete_suffix('#')}\\#"
+        end
+
+        def unescaped_hash_sign?(text)
+          text.end_with?('#') && text.delete_suffix('#')[/\\*\z/].length.even?
+        end
+
+        # Each interpolation is checked against the original source, so correcting it in the
+        # same pass as a preceding one that leaves a `#` (or nothing) could join that `#` and
+        # a `{` from this one. It's left for the next iteration instead.
+        def follows_literal_interpolation?(begin_node)
+          previous = begin_node.left_sibling
+          return false unless previous&.begin_type? && offending?(previous.children.last)
+
+          value = correctable_value(previous, previous.children.last)
+          value && (value.empty? || value.end_with?('#'))
+        end
+
+        def replacement(node, expanded_value)
+          return expanded_value unless node.str_type? && !node.value.valid_encoding?
+
+          node.source.delete_prefix('"').delete_suffix('"')
+        end
       end
     end
   end

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

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)

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

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

@@ -212,16 +212,23 @@ module RuboCop
         end
 
         def remove_local_variable_assignment_part(corrector, node)
-          corrector.remove(node.loc.name.begin.join(node.expression.source_range.begin))
-        end
-
-        def variable_in_loop_condition?(assignment_node, variable)
-          return false if assignment_node.each_ancestor(:any_def).any?
+          expression = node.expression
+          assignment_part = node.loc.name.begin.join(expression.source_range.begin)
 
-          loop_node = assignment_node.each_ancestor.find do |ancestor|
-            ancestor.type?(*VariableForce::LOOP_TYPES)
+          # `x = 1, 2` cannot become `1, 2`, so the values become an array literal.
+          if expression.array_type? && !expression.bracketed?
+            corrector.replace(assignment_part, '[')
+            corrector.insert_after(expression, ']')
+          else
+            corrector.remove(assignment_part)
           end
+        end
 
+        def variable_in_loop_condition?(assignment_node, variable)
+          # A method defined inside the loop has its own scope, so the loop condition
+          # can only read the variable if the loop is nearer than any method definition.
+          loop_node = assignment_node.each_ancestor(*VariableForce::LOOP_TYPES, :any_def).first
+          return false if !loop_node || loop_node.any_def_type?
           return false unless loop_node.respond_to?(:condition)
 
           condition_node = loop_node.condition

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

@@ -271,7 +271,14 @@ module RuboCop
           return if node.parent.type?(:if, :case, :when, :case_match, :in_pattern)
           return if (def_node = node.each_ancestor(:any_def).first) && def_node.assignment_method?
 
-          corrector.remove(range_with_surrounding_space(range: node.source_range, side: :left))
+          range = range_with_surrounding_space(range: void_expression_range(node), side: :left)
+          corrector.remove(range)
+        end
+
+        def void_expression_range(node)
+          return node.source_range unless node.respond_to?(:heredoc?) && node.heredoc?
+
+          node.source_range.join(node.loc.heredoc_end)
         end
 
         def autocorrect_nonmutating_send(corrector, node, suggestion)

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

@@ -40,6 +40,8 @@ module RuboCop
       class ClassLength < Base
         include CodeLength
 
+        LABEL = 'Class'
+
         def on_class(node)
           check_code_length(node)
         end
@@ -60,8 +62,8 @@ module RuboCop
 
         private
 
-        def message(length, max_length)
-          format('Class has too many lines. [%<length>d/%<max>d]', length: length, max: max_length)
+        def cop_label
+          LABEL
         end
 
         def find_expression_within_parent(parent)

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

@@ -48,10 +48,6 @@ module RuboCop
 
           1
         end
-
-        def count_block?(block)
-          KNOWN_ITERATING_METHODS.include? block.method_name
-        end
       end
     end
   end

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

@@ -38,6 +38,8 @@ module RuboCop
       class ModuleLength < Base
         include CodeLength
 
+        LABEL = 'Module'
+
         def on_module(node)
           check_code_length(node)
         end
@@ -53,8 +55,8 @@ module RuboCop
           (casgn nil? _ (any_block (send (const {nil? cbase} :Module) :new) ...))
         PATTERN
 
-        def message(length, max_length)
-          format('Module has too many lines. [%<length>d/%<max>d]', length: length, max: max_length)
+        def cop_label
+          LABEL
         end
       end
     end

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

@@ -15,6 +15,10 @@ module RuboCop
         cop_config['IndentationWidth'] || config.for_cop('Layout/IndentationWidth')['Width'] || 2
       end
 
+      def using_tabs?
+        config.for_cop('Layout/IndentationStyle')['EnforcedStyle'] == 'tabs'
+      end
+
       def indentation(node)
         offset(node) + (SPACE * configured_indentation_width)
       end