rubocop 1.71.1 → 1.92.0

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,40 +18,122 @@ 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
       #
       #   # good
-      #   def my_method() = x.foo
-      #                      .bar
-      #                      .baz
+      #   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
+        include LineLengthHelp
         include EndlessMethodRewriter
+        include EndlessMethodBodyHelp
         extend TargetRubyVersion
         extend AutoCorrector
 
@@ -57,14 +142,30 @@ 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.'
+
+        # `Style/MethodDefParentheses` adds the same parentheses a parameter list needs in
+        # an endless definition, so letting both correct in the same pass would double them.
+        def self.autocorrect_incompatible_with
+          [Style::MethodCallWithArgsParentheses, Style::MethodDefParentheses]
+        end
 
         def on_def(node)
-          if style == :disallow
-            handle_disallow_style(node)
-          else
+          return if node.assignment_method? || use_heredoc?(node)
+
+          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
+        alias on_defs on_def
 
         private
 
@@ -73,14 +174,146 @@ module RuboCop
           return if node.single_line? || style == :allow_always
 
           add_offense(node, message: MSG_MULTI_LINE) do |corrector|
+            next if endless_parent?(node)
+
             correct_to_multiline(corrector, node)
           end
         end
 
+        def handle_require_single_line_style(node)
+          if node.endless? && node.multiline?
+            add_offense(node, message: MSG_MULTI_LINE) do |corrector|
+              correct_to_multiline(corrector, node)
+            end
+          elsif !node.endless? && can_be_made_endless?(node) && single_line_when_made_endless?(node)
+            return if too_long_when_made_endless?(node)
+
+            add_offense(node, message: MSG_REQUIRE_SINGLE) do |corrector|
+              correct_to_endless(corrector, 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|
+            correct_to_endless(corrector, node)
+          end
+        end
+
         def handle_disallow_style(node)
           return unless node.endless?
 
-          add_offense(node) { |corrector| correct_to_multiline(corrector, node) }
+          add_offense(node) do |corrector|
+            next if endless_parent?(node)
+
+            correct_to_multiline(corrector, node)
+          end
+        end
+
+        def endless_parent?(node)
+          node.parent&.any_def_type? && node.parent.endless?
+        end
+
+        def use_heredoc?(node)
+          return false unless (body = node.body)
+          return true if body.any_str_type? && body.heredoc?
+
+          body.each_descendant(:any_str).any?(&:heredoc?)
+        end
+
+        def correct_to_endless(corrector, node)
+          if unparenthesized_arguments?(node)
+            corrector.replace(name_to_arguments_range(node), '(')
+            corrector.replace(signature_to_body_range(node), ') = ')
+          else
+            corrector.replace(signature_to_body_range(node), ' = ')
+          end
+
+          corrector.remove(body_to_end_range(node))
+        end
+
+        def unparenthesized_arguments?(node)
+          node.arguments.any? && !node.arguments.loc.begin
+        end
+
+        def name_to_arguments_range(node)
+          node.loc.name.end.join(node.arguments.source_range.begin)
+        end
+
+        def signature_to_body_range(node)
+          signature_end = node.arguments.any? ? node.arguments.source_range.end : node.loc.name.end
+
+          signature_end.join(node.body.source_range.begin)
+        end
+
+        def body_to_end_range(node)
+          node.body.source_range.end.join(node.loc.end.end)
+        end
+
+        def endless_replacement(node)
+          <<~RUBY.strip
+            def #{receiver(node)}#{node.method_name}#{arguments(node)} = #{node.body.source}
+          RUBY
+        end
+
+        def receiver(node)
+          node.receiver ? "#{node.receiver.source}#{node.loc.operator.source}" : ''
+        end
+
+        def arguments(node, missing = '')
+          return missing unless node.arguments.any?
+          return parenthesized_arguments(node) if unparenthesized_arguments?(node)
+
+          node.arguments.source
+        end
+
+        def parenthesized_arguments(node)
+          padding = space_inside_parens? ? ' ' : ''
+
+          "(#{padding}#{node.arguments.source}#{padding})"
+        end
+
+        def space_inside_parens?
+          return false unless config.cop_enabled?('Layout/SpaceInsideParens')
+
+          config.for_cop('Layout/SpaceInsideParens')['EnforcedStyle'] != 'no_space'
+        end
+
+        def can_be_made_endless?(node)
+          return false unless node.body
+          return false if comment_in_discarded_range?(node)
+
+          endless_method_body?(node.body)
+        end
+
+        def single_line_when_made_endless?(node)
+          !endless_replacement(node).include?("\n")
+        end
+
+        def too_long_when_made_endless?(node)
+          return false unless config.cop_enabled?('Layout/LineLength')
+
+          line_length(line_when_made_endless(node)) > max_line_length
+        end
+
+        def comment_in_discarded_range?(node)
+          discarded_ranges = [signature_to_body_range(node), body_to_end_range(node)]
+
+          processed_source.each_comment_in_lines(node.first_line..node.last_line).any? do |comment|
+            discarded_ranges.any? { |range| range.contains?(comment.source_range) }
+          end
+        end
+
+        def line_when_made_endless(node)
+          keyword_element = node.loc.keyword
+          code_before = keyword_element.source_line[0...keyword_element.column]
+          end_element = node.loc.end
+          code_after = end_element.source_line[end_element.last_column..]
+
+          "#{code_before}#{endless_replacement(node)}#{code_after}"
         end
       end
     end

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

@@ -45,6 +45,10 @@ module RuboCop
         def on_send(node)
           return unless env_home?(node)
           return if node.arguments.count == 2 && !node.arguments[1].nil_type?
+          # `ENV.fetch('HOME') { default }` supplies a fallback, just like
+          # `ENV.fetch('HOME', default)`. `Dir.home` ignores the block, so
+          # converting would silently drop it.
+          return if node.block_node
 
           add_offense(node) do |corrector|
             corrector.replace(node, 'Dir.home')

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

@@ -4,12 +4,12 @@ module RuboCop
   module Cop
     module Style
       # Ensures that eval methods (`eval`, `instance_eval`, `class_eval`
-      # and `module_eval`) are given filename and line number values (`\_\_FILE\_\_`
-      # and `\_\_LINE\_\_`). This data is used to ensure that any errors raised
+      # and `module_eval`) are given filename and line number values (`+__FILE__+`
+      # and `+__LINE__+`). This data is used to ensure that any errors raised
       # within the evaluated code will be given the correct identification
       # in a backtrace.
       #
-      # The cop also checks that the line number given relative to `\_\_LINE\_\_` is
+      # The cop also checks that the line number given relative to `+__LINE__+` is
       # correct.
       #
       # This cop will autocorrect incorrect or missing filename and line number

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

@@ -34,7 +34,7 @@ module RuboCop
           even_odd_candidate?(node) do |base_number, method, arg|
             replacement_method = replacement_method(arg, method)
             add_offense(node, message: format(MSG, method: replacement_method)) do |corrector|
-              correction = "#{base_number.source}.#{replacement_method}?"
+              correction = "#{receiver_source(base_number)}.#{replacement_method}?"
               corrector.replace(node, correction)
             end
           end
@@ -42,6 +42,16 @@ module RuboCop
 
         private
 
+        def receiver_source(node)
+          # A binary or unary operator receiver (e.g. `a * b`, `-a`) binds looser
+          # than the appended method call, so it must be wrapped in parentheses.
+          if node.send_type? && node.operator_method? && !node.method?(:[])
+            "(#{node.source})"
+          else
+            node.source
+          end
+        end
+
         def replacement_method(arg, method)
           case arg
           when 0

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

@@ -5,11 +5,15 @@ module RuboCop
     module Style
       # Checks for exact regexp match inside `Regexp` literals.
       #
+      # `=~` returns an index and `match` returns `MatchData`, so they are only
+      # autocorrected when their value is used as a condition. The same goes for
+      # safe navigation calls, which return `nil` for a `nil` receiver.
+      #
       # @example
       #
       #   # bad
       #   string =~ /\Astring\z/
-      #   string === /\Astring\z/
+      #   /\Astring\z/ === string
       #   string.match(/\Astring\z/)
       #   string.match?(/\Astring\z/)
       #
@@ -27,14 +31,15 @@ module RuboCop
 
         MSG = 'Use `%<prefer>s`.'
         RESTRICT_ON_SEND = %i[=~ === !~ match match?].freeze
+        BOOLEAN_METHODS = %i[=== !~ match?].to_set.freeze
 
+        # `String#===` is plain equality, so `===` only matches with the regexp as its receiver.
         # @!method exact_regexp_match(node)
         def_node_matcher :exact_regexp_match, <<~PATTERN
-          (call
-            _ {:=~ :=== :!~ :match :match?}
-            (regexp
-              (str $_)
-              (regopt)))
+          {
+            (call _ {:=~ :!~ :match :match?} (regexp (str $_) (regopt)))
+            (send (regexp (str $_) (regopt)) :=== _)
+          }
         PATTERN
 
         def on_send(node)
@@ -43,16 +48,55 @@ module RuboCop
           return unless (parsed_regexp = parse_regexp(regexp))
           return unless exact_match_pattern?(parsed_regexp)
 
-          prefer = "#{receiver.source} #{new_method(node)} '#{parsed_regexp[1].text}'"
+          string = escape_single_quotes(parsed_regexp[1].text)
+          subject = node.method?(:===) ? node.first_argument : receiver
+          prefer = "#{subject.source} #{new_method(node)} '#{string}'"
 
           add_offense(node, message: format(MSG, prefer: prefer)) do |corrector|
-            corrector.replace(node, prefer)
+            autocorrect(corrector, node, prefer)
           end
         end
         alias on_csend on_send
 
         private
 
+        def autocorrect(corrector, node, prefer)
+          return unless boolean_result?(node) || truthiness_only?(node)
+
+          corrector.replace(node, parenthesize?(node) ? "(#{prefer})" : prefer)
+        end
+
+        # `=~` returns an index, `match` returns `MatchData` and `&.` can return `nil`,
+        # so replacing them with `==` is only safe where the value is used as a condition.
+        def boolean_result?(node)
+          node.send_type? && BOOLEAN_METHODS.include?(node.method_name)
+        end
+
+        def truthiness_only?(node)
+          return true unless node.value_used?
+
+          parent = node.parent
+          if parent.type?(:begin, :and, :or)
+            truthiness_only?(parent)
+          elsif parent.type?(:if, :while, :until)
+            parent.condition.equal?(node)
+          else
+            parent.send_type? && parent.method?(:!)
+          end
+        end
+
+        def parenthesize?(node)
+          return false unless (parent = node.parent)&.call_type?
+
+          parent.receiver.equal?(node) || (parent.operator_method? && !parent.method?(:[]))
+        end
+
+        # Escape characters that are special inside a single-quoted string so the
+        # generated literal (e.g. for `/\Afoo'bar\z/`) stays valid Ruby.
+        def escape_single_quotes(text)
+          text.gsub(/['\\]/) { |char| "\\#{char}" }
+        end
+
         def exact_match_pattern?(parsed_regexp)
           tokens = parsed_regexp.map(&:token)
           return false unless tokens[0] == :bos && tokens[1] == :literal && tokens[2] == :eos

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

@@ -50,13 +50,16 @@ module RuboCop
           (block $_ (args $...) (yield $...))
         PATTERN
 
+        # `Style/LambdaCall` rewrites the `call` that the block argument is appended to, and
+        # `Style/TrailingCommaInArguments` changes the trailing comma where it is appended,
+        # in the same pass.
         def self.autocorrect_incompatible_with
-          [Lint::UnusedMethodArgument]
+          [Lint::UnusedMethodArgument, Style::LambdaCall, Style::TrailingCommaInArguments]
         end
 
         def initialize(config = nil, options = nil)
           super
-          @def_nodes = Set.new
+          @def_nodes = Set.new.compare_by_identity
         end
 
         def on_yield(node)
@@ -65,15 +68,18 @@ 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
             return unless def_node
+            return if argument_forwarding?(def_node)
 
             block_name = extract_block_name(def_node)
 
             add_offense(block_node) do |corrector|
+              next unless can_add_block_argument?(def_node, send_node, block_name)
+
               corrector.remove(block_body_range(block_node, send_node))
 
               add_block_argument(send_node, corrector, block_name)
@@ -84,6 +90,11 @@ module RuboCop
 
         private
 
+        # A block parameter can't be added next to `...`.
+        def argument_forwarding?(def_node)
+          def_node.arguments.any?(&:forward_arg_type?)
+        end
+
         def extract_block_name(def_node)
           if def_node.block_argument?
             def_node.last_argument.name
@@ -92,6 +103,27 @@ module RuboCop
           end
         end
 
+        def can_add_block_argument?(def_node, send_node, block_name)
+          return false if block_name_taken?(def_node, block_name)
+
+          !send_node.zsuper_type? || zsuper_arguments_forwardable?(def_node)
+        end
+
+        def block_name_taken?(def_node, block_name)
+          return false if def_node.block_argument?
+
+          def_node.each_descendant(:argument, :lvasgn).any? { |node| node.name.to_s == block_name }
+        end
+
+        # A destructuring argument can only be passed on as the original value,
+        # and anonymous arguments can only be forwarded since Ruby 3.2.
+        def zsuper_arguments_forwardable?(def_node)
+          def_node.arguments.none? do |arg|
+            arg.mlhs_type? ||
+              (arg.type?(:restarg, :kwrestarg) && !arg.name && target_ruby_version < 3.2)
+          end
+        end
+
         def yielding_arguments?(block_args, yield_args)
           yield_args = yield_args.dup.fill(
             nil,
@@ -110,6 +142,8 @@ module RuboCop
             insert_argument(node, corrector, block_name)
           elsif empty_arguments?(node)
             corrector.replace(node.arguments, "(&#{block_name})")
+          elsif index_call?(node)
+            corrector.replace(node.loc.selector, "[&#{block_name}]")
           elsif call_like?(node)
             correct_call_node(node, corrector, block_name)
           else
@@ -122,6 +156,10 @@ module RuboCop
           node.arguments.is_a?(RuboCop::AST::Node) && node.arguments.loc.begin
         end
 
+        def index_call?(node)
+          node.send_type? && node.method?(:[]) && !node.loc?(:dot)
+        end
+
         def call_like?(node)
           node.type?(:call, :zsuper, :super)
         end
@@ -135,13 +173,28 @@ module RuboCop
         end
 
         def correct_call_node(node, corrector, block_name)
-          corrector.insert_after(node, "(&#{block_name})")
-          return unless node.parenthesized?
+          new_arguments = if node.zsuper_type?
+                            args = build_new_arguments_for_zsuper(node) << "&#{block_name}"
+                            args.join(', ')
+                          else
+                            "&#{block_name}"
+                          end
+          if node.parenthesized?
+            corrector.replace(node.loc.begin.join(node.loc.end), "(#{new_arguments})")
+          else
+            corrector.insert_after(node, "(#{new_arguments})")
+          end
+        end
 
-          args_begin = Util.args_begin(node)
-          args_end = Util.args_end(node)
-          range = range_between(args_begin.begin_pos, args_end.end_pos)
-          corrector.remove(range)
+        def build_new_arguments_for_zsuper(node)
+          def_node = node.each_ancestor(:any_def).first
+          def_node.arguments.filter_map do |arg|
+            case arg.type
+            when :arg, :optarg then arg.name.to_s
+            when :kwarg, :kwoptarg then "#{arg.name}: #{arg.name}"
+            when :restarg, :kwrestarg then arg.source
+            end
+          end
         end
 
         def block_body_range(block_node, send_node)

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

@@ -59,9 +59,10 @@ 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
 
@@ -87,7 +88,7 @@ module RuboCop
           true
         end
 
-        def integral(node)
+        def integral?(node)
           mantissa, = node.source.split('e')
           /^-?[1-9](\d*[1-9])?$/.match?(mantissa)
         end
@@ -101,7 +102,7 @@ module RuboCop
           when :engineering
             !engineering?(node)
           when :integral
-            !integral(node)
+            !integral?(node)
           else
             false
           end