rubocop 1.30.1 → 1.64.0

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

@@ -5,27 +5,46 @@ module RuboCop
     module Style
       # Checks for unwanted parentheses in parameterless method calls.
       #
+      # This cop can be customized allowed methods with `AllowedMethods`.
+      # By default, there are no methods to allowed.
+      #
+      # NOTE: This cop allows the use of `it()` without arguments in blocks,
+      # as in `0.times { it() }`, following `Lint/ItWithoutArgumentsInBlock` cop.
+      #
       # @example
       #   # bad
       #   object.some_method()
       #
       #   # good
       #   object.some_method
+      #
+      # @example AllowedMethods: [] (default)
+      #   # bad
+      #   object.foo()
+      #
+      # @example AllowedMethods: [foo]
+      #   # good
+      #   object.foo()
+      #
       class MethodCallWithoutArgsParentheses < Base
-        include IgnoredMethods
+        include AllowedMethods
+        include AllowedPattern
         extend AutoCorrector
 
         MSG = 'Do not use parentheses for method calls with no arguments.'
 
+        # rubocop:disable Metrics/CyclomaticComplexity
         def on_send(node)
           return unless !node.arguments? && node.parenthesized?
           return if ineligible_node?(node)
           return if default_argument?(node)
-          return if ignored_method?(node.method_name)
+          return if allowed_method_name?(node.method_name)
           return if same_name_assignment?(node)
+          return if parenthesized_it_method_in_block?(node)
 
           register_offense(node)
         end
+        # rubocop:enable Metrics/CyclomaticComplexity
 
         private
 
@@ -44,7 +63,13 @@ module RuboCop
           node.parent&.optarg_type?
         end
 
+        def allowed_method_name?(name)
+          allowed_method?(name) || matches_allowed_pattern?(name)
+        end
+
         def same_name_assignment?(node)
+          return false if node.receiver
+
           any_assignment?(node) do |asgn_node|
             next variable_in_mass_assignment?(node.method_name, asgn_node) if asgn_node.masgn_type?
 
@@ -52,6 +77,20 @@ module RuboCop
           end
         end
 
+        # Respects `Lint/ItWithoutArgumentsInBlock` cop and the following Ruby 3.3's warning:
+        #
+        # $ ruby -e '0.times { begin; it; end }'
+        # -e:1: warning: `it` calls without arguments will refer to the first block param in
+        # Ruby 3.4; use it() or self.it
+        #
+        def parenthesized_it_method_in_block?(node)
+          return false unless node.method?(:it)
+          return false unless (block_node = node.each_ancestor(:block).first)
+          return false unless block_node.arguments.empty_and_without_delimiters?
+
+          !node.receiver && node.arguments.empty? && !node.block_literal?
+        end
+
         def any_assignment?(node)
           node.each_ancestor(*AST::Node::ASSIGNMENTS).any? do |asgn_node|
             # `obj.method = value` parses as (send ... :method= ...), and will

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

@@ -35,12 +35,15 @@ module RuboCop
           ignore_node(node.send_node)
         end
 
+        alias on_numblock on_block
+
         def on_send(node)
           return if ignored_node?(node)
 
           receiver = node.receiver
 
-          return unless receiver&.block_type? && receiver.loc.end.is?('end')
+          return unless (receiver&.block_type? || receiver&.numblock_type?) &&
+                        receiver.loc.end.is?('end')
 
           range = range_between(receiver.loc.end.begin_pos, node.source_range.end_pos)
 

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

@@ -10,7 +10,9 @@ module RuboCop
       #
       # 1. Endless methods
       # 2. Argument lists containing a `forward-arg` (`...`)
-      # 3. Argument lists containing an anonymous block forwarding (`&`)
+      # 3. Argument lists containing an anonymous rest arguments forwarding (`*`)
+      # 4. Argument lists containing an anonymous keyword rest arguments forwarding (`**`)
+      # 5. Argument lists containing an anonymous block forwarding (`&`)
       #
       # Removing the parens would be a syntax error here.
       #
@@ -130,9 +132,11 @@ module RuboCop
           # Regardless of style, parentheses are necessary for:
           # 1. Endless methods
           # 2. Argument lists containing a `forward-arg` (`...`)
-          # 3. Argument lists containing an anonymous block forwarding (`&`)
+          # 3. Argument lists containing an anonymous rest arguments forwarding (`*`)
+          # 4. Argument lists containing an anonymous keyword rest arguments forwarding (`**`)
+          # 5. Argument lists containing an anonymous block forwarding (`&`)
           # Removing the parens would be a syntax error here.
-          node.endless? || node.arguments.any?(&:forward_arg_type?) || anonymous_block_arg?(node)
+          node.endless? || anonymous_arguments?(node)
         end
 
         def require_parentheses?(args)
@@ -162,8 +166,11 @@ module RuboCop
           end
         end
 
-        def anonymous_block_arg?(node)
-          return false unless (last_argument = node.arguments.last)
+        def anonymous_arguments?(node)
+          return true if node.arguments.any? do |arg|
+            arg.forward_arg_type? || arg.restarg_type? || arg.kwrestarg_type?
+          end
+          return false unless (last_argument = node.last_argument)
 
           last_argument.blockarg_type? && last_argument.name.nil?
         end

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

@@ -48,13 +48,13 @@ module RuboCop
           when :return
             argument_range(node)
           else
-            node.loc.expression
+            node.source_range
           end
         end
 
         def argument_range(node)
-          first_argument_range = node.children.first.loc.expression
-          last_argument_range  = node.children.last.loc.expression
+          first_argument_range = node.children.first.source_range
+          last_argument_range  = node.children.last.source_range
 
           first_argument_range.join(last_argument_range)
         end

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

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Enforces the use of `max` or `min` instead of comparison for greater or less.
+      #
+      # NOTE: It can be used if you want to present limit or threshold in Ruby 2.7+.
+      # That it is slow though. So autocorrection will apply generic `max` or `min`:
+      #
+      # [source,ruby]
+      # ----
+      # a.clamp(b..) # Same as `[a, b].max`
+      # a.clamp(..b) # Same as `[a, b].min`
+      # ----
+      #
+      # @safety
+      #   This cop is unsafe because even if a value has `<` or `>` method,
+      #   it is not necessarily `Comparable`.
+      #
+      # @example
+      #
+      #   # bad
+      #   a > b ? a : b
+      #   a >= b ? a : b
+      #
+      #   # good
+      #   [a, b].max
+      #
+      #   # bad
+      #   a < b ? a : b
+      #   a <= b ? a : b
+      #
+      #   # good
+      #   [a, b].min
+      #
+      class MinMaxComparison < Base
+        extend AutoCorrector
+        include RangeHelp
+
+        MSG = 'Use `%<prefer>s` instead.'
+        GRATER_OPERATORS = %i[> >=].freeze
+        LESS_OPERATORS = %i[< <=].freeze
+        COMPARISON_OPERATORS = GRATER_OPERATORS + LESS_OPERATORS
+
+        def on_if(node)
+          lhs, operator, rhs = *node.condition
+          return unless COMPARISON_OPERATORS.include?(operator)
+
+          if_branch = node.if_branch
+          else_branch = node.else_branch
+          preferred_method = preferred_method(operator, lhs, rhs, if_branch, else_branch)
+          return unless preferred_method
+
+          replacement = "[#{lhs.source}, #{rhs.source}].#{preferred_method}"
+
+          add_offense(node, message: format(MSG, prefer: replacement)) do |corrector|
+            autocorrect(corrector, node, replacement)
+          end
+        end
+
+        private
+
+        def preferred_method(operator, lhs, rhs, if_branch, else_branch)
+          if lhs == if_branch && rhs == else_branch
+            GRATER_OPERATORS.include?(operator) ? 'max' : 'min'
+          elsif lhs == else_branch && rhs == if_branch
+            LESS_OPERATORS.include?(operator) ? 'max' : 'min'
+          end
+        end
+
+        def autocorrect(corrector, node, replacement)
+          if node.elsif?
+            corrector.remove(range_between(node.parent.loc.else.begin_pos, node.loc.else.begin_pos))
+            corrector.replace(node.else_branch, replacement)
+          else
+            corrector.replace(node, replacement)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -99,6 +99,7 @@ module RuboCop
       class MissingElse < Base
         include OnNormalIfUnless
         include ConfigurableEnforcedStyle
+        extend AutoCorrector
 
         MSG = '`%<type>s` condition requires an `else`-clause.'
         MSG_NIL = '`%<type>s` condition requires an `else`-clause with `nil` in it.'
@@ -126,7 +127,9 @@ module RuboCop
         def check(node)
           return if node.else?
 
-          add_offense(node, message: format(message_template, type: node.type))
+          add_offense(node, message: format(message_template, type: node.type)) do |corrector|
+            autocorrect(corrector, node)
+          end
         end
 
         def message_template
@@ -140,6 +143,15 @@ module RuboCop
           end
         end
 
+        def autocorrect(corrector, node)
+          case empty_else_style
+          when :empty
+            corrector.insert_before(node.loc.end, 'else; nil; ')
+          when :nil
+            corrector.insert_before(node.loc.end, 'else; ')
+          end
+        end
+
         def if_style?
           style == :if
         end

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

@@ -7,12 +7,12 @@ module RuboCop
       # defining `respond_to_missing?`.
       #
       # @example
-      #   #bad
+      #   # bad
       #   def method_missing(name, *args)
       #     # ...
       #   end
       #
-      #   #good
+      #   # good
       #   def respond_to_missing?(name, include_private)
       #     # ...
       #   end

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

@@ -40,7 +40,7 @@ module RuboCop
         def on_class(node)
           begin_node = node.child_nodes.find(&:begin_type?) || node
           begin_node.each_child_node(:send).select(&:macro?).each do |macro|
-            next unless MIXIN_METHODS.include?(macro.method_name)
+            next if !MIXIN_METHODS.include?(macro.method_name) || macro.arguments.empty?
 
             check(macro)
           end
@@ -51,9 +51,9 @@ module RuboCop
         private
 
         def range_to_remove_for_subsequent_mixin(mixins, node)
-          range = node.loc.expression
+          range = node.source_range
           prev_mixin = mixins.each_cons(2) { |m, n| break m if n == node }
-          between = prev_mixin.loc.expression.end.join(range.begin)
+          between = prev_mixin.source_range.end.join(range.begin)
           # if separated from previous mixin with only whitespace?
           unless /\S/.match?(between.source)
             range = range.join(between) # then remove that too
@@ -75,7 +75,7 @@ module RuboCop
           message = format(MSG, mixin: send_node.method_name, suffix: 'a single statement')
 
           add_offense(send_node, message: message) do |corrector|
-            range = send_node.loc.expression
+            range = send_node.source_range
             mixins = sibling_mixins(send_node)
             if send_node == mixins.first
               correction = group_mixins(send_node, mixins)
@@ -94,7 +94,7 @@ module RuboCop
           message = format(MSG, mixin: send_node.method_name, suffix: 'separate statements')
 
           add_offense(send_node, message: message) do |corrector|
-            range = send_node.loc.expression
+            range = send_node.source_range
             correction = separate_mixins(send_node)
 
             corrector.replace(range, correction)

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

@@ -3,13 +3,15 @@
 module RuboCop
   module Cop
     module Style
-      # Checks for use of `extend self` or `module_function` in a
-      # module.
+      # Checks for use of `extend self` or `module_function` in a module.
       #
-      # Supported styles are: module_function, extend_self, forbidden. `forbidden`
-      # style prohibits the usage of both styles.
+      # Supported styles are: `module_function` (default), `extend_self` and `forbidden`.
       #
-      # NOTE: the cop won't be activated when the module contains any private methods.
+      # A couple of things to keep in mind:
+      #
+      # - `forbidden` style prohibits the usage of both styles
+      # - in default mode (`module_function`), the cop won't be activated when the module
+      #   contains any private methods
       #
       # @safety
       #   Autocorrection is unsafe (and is disabled by default) because `extend self`
@@ -28,7 +30,6 @@ module RuboCop
       #     # ...
       #   end
       #
-      # @example EnforcedStyle: module_function (default)
       #   # good
       #   module Test
       #     extend self
@@ -37,6 +38,13 @@ module RuboCop
       #     # ...
       #   end
       #
+      #   # good
+      #   module Test
+      #     class << self
+      #       # ...
+      #     end
+      #   end
+      #
       # @example EnforcedStyle: extend_self
       #   # bad
       #   module Test
@@ -50,6 +58,13 @@ module RuboCop
       #     # ...
       #   end
       #
+      #   # good
+      #   module Test
+      #     class << self
+      #       # ...
+      #     end
+      #   end
+      #
       # @example EnforcedStyle: forbidden
       #   # bad
       #   module Test
@@ -70,6 +85,13 @@ module RuboCop
       #     private
       #     # ...
       #   end
+      #
+      #   # good
+      #   module Test
+      #     class << self
+      #       # ...
+      #     end
+      #   end
       class ModuleFunction < Base
         include ConfigurableEnforcedStyle
         extend AutoCorrector
@@ -117,10 +139,10 @@ module RuboCop
         end
 
         def check_module_function(nodes)
-          private_directive = nodes.any? { |node| private_directive?(node) }
+          return if nodes.any? { |node| private_directive?(node) }
 
           nodes.each do |node|
-            yield node if extend_self_node?(node) && !private_directive
+            yield node if extend_self_node?(node)
           end
         end
 

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

@@ -28,10 +28,10 @@ module RuboCop
         MSG = 'Avoid multi-line chains of blocks.'
 
         def on_block(node)
-          node.send_node.each_node(:send) do |send_node|
+          node.send_node.each_node(:send, :csend) do |send_node|
             receiver = send_node.receiver
 
-            next unless receiver&.block_type? && receiver&.multiline?
+            next unless (receiver&.block_type? || receiver&.numblock_type?) && receiver&.multiline?
 
             range = range_between(receiver.loc.end.begin_pos, node.send_node.source_range.end_pos)
 
@@ -42,6 +42,8 @@ module RuboCop
             break
           end
         end
+
+        alias on_numblock on_block
       end
     end
   end

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

@@ -19,8 +19,8 @@ module RuboCop
         include Alignment
         extend AutoCorrector
 
-        MSG = 'Favor a normal %<keyword>s-statement over a modifier' \
-              ' clause in a multiline statement.'
+        MSG = 'Favor a normal %<keyword>s-statement over a modifier ' \
+              'clause in a multiline statement.'
 
         def on_if(node)
           return unless node.modifier_form? && node.body.multiline?
@@ -40,10 +40,6 @@ module RuboCop
           [condition, indented_body, indented_end].join("\n")
         end
 
-        def configured_indentation_width
-          super || 2
-        end
-
         def indented_body(body, node)
           body_source = "#{offset(node)}#{body.source}"
           body_source.each_line.map do |line|

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

@@ -29,7 +29,7 @@ module RuboCop
           return unless non_modifier_then?(node)
 
           add_offense(node.loc.begin, message: format(MSG, keyword: node.keyword)) do |corrector|
-            corrector.remove(range_with_surrounding_space(range: node.loc.begin, side: :left))
+            corrector.remove(range_with_surrounding_space(node.loc.begin, side: :left))
           end
         end
 

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

@@ -41,9 +41,7 @@ module RuboCop
 
           range = node.loc.begin
           add_offense(range) do |corrector|
-            corrector.remove(
-              range_with_surrounding_space(range: range, side: :left, newlines: false)
-            )
+            corrector.remove(range_with_surrounding_space(range, side: :left, newlines: false))
           end
         end
 
@@ -51,7 +49,7 @@ module RuboCop
 
         # Requires `then` for write `in` and its body on the same line.
         def require_then?(in_pattern_node)
-          return true if in_pattern_node.pattern.first_line != in_pattern_node.pattern.last_line
+          return true unless in_pattern_node.pattern.single_line?
           return false unless in_pattern_node.body
 
           same_line?(in_pattern_node, in_pattern_node.body)

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

@@ -31,6 +31,7 @@ module RuboCop
       #     baz
       #   )
       class MultilineMemoization < Base
+        include Alignment
         include ConfigurableEnforcedStyle
         extend AutoCorrector
 
@@ -75,11 +76,10 @@ module RuboCop
         end
 
         def keyword_begin_str(node, node_buf)
-          indent = config.for_cop('Layout/IndentationWidth')['Width'] || 2
           if node_buf.source[node.loc.begin.end_pos] == "\n"
             'begin'
           else
-            "begin\n#{' ' * (node.loc.column + indent)}"
+            "begin\n#{' ' * (node.loc.column + configured_indentation_width)}"
           end
         end
 

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

@@ -28,14 +28,18 @@ module RuboCop
           return unless node.arguments?
           return if opening_line(node) == closing_line(node)
           return if correction_exceeds_max_line_length?(node)
+          return unless (begin_of_arguments = node.arguments.loc.begin)
 
-          add_offense(node) { |corrector| autocorrect(corrector, node) }
+          add_offense(node) do |corrector|
+            autocorrect(corrector, node, begin_of_arguments)
+          end
         end
         alias on_defs on_def
 
         private
 
-        def autocorrect(corrector, node)
+        # rubocop:disable Metrics/AbcSize
+        def autocorrect(corrector, node, begin_of_arguments)
           arguments = node.arguments
           joined_arguments = arguments.map(&:source).join(', ')
           last_line_source_of_arguments = last_line_source_of_arguments(arguments)
@@ -46,9 +50,17 @@ module RuboCop
             corrector.remove(range_by_whole_lines(arguments.loc.end, include_final_newline: true))
           end
 
-          corrector.remove(arguments_range(node))
-          corrector.insert_after(arguments.loc.begin, joined_arguments)
+          arguments_range = arguments_range(node)
+          # 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)
+            corrector.insert_after(node.loc.keyword, " #{node.loc.name.source}")
+          end
+
+          corrector.remove(arguments_range)
+          corrector.insert_after(begin_of_arguments, joined_arguments)
         end
+        # rubocop:enable Metrics/AbcSize
 
         def last_line_source_of_arguments(arguments)
           processed_source[arguments.last_line - 1].strip
@@ -59,7 +71,7 @@ module RuboCop
             node.first_argument.source_range.begin_pos, node.last_argument.source_range.end_pos
           )
 
-          range_with_surrounding_space(range: range, side: :left)
+          range_with_surrounding_space(range, side: :left)
         end
 
         def opening_line(node)
@@ -75,7 +87,7 @@ module RuboCop
         end
 
         def indentation_width(node)
-          processed_source.line_indentation(node.loc.expression.line)
+          processed_source.line_indentation(node.source_range.line)
         end
 
         def definition_width(node)

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

@@ -34,11 +34,12 @@ module RuboCop
       #   return cond ? b : c
       #
       class MultilineTernaryOperator < Base
+        include CommentsHelp
         extend AutoCorrector
 
         MSG_IF = 'Avoid multi-line ternary operators, use `if` or `unless` instead.'
         MSG_SINGLE_LINE = 'Avoid multi-line ternary operators, use single-line instead.'
-        SINGLE_LINE_TYPES = %i[return break next send].freeze
+        SINGLE_LINE_TYPES = %i[return break next send csend].freeze
 
         def on_if(node)
           return unless offense?(node)
@@ -46,16 +47,26 @@ module RuboCop
           message = enforce_single_line_ternary_operator?(node) ? MSG_SINGLE_LINE : MSG_IF
 
           add_offense(node, message: message) do |corrector|
-            next unless offense?(node)
+            next if part_of_ignored_node?(node)
 
-            corrector.replace(node, replacement(node))
+            autocorrect(corrector, node)
+
+            ignore_node(node)
           end
         end
 
         private
 
         def offense?(node)
-          node.ternary? && node.multiline?
+          node.ternary? && node.multiline? && node.source != replacement(node)
+        end
+
+        def autocorrect(corrector, node)
+          corrector.replace(node, replacement(node))
+          return unless (parent = node.parent)
+          return unless (comments_in_condition = comments_in_condition(node))
+
+          corrector.insert_before(parent, comments_in_condition)
         end
 
         def replacement(node)
@@ -72,8 +83,14 @@ module RuboCop
           end
         end
 
+        def comments_in_condition(node)
+          comments_in_range(node).map do |comment|
+            "#{comment.source}\n"
+          end.join
+        end
+
         def enforce_single_line_ternary_operator?(node)
-          SINGLE_LINE_TYPES.include?(node.parent.type) && !use_assignment_method?(node.parent)
+          SINGLE_LINE_TYPES.include?(node.parent&.type) && !use_assignment_method?(node.parent)
         end
 
         def use_assignment_method?(node)

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

@@ -39,9 +39,7 @@ module RuboCop
 
           range = node.loc.begin
           add_offense(range) do |corrector|
-            corrector.remove(
-              range_with_surrounding_space(range: range, side: :left, newlines: false)
-            )
+            corrector.remove(range_with_surrounding_space(range, side: :left, newlines: false))
           end
         end
 

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

@@ -40,6 +40,15 @@ module RuboCop
       #
       #   # good
       #   foo if [b.lightweight, b.heavyweight].include?(a)
+      #
+      # @example ComparisonsThreshold: 2 (default)
+      #   # bad
+      #   foo if a == 'a' || a == 'b'
+      #
+      # @example ComparisonsThreshold: 3
+      #   # good
+      #   foo if a == 'a' || a == 'b'
+      #
       class MultipleComparison < Base
         extend AutoCorrector
 
@@ -58,6 +67,7 @@ module RuboCop
           return unless node == root_of_or_node
           return unless nested_variable_comparison?(root_of_or_node)
           return if @allowed_method_comparison
+          return if @compared_elements.size < comparisons_threshold
 
           add_offense(node) do |corrector|
             elements = @compared_elements.join(', ')
@@ -151,6 +161,10 @@ module RuboCop
         def allow_method_comparison?
           cop_config.fetch('AllowMethodComparison', true)
         end
+
+        def comparisons_threshold
+          cop_config.fetch('ComparisonsThreshold', 2)
+        end
       end
     end
   end