rubocop 1.10.0 → 1.14.0

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)

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

@@ -29,6 +29,7 @@ module RuboCop
         MSG = 'Use `%<receiver>s[%<argument>s]` instead of `%<original>s`.'
         RESTRICT_ON_SEND = %i[dig].freeze
 
+        # @!method single_argument_dig?(node)
         def_node_matcher :single_argument_dig?, <<~PATTERN
           (send _ :dig $!splat)
         PATTERN
@@ -42,8 +43,7 @@ module RuboCop
           receiver = node.receiver.source
           argument = expression.source
 
-          message = format(MSG, receiver: receiver, argument: argument,
-                                original: node.source)
+          message = format(MSG, receiver: receiver, argument: argument, original: node.source)
           add_offense(node, message: message) do |corrector|
             correct_access = "#{receiver}[#{argument}]"
             corrector.replace(node, correct_access)

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

@@ -81,8 +81,7 @@ module RuboCop
         end
 
         def eligible_method?(node)
-          node.send_node.receiver &&
-            method_names.include?(node.send_node.method_name)
+          node.send_node.receiver && method_names.include?(node.send_node.method_name)
         end
 
         def methods
@@ -108,9 +107,7 @@ module RuboCop
 
           # Prepending an underscore to mark an unused parameter is allowed, so
           # we remove any leading underscores before comparing.
-          actual_args_no_underscores = actual_args.map do |arg|
-            arg.to_s.sub(/^_+/, '')
-          end
+          actual_args_no_underscores = actual_args.map { |arg| arg.to_s.sub(/^_+/, '') }
 
           actual_args_no_underscores == target_args(method_name)
         end

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

@@ -42,9 +42,7 @@ module RuboCop
           return if node.endless?
           return if allow_empty? && !node.body
 
-          add_offense(node) do |corrector|
-            autocorrect(corrector, node)
-          end
+          add_offense(node) { |corrector| autocorrect(corrector, node) }
         end
         alias on_defs on_def
 
@@ -70,6 +68,7 @@ module RuboCop
           return false unless endless_method_config['Enabled']
           return false if endless_method_config['EnforcedStyle'] == 'disallow'
           return false unless body_node
+          return false if body_node.parent.assignment_method?
 
           !(body_node.begin_type? || body_node.kwbegin_type?)
         end
@@ -91,8 +90,11 @@ module RuboCop
         end
 
         def correct_to_endless(corrector, node)
+          self_receiver = node.self_receiver? ? 'self.' : ''
           arguments = node.arguments.any? ? node.arguments.source : '()'
-          replacement = "def #{node.method_name}#{arguments} = #{node.body.source}"
+          body_source = method_body_source(node.body)
+          replacement = "def #{self_receiver}#{node.method_name}#{arguments} = #{body_source}"
+
           corrector.replace(node, replacement)
         end
 
@@ -112,6 +114,21 @@ module RuboCop
             node: node, corrector: corrector
           )
         end
+
+        def method_body_source(method_body)
+          if require_parentheses?(method_body)
+            arguments_source = method_body.arguments.map(&:source).join(', ')
+            body_source = "#{method_body.method_name}(#{arguments_source})"
+
+            method_body.receiver ? "#{method_body.receiver.source}.#{body_source}" : body_source
+          else
+            method_body.source
+          end
+        end
+
+        def require_parentheses?(method_body)
+          method_body.send_type? && !method_body.arguments.empty? && !method_body.comparison_method?
+        end
       end
     end
   end

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

@@ -21,6 +21,7 @@ module RuboCop
         MSG = 'Prefer ary[n..] over ary[n..-1].'
         RESTRICT_ON_SEND = %i[[]].freeze
 
+        # @!method range_till_minus_one?(node)
         def_node_matcher :range_till_minus_one?, '(irange !nil? (int -1))'
 
         def on_send(node)

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

@@ -36,13 +36,13 @@ module RuboCop
         include RangeHelp
         extend AutoCorrector
 
-        MSG = 'Consider merging nested conditions into '\
-              'outer `%<conditional_type>s` conditions.'
+        MSG = 'Consider merging nested conditions into outer `%<conditional_type>s` conditions.'
 
         def on_if(node)
           return if node.ternary? || node.else? || node.elsif?
 
           if_branch = node.if_branch
+          return if use_variable_assignment_in_condition?(node.condition, if_branch)
           return unless offending_branch?(if_branch)
 
           message = format(MSG, conditional_type: node.keyword)
@@ -53,6 +53,21 @@ module RuboCop
 
         private
 
+        def use_variable_assignment_in_condition?(condition, if_branch)
+          assigned_variables = assigned_variables(condition)
+
+          assigned_variables && if_branch&.if_type? &&
+            assigned_variables.include?(if_branch.condition.source)
+        end
+
+        def assigned_variables(condition)
+          assigned_variables = condition.assignment? ? [condition.children.first.to_s] : []
+
+          assigned_variables + condition.descendants.select(&:assignment?).map do |node|
+            node.children.first.to_s
+          end
+        end
+
         def offending_branch?(branch)
           return false unless branch
 
@@ -65,10 +80,7 @@ module RuboCop
         def autocorrect(corrector, node, if_branch)
           corrector.wrap(node.condition, '(', ')') if node.condition.or_type?
 
-          if node.unless?
-            corrector.replace(node.loc.keyword, 'if')
-            corrector.insert_before(node.condition, '!')
-          end
+          correct_from_unless_to_if(corrector, node) if node.unless?
 
           and_operator = if_branch.unless? ? ' && !' : ' && '
           if if_branch.modifier_form?
@@ -79,6 +91,17 @@ module RuboCop
           end
         end
 
+        def correct_from_unless_to_if(corrector, node)
+          corrector.replace(node.loc.keyword, 'if')
+
+          condition = node.condition
+          if condition.send_type? && condition.comparison_method? && !condition.parenthesized?
+            corrector.wrap(node.condition, '!(', ')')
+          else
+            corrector.insert_before(node.condition, '!')
+          end
+        end
+
         def correct_for_guard_condition_style(corrector, node, if_branch, and_operator)
           outer_condition = node.condition
           correct_outer_condition(corrector, outer_condition)
@@ -121,7 +144,8 @@ module RuboCop
         end
 
         def requrie_parentheses?(condition)
-          condition.send_type? && !condition.arguments.empty? && !condition.parenthesized?
+          condition.send_type? && !condition.arguments.empty? && !condition.parenthesized? &&
+            !condition.comparison_method?
         end
 
         def arguments_range(node)

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

@@ -80,25 +80,15 @@ module RuboCop
           :$* => %i[$ARGV ARGV]
         }
 
-        PERL_VARS =
-          ENGLISH_VARS.flat_map { |k, vs| vs.map { |v| [v, [k]] } }.to_h
-
-        ENGLISH_VARS.merge!(
-          ENGLISH_VARS.flat_map { |_, vs| vs.map { |v| [v, [v]] } }.to_h
-        )
-        PERL_VARS.merge!(
-          PERL_VARS.flat_map { |_, vs| vs.map { |v| [v, [v]] } }.to_h
-        )
+        PERL_VARS = ENGLISH_VARS.flat_map { |k, vs| vs.map { |v| [v, [k]] } }.to_h
+
+        ENGLISH_VARS.merge!(ENGLISH_VARS.flat_map { |_, vs| vs.map { |v| [v, [v]] } }.to_h)
+        PERL_VARS.merge!(PERL_VARS.flat_map { |_, vs| vs.map { |v| [v, [v]] } }.to_h)
         ENGLISH_VARS.each_value(&:freeze).freeze
         PERL_VARS.each_value(&:freeze).freeze
 
         # Anything *not* in this set is provided by the English library.
-        NON_ENGLISH_VARS = Set.new(%i[
-                                     $LOAD_PATH
-                                     $LOADED_FEATURES
-                                     $PROGRAM_NAME
-                                     ARGV
-                                   ]).freeze
+        NON_ENGLISH_VARS = Set.new(%i[$LOAD_PATH $LOADED_FEATURES $PROGRAM_NAME ARGV]).freeze
 
         def on_gvar(node)
           global_var, = *node
@@ -120,9 +110,7 @@ module RuboCop
           if style == :use_english_names
             format_english_message(global_var)
           else
-            format(MSG_REGULAR,
-                   prefer: preferred_names(global_var).first,
-                   global: global_var)
+            format(MSG_REGULAR, prefer: preferred_names(global_var).first, global: global_var)
           end
         end
 

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

@@ -24,8 +24,7 @@ module RuboCop
         extend AutoCorrector
 
         MSG_REQUIRE = 'Wrap stabby lambda arguments with parentheses.'
-        MSG_NO_REQUIRE = 'Do not wrap stabby lambda arguments ' \
-                         'with parentheses.'
+        MSG_NO_REQUIRE = 'Do not wrap stabby lambda arguments with parentheses.'
         def on_send(node)
           return unless stabby_lambda_with_args?(node)
           return unless redundant_parentheses?(node) || missing_parentheses?(node)

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

@@ -18,10 +18,10 @@ module RuboCop
         include RangeHelp
         extend AutoCorrector
 
-        MSG =
-          'Use `warn` instead of `%<bad>s` to allow such output to be disabled.'
+        MSG = 'Use `warn` instead of `%<bad>s` to allow such output to be disabled.'
         RESTRICT_ON_SEND = %i[puts].freeze
 
+        # @!method stderr_puts?(node)
         def_node_matcher :stderr_puts?, <<~PATTERN
           (send
             {(gvar #stderr_gvar?) (const {nil? cbase} :STDERR)}
@@ -49,10 +49,7 @@ module RuboCop
         end
 
         def stderr_puts_range(send)
-          range_between(
-            send.loc.expression.begin_pos,
-            send.loc.selector.end_pos
-          )
+          range_between(send.loc.expression.begin_pos, send.loc.selector.end_pos)
         end
       end
     end