rubocop 1.9.0 → 1.12.1

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

@@ -19,6 +19,7 @@ module RuboCop
               ' rather than just a message.'
         RESTRICT_ON_SEND = %i[raise fail].freeze
 
+        # @!method implicit_runtime_error_raise_or_fail(node)
         def_node_matcher :implicit_runtime_error_raise_or_fail,
                          '(send nil? ${:raise :fail} {str dstr})'
 

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

@@ -48,6 +48,7 @@ module RuboCop
           [Style::Not, Style::SymbolProc]
         end
 
+        # @!method inverse_candidate?(node)
         def_node_matcher :inverse_candidate?, <<~PATTERN
           {
             (send $(send $(...) $_ $...) :!)
@@ -56,6 +57,7 @@ module RuboCop
           }
         PATTERN
 
+        # @!method inverse_block?(node)
         def_node_matcher :inverse_block?, <<~PATTERN
           (block $(send (...) $_) ... { $(send ... :!)
                                         $(send (...) {:!= :!~} ...)

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'

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)
@@ -43,6 +45,10 @@ module RuboCop
             node.each_ancestor(:def).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)
             node.super_type? && node.arguments.none?
           end
@@ -53,6 +59,11 @@ module RuboCop
               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)
             node.multiline? &&
               node.loc.begin.source_line
@@ -101,7 +112,7 @@ 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
@@ -114,7 +125,7 @@ module RuboCop
           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.csend_type? || node.parent.super_type? || node.parent.yield_type?)
           end
 
           def hash_literal_in_arguments?(node)
@@ -172,7 +183,12 @@ module RuboCop
             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/min_max.rb

@@ -34,6 +34,7 @@ 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

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

@@ -45,11 +45,13 @@ module RuboCop
               '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

@@ -82,8 +82,13 @@ module RuboCop
         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_method_signature.rb

@@ -40,7 +40,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 +48,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/multiple_comparison.rb

@@ -47,11 +47,12 @@ module RuboCop
           'in a conditional, use `Array#include?` instead.'
 
         def on_new_investigation
-          @compared_elements = []
-          @allowed_method_comparison = false
+          @last_comparison = nil
         end
 
         def on_or(node)
+          reset_comparison if switch_comparison?(node)
+
           root_of_or_node = root_of_or_node(node)
 
           return unless node == root_of_or_node
@@ -64,14 +65,21 @@ module RuboCop
 
             corrector.replace(node, prefer_method)
           end
+
+          @last_comparison = node
         end
 
         private
 
+        # @!method simple_double_comparison?(node)
         def_node_matcher :simple_double_comparison?, '(send $lvar :== $lvar)'
+
+        # @!method simple_comparison_lhs?(node)
         def_node_matcher :simple_comparison_lhs?, <<~PATTERN
           (send $lvar :== $_)
         PATTERN
+
+        # @!method simple_comparison_rhs?(node)
         def_node_matcher :simple_comparison_rhs?, <<~PATTERN
           (send $_ :== $lvar)
         PATTERN
@@ -131,6 +139,17 @@ module RuboCop
           end
         end
 
+        def switch_comparison?(node)
+          return true if @last_comparison.nil?
+
+          @last_comparison.descendants.none? { |descendant| descendant == node }
+        end
+
+        def reset_comparison
+          @compared_elements = []
+          @allowed_method_comparison = false
+        end
+
         def allow_method_comparison?
           cop_config.fetch('AllowMethodComparison', true)
         end

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

@@ -154,12 +154,14 @@ module RuboCop
           end
         end
 
+        # @!method splat_value(node)
         def_node_matcher :splat_value, <<~PATTERN
           (array (splat $_))
         PATTERN
 
         # Some of these patterns may not actually return an immutable object,
         # but we want to consider them immutable for this cop.
+        # @!method operation_produces_immutable_object?(node)
         def_node_matcher :operation_produces_immutable_object?, <<~PATTERN
           {
             (const _ _)
@@ -176,6 +178,7 @@ module RuboCop
           }
         PATTERN
 
+        # @!method range_enclosed_in_parentheses?(node)
         def_node_matcher :range_enclosed_in_parentheses?, <<~PATTERN
           (begin ({irange erange} _ _))
         PATTERN

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

@@ -29,12 +29,14 @@ module RuboCop
       #
       class NegatedIfElseCondition < Base
         include RangeHelp
+        include CommentsHelp
         extend AutoCorrector
 
         MSG = 'Invert the negated condition and swap the %<type>s branches.'
 
         NEGATED_EQUALITY_METHODS = %i[!= !~].freeze
 
+        # @!method double_negation?(node)
         def_node_matcher :double_negation?, '(send (send _ :!) :!)'
 
         def self.autocorrect_incompatible_with
@@ -96,10 +98,22 @@ module RuboCop
           if node.if_branch.nil?
             corrector.remove(range_by_whole_lines(node.loc.else, include_final_newline: true))
           else
-            corrector.replace(node.if_branch, node.else_branch.source)
-            corrector.replace(node.else_branch, node.if_branch.source)
+            if_range = node_with_comments(node.if_branch)
+            else_range = node_with_comments(node.else_branch)
+
+            corrector.replace(if_range, else_range.source)
+            corrector.replace(else_range, if_range.source)
           end
         end
+
+        def node_with_comments(node)
+          first_statement = node.begin_type? ? node.children[0] : node
+          return node if processed_source.ast_with_comments[first_statement].empty?
+
+          begin_pos = source_range_with_comment(first_statement).begin_pos
+          end_pos = node.source_range.end_pos
+          Parser::Source::Range.new(buffer, begin_pos, end_pos)
+        end
       end
     end
   end

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

@@ -37,7 +37,10 @@ module RuboCop
 
         RESTRICT_ON_SEND = %i[== === nil?].freeze
 
+        # @!method nil_comparison?(node)
         def_node_matcher :nil_comparison?, '(send _ {:== :===} nil)'
+
+        # @!method nil_check?(node)
         def_node_matcher :nil_check?, '(send _ :nil?)'
 
         def on_send(node)
@@ -50,7 +53,9 @@ module RuboCop
                          end
 
               corrector.replace(node, new_code)
-              corrector.wrap(node, '(', ')') if node.parent&.method?(:!)
+
+              parent = node.parent
+              corrector.wrap(node, '(', ')') if parent.respond_to?(:method?) && parent.method?(:!)
             end
           end
         end

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

@@ -28,6 +28,7 @@ module RuboCop
 
         MSG = 'Use an empty lambda instead of always returning nil.'
 
+        # @!method nil_return?(node)
         def_node_matcher :nil_return?, <<~PATTERN
           { ({return next break} nil) (nil) }
         PATTERN

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

@@ -49,9 +49,16 @@ module RuboCop
 
         RESTRICT_ON_SEND = %i[!= nil? !].freeze
 
+        # @!method not_equal_to_nil?(node)
         def_node_matcher :not_equal_to_nil?, '(send _ :!= nil)'
+
+        # @!method unless_check?(node)
         def_node_matcher :unless_check?, '(if (send _ :nil?) ...)'
+
+        # @!method nil_check?(node)
         def_node_matcher :nil_check?, '(send _ :nil?)'
+
+        # @!method not_and_nil_check?(node)
         def_node_matcher :not_and_nil_check?, '(send (send _ :nil?) :!)'
 
         def on_send(node)

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

@@ -28,10 +28,6 @@ module RuboCop
       #   10_000_00 # typical representation of $10,000 in cents
       #
       class NumericLiterals < Base
-        # The parameter is called MinDigits (meaning the minimum number of
-        # digits for which an offense can be registered), but essentially it's
-        # a Max parameter (the maximum number of something that's allowed).
-        include ConfigurableMax
         include IntegerNode
         extend AutoCorrector
 
@@ -39,6 +35,11 @@ module RuboCop
               'separate every 3 digits with them.'
         DELIMITER_REGEXP = /[eE.]/.freeze
 
+        # The parameter is called MinDigits (meaning the minimum number of
+        # digits for which an offense can be registered), but essentially it's
+        # a Max parameter (the maximum number of something that's allowed).
+        exclude_limit 'MinDigits'
+
         def on_int(node)
           check(node)
         end
@@ -49,10 +50,6 @@ module RuboCop
 
         private
 
-        def max_parameter_name
-          'MinDigits'
-        end
-
         def check(node)
           int = integer_part(node)
 
@@ -62,7 +59,7 @@ module RuboCop
 
           case int
           when /^\d+$/
-            return unless (self.max = int.size + 1)
+            return unless (self.min_digits = int.size + 1)
 
             register_offense(node)
           when /\d{4}/, short_group_regex