rubocop 0.89.1 → 0.93.0

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

@@ -26,12 +26,13 @@ module RuboCop
       # @example AllowAsExpressionSeparator: true
       #   # good
       #   foo = 1; bar = 2
-      class Semicolon < Cop
+      class Semicolon < Base
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Do not use semicolons to terminate expressions.'
 
-        def investigate(processed_source)
+        def on_new_investigation
           return if processed_source.blank?
 
           @processed_source = processed_source
@@ -66,12 +67,6 @@ module RuboCop
           end
         end
 
-        def autocorrect(range)
-          return unless range
-
-          ->(corrector) { corrector.remove(range) }
-        end
-
         private
 
         def check_for_line_terminator_or_opener
@@ -93,7 +88,9 @@ module RuboCop
           range = source_range(@processed_source.buffer, line, column)
           # Don't attempt to autocorrect if semicolon is separating statements
           # on the same line
-          add_offense(autocorrect ? range : nil, location: range)
+          add_offense(range) do |corrector|
+            corrector.remove(range) if autocorrect
+          end
         end
       end
     end

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

@@ -13,16 +13,15 @@ module RuboCop
       #   # good
       #   Foo.__send__(:bar)
       #   quuz.public_send(:fred)
-      class Send < Cop
+      class Send < Base
         MSG = 'Prefer `Object#__send__` or `Object#public_send` to ' \
               '`send`.'
-
-        def_node_matcher :sending?, '({send csend} _ :send ...)'
+        RESTRICT_ON_SEND = %i[send].freeze
 
         def on_send(node)
-          return unless sending?(node) && node.arguments?
+          return unless node.arguments?
 
-          add_offense(node, location: :selector)
+          add_offense(node.loc.selector)
         end
         alias on_csend on_send
       end

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

@@ -104,18 +104,21 @@ module RuboCop
       #
       #   explicit_receiver.fail
       #   explicit_receiver.raise
-      class SignalException < Cop
+      class SignalException < Base
         include ConfigurableEnforcedStyle
+        extend AutoCorrector
 
         FAIL_MSG = 'Use `fail` instead of `raise` to signal exceptions.'
         RAISE_MSG = 'Use `raise` instead of `fail` to ' \
                     'rethrow exceptions.'
 
+        RESTRICT_ON_SEND = %i[raise fail].freeze
+
         def_node_matcher :kernel_call?, '(send (const {nil? cbase} :Kernel) %1 ...)'
         def_node_search :custom_fail_methods,
                         '{(def :fail ...) (defs _ :fail ...)}'
 
-        def investigate(processed_source)
+        def on_new_investigation
           ast = processed_source.ast
           @custom_fail_defined = ast && custom_fail_methods(ast).any?
         end
@@ -145,20 +148,6 @@ module RuboCop
           end
         end
 
-        def autocorrect(node)
-          lambda do |corrector|
-            name =
-              case style
-              when :semantic
-                command_or_kernel_call?(:raise, node) ? 'fail' : 'raise'
-              when :only_raise then 'raise'
-              when :only_fail then 'fail'
-              end
-
-            corrector.replace(node.loc.selector, name)
-          end
-        end
-
         private
 
         def message(method_name)
@@ -178,8 +167,9 @@ module RuboCop
           each_command_or_kernel_call(method_name, node) do |send_node|
             next if ignored_node?(send_node)
 
-            add_offense(send_node,
-                        location: :selector, message: message(method_name))
+            add_offense(send_node.loc.selector, message: message(method_name)) do |corrector|
+              autocorrect(corrector, send_node)
+            end
             ignore_node(send_node)
           end
         end
@@ -187,7 +177,21 @@ module RuboCop
         def check_send(method_name, node)
           return unless node && command_or_kernel_call?(method_name, node)
 
-          add_offense(node, location: :selector, message: message(method_name))
+          add_offense(node.loc.selector, message: message(method_name)) do |corrector|
+            autocorrect(corrector, node)
+          end
+        end
+
+        def autocorrect(corrector, node)
+          name =
+            case style
+            when :semantic
+              command_or_kernel_call?(:raise, node) ? 'fail' : 'raise'
+            when :only_raise then 'raise'
+            when :only_fail then 'fail'
+            end
+
+          corrector.replace(node.loc.selector, name)
         end
 
         def command_or_kernel_call?(name, node)

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

@@ -27,6 +27,7 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Use `%<receiver>s[%<argument>s]` instead of `%<original>s`.'
+        RESTRICT_ON_SEND = %i[dig].freeze
 
         def_node_matcher :single_argument_dig?, <<~PATTERN
           (send _ :dig $!splat)

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

@@ -28,7 +28,7 @@ module RuboCop
       #   foo.reduce do |c, d|
       #     c + d
       #   end
-      class SingleLineBlockParams < Cop
+      class SingleLineBlockParams < Base
         MSG = 'Name `%<method>s` block params `|%<params>s|`.'
 
         def on_block(node)
@@ -39,7 +39,9 @@ module RuboCop
 
           return if args_match?(node.send_node.method_name, node.arguments)
 
-          add_offense(node.arguments)
+          message = message(node.arguments)
+
+          add_offense(node.arguments, message: message)
         end
 
         private

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

@@ -24,8 +24,9 @@ module RuboCop
       #   # bad
       #   def no_op; end
       #
-      class SingleLineMethods < Cop
+      class SingleLineMethods < Base
         include Alignment
+        extend AutoCorrector
 
         MSG = 'Avoid single-line method definitions.'
 
@@ -33,29 +34,29 @@ module RuboCop
           return unless node.single_line?
           return if allow_empty? && !node.body
 
-          add_offense(node)
+          add_offense(node) do |corrector|
+            autocorrect(corrector, node)
+          end
         end
         alias on_defs on_def
 
-        def autocorrect(node)
-          lambda do |corrector|
-            each_part(node.body) do |part|
-              LineBreakCorrector.break_line_before(
-                range: part, node: node, corrector: corrector,
-                configured_width: configured_indentation_width
-              )
-            end
+        private
 
+        def autocorrect(corrector, node)
+          each_part(node.body) do |part|
             LineBreakCorrector.break_line_before(
-              range: node.loc.end, node: node, corrector: corrector,
-              indent_steps: 0, configured_width: configured_indentation_width
+              range: part, node: node, corrector: corrector,
+              configured_width: configured_indentation_width
             )
-
-            move_comment(node, corrector)
           end
-        end
 
-        private
+          LineBreakCorrector.break_line_before(
+            range: node.loc.end, node: node, corrector: corrector,
+            indent_steps: 0, configured_width: configured_indentation_width
+          )
+
+          move_comment(node, corrector)
+        end
 
         def allow_empty?
           cop_config['AllowIfMethodIsEmpty']

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

@@ -12,25 +12,23 @@ module RuboCop
       #
       #   # good
       #   items[1..]
-      class SlicingWithRange < Cop
+      class SlicingWithRange < Base
+        extend AutoCorrector
         extend TargetRubyVersion
 
         minimum_target_ruby_version 2.6
 
         MSG = 'Prefer ary[n..] over ary[n..-1].'
+        RESTRICT_ON_SEND = %i[[]].freeze
 
         def_node_matcher :range_till_minus_one?, '(irange !nil? (int -1))'
 
         def on_send(node)
-          return unless node.method?(:[]) && node.arguments.count == 1
+          return unless node.arguments.count == 1
           return unless range_till_minus_one?(node.arguments.first)
 
-          add_offense(node.arguments.first)
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
-            corrector.remove(node.end)
+          add_offense(node.first_argument) do |corrector|
+            corrector.remove(node.first_argument.end)
           end
         end
       end

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

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # If the branch of a conditional consists solely of a conditional node,
+      # its conditions can be combined with the conditions of the outer branch.
+      # This helps to keep the nesting level from getting too deep.
+      #
+      # @example
+      #   # bad
+      #   if condition_a
+      #     if condition_b
+      #       do_something
+      #     end
+      #   end
+      #
+      #   # good
+      #   if condition_a && condition_b
+      #     do_something
+      #   end
+      #
+      # @example AllowModifier: false (default)
+      #   # bad
+      #   if condition_a
+      #     do_something if condition_b
+      #   end
+      #
+      # @example AllowModifier: true
+      #   # good
+      #   if condition_a
+      #     do_something if condition_b
+      #   end
+      #
+      class SoleNestedConditional < Base
+        MSG = 'Consider merging nested conditions into '\
+              'outer `%<conditional_type>s` conditions.'
+
+        def on_if(node)
+          return if node.ternary? || node.else? || node.elsif?
+
+          branch = node.if_branch
+          return unless offending_branch?(branch)
+
+          message = format(MSG, conditional_type: node.keyword)
+          add_offense(branch.loc.keyword, message: message)
+        end
+
+        private
+
+        def offending_branch?(branch)
+          return false unless branch
+
+          branch.if_type? &&
+            !branch.else? &&
+            !branch.ternary? &&
+            !(branch.modifier_form? && allow_modifier?)
+        end
+
+        def allow_modifier?
+          cop_config['AllowModifier']
+        end
+      end
+    end
+  end
+end

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

@@ -56,8 +56,9 @@ module RuboCop
       #   puts $'
       #   puts $+
       #
-      class SpecialGlobalVars < Cop
+      class SpecialGlobalVars < Base
         include ConfigurableEnforcedStyle
+        extend AutoCorrector
 
         MSG_BOTH = 'Prefer `%<prefer>s` from the stdlib \'English\' ' \
         'module (don\'t forget to require it) or `%<regular>s` over ' \
@@ -120,13 +121,14 @@ module RuboCop
             correct_style_detected
           else
             opposite_style_detected
-            add_offense(node)
+
+            add_offense(node, message: message(global_var)) do |corrector|
+              autocorrect(corrector, node, global_var)
+            end
           end
         end
 
-        def message(node)
-          global_var, = *node
-
+        def message(global_var)
           if style == :use_english_names
             format_english_message(global_var)
           else
@@ -136,17 +138,10 @@ module RuboCop
           end
         end
 
-        def autocorrect(node)
-          lambda do |corrector|
-            global_var, = *node
+        def autocorrect(corrector, node, global_var)
+          node = node.parent while node.parent&.begin_type? && node.parent.children.one?
 
-            while node.parent&.begin_type? &&
-                  node.parent.children.one?
-              node = node.parent
-            end
-
-            corrector.replace(node, replacement(node, global_var))
-          end
+          corrector.replace(node, replacement(node, global_var))
         end
 
         private

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

@@ -19,26 +19,26 @@ module RuboCop
       #
       #   # good
       #   ->a,b,c { a + b + c}
-      class StabbyLambdaParentheses < Cop
+      class StabbyLambdaParentheses < Base
         include ConfigurableEnforcedStyle
+        extend AutoCorrector
 
         MSG_REQUIRE = '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)
+          return unless redundant_parentheses?(node) || missing_parentheses?(node)
 
-          add_offense(node.block_node.arguments)
-        end
+          arguments = node.block_node.arguments
 
-        def autocorrect(node)
-          case style
-          when :require_parentheses
-            missing_parentheses_corrector(node)
-          when :require_no_parentheses
-            unwanted_parentheses_corrector(node)
+          add_offense(arguments) do |corrector|
+            case style
+            when :require_parentheses
+              missing_parentheses_corrector(corrector, arguments)
+            when :require_no_parentheses
+              unwanted_parentheses_corrector(corrector, arguments)
+            end
           end
         end
 
@@ -56,19 +56,15 @@ module RuboCop
           style == :require_parentheses ? MSG_REQUIRE : MSG_NO_REQUIRE
         end
 
-        def missing_parentheses_corrector(node)
-          lambda do |corrector|
-            corrector.wrap(node, '(', ')')
-          end
+        def missing_parentheses_corrector(corrector, node)
+          corrector.wrap(node, '(', ')')
         end
 
-        def unwanted_parentheses_corrector(node)
-          lambda do |corrector|
-            args_loc = node.loc
+        def unwanted_parentheses_corrector(corrector, node)
+          args_loc = node.loc
 
-            corrector.replace(args_loc.begin, '')
-            corrector.remove(args_loc.end)
-          end
+          corrector.replace(args_loc.begin, '')
+          corrector.remove(args_loc.end)
         end
 
         def stabby_lambda_with_args?(node)

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

@@ -14,11 +14,13 @@ module RuboCop
       #   # good
       #   warn('hello')
       #
-      class StderrPuts < Cop
+      class StderrPuts < Base
         include RangeHelp
+        extend AutoCorrector
 
         MSG =
           'Use `warn` instead of `%<bad>s` to allow such output to be disabled.'
+        RESTRICT_ON_SEND = %i[puts].freeze
 
         def_node_matcher :stderr_puts?, <<~PATTERN
           (send
@@ -30,11 +32,8 @@ module RuboCop
         def on_send(node)
           return unless stderr_puts?(node)
 
-          add_offense(node, location: stderr_puts_range(node))
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
+          message = message(node)
+          add_offense(stderr_puts_range(node), message: message) do |corrector|
             corrector.replace(stderr_puts_range(node), 'warn')
           end
         end