rubocop 1.9.1 → 1.13.0

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

@@ -22,8 +22,7 @@ module RuboCop
 
         MSG = 'Use `%<q_type>s` only for strings that contain both ' \
               'single quotes and double quotes%<extra>s.'
-        DYNAMIC_MSG = ', or for dynamic strings that contain ' \
-                      'double quotes'
+        DYNAMIC_MSG = ', or for dynamic strings that contain double quotes'
         SINGLE_QUOTE = "'"
         QUOTE = '"'
         EMPTY = ''

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

@@ -72,10 +72,7 @@ module RuboCop
         end
 
         def delimiter?(node, char)
-          delimiters = [
-            node.loc.begin.source[-1],
-            node.loc.end.source[0]
-          ]
+          delimiters = [node.loc.begin.source[-1], node.loc.end.source[0]]
 
           delimiters.include?(char)
         end

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

@@ -71,9 +71,12 @@ module RuboCop
           elsif hash_without_braces?(return_node.first_argument)
             add_braces(corrector, return_node.first_argument)
           end
+          if return_node.splat_argument?
+            first_argument = return_node.first_argument
+            corrector.replace(first_argument, first_argument.source.delete_prefix('*'))
+          end
 
-          keyword = range_with_surrounding_space(range: return_node.loc.keyword,
-                                                 side: :right)
+          keyword = range_with_surrounding_space(range: return_node.loc.keyword, side: :right)
           corrector.remove(keyword)
         end
 
@@ -109,8 +112,7 @@ module RuboCop
         # rubocop:enable Metrics/CyclomaticComplexity
 
         def check_return_node(node)
-          return if cop_config['AllowMultipleReturnValues'] &&
-                    node.children.size > 1
+          return if cop_config['AllowMultipleReturnValues'] && node.children.size > 1
 
           add_offense(node.loc.keyword, message: message(node)) do |corrector|
             if node.arguments?

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

@@ -11,7 +11,7 @@ module RuboCop
       #   presence of a method name clash with an argument or a local
       #   variable.
       #
-      # * Calling an attribute writer to prevent an local variable assignment.
+      # * Calling an attribute writer to prevent a local variable assignment.
       #
       # Note, with using explicit self you can only send messages with public or
       # protected scope, you cannot send private messages this way.
@@ -92,9 +92,7 @@ module RuboCop
 
         def on_masgn(node)
           lhs, rhs = *node
-          lhs.children.each do |child|
-            add_lhs_to_local_variables_scopes(rhs, child.to_a.first)
-          end
+          lhs.children.each { |child| add_lhs_to_local_variables_scopes(rhs, child.to_a.first) }
         end
 
         def on_lvasgn(node)
@@ -144,8 +142,12 @@ module RuboCop
         end
 
         def on_argument(node)
-          name, = *node
-          @local_variables_scopes[node] << name
+          if node.mlhs_type?
+            on_args(node)
+          else
+            name, = *node
+            @local_variables_scopes[node] << name
+          end
         end
 
         def allow_self(node)
@@ -156,9 +158,7 @@ module RuboCop
 
         def add_lhs_to_local_variables_scopes(rhs, lhs)
           if rhs&.send_type? && !rhs.arguments.empty?
-            rhs.arguments.each do |argument|
-              @local_variables_scopes[argument] << lhs
-            end
+            rhs.arguments.each { |argument| @local_variables_scopes[argument] << lhs }
           else
             @local_variables_scopes[rhs] << lhs
           end

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

@@ -66,8 +66,8 @@ module RuboCop
         alias on_gvasgn on_lvasgn
 
         def on_send(node)
-          # TODO: replace with #end_with? after supporting only ruby >= 2.7
-          return unless node.method_name.match?(/=$/)
+          # TODO: Remove `Symbol#to_s` after supporting only Ruby >= 2.7.
+          return unless node.method_name.to_s.end_with?('=')
           return unless redundant_assignment?(node)
 
           message = format(MSG, method_name: node.first_argument.method_name)
@@ -82,6 +82,7 @@ module RuboCop
           METHODS_RETURNING_SELF.include?(method_name)
         end
 
+        # @!method redundant_self_assignment?(node, method_name)
         def_node_matcher :redundant_self_assignment?, <<~PATTERN
           (send
             (self) _
@@ -91,6 +92,7 @@ module RuboCop
               ...))
         PATTERN
 
+        # @!method redundant_nonself_assignment?(node, receiver, method_name)
         def_node_matcher :redundant_nonself_assignment?, <<~PATTERN
           (send
             %1 _

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

@@ -53,11 +53,11 @@ module RuboCop
         include RangeHelp
         extend AutoCorrector
 
-        MSG = 'Use `%<suggestion>s` instead of '\
-              '`%<sorter>s...%<accessor_source>s`.'
+        MSG = 'Use `%<suggestion>s` instead of `%<sorter>s...%<accessor_source>s`.'
 
         RESTRICT_ON_SEND = %i[sort sort_by].freeze
 
+        # @!method redundant_sort?(node)
         def_node_matcher :redundant_sort?, <<~MATCHER
           {
             (send $(send _ $:sort ...) ${:last :first})
@@ -111,9 +111,7 @@ module RuboCop
           ).source
 
           format(MSG,
-                 suggestion: suggestion(sorter,
-                                        accessor,
-                                        arg_value(node)),
+                 suggestion: suggestion(sorter, accessor, arg_value(node)),
                  sorter: sorter,
                  accessor_source: accessor_source)
         end

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

@@ -21,6 +21,7 @@ module RuboCop
 
         MSG = 'Use `sort` instead of `sort_by { |%<var>s| %<var>s }`.'
 
+        # @!method redundant_sort_by(node)
         def_node_matcher :redundant_sort_by, <<~PATTERN
           (block $(send _ :sort_by) (args (arg $_x)) (lvar _x))
         PATTERN

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

@@ -107,13 +107,11 @@ module RuboCop
         private
 
         def allowed_slash_literal?(node)
-          style == :slashes && !contains_disallowed_slash?(node) ||
-            allowed_mixed_slash?(node)
+          style == :slashes && !contains_disallowed_slash?(node) || allowed_mixed_slash?(node)
         end
 
         def allowed_mixed_slash?(node)
-          style == :mixed && node.single_line? &&
-            !contains_disallowed_slash?(node)
+          style == :mixed && node.single_line? && !contains_disallowed_slash?(node)
         end
 
         def allowed_percent_r_literal?(node)
@@ -123,8 +121,7 @@ module RuboCop
         end
 
         def allowed_mixed_percent_r?(node)
-          style == :mixed && node.multiline? ||
-            contains_disallowed_slash?(node)
+          style == :mixed && node.multiline? || contains_disallowed_slash?(node)
         end
 
         def contains_disallowed_slash?(node)
@@ -149,8 +146,7 @@ module RuboCop
         end
 
         def preferred_delimiters
-          config.for_cop('Style/PercentLiteralDelimiters') \
-            ['PreferredDelimiters']['%r'].split(//)
+          config.for_cop('Style/PercentLiteralDelimiters') ['PreferredDelimiters']['%r'].chars
         end
 
         def correct_delimiters(node, corrector)

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

@@ -39,23 +39,27 @@ module RuboCop
       #   rescue SomeException
       #     handle_error
       #   end
-      class RescueModifier < Cop
+      class RescueModifier < Base
         include Alignment
+        include RangeHelp
         include RescueNode
+        extend AutoCorrector
 
         MSG = 'Avoid using `rescue` in its modifier form.'
 
+        def self.autocorrect_incompatible_with
+          [Style::MethodCallWithArgsParentheses]
+        end
+
         def on_resbody(node)
           return unless rescue_modifier?(node)
 
-          add_offense(node.parent)
-        end
+          rescue_node = node.parent
+          add_offense(rescue_node) do |corrector|
+            parenthesized = parenthesized?(rescue_node)
 
-        def autocorrect(node)
-          parenthesized = parenthesized?(node)
-          lambda do |corrector|
-            corrector.replace(node, corrected_block(node, parenthesized))
-            ParenthesesCorrector.correct(corrector, node.parent) if parenthesized
+            correct_rescue_block(corrector, rescue_node, parenthesized)
+            ParenthesesCorrector.correct(corrector, rescue_node.parent) if parenthesized
           end
         end
 
@@ -65,17 +69,20 @@ module RuboCop
           node.parent && parentheses?(node.parent)
         end
 
-        def corrected_block(node, parenthesized)
+        def correct_rescue_block(corrector, node, parenthesized)
           operation, rescue_modifier, = *node
           *_, rescue_args = *rescue_modifier
 
           node_indentation, node_offset = indentation_and_offset(node, parenthesized)
 
-          "begin\n" \
-            "#{operation.source.gsub(/^/, node_indentation)}" \
-            "\n#{node_offset}rescue\n" \
-            "#{rescue_args.source.gsub(/^/, node_indentation)}" \
-            "\n#{node_offset}end"
+          corrector.remove(range_between(operation.source_range.end_pos, node.source_range.end_pos))
+          corrector.insert_before(operation, "begin\n#{node_indentation}")
+          corrector.insert_after(operation, <<~RESCUE_CLAUSE.chop)
+
+            #{node_offset}rescue
+            #{node_indentation}#{rescue_args.source}
+            #{node_offset}end
+          RESCUE_CLAUSE
         end
 
         def indentation_and_offset(node, parenthesized)

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

@@ -76,15 +76,15 @@ module RuboCop
         include RangeHelp
         extend AutoCorrector
 
-        MSG_IMPLICIT = 'Omit the error class when rescuing ' \
-          '`StandardError` by itself.'
-        MSG_EXPLICIT = 'Avoid rescuing without specifying ' \
-          'an error class.'
+        MSG_IMPLICIT = 'Omit the error class when rescuing `StandardError` by itself.'
+        MSG_EXPLICIT = 'Avoid rescuing without specifying an error class.'
 
+        # @!method rescue_without_error_class?(node)
         def_node_matcher :rescue_without_error_class?, <<~PATTERN
           (resbody nil? _ _)
         PATTERN
 
+        # @!method rescue_standard_error?(node)
         def_node_matcher :rescue_standard_error?, <<~PATTERN
           (resbody $(array (const {nil? cbase} :StandardError)) _ _)
         PATTERN
@@ -98,9 +98,7 @@ module RuboCop
               offense_for_implicit_enforced_style(node, error)
             end
           when :explicit
-            rescue_without_error_class?(node) do
-              offense_for_exlicit_enforced_style(node)
-            end
+            rescue_without_error_class?(node) { offense_for_exlicit_enforced_style(node) }
           end
         end
 

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

@@ -35,7 +35,10 @@ module RuboCop
         RETURN_MSG = 'Use `return` instead of `return nil`.'
         RETURN_NIL_MSG = 'Use `return nil` instead of `return`.'
 
+        # @!method return_node?(node)
         def_node_matcher :return_node?, '(return)'
+
+        # @!method return_nil_node?(node)
         def_node_matcher :return_nil_node?, '(return nil)'
 
         def on_return(node)
@@ -71,15 +74,17 @@ module RuboCop
         end
 
         def correct_style?(node)
-          style == :return && !return_nil_node?(node) ||
-            style == :return_nil && !return_node?(node)
+          style == :return && !return_nil_node?(node) || style == :return_nil && !return_node?(node)
         end
 
         def scoped_node?(node)
           node.def_type? || node.defs_type? || node.lambda?
         end
 
+        # @!method chained_send?(node)
         def_node_matcher :chained_send?, '(send !nil? ...)'
+
+        # @!method define_method?(node)
         def_node_matcher :define_method?, <<~PATTERN
           (send _ {:define_method :define_singleton_method} _)
         PATTERN

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

@@ -69,11 +69,11 @@ module RuboCop
 
         MSG = 'Use safe navigation (`&.`) instead of checking if an object ' \
               'exists before calling the method.'
-        LOGIC_JUMP_KEYWORDS = %i[break fail next raise
-                                 return throw yield].freeze
+        LOGIC_JUMP_KEYWORDS = %i[break fail next raise return throw yield].freeze
 
         # if format: (if checked_variable body nil)
         # unless format: (if checked_variable nil body)
+        # @!method modifier_if_safe_navigation_candidate(node)
         def_node_matcher :modifier_if_safe_navigation_candidate, <<~PATTERN
           {
             (if {
@@ -88,6 +88,7 @@ module RuboCop
           }
         PATTERN
 
+        # @!method not_nil_check?(node)
         def_node_matcher :not_nil_check?, '(send (send $_ :nil?) :!)'
 
         def on_if(node)
@@ -110,9 +111,7 @@ module RuboCop
           return if unsafe_method_used?(method_chain, method)
           return if method_chain.method?(:empty?)
 
-          add_offense(node) do |corrector|
-            autocorrect(corrector, node)
-          end
+          add_offense(node) { |corrector| autocorrect(corrector, node) }
         end
 
         def use_var_only_in_unless_modifier?(node, variable)
@@ -137,8 +136,7 @@ module RuboCop
           comments = comments(node)
           return if comments.empty?
 
-          corrector.insert_before(method_call,
-                                  "#{comments.map(&:text).join("\n")}\n")
+          corrector.insert_before(method_call, "#{comments.map(&:text).join("\n")}\n")
         end
 
         def comments(node)
@@ -179,11 +177,9 @@ module RuboCop
         end
 
         def extract_parts_from_if(node)
-          variable, receiver =
-            modifier_if_safe_navigation_candidate(node)
+          variable, receiver = modifier_if_safe_navigation_candidate(node)
 
-          checked_variable, matching_receiver, method =
-            extract_common_parts(receiver, variable)
+          checked_variable, matching_receiver, method = extract_common_parts(receiver, variable)
 
           matching_receiver = nil if receiver && LOGIC_JUMP_KEYWORDS.include?(receiver.type)
 
@@ -193,18 +189,15 @@ module RuboCop
         def extract_parts_from_and(node)
           checked_variable, rhs = *node
           if cop_config['ConvertCodeThatCanStartToReturnNil']
-            checked_variable =
-              not_nil_check?(checked_variable) || checked_variable
+            checked_variable = not_nil_check?(checked_variable) || checked_variable
           end
 
-          checked_variable, matching_receiver, method =
-            extract_common_parts(rhs, checked_variable)
+          checked_variable, matching_receiver, method = extract_common_parts(rhs, checked_variable)
           [checked_variable, matching_receiver, rhs, method]
         end
 
         def extract_common_parts(method_chain, checked_variable)
-          matching_receiver =
-            find_matching_receiver_invocation(method_chain, checked_variable)
+          matching_receiver = find_matching_receiver_invocation(method_chain, checked_variable)
 
           method = matching_receiver.parent if matching_receiver
 
@@ -262,13 +255,11 @@ module RuboCop
         end
 
         def begin_range(node, method_call)
-          range_between(node.loc.expression.begin_pos,
-                        method_call.loc.expression.begin_pos)
+          range_between(node.loc.expression.begin_pos, method_call.loc.expression.begin_pos)
         end
 
         def end_range(node, method_call)
-          range_between(method_call.loc.expression.end_pos,
-                        node.loc.expression.end_pos)
+          range_between(method_call.loc.expression.end_pos, node.loc.expression.end_pos)
         end
 
         def add_safe_nav_to_all_methods_in_chain(corrector,

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

@@ -33,6 +33,7 @@ module RuboCop
         MSG = 'Use `%<correct>s` instead of `%<incorrect>s`.'
         RESTRICT_ON_SEND = %i[first last [] at slice].freeze
 
+        # @!method sample_candidate?(node)
         def_node_matcher :sample_candidate?, <<~PATTERN
           (send $(send _ :shuffle $...) ${:#{RESTRICT_ON_SEND.join(' :')}} $...)
         PATTERN

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

@@ -14,8 +14,7 @@ module RuboCop
       #   Foo.__send__(:bar)
       #   quuz.public_send(:fred)
       class Send < Base
-        MSG = 'Prefer `Object#__send__` or `Object#public_send` to ' \
-              '`send`.'
+        MSG = 'Prefer `Object#__send__` or `Object#public_send` to `send`.'
         RESTRICT_ON_SEND = %i[send].freeze
 
         def on_send(node)

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

@@ -109,14 +109,15 @@ module RuboCop
         extend AutoCorrector
 
         FAIL_MSG = 'Use `fail` instead of `raise` to signal exceptions.'
-        RAISE_MSG = 'Use `raise` instead of `fail` to ' \
-                    'rethrow exceptions.'
+        RAISE_MSG = 'Use `raise` instead of `fail` to rethrow exceptions.'
 
         RESTRICT_ON_SEND = %i[raise fail].freeze
 
+        # @!method kernel_call?(node, name)
         def_node_matcher :kernel_call?, '(send (const {nil? cbase} :Kernel) %1 ...)'
-        def_node_search :custom_fail_methods,
-                        '{(def :fail ...) (defs _ :fail ...)}'
+
+        # @!method custom_fail_methods(node)
+        def_node_search :custom_fail_methods, '{(def :fail ...) (defs _ :fail ...)}'
 
         def on_new_investigation
           ast = processed_source.ast
@@ -201,9 +202,7 @@ module RuboCop
         end
 
         def allow(method_name, node)
-          each_command_or_kernel_call(method_name, node) do |send_node|
-            ignore_node(send_node)
-          end
+          each_command_or_kernel_call(method_name, node) { |send_node| ignore_node(send_node) }
         end
 
         def each_command_or_kernel_call(method_name, node)