rubocop 1.31.1 → 1.52.1

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

@@ -13,22 +13,20 @@ module RuboCop
 
           private
 
-          # rubocop:disable Metrics/PerceivedComplexity
-          def omit_parentheses(node)
+          def omit_parentheses(node) # rubocop:disable Metrics/PerceivedComplexity
             return unless node.parenthesized?
             return if inside_endless_method_def?(node)
             return if require_parentheses_for_hash_value_omission?(node)
             return if syntax_like_method_call?(node)
             return if super_call_without_arguments?(node)
-            return if allowed_camel_case_method_call?(node)
             return if legitimate_call_with_parentheses?(node)
+            return if allowed_camel_case_method_call?(node)
             return if allowed_string_interpolation_method_call?(node)
 
             add_offense(offense_range(node), message: OMIT_MSG) do |corrector|
               autocorrect(corrector, node)
             end
           end
-          # rubocop:enable Metrics/PerceivedComplexity
 
           def autocorrect(corrector, node)
             if parentheses_at_the_end_of_multiline_call?(node)
@@ -52,17 +50,13 @@ module RuboCop
             return false unless (last_argument = node.last_argument)
             return false if !last_argument.hash_type? || !last_argument.pairs.last&.value_omission?
 
-            modifier_form?(node) || exist_next_line_expression?(node)
-          end
-
-          def modifier_form?(node)
-            node.parent.respond_to?(:modifier_form?) && node.parent.modifier_form?
+            node.parent&.conditional? || !last_expression?(node)
           end
 
           # Require hash value omission be enclosed in parentheses to prevent the following issue:
           # https://bugs.ruby-lang.org/issues/18396.
-          def exist_next_line_expression?(node)
-            node.parent&.assignment? ? node.parent.right_sibling : node.right_sibling
+          def last_expression?(node)
+            !(node.parent&.assignment? ? node.parent.right_sibling : node.right_sibling)
           end
 
           def syntax_like_method_call?(node)
@@ -90,31 +84,36 @@ module RuboCop
                   .end_with?('(')
           end
 
-          def legitimate_call_with_parentheses?(node)
+          def legitimate_call_with_parentheses?(node) # rubocop:disable Metrics/PerceivedComplexity
             call_in_literals?(node) ||
               call_with_ambiguous_arguments?(node) ||
               call_in_logical_operators?(node) ||
               call_in_optional_arguments?(node) ||
               call_in_single_line_inheritance?(node) ||
               allowed_multiline_call_with_parentheses?(node) ||
-              allowed_chained_call_with_parentheses?(node)
+              allowed_chained_call_with_parentheses?(node) ||
+              assignment_in_condition?(node) ||
+              forwards_anonymous_rest_arguments?(node)
           end
 
           def call_in_literals?(node)
-            node.parent &&
-              (node.parent.pair_type? ||
-              node.parent.array_type? ||
-              node.parent.range_type? ||
-              splat?(node.parent) ||
-              ternary_if?(node.parent))
+            parent = node.parent&.block_type? ? node.parent.parent : node.parent
+            return unless parent
+
+            parent.pair_type? ||
+              parent.array_type? ||
+              parent.range_type? ||
+              splat?(parent) ||
+              ternary_if?(parent)
           end
 
           def call_in_logical_operators?(node)
             parent = node.parent&.block_type? ? node.parent.parent : node.parent
-            parent &&
-              (logical_operator?(parent) ||
+            return unless parent
+
+            logical_operator?(parent) ||
               (parent.send_type? &&
-              parent.arguments.any? { |argument| logical_operator?(argument) }))
+              parent.arguments.any? { |argument| logical_operator?(argument) })
           end
 
           def call_in_optional_arguments?(node)
@@ -130,14 +129,13 @@ module RuboCop
               call_as_argument_or_chain?(node) ||
               hash_literal_in_arguments?(node) ||
               node.descendants.any? do |n|
-                n.forwarded_args_type? || ambigious_literal?(n) || logical_operator?(n) ||
+                n.forwarded_args_type? || ambiguous_literal?(n) || logical_operator?(n) ||
                   call_with_braced_block?(n)
               end
           end
 
           def call_with_braced_block?(node)
-            (node.send_type? || node.super_type?) &&
-              ((node.parent&.block_type? || node.parent&.numblock_type?) && node.parent&.braces?)
+            (node.send_type? || node.super_type?) && node.block_node&.braces?
           end
 
           def call_as_argument_or_chain?(node)
@@ -166,7 +164,7 @@ module RuboCop
             previous.parenthesized? || allowed_chained_call_with_parentheses?(previous)
           end
 
-          def ambigious_literal?(node)
+          def ambiguous_literal?(node)
             splat?(node) || ternary_if?(node) || regexp_slash_literal?(node) || unary_literal?(node)
           end
 
@@ -202,6 +200,23 @@ module RuboCop
           def inside_string_interpolation?(node)
             node.ancestors.drop_while { |a| !a.begin_type? }.any?(&:dstr_type?)
           end
+
+          def assignment_in_condition?(node)
+            parent = node.parent
+            return false unless parent
+
+            grandparent = parent.parent
+            return false unless grandparent
+
+            parent.assignment? && (grandparent.conditional? || grandparent.when_type?)
+          end
+
+          def forwards_anonymous_rest_arguments?(node)
+            return false unless (last_argument = node.last_argument)
+            return true if last_argument.forwarded_restarg_type?
+
+            last_argument.hash_type? && last_argument.children.first&.forwarded_kwrestarg_type?
+          end
         end
         # rubocop:enable Metrics/ModuleLength, Metrics/CyclomaticComplexity
       end

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

@@ -12,7 +12,7 @@ module RuboCop
           private
 
           def require_parentheses(node)
-            return if ignored_method?(node.method_name)
+            return if allowed_method_name?(node.method_name)
             return if matches_allowed_pattern?(node.method_name)
             return if eligible_for_parentheses_omission?(node)
             return unless node.arguments? && !node.parenthesized?
@@ -24,6 +24,10 @@ module RuboCop
             end
           end
 
+          def allowed_method_name?(name)
+            allowed_method?(name) || matches_allowed_pattern?(name)
+          end
+
           def eligible_for_parentheses_omission?(node)
             node.operator_method? || node.setter_method? || ignored_macro?(node)
           end

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

@@ -6,22 +6,20 @@ module RuboCop
       # Enforces the presence (default) or absence of parentheses in
       # method calls containing parameters.
       #
-      # In the default style (require_parentheses), macro methods are ignored.
-      # Additional methods can be added to the `IgnoredMethods`
-      # or `AllowedPatterns` list. These options are
-      # valid only in the default style. Macros can be included by
-      # either setting `IgnoreMacros` to false or adding specific macros to
-      # the `IncludedMacros` list.
+      # In the default style (require_parentheses), macro methods are allowed.
+      # Additional methods can be added to the `AllowedMethods` or
+      # `AllowedPatterns` list. These options are valid only in the default
+      # style. Macros can be included by either setting `IgnoreMacros` to false
+      # or adding specific macros to the `IncludedMacros` list.
       #
-      # Precedence of options is all follows:
+      # Precedence of options is as follows:
       #
-      # 1. `IgnoredMethods`
+      # 1. `AllowedMethods`
       # 2. `AllowedPatterns`
       # 3. `IncludedMacros`
       #
-      # eg. If a method is listed in both
-      # `IncludedMacros` and `IgnoredMethods`, then the latter takes
-      # precedence (that is, the method is ignored).
+      # If a method is listed in both `IncludedMacros` and `AllowedMethods`,
+      # then the latter takes precedence (that is, the method is allowed).
       #
       # In the alternative style (omit_parentheses), there are three additional
       # options.
@@ -40,14 +38,29 @@ module RuboCop
       #     to `true` allows the presence of parentheses in such a method call
       #     even with arguments.
       #
-      # NOTE: Parentheses are still allowed in cases where omitting them
-      # results in ambiguous or syntactically incorrect code. For example,
-      # parentheses are required around a method with arguments when inside an
-      # endless method definition introduced in Ruby 3.0. Parentheses are also
-      # allowed when forwarding arguments with the triple-dot syntax introduced
-      # in Ruby 2.7 as omitting them starts an endless range.
-      # And Ruby 3.1's hash omission syntax has a case that requires parentheses
-      # because of the following issue: https://bugs.ruby-lang.org/issues/18396.
+      # NOTE: The style of `omit_parentheses` allows parentheses in cases where
+      # omitting them results in ambiguous or syntactically incorrect code.
+      #
+      # Non-exhaustive list of examples:
+      #
+      # - Parentheses are required allowed in method calls with arguments inside
+      #   literals, logical operators, setting default values in position and
+      #   keyword arguments, chaining and more.
+      # - Parentheses are allowed in method calls with arguments inside
+      #   operators to avoid ambiguity.
+      #   triple-dot syntax introduced in Ruby 2.7 as omitting them starts an
+      #   endless range.
+      # - Parentheses are allowed when forwarding arguments with the
+      #   triple-dot syntax introduced in Ruby 2.7 as omitting them starts an
+      #   endless range.
+      # - Parentheses are required in calls with arguments when inside an
+      #   endless method definition introduced in Ruby 3.0.
+      # - Ruby 3.1's hash omission syntax allows parentheses if the method call
+      #   is in conditionals and requires parentheses if the call
+      #   is not the value-returning expression. See
+      #   https://bugs.ruby-lang.org/issues/18396.
+      # - Parentheses are required in anonymous arguments, keyword arguments
+      #   and block passing in Ruby 3.2.
       #
       # @example EnforcedStyle: require_parentheses (default)
       #
@@ -65,7 +78,7 @@ module RuboCop
       #   # Setter methods don't need parens
       #   foo.bar = baz
       #
-      #   # okay with `puts` listed in `IgnoredMethods`
+      #   # okay with `puts` listed in `AllowedMethods`
       #   puts 'test'
       #
       #   # okay with `^assert` listed in `AllowedPatterns`
@@ -80,34 +93,28 @@ module RuboCop
       #   array.delete e
       #
       #   # bad
-      #   foo.enforce(strict: true)
+      #   action.enforce(strict: true)
       #
       #   # good
-      #   foo.enforce strict: true
+      #   action.enforce strict: true
       #
       #   # good
-      #   # Allows parens for calls that won't produce valid Ruby or be ambiguous.
-      #   model.validate strict(true)
+      #   # Parentheses are allowed for code that can be ambiguous without
+      #   # them.
+      #   action.enforce(condition) || other_condition
       #
       #   # good
-      #   # Allows parens for calls that won't produce valid Ruby or be ambiguous.
+      #   # Parentheses are allowed for calls that won't produce valid Ruby
+      #   # without them.
       #   yield path, File.basename(path)
       #
       #   # good
-      #   # Operators methods calls with parens
-      #   array&.[](index)
-      #
-      #   # good
-      #   # Operators methods without parens, if you prefer
-      #   array.[] index
-      #
-      #   # good
-      #   # Operators methods calls with parens
-      #   array&.[](index)
-      #
-      #   # good
-      #   # Operators methods without parens, if you prefer
-      #   array.[] index
+      #   # Omitting the parentheses in Ruby 3.1 hash omission syntax can lead
+      #   # to ambiguous code. We allow them in conditionals and non-last
+      #   # expressions. See https://bugs.ruby-lang.org/issues/18396
+      #   if meets(criteria:, action:)
+      #     safe_action(action) || dangerous_action(action)
+      #   end
       #
       # @example IgnoreMacros: true (default)
       #
@@ -197,7 +204,7 @@ module RuboCop
         require_relative 'method_call_with_args_parentheses/require_parentheses'
 
         include ConfigurableEnforcedStyle
-        include IgnoredMethods
+        include AllowedMethods
         include AllowedPattern
         include RequireParentheses
         include OmitParentheses
@@ -226,7 +233,7 @@ module RuboCop
         end
 
         def args_end(node)
-          node.loc.expression.end
+          node.source_range.end
         end
 
         def args_parenthesized?(node)

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

@@ -5,14 +5,27 @@ 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.
+      #
       # @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.'
@@ -21,7 +34,7 @@ module RuboCop
           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)
 
           register_offense(node)
@@ -44,7 +57,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?
 

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,7 +166,10 @@ module RuboCop
           end
         end
 
-        def anonymous_block_arg?(node)
+        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.arguments.last)
 
           last_argument.blockarg_type? && last_argument.name.nil?

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

@@ -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