rubocop 1.9.1 → 1.22.3

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

@@ -5,6 +5,7 @@ module RuboCop
     module Style
       class MethodCallWithArgsParentheses
         # Style omit_parentheses
+        # rubocop:disable Metrics/ModuleLength, Metrics/CyclomaticComplexity
         module OmitParentheses
           TRAILING_WHITESPACE_REGEX = /\s+\Z/.freeze
           OMIT_MSG = 'Omit parentheses for method calls with arguments.'
@@ -15,10 +16,11 @@ module RuboCop
           def omit_parentheses(node)
             return unless node.parenthesized?
             return if inside_endless_method_def?(node)
-            return if node.implicit_call?
+            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_string_interpolation_method_call?(node)
 
             add_offense(offense_range(node), message: OMIT_MSG) do |corrector|
               auto_correct(corrector, node)
@@ -40,7 +42,11 @@ module RuboCop
 
           def inside_endless_method_def?(node)
             # parens are required around arguments inside an endless method
-            node.each_ancestor(:def).any?(&:endless?) && node.arguments.any?
+            node.each_ancestor(:def, :defs).any?(&:endless?) && node.arguments.any?
+          end
+
+          def syntax_like_method_call?(node)
+            node.implicit_call? || node.operator_method?
           end
 
           def super_call_without_arguments?(node)
@@ -49,8 +55,12 @@ module RuboCop
 
           def allowed_camel_case_method_call?(node)
             node.camel_case_method? &&
-              (node.arguments.none? ||
-              cop_config['AllowParenthesesInCamelCaseMethod'])
+              (node.arguments.none? || cop_config['AllowParenthesesInCamelCaseMethod'])
+          end
+
+          def allowed_string_interpolation_method_call?(node)
+            cop_config['AllowParenthesesInStringInterpolation'] &&
+              inside_string_interpolation?(node)
           end
 
           def parentheses_at_the_end_of_multiline_call?(node)
@@ -83,13 +93,12 @@ module RuboCop
             parent = node.parent&.block_type? ? node.parent.parent : node.parent
             parent &&
               (logical_operator?(parent) ||
-              parent.send_type? &&
-              parent.arguments.any? { |argument| logical_operator?(argument) })
+              (parent.send_type? &&
+              parent.arguments.any? { |argument| logical_operator?(argument) }))
           end
 
           def call_in_optional_arguments?(node)
-            node.parent &&
-              (node.parent.optarg_type? || node.parent.kwoptarg_type?)
+            node.parent && (node.parent.optarg_type? || node.parent.kwoptarg_type?)
           end
 
           def call_in_single_line_inheritance?(node)
@@ -101,26 +110,26 @@ module RuboCop
               call_as_argument_or_chain?(node) ||
               hash_literal_in_arguments?(node) ||
               node.descendants.any? do |n|
-                ambigious_literal?(n) || logical_operator?(n) ||
+                n.forwarded_args_type? || ambigious_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.block_node && node.block_node.braces?
+              ((node.parent&.block_type? || node.parent&.numblock_type?) && node.parent&.braces?)
           end
 
           def call_as_argument_or_chain?(node)
             node.parent &&
-              (node.parent.send_type? && !assigned_before?(node.parent, node) ||
-              node.parent.csend_type? || node.parent.super_type?)
+              ((node.parent.send_type? && !assigned_before?(node.parent, node)) ||
+              node.parent.csend_type? || node.parent.super_type? || node.parent.yield_type?)
           end
 
           def hash_literal_in_arguments?(node)
             node.arguments.any? do |n|
               hash_literal?(n) ||
-                n.send_type? && node.descendants.any? { |descendant| hash_literal?(descendant) }
+                (n.send_type? && node.descendants.any? { |descendant| hash_literal?(descendant) })
             end
           end
 
@@ -134,13 +143,11 @@ module RuboCop
             previous = node.descendants.first
             return false unless previous&.send_type?
 
-            previous.parenthesized? ||
-              allowed_chained_call_with_parentheses?(previous)
+            previous.parenthesized? || allowed_chained_call_with_parentheses?(previous)
           end
 
           def ambigious_literal?(node)
-            splat?(node) || ternary_if?(node) || regexp_slash_literal?(node) ||
-              unary_literal?(node)
+            splat?(node) || ternary_if?(node) || regexp_slash_literal?(node) || unary_literal?(node)
           end
 
           def splat?(node)
@@ -164,15 +171,19 @@ module RuboCop
           end
 
           def unary_literal?(node)
-            node.numeric_type? && node.sign? ||
-              node.parent&.send_type? && node.parent&.unary_operation?
+            (node.numeric_type? && node.sign?) ||
+              (node.parent&.send_type? && node.parent&.unary_operation?)
           end
 
           def assigned_before?(node, target)
-            node.assignment? &&
-              node.loc.operator.begin < target.loc.begin
+            node.assignment? && node.loc.operator.begin < target.loc.begin
+          end
+
+          def inside_string_interpolation?(node)
+            node.ancestors.drop_while { |a| !a.begin_type? }.any?(&:dstr_type?)
           end
         end
+        # rubocop:enable Metrics/ModuleLength, Metrics/CyclomaticComplexity
       end
     end
   end

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

@@ -40,8 +40,12 @@ module RuboCop
       #     to `true` allows the presence of parentheses in such a method call
       #     even with arguments.
       #
-      # NOTE: Parens are required around a method with arguments when inside an
-      # endless method definition (>= Ruby 3.0).
+      # 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.
       #
       # @example EnforcedStyle: require_parentheses (default)
       #
@@ -79,6 +83,30 @@ module RuboCop
       #   # good
       #   foo.enforce strict: true
       #
+      #   # good
+      #   # Allows parens for calls that won't produce valid Ruby or be ambiguous.
+      #   model.validate strict(true)
+      #
+      #   # good
+      #   # Allows parens for calls that won't produce valid Ruby or be ambiguous.
+      #   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
+      #
       # @example IgnoreMacros: true (default)
       #
       #   # good
@@ -146,6 +174,22 @@ module RuboCop
       #
       #   # good
       #   Array 1
+      #
+      # @example AllowParenthesesInStringInterpolation: false (default)
+      #
+      #   # bad
+      #   "#{t('this.is.bad')}"
+      #
+      #   # good
+      #   "#{t 'this.is.better'}"
+      #
+      # @example AllowParenthesesInStringInterpolation: true
+      #
+      #   # good
+      #   "#{t('this.is.good')}"
+      #
+      #   # good
+      #   "#{t 'this.is.also.good'}"
       class MethodCallWithArgsParentheses < Base
         require_relative 'method_call_with_args_parentheses/omit_parentheses'
         require_relative 'method_call_with_args_parentheses/require_parentheses'
@@ -158,7 +202,7 @@ module RuboCop
         extend AutoCorrector
 
         def self.autocorrect_incompatible_with
-          [Style::NestedParenthesizedCalls]
+          [Style::NestedParenthesizedCalls, Style::RescueModifier]
         end
 
         def on_send(node)

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

@@ -15,8 +15,7 @@ module RuboCop
         include IgnoredMethods
         extend AutoCorrector
 
-        MSG = 'Do not use parentheses for method calls with ' \
-              'no arguments.'
+        MSG = 'Do not use parentheses for method calls with no arguments.'
 
         def on_send(node)
           return unless !node.arguments? && node.parenthesized?

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

@@ -40,11 +40,9 @@ module RuboCop
 
           receiver = node.receiver
 
-          return unless receiver&.block_type? &&
-                        receiver.loc.end.is?('end')
+          return unless receiver&.block_type? && receiver.loc.end.is?('end')
 
-          range = range_between(receiver.loc.end.begin_pos,
-                                node.source_range.end_pos)
+          range = range_between(receiver.loc.end.begin_pos, node.source_range.end_pos)
 
           add_offense(range)
         end

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

@@ -93,11 +93,10 @@ module RuboCop
         extend AutoCorrector
 
         MSG_PRESENT = 'Use def without parentheses.'
-        MSG_MISSING = 'Use def with parentheses when there are ' \
-                      'parameters.'
+        MSG_MISSING = 'Use def with parentheses when there are parameters.'
 
         def on_def(node)
-          return if node.endless?
+          return if forced_parentheses?(node)
 
           args = node.arguments
 
@@ -124,18 +123,24 @@ module RuboCop
 
         def correct_definition(def_node, corrector)
           arguments_range = def_node.arguments.source_range
-          args_with_space = range_with_surrounding_space(range: arguments_range,
-                                                         side: :left)
-          leading_space = range_between(args_with_space.begin_pos,
-                                        arguments_range.begin_pos)
+          args_with_space = range_with_surrounding_space(range: arguments_range, side: :left)
+          leading_space = range_between(args_with_space.begin_pos, arguments_range.begin_pos)
           corrector.replace(leading_space, '(')
           corrector.insert_after(arguments_range, ')')
         end
 
+        def forced_parentheses?(node)
+          # Regardless of style, parentheses are necessary for:
+          # 1. Endless methods
+          # 2. Argument lists containing a `forward-arg` (`...`)
+          # Removing the parens would be a syntax error here.
+
+          node.endless? || node.arguments.any?(&:forward_arg_type?)
+        end
+
         def require_parentheses?(args)
           style == :require_parentheses ||
-            (style == :require_no_parentheses_except_multiline &&
-             args.multiline?)
+            (style == :require_no_parentheses_except_multiline && args.multiline?)
         end
 
         def arguments_without_parentheses?(node)

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

@@ -34,13 +34,13 @@ module RuboCop
 
         private
 
+        # @!method min_max_candidate(node)
         def_node_matcher :min_max_candidate, <<~PATTERN
           ({array return} (send [$_receiver !nil?] :min) (send [$_receiver !nil?] :max))
         PATTERN
 
         def message(offender, receiver)
-          format(MSG, offender: offender.source,
-                      receiver: receiver.source)
+          format(MSG, offender: offender.source, receiver: receiver.source)
         end
 
         def offending_range(node)

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

@@ -5,6 +5,9 @@ module RuboCop
     module Style
       # Checks for `if` expressions that do not have an `else` branch.
       #
+      # NOTE: Pattern matching is allowed to have no `else` branch because unlike `if` and `case`,
+      # it raises `NoMatchingPatternError` if the pattern doesn't match and without having `else`.
+      #
       # Supported styles are: if, case, both.
       #
       # @example EnforcedStyle: if
@@ -98,10 +101,8 @@ module RuboCop
         include ConfigurableEnforcedStyle
 
         MSG = '`%<type>s` condition requires an `else`-clause.'
-        MSG_NIL = '`%<type>s` condition requires an `else`-clause with ' \
-                  '`nil` in it.'
-        MSG_EMPTY = '`%<type>s` condition requires an empty ' \
-                    '`else`-clause.'
+        MSG_NIL = '`%<type>s` condition requires an `else`-clause with `nil` in it.'
+        MSG_EMPTY = '`%<type>s` condition requires an empty `else`-clause.'
 
         def on_normal_if_unless(node)
           return if case_style?
@@ -116,6 +117,10 @@ module RuboCop
           check(node)
         end
 
+        def on_case_match(node)
+          # do nothing.
+        end
+
         private
 
         def check(node)

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

@@ -22,8 +22,7 @@ module RuboCop
       #   end
       #
       class MissingRespondToMissing < Base
-        MSG =
-          'When using `method_missing`, define `respond_to_missing?`.'
+        MSG = 'When using `method_missing`, define `respond_to_missing?`.'
 
         def on_def(node)
           return unless node.method?(:method_missing)

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

@@ -53,8 +53,7 @@ module RuboCop
         def range_to_remove_for_subsequent_mixin(mixins, node)
           range = node.loc.expression
           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.loc.expression.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
@@ -103,12 +102,9 @@ module RuboCop
         end
 
         def sibling_mixins(send_node)
-          siblings = send_node.parent.each_child_node(:send)
-                              .select(&:macro?)
+          siblings = send_node.parent.each_child_node(:send).select(&:macro?)
 
-          siblings.select do |sibling_node|
-            sibling_node.method?(send_node.method_name)
-          end
+          siblings.select { |sibling_node| sibling_node.method?(send_node.method_name) }
         end
 
         def grouped_style?
@@ -129,9 +125,7 @@ module RuboCop
         end
 
         def group_mixins(node, mixins)
-          mixin_names = mixins.reverse.flat_map do |mixin|
-            mixin.arguments.map(&:source)
-          end
+          mixin_names = mixins.reverse.flat_map { |mixin| mixin.arguments.map(&:source) }
 
           "#{node.method_name} #{mixin_names.join(', ')}"
         end

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

@@ -41,15 +41,16 @@ module RuboCop
       #     prepend M
       #   end
       class MixinUsage < Base
-        MSG = '`%<statement>s` is used at the top level. Use inside `class` ' \
-              'or `module`.'
+        MSG = '`%<statement>s` is used at the top level. Use inside `class` or `module`.'
         RESTRICT_ON_SEND = %i[include extend prepend].freeze
 
+        # @!method include_statement(node)
         def_node_matcher :include_statement, <<~PATTERN
           (send nil? ${:include :extend :prepend}
             const)
         PATTERN
 
+        # @!method in_top_level_scope?(node)
         def_node_matcher :in_top_level_scope?, <<~PATTERN
           {
             root?                        # either at the top level

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

@@ -6,7 +6,14 @@ module RuboCop
       # This cop checks for use of `extend self` or `module_function` in a
       # module.
       #
-      # Supported styles are: module_function, extend_self, forbidden.
+      # Supported styles are: module_function, extend_self, forbidden. `forbidden`
+      # style prohibits the usage of both styles.
+      #
+      # NOTE: 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`
+      #   and `module_function` do not behave exactly the same.
       #
       # @example EnforcedStyle: module_function (default)
       #   # bad
@@ -21,9 +28,6 @@ module RuboCop
       #     # ...
       #   end
       #
-      # In case there are private methods, the cop won't be activated.
-      # Otherwise, it forces to change the flow of the default code.
-      #
       # @example EnforcedStyle: module_function (default)
       #   # good
       #   module Test
@@ -46,8 +50,6 @@ module RuboCop
       #     # ...
       #   end
       #
-      # The option `forbidden` prohibits the usage of both styles.
-      #
       # @example EnforcedStyle: forbidden
       #   # bad
       #   module Test
@@ -68,22 +70,21 @@ module RuboCop
       #     private
       #     # ...
       #   end
-      #
-      # These offenses are not safe to auto-correct since there are different
-      # implications to each approach.
       class ModuleFunction < Base
         include ConfigurableEnforcedStyle
         extend AutoCorrector
 
-        MODULE_FUNCTION_MSG =
-          'Use `module_function` instead of `extend self`.'
-        EXTEND_SELF_MSG =
-          'Use `extend self` instead of `module_function`.'
-        FORBIDDEN_MSG =
-          'Do not use `module_function` or `extend self`.'
+        MODULE_FUNCTION_MSG = 'Use `module_function` instead of `extend self`.'
+        EXTEND_SELF_MSG = 'Use `extend self` instead of `module_function`.'
+        FORBIDDEN_MSG = 'Do not use `module_function` or `extend self`.'
 
+        # @!method module_function_node?(node)
         def_node_matcher :module_function_node?, '(send nil? :module_function)'
+
+        # @!method extend_self_node?(node)
         def_node_matcher :extend_self_node?, '(send nil? :extend self)'
+
+        # @!method private_directive?(node)
         def_node_matcher :private_directive?, '(send nil? :private ...)'
 
         def on_module(node)

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

@@ -33,8 +33,7 @@ module RuboCop
 
             next unless receiver&.block_type? && receiver&.multiline?
 
-            range = range_between(receiver.loc.end.begin_pos,
-                                  node.send_node.source_range.end_pos)
+            range = range_between(receiver.loc.end.begin_pos, node.send_node.source_range.end_pos)
 
             add_offense(range)
 

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

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks uses of the `then` keyword in multi-line `in` statement.
+      #
+      # @example
+      #   # bad
+      #   case expression
+      #   in pattern then
+      #   end
+      #
+      #   # good
+      #   case expression
+      #   in pattern
+      #   end
+      #
+      #   # good
+      #   case expression
+      #   in pattern then do_something
+      #   end
+      #
+      #   # good
+      #   case expression
+      #   in pattern then do_something(arg1,
+      #                                arg2)
+      #   end
+      #
+      class MultilineInPatternThen < Base
+        include RangeHelp
+        extend AutoCorrector
+        extend TargetRubyVersion
+
+        minimum_target_ruby_version 2.7
+
+        MSG = 'Do not use `then` for multiline `in` statement.'
+
+        def on_in_pattern(node)
+          return if !node.then? || require_then?(node)
+
+          range = node.loc.begin
+          add_offense(range) do |corrector|
+            corrector.remove(
+              range_with_surrounding_space(range: range, side: :left, newlines: false)
+            )
+          end
+        end
+
+        private
+
+        # 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 false unless in_pattern_node.body
+
+          same_line?(in_pattern_node, in_pattern_node.body)
+        end
+      end
+    end
+  end
+end

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

@@ -29,9 +29,7 @@ module RuboCop
           return if opening_line(node) == closing_line(node)
           return if correction_exceeds_max_line_length?(node)
 
-          add_offense(node) do |corrector|
-            autocorrect(corrector, node)
-          end
+          add_offense(node) { |corrector| autocorrect(corrector, node) }
         end
         alias on_defs on_def
 
@@ -40,7 +38,7 @@ module RuboCop
         def autocorrect(corrector, node)
           arguments = node.arguments
           joined_arguments = arguments.map(&:source).join(', ')
-          last_line_source_of_arguments = processed_source[arguments.last_line - 1].strip
+          last_line_source_of_arguments = last_line_source_of_arguments(arguments)
 
           if last_line_source_of_arguments.start_with?(')')
             joined_arguments = "#{joined_arguments}#{last_line_source_of_arguments}"
@@ -48,13 +46,20 @@ module RuboCop
             corrector.remove(range_by_whole_lines(arguments.loc.end, include_final_newline: true))
           end
 
-          corrector.replace(arguments_range(node), joined_arguments)
+          corrector.remove(arguments_range(node))
+          corrector.insert_after(arguments.loc.begin, joined_arguments)
+        end
+
+        def last_line_source_of_arguments(arguments)
+          processed_source[arguments.last_line - 1].strip
         end
 
         def arguments_range(node)
-          range_between(
+          range = range_between(
             node.first_argument.source_range.begin_pos, node.last_argument.source_range.end_pos
           )
+
+          range_with_surrounding_space(range: range, side: :left)
         end
 
         def opening_line(node)

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

@@ -28,8 +28,7 @@ module RuboCop
       class MultilineTernaryOperator < Base
         extend AutoCorrector
 
-        MSG = 'Avoid multi-line ternary operators, ' \
-              'use `if` or `unless` instead.'
+        MSG = 'Avoid multi-line ternary operators, use `if` or `unless` instead.'
 
         def on_if(node)
           return unless offense?(node)

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

@@ -35,17 +35,7 @@ module RuboCop
         MSG = 'Do not use `then` for multiline `when` statement.'
 
         def on_when(node)
-          # Without `then`, there's no offense
-          return unless node.then?
-
-          # Single line usage of `then` is not an offense
-          return if !node.children.last.nil? && !node.multiline?
-
-          # Requires `then` for write `when` and its body on the same line.
-          return if require_then?(node)
-
-          # For arrays and hashes there's no offense
-          return if accept_node_type?(node.body)
+          return if !node.then? || require_then?(node)
 
           range = node.loc.begin
           add_offense(range) do |corrector|
@@ -57,13 +47,14 @@ module RuboCop
 
         private
 
+        # Requires `then` for write `when` and its body on the same line.
         def require_then?(when_node)
           unless when_node.conditions.first.first_line == when_node.conditions.last.last_line
             return true
           end
           return false unless when_node.body
 
-          when_node.loc.line == when_node.body.loc.line
+          same_line?(when_node, when_node.body)
         end
 
         def accept_node_type?(node)