rubocop 1.71.2 → 1.74.0

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

@@ -9,8 +9,8 @@ module RuboCop
       # These keywords are: `class`, `module`, `def`, `begin`, `end`.
       #
       # Note that some comments
-      # (`:nodoc:`, `:yields:`, `rubocop:disable` and `rubocop:todo`)
-      # and RBS::Inline annotation comments are allowed.
+      # (`:nodoc:`, `:yields:`, `rubocop:disable` and `rubocop:todo`),
+      # RBS::Inline annotation, and Steep annotation (`steep:ignore`) are allowed.
       #
       # Autocorrection removes comments from `end` keyword and keeps comments
       # for `class`, `module`, `def` and `begin` above the keyword.
@@ -57,9 +57,11 @@ module RuboCop
 
         REGEXP = /(?<keyword>\S+).*#/.freeze
 
-        SUBCLASS_DEFINITION = /\A\s*class\s+\w+\s*<\s*\w+/.freeze
+        SUBCLASS_DEFINITION = /\A\s*class\s+(\w|::)+\s*<\s*(\w|::)+/.freeze
         METHOD_DEFINITION = /\A\s*def\s/.freeze
 
+        STEEP_REGEXP = /#\ssteep:ignore(\s|\z)/.freeze
+
         def on_new_investigation
           processed_source.comments.each do |comment|
             next unless offensive?(comment) && (match = source_line(comment).match(REGEXP))
@@ -86,6 +88,7 @@ module RuboCop
         def offensive?(comment)
           line = source_line(comment)
           return false if rbs_inline_annotation?(line, comment)
+          return false if steep_annotation?(comment)
 
           KEYWORD_REGEXES.any? { |r| r.match?(line) } &&
             ALLOWED_COMMENT_REGEXES.none? { |r| r.match?(line) }
@@ -105,6 +108,10 @@ module RuboCop
             false
           end
         end
+
+        def steep_annotation?(comment)
+          comment.text.match?(STEEP_REGEXP)
+        end
       end
     end
   end

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

@@ -109,7 +109,7 @@ module RuboCop
         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/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/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/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/if_unless_modifier.rb

@@ -164,8 +164,8 @@ module RuboCop
 
         def too_long_due_to_comment_after_modifier?(node, comment)
           source_length = processed_source.lines[node.first_line - 1].length
-          source_length >= max_line_length &&
-            source_length - comment.source_range.length <= max_line_length
+
+          max_line_length.between?(source_length - comment.source_range.length, source_length)
         end
 
         def allowed_patterns

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

@@ -46,6 +46,7 @@ module RuboCop
 
         MSG = 'Use `%<inverse>s` instead of inverting `%<method>s`.'
         CLASS_COMPARISON_METHODS = %i[<= >= < >].freeze
+        SAFE_NAVIGATION_INCOMPATIBLE_METHODS = (CLASS_COMPARISON_METHODS + %i[any? none?]).freeze
         EQUALITY_METHODS = %i[== != =~ !~ <= >= < >].freeze
         NEGATED_EQUALITY_METHODS = %i[!= !~].freeze
         CAMEL_CASE = /[A-Z]+[a-z]+/.freeze
@@ -77,7 +78,7 @@ module RuboCop
         def on_send(node)
           inverse_candidate?(node) do |method_call, lhs, method, rhs|
             return unless inverse_methods.key?(method)
-            return if negated?(node) || relational_comparison_with_safe_navigation?(method_call)
+            return if negated?(node) || safe_navigation_incompatible?(method_call)
             return if part_of_ignored_node?(node)
             return if possible_class_hierarchy_check?(lhs, rhs, method)
 
@@ -154,10 +155,6 @@ module RuboCop
           node.parent.respond_to?(:method?) && node.parent.method?(:!)
         end
 
-        def relational_comparison_with_safe_navigation?(node)
-          node.csend_type? && CLASS_COMPARISON_METHODS.include?(node.method_name)
-        end
-
         def not_to_receiver(node, method_call)
           node.loc.selector.begin.join(method_call.source_range.begin)
         end
@@ -166,6 +163,12 @@ module RuboCop
           method_call.source_range.end.join(node.source_range.end)
         end
 
+        def safe_navigation_incompatible?(node)
+          return false unless node.csend_type?
+
+          SAFE_NAVIGATION_INCOMPATIBLE_METHODS.include?(node.method_name)
+        end
+
         # When comparing classes, `!(Integer < Numeric)` is not the same as
         # `Integer > Numeric`.
         def possible_class_hierarchy_check?(lhs, rhs, method)

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

@@ -42,19 +42,25 @@ module RuboCop
           return if kwarg_nodes.empty?
 
           add_offense(node) do |corrector|
-            if node.parent.find(&:kwoptarg_type?) == node
-              corrector.insert_before(node, "#{kwarg_nodes.map(&:source).join(', ')}, ")
+            defining_node = node.each_ancestor(:def, :defs, :block).first
+            next if processed_source.contains_comment?(arguments_range(defining_node))
+            next unless node.parent.find(&:kwoptarg_type?) == node
 
-              arguments = node.each_ancestor(:def, :defs, :block).first.arguments
-              append_newline_to_last_kwoptarg(arguments, corrector) unless parentheses?(arguments)
-
-              remove_kwargs(kwarg_nodes, corrector)
-            end
+            autocorrect(corrector, node, defining_node, kwarg_nodes)
           end
         end
 
         private
 
+        def autocorrect(corrector, node, defining_node, kwarg_nodes)
+          corrector.insert_before(node, "#{kwarg_nodes.map(&:source).join(', ')}, ")
+
+          arguments = defining_node.arguments
+          append_newline_to_last_kwoptarg(arguments, corrector) unless parentheses?(arguments)
+
+          remove_kwargs(kwarg_nodes, corrector)
+        end
+
         def append_newline_to_last_kwoptarg(arguments, corrector)
           last_argument = arguments.last
           return if last_argument.type?(:kwrestarg, :blockarg)

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

@@ -36,7 +36,7 @@ module RuboCop
         include RangeHelp
         extend AutoCorrector
 
-        MSG = 'Use `\\` instead of `+` or `<<` to concatenate those strings.'
+        MSG = 'Use `\\` instead of `%<operator>s` to concatenate multiline strings.'
         CONCAT_TOKEN_TYPES = %i[tPLUS tLSHFT].freeze
         SIMPLE_STRING_TOKEN_TYPE = :tSTRING
         COMPLEX_STRING_BEGIN_TOKEN = :tSTRING_BEG
@@ -61,14 +61,20 @@ module RuboCop
           successor = tokens[index + 2]
 
           return unless eligible_token_set?(predecessor, operator, successor)
-
           return if same_line?(operator, successor)
 
           next_successor = token_after_last_string(successor, index)
-
           return unless eligible_next_successor?(next_successor)
 
-          add_offense(operator.pos) { |corrector| autocorrect(corrector, operator.pos) }
+          register_offense(operator)
+        end
+
+        def register_offense(operator)
+          message = format(MSG, operator: operator.text)
+
+          add_offense(operator.pos, message: message) do |corrector|
+            autocorrect(corrector, operator.pos)
+          end
         end
 
         def autocorrect(corrector, operator_range)

data/lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb

@@ -108,7 +108,7 @@ module RuboCop
           end
 
           def call_in_literals?(node)
-            parent = node.parent&.block_type? ? node.parent.parent : node.parent
+            parent = node.parent&.any_block_type? ? node.parent.parent : node.parent
             return false unless parent
 
             parent.type?(:pair, :array, :range) ||
@@ -117,7 +117,7 @@ module RuboCop
           end
 
           def call_in_logical_operators?(node)
-            parent = node.parent&.block_type? ? node.parent.parent : node.parent
+            parent = node.parent&.any_block_type? ? node.parent.parent : node.parent
             return false unless parent
 
             logical_operator?(parent) ||
@@ -153,7 +153,7 @@ module RuboCop
           end
 
           def call_in_argument_with_block?(node)
-            parent = node.parent&.block_type? && node.parent.parent
+            parent = node.parent&.any_block_type? && node.parent.parent
             return false unless parent
 
             parent.type?(:call, :super, :yield)

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

@@ -41,7 +41,7 @@ module RuboCop
           return if ignored_node?(node)
 
           return unless (receiver = node.receiver)
-          return unless receiver.any_block_type? && receiver.loc.end.is?('end')
+          return unless receiver.any_block_type? && receiver.keywords?
 
           range = range_between(receiver.loc.end.begin_pos, node.source_range.end_pos)
 

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

@@ -28,7 +28,7 @@ module RuboCop
         MSG = 'Avoid multi-line chains of blocks.'
 
         def on_block(node)
-          node.send_node.each_node(:send, :csend) do |send_node|
+          node.send_node.each_node(:call) do |send_node|
             receiver = send_node.receiver
 
             next unless receiver&.any_block_type? && receiver.multiline?

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

@@ -50,7 +50,7 @@ module RuboCop
             corrector.remove(range_by_whole_lines(arguments.loc.end, include_final_newline: true))
           end
 
-          arguments_range = arguments_range(node)
+          arguments_range = range_with_surrounding_space(arguments_range(node), side: :left)
           # If the method name isn't on the same line as def, move it directly after def
           if arguments_range.first_line != opening_line(node)
             corrector.remove(node.loc.name)
@@ -66,14 +66,6 @@ module RuboCop
           processed_source[arguments.last_line - 1].strip
         end
 
-        def arguments_range(node)
-          range = range_between(
-            node.first_argument.source_range.begin_pos, node.last_argument.source_range.end_pos
-          )
-
-          range_with_surrounding_space(range, side: :left)
-        end
-
         def opening_line(node)
           node.first_line
         end