rubocop 1.71.1 → 1.92.0

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

@@ -3,16 +3,29 @@
 module RuboCop
   module Cop
     module Style
-      # Use a consistent style for named format string tokens.
+      # Use a consistent style for tokens within a format string.
       #
-      # NOTE: `unannotated` style cop only works for strings
-      # which are passed as arguments to those methods:
-      # `printf`, `sprintf`, `format`, `%`.
-      # The reason is that _unannotated_ format is very similar
-      # to encoded URLs or Date/Time formatting strings.
+      # By default, all strings are evaluated. In some cases, this may be undesirable,
+      # as they could be used as arguments to a method that does not consider
+      # them to be tokens, but rather other identifiers or just part of the string.
       #
-      # This cop's allowed methods can be customized with `AllowedMethods`.
-      # By default, there are no allowed methods.
+      # `AllowedMethods` or `AllowedPatterns` can be configured with in order to mark specific
+      # methods as always allowed, thereby avoiding an offense from the cop. By default, there
+      # are no allowed methods.
+      #
+      # Additionally, the cop can be made conservative by configuring it with
+      # `Mode: conservative` (default `aggressive`). In this mode, tokens (regardless
+      # of `EnforcedStyle`) are only considered if used in the format string argument to the
+      # methods `printf`, `sprintf`, `format` and `%`.
+      #
+      # NOTE: In `aggressive` mode, offenses are registered for all strings containing tokens,
+      # but autocorrection is only applied when the string appears in a known formatting context
+      # (`format`, `sprintf`, `printf`, or `%`). This is done in order to prevent false
+      # autocorrections for strings that are not actually format strings.
+      #
+      # NOTE: Tokens in the `unannotated` style (eg. `%s`) are always treated as if
+      # configured with `Conservative: true`. This is done in order to prevent false positives,
+      # because this format is very similar to encoded URLs or Date/Time formatting strings.
       #
       # @example EnforcedStyle: annotated (default)
       #
@@ -82,6 +95,42 @@ module RuboCop
       #   # good
       #   redirect('foo/%{bar_id}')
       #
+      # @example Mode: aggressive (default), EnforcedStyle: annotated
+      #
+      #   # bad
+      #   "%{greeting}"
+      #   foo("%{greeting}")
+      #
+      #   # bad
+      #   format("%{greeting}", greeting: 'Hello')
+      #   printf("%{greeting}", greeting: 'Hello')
+      #   sprintf("%{greeting}", greeting: 'Hello')
+      #   "%{greeting}" % { greeting: 'Hello' }
+      #
+      #   # good
+      #   format("%<greeting>s", greeting: 'Hello')
+      #   printf("%<greeting>s", greeting: 'Hello')
+      #   sprintf("%<greeting>s", greeting: 'Hello')
+      #   "%<greeting>s" % { greeting: 'Hello' }
+      #
+      # @example Mode: conservative, EnforcedStyle: annotated
+      #
+      #   # good
+      #   "%{greeting}"
+      #   foo("%{greeting}")
+      #
+      #   # bad
+      #   format("%{greeting}", greeting: 'Hello')
+      #   printf("%{greeting}", greeting: 'Hello')
+      #   sprintf("%{greeting}", greeting: 'Hello')
+      #   "%{greeting}" % { greeting: 'Hello' }
+      #
+      #   # good
+      #   format("%<greeting>s", greeting: 'Hello')
+      #   printf("%<greeting>s", greeting: 'Hello')
+      #   sprintf("%<greeting>s", greeting: 'Hello')
+      #   "%<greeting>s" % { greeting: 'Hello' }
+      #
       class FormatStringToken < Base
         include ConfigurableEnforcedStyle
         include AllowedMethods
@@ -96,7 +145,7 @@ module RuboCop
           return if allowed_unannotated?(detections)
 
           detections.each do |detected_sequence, token_range|
-            check_sequence(detected_sequence, token_range)
+            check_sequence(node, detected_sequence, token_range)
           end
         end
 
@@ -121,17 +170,34 @@ module RuboCop
             matches_allowed_pattern?(send_parent.method_name))
         end
 
-        def check_sequence(detected_sequence, token_range)
+        def check_sequence(node, detected_sequence, token_range)
           if detected_sequence.style == style
             correct_style_detected
           elsif correctable_sequence?(detected_sequence.type)
             style_detected(detected_sequence.style)
-            add_offense(token_range, message: message(detected_sequence.style)) do |corrector|
+            register_offense(node, detected_sequence, token_range)
+          end
+        end
+
+        def register_offense(node, detected_sequence, token_range)
+          msg = message(detected_sequence.style)
+
+          if format_string_context?(node)
+            add_offense(token_range, message: msg) do |corrector|
               autocorrect_sequence(corrector, detected_sequence, token_range)
             end
+          else
+            add_offense(token_range, message: msg)
           end
         end
 
+        def format_string_context?(node)
+          format_string_in_typical_context?(node) ||
+            node.each_ancestor(:dstr).any? do |dstr_node|
+              format_string_in_typical_context?(dstr_node)
+            end
+        end
+
         def correctable_sequence?(detected_type)
           detected_type == 's' || style == :annotated || style == :unannotated
         end
@@ -153,15 +219,16 @@ module RuboCop
           corrector.replace(token_range, correction)
         end
 
-        def unannotated_format?(node, detected_style)
-          detected_style == :unannotated && !format_string_in_typical_context?(node)
+        def allowed_string?(node, detected_style)
+          (detected_style == :unannotated || conservative?) &&
+            !format_string_in_typical_context?(node)
         end
 
         def message(detected_style)
           "Prefer #{message_text(style)} over #{message_text(detected_style)}."
         end
 
-        # rubocop:disable Style/FormatStringToken
+        # rubocop:disable-next Style/FormatStringToken -- the cop needs the token style it is matching
         def message_text(style)
           {
             annotated: 'annotated tokens (like `%<foo>s`)',
@@ -169,7 +236,6 @@ module RuboCop
             unannotated: 'unannotated tokens (like `%s`)'
           }[style]
         end
-        # rubocop:enable Style/FormatStringToken
 
         def tokens(str_node, &block)
           return if str_node.source == '__FILE__'
@@ -203,7 +269,7 @@ module RuboCop
         def collect_detections(node)
           detections = []
           tokens(node) do |detected_sequence, token_range|
-            unless unannotated_format?(node, detected_sequence.style)
+            unless allowed_string?(node, detected_sequence.style)
               detections << [detected_sequence, token_range]
             end
           end
@@ -222,6 +288,10 @@ module RuboCop
         def max_unannotated_placeholders_allowed
           cop_config['MaxUnannotatedPlaceholdersAllowed']
         end
+
+        def conservative?
+          cop_config.fetch('Mode', :aggressive).to_sym == :conservative
+        end
       end
     end
   end

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

@@ -142,7 +142,8 @@ module RuboCop
           end
 
           next_token = processed_source.tokens[token_number]
-          if next_token&.text&.valid_encoding? && Encoding::ENCODING_PATTERN.match?(next_token.text)
+          if next_token&.text&.valid_encoding? &&
+             MagicComment.parse(next_token.text).encoding_specified?
             token = next_token
           end
 
@@ -151,7 +152,7 @@ module RuboCop
 
         def frozen_string_literal_comment(processed_source)
           processed_source.tokens.find do |token|
-            token.text.start_with?(FROZEN_STRING_LITERAL_REGEXP)
+            MagicComment.parse(token.text).frozen_string_literal_specified?
           end
         end
 
@@ -189,8 +190,9 @@ module RuboCop
 
         def enable_comment(corrector)
           comment = frozen_string_literal_comment(processed_source)
+          replacement = MagicComment.parse(comment.text).new_frozen_string_literal(true)
 
-          corrector.replace(line_range(comment.line), FROZEN_STRING_LITERAL_ENABLED)
+          corrector.replace(line_range(comment.line), replacement)
         end
 
         def insert_comment(corrector)

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

@@ -8,6 +8,9 @@ module RuboCop
       # reassign (possibly to redirect some stream) constants in Ruby, you'll get
       # an interpreter warning if you do so.
       #
+      # Additionally, `$stdout/$stderr/$stdin` can safely be accessed in a Ractor because they
+      # are ractor-local, while `STDOUT/STDERR/STDIN` will raise `Ractor::IsolationError`.
+      #
       # @safety
       #   Autocorrection is unsafe because `STDOUT` and `$stdout` may point to different
       #   objects, for example.

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

@@ -3,7 +3,10 @@
 module RuboCop
   module Cop
     module Style
-      # Looks for uses of global variables.
+      # Looks for uses of global variables. Global variables introduce
+      # shared mutable state that makes code harder to test, debug,
+      # and reason about, since any part of the program can read or modify them.
+      #
       # It does not report offenses for built-in global variables.
       # Built-in global variables are allowed by default. Additionally
       # users can allow additional variables via the AllowedVariables option.
@@ -54,7 +57,7 @@ module RuboCop
         ].map(&:to_sym)
 
         def user_vars
-          cop_config['AllowedVariables'].map(&:to_sym)
+          @user_vars ||= cop_config['AllowedVariables'].map(&:to_sym).freeze
         end
 
         def allowed_var?(global_var)

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

@@ -45,17 +45,6 @@ module RuboCop
       #   ok
       #
       #   # bad
-      #   if something
-      #     foo || raise('exception')
-      #   else
-      #     ok
-      #   end
-      #
-      #   # good
-      #   foo || raise('exception') if something
-      #   ok
-      #
-      #   # bad
       #   define_method(:test) do
       #     if something
       #       work
@@ -120,6 +109,10 @@ module RuboCop
         MSG = 'Use a guard clause (`%<example>s`) instead of wrapping the ' \
               'code inside a conditional expression.'
 
+        def self.autocorrect_incompatible_with
+          [Style::MissingElse]
+        end
+
         def on_def(node)
           body = node.body
 
@@ -135,6 +128,7 @@ module RuboCop
           on_def(node)
         end
         alias on_numblock on_block
+        alias on_itblock on_block
 
         def on_if(node)
           return if accepted_form?(node)
@@ -206,19 +200,19 @@ module RuboCop
           end
         end
 
-        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        # rubocop:disable-next Metrics/AbcSize
         def autocorrect(corrector, node, condition, replacement, guard)
           corrector.replace(node.loc.keyword.join(condition.source_range), replacement)
 
           if_branch = node.if_branch
           else_branch = node.else_branch
 
-          corrector.replace(node.loc.begin, "\n") if node.loc.begin&.is?('then')
+          corrector.replace(node.loc.begin, "\n") if node.then?
 
-          if if_branch&.send_type? && heredoc?(if_branch.last_argument)
-            autocorrect_heredoc_argument(corrector, node, if_branch, else_branch, guard)
-          elsif else_branch&.send_type? && heredoc?(else_branch.last_argument)
-            autocorrect_heredoc_argument(corrector, node, else_branch, if_branch, guard)
+          if (if_heredoc = find_heredoc_argument(if_branch))
+            autocorrect_heredoc_argument(corrector, node, if_heredoc, else_branch, guard)
+          elsif (else_heredoc = find_heredoc_argument(else_branch))
+            autocorrect_heredoc_argument(corrector, node, else_heredoc, if_branch, guard)
           else
             corrector.remove(node.loc.end)
             return unless node.else?
@@ -227,22 +221,37 @@ module RuboCop
             corrector.remove(range_of_branch_to_remove(node, guard))
           end
         end
-        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         def heredoc?(argument)
           argument.respond_to?(:heredoc?) && argument.heredoc?
         end
 
-        def autocorrect_heredoc_argument(corrector, node, heredoc_branch, leave_branch, guard)
+        def find_heredoc_argument(node)
+          return unless node
+
+          node = node.children.first while node.begin_type?
+          return node if heredoc?(node)
+          return unless node.call_type?
+
+          node.arguments.reverse_each do |argument|
+            heredoc_argument = find_heredoc_argument(argument)
+            return heredoc_argument if heredoc_argument
+          end
+
+          find_heredoc_argument(node.receiver)
+        end
+
+        def autocorrect_heredoc_argument(corrector, node, heredoc_node, leave_branch, guard)
           remove_whole_lines(corrector, node.loc.end)
           return unless node.else?
 
-          remove_whole_lines(corrector, leave_branch.source_range)
+          if leave_branch
+            remove_whole_lines(corrector, leave_branch.source_range)
+            corrector.insert_after(heredoc_node.loc.heredoc_end, "\n#{leave_branch.source}")
+          end
+
           remove_whole_lines(corrector, node.loc.else)
           remove_whole_lines(corrector, range_of_branch_to_remove(node, guard))
-          corrector.insert_after(
-            heredoc_branch.last_argument.loc.heredoc_end, "\n#{leave_branch.source}"
-          )
         end
 
         def range_of_branch_to_remove(node, guard)
@@ -273,7 +282,15 @@ module RuboCop
         end
 
         def accepted_form?(node, ending: false)
-          accepted_if?(node, ending) || node.condition.multiline? || node.parent&.assignment?
+          accepted_if?(node, ending) || node.condition.multiline? ||
+            node.parent&.assignment? || endless_method_body?(node)
+        end
+
+        # The body of an endless method is a single expression, so there is no
+        # room for a guard clause followed by the rest of the code.
+        def endless_method_body?(node)
+          parent = node.parent
+          parent&.any_def_type? && parent.endless?
         end
 
         def trivial?(node)

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

@@ -6,8 +6,13 @@ module RuboCop
       # Checks for presence or absence of braces around hash literal as a last
       # array item depending on configuration.
       #
-      # NOTE: This cop will ignore arrays where all items are hashes, regardless of
-      # EnforcedStyle.
+      # NOTE: This cop will ignore arrays where multiple items are all hashes,
+      # regardless of `EnforcedStyle`.
+      #
+      # [source,ruby]
+      # ----
+      # [{ one: 1 }, { two: 2 }]
+      # ----
       #
       # @example EnforcedStyle: braces (default)
       #   # bad
@@ -16,8 +21,11 @@ module RuboCop
       #   # good
       #   [1, 2, { one: 1, two: 2 }]
       #
+      #   # bad
+      #   [one: 1, two: 2]
+      #
       #   # good
-      #   [{ one: 1 }, { two: 2 }]
+      #   [{ one: 1, two: 2 }]
       #
       # @example EnforcedStyle: no_braces
       #   # bad
@@ -26,8 +34,11 @@ module RuboCop
       #   # good
       #   [1, 2, one: 1, two: 2]
       #
+      #   # bad
+      #   [{ one: 1, two: 2 }]
+      #
       #   # good
-      #   [{ one: 1 }, { two: 2 }]
+      #   [one: 1, two: 2]
       class HashAsLastArrayItem < Base
         include RangeHelp
         include ConfigurableEnforcedStyle
@@ -36,7 +47,7 @@ module RuboCop
         def on_hash(node)
           return if node.children.first&.kwsplat_type?
           return unless (array = containing_array(node))
-          return unless last_array_item?(array, node) && explicit_array?(array)
+          return unless expected_braced_last_array_item?(array, node) && explicit_array?(array)
 
           if braces_style?
             check_braces(node)
@@ -52,10 +63,12 @@ module RuboCop
           parent if parent&.array_type?
         end
 
-        def last_array_item?(array, node)
-          return false if array.child_nodes.all?(&:hash_type?)
+        def expected_braced_last_array_item?(array, node)
+          return false if array.each_value.all? do |node|
+            node.hash_type? && (braces_style? ? node.braces? : !node.braces?)
+          end
 
-          array.children.last.equal?(node)
+          !array.values[-2]&.hash_type? && array.values.last.equal?(node)
         end
 
         def explicit_array?(array)
@@ -67,7 +80,12 @@ module RuboCop
           return if node.braces?
 
           add_offense(node, message: 'Wrap hash in `{` and `}`.') do |corrector|
-            corrector.wrap(node, '{', '}')
+            if node.single_line? || same_line?(node, node.parent)
+              corrector.wrap(node, '{', '}')
+            else
+              indent = indent(node)
+              corrector.wrap(node, "{\n#{indent}", "\n#{indent}}")
+            end
           end
         end
 

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

@@ -44,17 +44,23 @@ module RuboCop
       class HashConversion < Base
         extend AutoCorrector
 
-        MSG_TO_H = 'Prefer ary.to_h to Hash[ary].'
-        MSG_LITERAL_MULTI_ARG = 'Prefer literal hash to Hash[arg1, arg2, ...].'
-        MSG_LITERAL_HASH_ARG = 'Prefer literal hash to Hash[key: value, ...].'
-        MSG_SPLAT = 'Prefer array_of_pairs.to_h to Hash[*array].'
+        MSG_TO_H = 'Prefer `ary.to_h` to `Hash[ary]`.'
+        MSG_LITERAL_MULTI_ARG = 'Prefer literal hash to `Hash[arg1, arg2, ...]`.'
+        MSG_LITERAL_HASH_ARG = 'Prefer literal hash to `Hash[key: value, ...]`.'
+        MSG_SPLAT = 'Prefer `array_of_pairs.to_h` to `Hash[*array]`.'
         RESTRICT_ON_SEND = %i[[]].freeze
 
         # @!method hash_from_array?(node)
         def_node_matcher :hash_from_array?, '(send (const {nil? cbase} :Hash) :[] ...)'
 
+        # A hash literal as the first argument needs the parentheses of the call,
+        # which `Style/MethodCallWithArgsParentheses` removes in the same pass.
+        def self.autocorrect_incompatible_with
+          [Style::MethodCallWithArgsParentheses]
+        end
+
         def on_send(node)
-          return unless hash_from_array?(node)
+          return if part_of_ignored_node?(node) || !hash_from_array?(node)
 
           # There are several cases:
           # If there is one argument:
@@ -63,7 +69,8 @@ module RuboCop
           # If there is 0 or 2+ arguments:
           #   Hash[a1, a2, a3, a4] => {a1 => a2, a3 => a4}
           #   ...but don't suggest correction if there is odd number of them (it is a bug)
-          node.arguments.count == 1 ? single_argument(node) : multi_argument(node)
+          node.arguments.one? ? single_argument(node) : multi_argument(node)
+          ignore_node(node)
         end
 
         private
@@ -72,7 +79,7 @@ module RuboCop
           first_argument = node.first_argument
           if first_argument.hash_type?
             register_offense_for_hash(node, first_argument)
-          elsif first_argument.splat_type?
+          elsif first_argument.type?(:splat, :forwarded_restarg)
             add_offense(node, message: MSG_SPLAT) unless allowed_splat_argument?
           elsif use_zip_method_without_argument?(first_argument)
             register_offense_for_zip_method(node, first_argument)
@@ -94,12 +101,30 @@ module RuboCop
         def register_offense_for_hash(node, hash_argument)
           add_offense(node, message: MSG_LITERAL_HASH_ARG) do |corrector|
             corrector.replace(node, "{#{hash_argument.source}}")
-
-            parent = node.parent
-            add_parentheses(parent, corrector) if parent&.send_type? && !parent.parenthesized?
+            add_parentheses_to_parent_call(node, corrector)
           end
         end
 
+        # Without parentheses, a hash literal at the start of the first argument would be
+        # parsed as a block. That includes an argument like `Hash[a, b].merge(c)`.
+        def add_parentheses_to_parent_call(node, corrector)
+          node = node.parent while starts_parent?(node)
+          parent = node.parent
+          return unless parent&.type?(:call, :super, :yield)
+          return if parent.parenthesized? || operator_syntax?(parent)
+
+          add_parentheses(parent, corrector)
+        end
+
+        def starts_parent?(node)
+          node.parent && node.parent.source_range.begin_pos == node.source_range.begin_pos
+        end
+
+        # `foo[x]`, `foo.bar = x` and `foo == x` take a hash literal as it is.
+        def operator_syntax?(call)
+          call.setter_method? || (call.operator_method? && !call.loc?(:dot))
+        end
+
         def register_offense_for_zip_method(node, zip_method)
           add_offense(node, message: MSG_TO_H) do |corrector|
             if zip_method.parenthesized?
@@ -111,19 +136,30 @@ module RuboCop
         end
 
         def requires_parens?(node)
-          (node.call_type? && node.arguments.any? && !node.parenthesized?) || node.operator_keyword?
+          if node.call_type?
+            return false if node.method?(:[])
+            return true if node.arguments.any? && !node.parenthesized?
+          end
+
+          node.operator_keyword?
         end
 
         def multi_argument(node)
+          # A splat argument can expand to any number of elements, so the pairs
+          # can't be built statically and there is no literal hash to suggest.
+          return if node.arguments.any?(&:splat_type?)
+
           if node.arguments.count.odd?
             add_offense(node, message: MSG_LITERAL_MULTI_ARG)
           else
-            add_offense(node, message: MSG_LITERAL_MULTI_ARG) do |corrector|
-              corrector.replace(node, args_to_hash(node.arguments))
+            correct_multi_argument(node)
+          end
+        end
 
-              parent = node.parent
-              add_parentheses(parent, corrector) if parent&.send_type? && !parent.parenthesized?
-            end
+        def correct_multi_argument(node)
+          add_offense(node, message: MSG_LITERAL_MULTI_ARG) do |corrector|
+            corrector.replace(node, args_to_hash(node.arguments))
+            add_parentheses_to_parent_call(node, corrector)
           end
         end
 

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

@@ -74,8 +74,9 @@ module RuboCop
           check_unused_block_args(node, key, value)
         end
         alias on_numblock on_block
+        alias on_itblock on_block
 
-        # rubocop:disable Metrics/AbcSize
+        # rubocop:disable-next Metrics/AbcSize
         def check_unused_block_args(node, key, value)
           return if node.body.nil?
 
@@ -95,7 +96,6 @@ module RuboCop
             register_each_args_offense(node, message, 'each_value', unused_range)
           end
         end
-        # rubocop:enable Metrics/AbcSize
 
         def on_block_pass(node)
           kv_each_with_block_pass(node.parent) do |target, method|
@@ -128,8 +128,8 @@ module RuboCop
           lvar_sources = node.body.each_descendant(:lvar).map(&:source)
 
           if block_arg.mlhs_type?
-            block_arg.each_descendant(:arg, :restarg).all? do |block_arg|
-              lvar_sources.none?(block_arg.source.delete_prefix('*'))
+            block_arg.each_descendant(:arg, :restarg).all? do |descendant|
+              lvar_sources.none?(descendant.source.delete_prefix('*'))
             end
           else
             lvar_sources.none?(block_arg.source.delete_prefix('*'))