rubocop 1.92.1 → 1.92.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0f289b93d86b59bdf80728f8130f7daeb1b6b6f940d6144cc425b627efe00061
-  data.tar.gz: c87922f68ef6b6fb2d1cdf8ac29998908f6be8f7d39d8ed14b7a0772d33a6b69
+  metadata.gz: 2e582386de45680cecfa5173359f6ccb24894b2440ef9d6fec5ec5c0d28d0b41
+  data.tar.gz: ef3bdbb7e39a1960f5e1feb41df80f7afef2f35148a44693566f725b99715a3a
 SHA512:
-  metadata.gz: cc6d21f74027a289aa14bf41cacbf840a0d156c93a33fa3526ee75607cb6d85ca3a6e219f4117c4d70462ef80fd8ae81d62ffd74cc8451c89c67754c4c719c87
-  data.tar.gz: 8a0a4af9e4cbba6b0c242461cacba0ef1fe5ba6049e5d5814eeac5db118f73a18142927ea33ea43a9ffd7b751f340893abd861eeb7fcc502506897d09c74e860
+  metadata.gz: dff3c8ee84b5334d4aabb751f7de89b2cf2b87d65ad7970913132f558909d80da6306f60707f0ba1001d826a22c3491d9ab716c82defb20bb10216654cf75902
+  data.tar.gz: 6c6913ed8f1d4f30ee0044df54c2c370aa59b2f1f91de340f33295af795fcd56138b75583c37049c3fd117ffd51241600bd24e0c5e82d41b58304821a8170a25

data/lib/rubocop/config.rb

@@ -56,10 +56,6 @@ module RuboCop
             deprecated_config = @for_cop[deprecated_cop_name]
             next if deprecated_config.empty?
 
-            warn Rainbow(<<~WARNING).yellow
-              Warning: Using `#{deprecated_cop_name}` configuration in #{loaded_path} for `#{cop}`.
-            WARNING
-
             cop_options.merge!(@for_cop[deprecated_cop_name])
           end
         end

data/lib/rubocop/config_obsoletion.rb

@@ -76,6 +76,15 @@ module RuboCop
       raise ValidationError, messages.join("\n")
     end
 
+    # Messages for every violated rule, regardless of severity, without raising.
+    # Used for configuration the user does not own (a plugin's defaults), where an
+    # obsolete key should be reported but must not stop the run. Extracted cops are
+    # left out: whether their gem is loaded is only known once every plugin has been
+    # integrated, and this is called while plugins are still loading.
+    def messages
+      rules.grep_v(ExtractedCop).select(&:violated?).map(&:message)
+    end
+
     def legacy_cop_names
       # Used by DepartmentName#qualified_legacy_cop_name
       cop_rules.map(&:old_name)

data/lib/rubocop/cop/correctors/empty_line_corrector.rb

@@ -12,7 +12,7 @@ module RuboCop
           when :no_empty_lines
             corrector.remove(range)
           when :empty_lines
-            corrector.insert_before(range.begin, "\n")
+            corrector.replace(range.begin.adjust(begin_pos: -1), "\n\n")
           end
         end
 

data/lib/rubocop/cop/layout/empty_lines_after_module_inclusion.rb

@@ -91,7 +91,7 @@ module RuboCop
         end
 
         def next_line_node(node)
-          return if node.parent.type?(:if, :rescue, :ensure)
+          return if node.parent.type?(:if, :rescue, :ensure, :and, :or)
 
           node.right_sibling
         end

data/lib/rubocop/cop/layout/end_alignment.rb

@@ -80,10 +80,6 @@ module RuboCop
         include RangeHelp
         extend AutoCorrector
 
-        def on_class(node)
-          check_other_alignment(node)
-        end
-
         def on_sclass(node)
           if node.parent&.assignment?
             check_asgn_alignment(node.parent, node)
@@ -91,10 +87,8 @@ module RuboCop
             check_other_alignment(node)
           end
         end
-
-        def on_module(node)
-          check_other_alignment(node)
-        end
+        alias on_class on_sclass
+        alias on_module on_sclass
 
         def on_if(node)
           check_other_alignment(node) unless node.ternary?

data/lib/rubocop/cop/layout/extra_spacing.rb

@@ -30,6 +30,7 @@ module RuboCop
       #   some_object.method(arg)    # this is some comment
       class ExtraSpacing < Base
         extend AutoCorrector
+        include LineLengthHelp
         include PrecedingFollowingAlignment
         include RangeHelp
 
@@ -77,9 +78,14 @@ module RuboCop
         def check_assignment(token)
           return unless aligned_with_preceding_equals_operator(token) == :no
 
+          tokens, align_to = equal_sign_alignment(token.line)
+          return if exceeds_max_line_length?(tokens, align_to)
+
           message = format(MSG_UNALIGNED_ASGN, location: 'preceding')
           add_offense(token.pos, message: message) do |corrector|
-            align_equal_signs(token.pos, corrector)
+            tokens.each do |asgn_token|
+              align_equal_sign(corrector, asgn_token, align_to)
+            end
           end
         end
 
@@ -240,14 +246,19 @@ module RuboCop
           cop_config['ForceEqualSignAlignment']
         end
 
-        def align_equal_signs(range, corrector)
-          lines  = all_relevant_assignment_lines(range.line)
+        def equal_sign_alignment(line_number)
+          lines  = all_relevant_assignment_lines(line_number)
           tokens = assignment_tokens.select { |t| lines.include?(t.line) }
 
-          columns  = tokens.map { |t| align_column(t) }
-          align_to = columns.max
+          [tokens, tokens.map { |t| align_column(t) }.max]
+        end
 
-          tokens.each { |token| align_equal_sign(corrector, token, align_to) }
+        def exceeds_max_line_length?(tokens, align_to)
+          max_line_length && tokens.any? do |token|
+            padding = align_to - token.pos.last_column
+
+            padding.positive? && line_length(token.pos.source_line) + padding > max_line_length
+          end
         end
 
         def align_equal_sign(corrector, token, align_to)

data/lib/rubocop/cop/layout/line_length.rb

@@ -125,6 +125,7 @@ module RuboCop
           @breakable_strings = {}
           @endless_methods_by_line = {}
           @heredocs = nil
+          @heredoc_openers = nil
 
           return unless processed_source.raw_source.include?(';')
 
@@ -214,11 +215,24 @@ module RuboCop
           range = breakable_node.source_range
 
           existing = breakable_range_by_line_index[line_index]
-          return if existing
+          return if existing || after_heredoc_opener?(range)
 
           breakable_range_by_line_index[line_index] = range
         end
 
+        def after_heredoc_opener?(range)
+          heredoc_openers.any? do |opener|
+            opener.line == range.line && opener.begin_pos < range.begin_pos
+          end
+        end
+
+        def heredoc_openers
+          ast = processed_source.ast
+          return [] if ast.nil?
+
+          @heredoc_openers ||= ast.each_node(:any_str).select(&:heredoc?).map(&:source_range)
+        end
+
         def compact_nested_array_break?(node, breakable_node)
           return false if !node.array_type? || !node.square_brackets?
           return false unless breakable_node.equal?(node.children.first)
@@ -237,21 +251,24 @@ module RuboCop
           tokens = processed_source.tokens.select { |t| t.type == :tSEMI }
           tokens.reverse_each do |token|
             range = breakable_range_after_semicolon(token)
-            breakable_range_by_line_index[range.line - 1] = range if range
+            next if range.nil? || after_heredoc_opener?(range)
+
+            breakable_range_by_line_index[range.line - 1] = range
           end
         end
 
         def check_for_breakable_block(block_node)
           return unless block_node.single_line?
-          return if receiver_contains_heredoc?(block_node)
 
           line_index = block_node.loc.line - 1
           return if breakable_string_delimiters[line_index]
 
           range = breakable_block_range(block_node)
           pos = range.begin_pos + 1
+          range = range_between(pos, pos + 1)
+          return if after_heredoc_opener?(range)
 
-          breakable_range_by_line_index[line_index] = range_between(pos, pos + 1)
+          breakable_range_by_line_index[line_index] = range
         end
 
         # rubocop:disable-next Metrics/AbcSize
@@ -289,7 +306,8 @@ module RuboCop
             !node.heredoc? &&
             # TODO: strings inside hashes, kwargs and arrays are currently ignored,
             # but could be considered in the future
-            !node.parent&.type?(:pair, :kwoptarg, :array)
+            !node.parent&.type?(:pair, :kwoptarg, :array) &&
+            !after_heredoc_opener?(node.source_range)
         end
 
         def breakable_block_range(block_node)

data/lib/rubocop/cop/layout/rescue_ensure_alignment.rb

@@ -115,7 +115,7 @@ module RuboCop
               node.loc.name
             when :sclass
               node.identifier.source_range
-            when :masgn
+            when :masgn, :op_asgn, :or_asgn, :and_asgn
               node.lhs.source_range
             else
               # It is a wrapper with receiver of object attribute or access modifier.

data/lib/rubocop/cop/layout/single_line_block_chain.rb

@@ -28,7 +28,7 @@ module RuboCop
         # These cops rewrite a method chained to the block in the same pass,
         # which must not start a line of its own.
         def self.autocorrect_incompatible_with
-          [Style::FloatDivision, Style::MapToHash, Style::NilComparison, Style::RedundantSort]
+          [Style::FloatDivision, Style::MapToHash, Style::MapToSet, Style::NilComparison, Style::RedundantSort]
         end
 
         def on_send(node)

data/lib/rubocop/cop/layout/space_around_operators.rb

@@ -245,20 +245,30 @@ module RuboCop
             return if with_space.is?(operator.source)
 
             "Space around operator `#{operator.source}` detected."
-          elsif !/^\s.*\s$/.match?(with_space.source)
+          elsif missing_surrounding_space?(with_space)
             "Surrounding space missing for operator `#{operator.source}`."
-          elsif excess_leading_space?(type, operator, with_space) ||
+          elsif excess_leading_space?(type, operator, with_space, right_operand) ||
                 excess_trailing_space?(right_operand.source_range, with_space)
             "Operator `#{operator.source}` should be surrounded " \
               'by a single space.'
           end
         end
 
-        def excess_leading_space?(type, operator, with_space)
+        def missing_surrounding_space?(with_space)
+          return false if /\A\s.*\s\z/m.match?(with_space.source)
+
+          !with_space.source.start_with?(/\s/) || !line_continuation_after?(with_space)
+        end
+
+        def line_continuation_after?(range)
+          processed_source.buffer.source[range.end_pos, 2] == "\\\n"
+        end
+
+        def excess_leading_space?(type, operator, with_space, right_operand)
           return false unless allow_for_alignment?
           return false unless with_space.source.start_with?(EXCESSIVE_SPACE)
 
-          return !aligned_with_operator?(operator) unless grouped_alignment_type?(type)
+          return !aligned?(type, operator, right_operand) unless grouped_alignment_type?(type)
 
           token            = Token.new(operator, nil, operator.source)
           align_preceding  = aligned_with_preceding_equals_operator(token)
@@ -269,6 +279,23 @@ module RuboCop
           aligned_with_subsequent_equals_operator(token) != :yes
         end
 
+        def aligned?(type, operator, right_operand)
+          return true if aligned_with_operator?(operator)
+
+          type == :pair && aligned_with_another_hash_rocket?(right_operand)
+        end
+
+        def aligned_with_another_hash_rocket?(pair)
+          hash_rocket_columns(pair.parent)[pair.loc.operator.column] > 1
+        end
+
+        def hash_rocket_columns(hash_node)
+          @hash_rocket_columns ||= {}.compare_by_identity
+          @hash_rocket_columns[hash_node] ||= hash_node.pairs.select(&:hash_rocket?).map do |pair|
+            pair.loc.operator.column
+          end.tally
+        end
+
         def grouped_alignment_type?(type)
           type == :assignment || (type == :special_asgn && force_equal_sign_alignment?)
         end

data/lib/rubocop/cop/layout/space_before_block_braces.rb

@@ -136,11 +136,23 @@ module RuboCop
 
         def autocorrect(corrector, range)
           case range.source
+          when /\n/ then remove_line_continuation(corrector, range)
           when /\s/ then corrector.remove(range)
           else           corrector.insert_before(range, ' ')
           end
         end
 
+        # When a heredoc body sits between the `\` and the brace, the newline before
+        # the brace ends the heredoc, and removing it would break the terminator.
+        def remove_line_continuation(corrector, range)
+          source = processed_source.buffer.source
+          return unless source[range.begin_pos - 1] == '\\'
+
+          begin_pos = range.begin_pos
+          begin_pos -= 1 while source[begin_pos - 1].match?(/[ \t\\]/)
+          corrector.remove(range_between(begin_pos, range.end_pos))
+        end
+
         def style_for_empty_braces
           case cop_config['EnforcedStyleForEmptyBraces']
           when 'space'    then :space

data/lib/rubocop/cop/layout/space_inside_block_braces.rb

@@ -83,7 +83,7 @@ module RuboCop
         extend AutoCorrector
 
         def self.autocorrect_incompatible_with
-          [Style::BlockDelimiters]
+          [Layout::BlockAlignment, Style::BlockDelimiters]
         end
 
         def on_block(node)

data/lib/rubocop/cop/layout/space_inside_range_literal.rb

@@ -18,6 +18,7 @@ module RuboCop
       #   # good
       #   'a'..'z'
       class SpaceInsideRangeLiteral < Base
+        include RangeHelp
         extend AutoCorrector
 
         MSG = 'Space inside range literal.'
@@ -33,21 +34,38 @@ module RuboCop
         private
 
         def check(node)
-          expression = node.source
-          op = node.loc.operator.source
-          escaped_op = op.gsub('.', '\.')
-
-          # account for multiline range literals
-          expression.sub!(/#{escaped_op}\n\s*/, op)
-
-          return unless /(\s#{escaped_op})|(#{escaped_op}\s)/.match?(expression)
+          operator = node.loc.operator
+          spaces = [space_before(node, operator), space_after(node, operator)].compact
+          return if spaces.all? { |space| line_break_after_operator?(space, operator) }
 
           add_offense(node) do |corrector|
-            corrector.replace(
-              node, expression.sub(/\s+#{escaped_op}/, op).sub(/#{escaped_op}\s+/, op)
-            )
+            spaces.each do |space|
+              corrector.remove(space)
+            end
           end
         end
+
+        def space_before(node, operator)
+          return unless node.begin
+
+          whitespace_range(node.begin.source_range.end_pos, operator.begin_pos)
+        end
+
+        def space_after(node, operator)
+          return unless node.end
+
+          whitespace_range(operator.end_pos, node.end.source_range.begin_pos)
+        end
+
+        def line_break_after_operator?(space, operator)
+          space.begin_pos == operator.end_pos && space.source.start_with?("\n")
+        end
+
+        def whitespace_range(begin_pos, end_pos)
+          range = range_between(begin_pos, end_pos)
+
+          range if range.source.match?(/\A\s+\z/)
+        end
       end
     end
   end

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

@@ -41,26 +41,22 @@ module RuboCop
 
         private
 
-        # rubocop:disable-next Metrics/CyclomaticComplexity
         def check(node)
           return if node.parent&.regexp_type?
           return unless /(?<!\\)#\{.*\}/.match?(node.source)
           return if heredoc?(node)
-          return unless node.loc.begin && node.loc.end
+          return unless single_quoted?(node)
           return unless valid_syntax?(node)
 
           add_offense(node) { |corrector| autocorrect(corrector, node) }
         end
 
-        def autocorrect(corrector, node)
-          starting_token, ending_token = if node.source.include?('"')
-                                           ['%{', '}']
-                                         else
-                                           ['"', '"']
-                                         end
+        def single_quoted?(node)
+          node.loc.begin&.is?("'") && node.loc.end
+        end
 
-          corrector.replace(node.loc.begin, starting_token)
-          corrector.replace(node.loc.end, ending_token)
+        def autocorrect(corrector, node)
+          corrector.replace(node, interpolated_source(node))
         end
 
         def heredoc?(node)
@@ -68,15 +64,22 @@ module RuboCop
         end
 
         def valid_syntax?(node)
-          double_quoted_string = if node.source.include?('"')
-                                   node.source.sub(/\A'/, '%{').sub(/'\z/, '}')
-                                 else
-                                   node.source.gsub(/\A'|'\z/, '"')
-                                 end
-
-          processed_source = parse(double_quoted_string)
+          processed_source = parse(interpolated_source(node))
           processed_source.valid_syntax? && processed_source.ast.dstr_type?
         end
+
+        def interpolated_source(node)
+          content = node.source[1...-1]
+          return %("#{content}") unless content.include?('"')
+          return "%{#{content}}" unless continued_string_part?(node)
+
+          %("#{content.gsub(/\\.|"/) { |m| m == '"' ? '\"' : m }}")
+        end
+
+        # A percent literal right after another string part is parsed as the `%` operator.
+        def continued_string_part?(node)
+          node.parent&.dstr_type? && node.left_sibling
+        end
       end
     end
   end

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