rubocop 1.71.2 → 1.75.2

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

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for logical comparison which can be replaced with `Comparable#between?`.
+      #
+      # NOTE: `Comparable#between?` is on average slightly slower than logical comparison,
+      # although the difference generally isn't observable. If you require maximum
+      # performance, consider using logical comparison.
+      #
+      # @example
+      #
+      #   # bad
+      #   x >= min && x <= max
+      #
+      #   # bad
+      #   x <= max && x >= min
+      #
+      #   # good
+      #   x.between?(min, max)
+      #
+      class ComparableBetween < Base
+        extend AutoCorrector
+
+        MSG = 'Prefer `%<prefer>s` over logical comparison.'
+
+        # @!method logical_comparison_between_by_min_first?(node)
+        def_node_matcher :logical_comparison_between_by_min_first?, <<~PATTERN
+          (and
+            (send
+              {$_value :>= $_min | $_min :<= $_value})
+            (send
+              {$_value :<= $_max | $_max :>= $_value}))
+        PATTERN
+
+        # @!method logical_comparison_between_by_max_first?(node)
+        def_node_matcher :logical_comparison_between_by_max_first?, <<~PATTERN
+          (and
+            (send
+              {$_value :<= $_max | $_max :>= $_value})
+            (send
+              {$_value :>= $_min | $_min :<= $_value}))
+        PATTERN
+
+        def on_and(node)
+          logical_comparison_between_by_min_first?(node) do |*args|
+            min_and_value, max_and_value = args.each_slice(2).to_a
+
+            register_offense(node, min_and_value, max_and_value)
+          end
+
+          logical_comparison_between_by_max_first?(node) do |*args|
+            max_and_value, min_and_value = args.each_slice(2).to_a
+
+            register_offense(node, min_and_value, max_and_value)
+          end
+        end
+
+        private
+
+        def register_offense(node, min_and_value, max_and_value)
+          value = (min_and_value & max_and_value).first
+          min = min_and_value.find { _1 != value }
+          max = max_and_value.find { _1 != value }
+
+          prefer = "#{value.source}.between?(#{min.source}, #{max.source})"
+          add_offense(node, message: format(MSG, prefer: prefer)) do |corrector|
+            corrector.replace(node, prefer)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -436,9 +436,11 @@ module RuboCop
       # Helper module to provide common methods to ConditionalAssignment
       # correctors
       module ConditionalCorrectorHelper
+        # rubocop:disable Metrics/AbcSize
         def remove_whitespace_in_branches(corrector, branch, condition, column)
           branch.each_node do |child|
             next if child.source_range.nil?
+            next if child.parent.dstr_type?
 
             white_space = white_space_range(child, column)
             corrector.remove(white_space) if white_space.source.strip.empty?
@@ -450,6 +452,7 @@ module RuboCop
             corrector.remove_preceding(loc, loc.column - column)
           end
         end
+        # rubocop:enable Metrics/AbcSize
 
         def white_space_range(node, column)
           expression = node.source_range

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

@@ -102,14 +102,14 @@ module RuboCop
 
         def find_def_node_from_ascendant(node)
           return unless (parent = node.parent)
-          return parent if parent.type?(:def, :defs)
+          return parent if parent.any_def_type?
           return node.parent.child_nodes.first if define_method?(parent)
 
           find_def_node_from_ascendant(node.parent)
         end
 
         def define_method?(node)
-          return false unless node.block_type?
+          return false unless node.any_block_type?
 
           child = node.child_nodes.first
           return false unless child.send_type?

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

@@ -6,6 +6,10 @@ module RuboCop
       # Checks for the use of a method, the result of which
       # would be a literal, like an empty array, hash, or string.
       #
+      # NOTE: When frozen string literals are enabled, `String.new`
+      # isn't corrected to an empty string since the former is
+      # mutable and the latter would be frozen.
+      #
       # @example
       #   # bad
       #   a = Array.new

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

@@ -5,8 +5,11 @@ module RuboCop
     module Style
       # Checks for endless methods.
       #
-      # It can enforce either the use of endless methods definitions
-      # for single-lined method bodies, or disallow endless methods.
+      # It can enforce endless method definitions whenever possible or with single line methods.
+      # It can also disallow multiline endless method definitions or all endless definitions.
+      #
+      # `require_single_line` style enforces endless method definitions for single line methods.
+      # `require_always` style enforces endless method definitions for single statement methods.
       #
       # Other method definition types are not considered by this cop.
       #
@@ -15,36 +18,116 @@ module RuboCop
       # * allow_single_line (default) - only single line endless method definitions are allowed.
       # * allow_always - all endless method definitions are allowed.
       # * disallow - all endless method definitions are disallowed.
+      # * require_single_line - endless method definitions are required for single line methods.
+      # * require_always - all endless method definitions are required.
       #
       # NOTE: Incorrect endless method definitions will always be
       # corrected to a multi-line definition.
       #
       # @example EnforcedStyle: allow_single_line (default)
+      #   # bad, multi-line endless method
+      #   def my_method = x.foo
+      #                    .bar
+      #                    .baz
+      #
       #   # good
-      #   def my_method() = x
+      #   def my_method
+      #     x
+      #   end
       #
-      #   # bad, multi-line endless method
-      #   def my_method() = x.foo
-      #                      .bar
-      #                      .baz
+      #   # good
+      #   def my_method = x
+      #
+      #   # good
+      #   def my_method
+      #     x.foo
+      #      .bar
+      #      .baz
+      #   end
       #
       # @example EnforcedStyle: allow_always
       #   # good
-      #   def my_method() = x
+      #   def my_method
+      #     x
+      #   end
       #
       #   # good
-      #   def my_method() = x.foo
-      #                      .bar
-      #                      .baz
+      #   def my_method = x
+      #
+      #   # good
+      #   def my_method = x.foo
+      #                    .bar
+      #                    .baz
+      #
+      #   # good
+      #   def my_method
+      #     x.foo
+      #      .bar
+      #      .baz
+      #   end
       #
       # @example EnforcedStyle: disallow
       #   # bad
-      #   def my_method() = x
+      #   def my_method = x
+      #
+      #   # bad
+      #   def my_method = x.foo
+      #                    .bar
+      #                    .baz
+      #
+      #   # good
+      #   def my_method
+      #     x
+      #   end
+      #
+      #   # good
+      #   def my_method
+      #     x.foo
+      #      .bar
+      #      .baz
+      #   end
+      #
+      # @example EnforcedStyle: require_single_line
+      #   # bad
+      #   def my_method
+      #     x
+      #   end
+      #
+      #   # bad
+      #   def my_method = x.foo
+      #                    .bar
+      #                    .baz
+      #
+      #   # good
+      #   def my_method = x
+      #
+      #   # good
+      #   def my_method
+      #     x.foo
+      #      .bar
+      #      .baz
+      #   end
+      #
+      # @example EnforcedStyle: require_always
+      #   # bad
+      #   def my_method
+      #     x
+      #   end
       #
       #   # bad
-      #   def my_method() = x.foo
-      #                      .bar
-      #                      .baz
+      #   def my_method
+      #     x.foo
+      #      .bar
+      #      .baz
+      #   end
+      #
+      #   # good
+      #   def my_method = x
+      #
+      #   # good
+      #   def my_method = x.foo
+      #                    .bar
+      #                    .baz
       #
       class EndlessMethod < Base
         include ConfigurableEnforcedStyle
@@ -57,12 +140,21 @@ module RuboCop
         CORRECTION_STYLES = %w[multiline single_line].freeze
         MSG = 'Avoid endless method definitions.'
         MSG_MULTI_LINE = 'Avoid endless method definitions with multiple lines.'
+        MSG_REQUIRE_SINGLE = 'Use endless method definitions for single line methods.'
+        MSG_REQUIRE_ALWAYS = 'Use endless method definitions.'
 
         def on_def(node)
-          if style == :disallow
-            handle_disallow_style(node)
-          else
+          return if node.assignment_method?
+
+          case style
+          when :allow_single_line, :allow_always
             handle_allow_style(node)
+          when :disallow
+            handle_disallow_style(node)
+          when :require_single_line
+            handle_require_single_line_style(node)
+          when :require_always
+            handle_require_always_style(node)
           end
         end
 
@@ -77,11 +169,64 @@ module RuboCop
           end
         end
 
+        def handle_require_single_line_style(node)
+          if node.endless? && !node.single_line?
+            add_offense(node, message: MSG_MULTI_LINE) do |corrector|
+              correct_to_multiline(corrector, node)
+            end
+          elsif !node.endless? && can_be_made_endless?(node) && node.body.single_line?
+            return if too_long_when_made_endless?(node)
+
+            add_offense(node, message: MSG_REQUIRE_SINGLE) do |corrector|
+              corrector.replace(node, endless_replacement(node))
+            end
+          end
+        end
+
+        def handle_require_always_style(node)
+          return if node.endless? || !can_be_made_endless?(node)
+          return if too_long_when_made_endless?(node)
+
+          add_offense(node, message: MSG_REQUIRE_ALWAYS) do |corrector|
+            corrector.replace(node, endless_replacement(node))
+          end
+        end
+
         def handle_disallow_style(node)
           return unless node.endless?
 
           add_offense(node) { |corrector| correct_to_multiline(corrector, node) }
         end
+
+        def correct_to_multiline(corrector, node)
+          replacement = <<~RUBY.strip
+            def #{node.method_name}#{arguments(node)}
+              #{node.body.source}
+            end
+          RUBY
+
+          corrector.replace(node, replacement)
+        end
+
+        def endless_replacement(node)
+          <<~RUBY.strip
+            def #{node.method_name}#{arguments(node)} = #{node.body.source}
+          RUBY
+        end
+
+        def arguments(node, missing = '')
+          node.arguments.any? ? node.arguments.source : missing
+        end
+
+        def can_be_made_endless?(node)
+          node.body && !node.body.begin_type? && !node.body.kwbegin_type?
+        end
+
+        def too_long_when_made_endless?(node)
+          return false unless config.cop_enabled?('Layout/LineLength')
+
+          endless_replacement(node).length > config.for_cop('Layout/LineLength')['Max']
+        end
       end
     end
   end

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

@@ -137,11 +137,11 @@ module RuboCop
 
           case depth(stripped_current_path)
           when 0
-            range = arguments_range(current_path)
+            range = arguments_range(current_path.parent)
 
             corrector.replace(range, '__FILE__')
           when 1
-            range = arguments_range(current_path)
+            range = arguments_range(current_path.parent)
 
             corrector.replace(range, '__dir__')
           else
@@ -185,11 +185,6 @@ module RuboCop
           corrector.remove(node.loc.dot)
           corrector.remove(node.loc.selector)
         end
-
-        def arguments_range(node)
-          range_between(node.parent.first_argument.source_range.begin_pos,
-                        node.parent.last_argument.source_range.end_pos)
-        end
       end
     end
   end

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

@@ -65,7 +65,7 @@ module RuboCop
           yielding_block?(block_node) do |send_node, block_args, yield_args|
             return unless yielding_arguments?(block_args, yield_args)
 
-            def_node = block_node.each_ancestor(:def, :defs).first
+            def_node = block_node.each_ancestor(:any_def).first
             # if `yield` is being called outside of a method context, ignore
             # this is not a valid ruby pattern, but can happen in haml or erb,
             # so this can cause crashes in haml_lint
@@ -151,7 +151,7 @@ module RuboCop
         end
 
         def build_new_arguments_for_zsuper(node)
-          def_node = node.each_ancestor(:def, :defs).first
+          def_node = node.each_ancestor(:any_def).first
           def_node.arguments.map do |arg|
             arg.optarg_type? ? arg.node_parts[0] : arg.source
           end

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

@@ -60,8 +60,8 @@ module RuboCop
       class ExponentialNotation < Base
         include ConfigurableEnforcedStyle
         MESSAGES = {
-          scientific: 'Use a mantissa in [1, 10[.',
-          engineering: 'Use an exponent divisible by 3 and a mantissa in [0.1, 1000[.',
+          scientific: 'Use a mantissa >= 1 and < 10.',
+          engineering: 'Use an exponent divisible by 3 and a mantissa >= 0.1 and < 1000.',
           integral: 'Use an integer as mantissa, without trailing zero.'
         }.freeze
 

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

@@ -77,6 +77,7 @@ module RuboCop
         end
 
         alias on_numblock on_block
+        alias on_itblock on_block
 
         private
 

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

@@ -3,16 +3,24 @@
 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: 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 +90,20 @@ module RuboCop
       #   # good
       #   redirect('foo/%{bar_id}')
       #
+      # @example Mode: conservative, EnforcedStyle: annotated
+      #   # In `conservative` mode, offenses are only registered for strings
+      #   # given to a known formatting method.
+      #
+      #   # good
+      #   "%{greeting}"
+      #   foo("%{greeting}")
+      #
+      #   # bad
+      #   format("%{greeting}", greeting: 'Hello')
+      #   printf("%{greeting}", greeting: 'Hello')
+      #   sprintf("%{greeting}", greeting: 'Hello')
+      #   "%{greeting}" % { greeting: 'Hello' }
+      #
       class FormatStringToken < Base
         include ConfigurableEnforcedStyle
         include AllowedMethods
@@ -153,8 +175,9 @@ 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)
@@ -203,7 +226,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 +245,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

@@ -151,7 +151,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 +189,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/guard_clause.rb

@@ -135,6 +135,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)
@@ -213,7 +214,7 @@ module RuboCop
           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)

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

@@ -74,6 +74,7 @@ module RuboCop
           check_unused_block_args(node, key, value)
         end
         alias on_numblock on_block
+        alias on_itblock on_block
 
         # rubocop:disable Metrics/AbcSize
         def check_unused_block_args(node, key, value)
@@ -128,8 +129,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('*'))

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

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Use `Hash#dig` instead of chaining potentially null `fetch` calls.
+      #
+      # When `fetch(identifier, nil)` calls are chained on a hash, the expectation
+      # is that each step in the chain returns either `nil` or another hash,
+      # and in both cases, these can be simplified with a single call to `dig` with
+      # multiple arguments.
+      #
+      # If the 2nd parameter is `{}` or `Hash.new`, an offense will also be registered,
+      # as long as the final call in the chain is a nil value. If a non-nil value is given,
+      # the chain will not be registered as an offense, as the default value cannot be safely
+      # given with `dig`.
+      #
+      # NOTE: See `Style/DigChain` for replacing chains of `dig` calls with
+      # a single method call.
+      #
+      # @safety
+      #   This cop is unsafe because it cannot be guaranteed that the receiver
+      #   is a `Hash` or that `fetch` or `dig` have the expected standard implementation.
+      #
+      # @example
+      #   # bad
+      #   hash.fetch('foo', nil)&.fetch('bar', nil)
+      #
+      #   # bad
+      #   # earlier members of the chain can return `{}` as long as the final `fetch`
+      #   # has `nil` as a default value
+      #   hash.fetch('foo', {}).fetch('bar', nil)
+      #
+      #   # good
+      #   hash.dig('foo', 'bar')
+      #
+      #   # ok - not handled by the cop since the final `fetch` value is non-nil
+      #   hash.fetch('foo', {}).fetch('bar', {})
+      #
+      class HashFetchChain < Base
+        extend AutoCorrector
+        extend TargetRubyVersion
+        include IgnoredNode
+
+        MSG = 'Use `%<replacement>s` instead.'
+        RESTRICT_ON_SEND = %i[fetch].freeze
+
+        minimum_target_ruby_version 2.3
+
+        # @!method diggable?(node)
+        def_node_matcher :diggable?, <<~PATTERN
+          (call _ :fetch $_arg {nil (hash) (send (const {nil? cbase} :Hash) :new)})
+        PATTERN
+
+        def on_send(node)
+          return if ignored_node?(node)
+          return if last_fetch_non_nil?(node)
+
+          last_replaceable_node, arguments = inspect_chain(node)
+          return unless last_replaceable_node
+          return unless arguments.size > 1
+
+          range = last_replaceable_node.selector.join(node.loc.end)
+          replacement = replacement(arguments)
+          message = format(MSG, replacement: replacement)
+
+          add_offense(range, message: message) do |corrector|
+            corrector.replace(range, replacement)
+          end
+        end
+        alias on_csend on_send
+
+        private
+
+        def last_fetch_non_nil?(node)
+          # When chaining `fetch` methods, `fetch(x, {})` is acceptable within
+          # the chain, as long as the last method in the chain has a `nil`
+          # default value.
+
+          return false unless node.method?(:fetch)
+
+          !node.last_argument&.nil_type?
+        end
+
+        def inspect_chain(node)
+          arguments = []
+
+          while (arg = diggable?(node))
+            arguments.unshift(arg)
+            ignore_node(node)
+            last_replaceable_node = node
+            node = node.receiver
+          end
+
+          [last_replaceable_node, arguments]
+        end
+
+        def replacement(arguments)
+          values = arguments.map(&:source).join(', ')
+          "dig(#{values})"
+        end
+      end
+    end
+  end
+end