rubocop 0.89.1 → 0.90.0

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

@@ -12,7 +12,8 @@ module RuboCop
       #
       #   # good
       #   items[1..]
-      class SlicingWithRange < Cop
+      class SlicingWithRange < Base
+        extend AutoCorrector
         extend TargetRubyVersion
 
         minimum_target_ruby_version 2.6
@@ -25,12 +26,8 @@ module RuboCop
           return unless node.method?(:[]) && 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,8 +14,9 @@ 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.'
@@ -30,11 +31,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

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

@@ -12,7 +12,9 @@ module RuboCop
       #
       #   # good
       #   { one: 1, two: 2, three: 3 }
-      class StringHashKeys < Cop
+      class StringHashKeys < Base
+        extend AutoCorrector
+
         MSG = 'Prefer symbols instead of strings as hash keys.'
 
         def_node_matcher :string_hash_key?, <<~PATTERN
@@ -35,13 +37,10 @@ module RuboCop
           return unless string_hash_key?(node)
           return if receive_environments_method?(node)
 
-          add_offense(node.key)
-        end
+          add_offense(node.key) do |corrector|
+            symbol_content = node.key.str_content.to_sym.inspect
 
-        def autocorrect(node)
-          lambda do |corrector|
-            symbol_content = node.str_content.to_sym.inspect
-            corrector.replace(node, symbol_content)
+            corrector.replace(node.key, symbol_content)
           end
         end
       end

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

@@ -14,32 +14,22 @@ module RuboCop
       #   # good
       #   'name'.to_sym
       #   'var'.preferred_method
-      class StringMethods < Cop
+      class StringMethods < Base
         include MethodPreference
+        extend AutoCorrector
 
         MSG = 'Prefer `%<prefer>s` over `%<current>s`.'
 
         def on_send(node)
-          return unless preferred_method(node.method_name)
+          return unless (preferred_method = preferred_method(node.method_name))
 
-          add_offense(node, location: :selector)
-        end
-        alias on_csend on_send
+          message = format(MSG, prefer: preferred_method, current: node.method_name)
 
-        def autocorrect(node)
-          lambda do |corrector|
-            corrector.replace(node.loc.selector,
-                              preferred_method(node.method_name))
+          add_offense(node.loc.selector, message: message) do |corrector|
+            corrector.replace(node.loc.selector, preferred_method(node.method_name))
           end
         end
-
-        private
-
-        def message(node)
-          format(MSG,
-                 prefer: preferred_method(node.method_name),
-                 current: node.method_name)
-        end
+        alias on_csend on_send
       end
     end
   end

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

@@ -13,8 +13,9 @@ module RuboCop
       #
       #   # good
       #   'abc'.strip
-      class Strip < Cop
+      class Strip < Base
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Use `strip` instead of `%<methods>s`.'
 
@@ -25,20 +26,13 @@ module RuboCop
 
         def on_send(node)
           lstrip_rstrip(node) do |first_send, method_one, method_two|
-            range = range_between(first_send.loc.selector.begin_pos,
-                                  node.source_range.end_pos)
-            add_offense(node,
-                        location: range,
-                        message: format(MSG,
-                                        methods: "#{method_one}.#{method_two}"))
-          end
-        end
+            range = range_between(first_send.loc.selector.begin_pos, node.source_range.end_pos)
+            message = format(MSG, methods: "#{method_one}.#{method_two}")
 
-        def autocorrect(node)
-          range = range_between(node.receiver.loc.selector.begin_pos,
-                                node.source_range.end_pos)
-
-          ->(corrector) { corrector.replace(range, 'strip') }
+            add_offense(range, message: message) do |corrector|
+              corrector.replace(range, 'strip')
+            end
+          end
         end
       end
     end

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

@@ -19,8 +19,9 @@ module RuboCop
       #       42
       #     end
       #   end
-      class StructInheritance < Cop
+      class StructInheritance < Base
         include RangeHelp
+        extend AutoCorrector
 
         MSG = "Don't extend an instance initialized by `Struct.new`. " \
               'Use a block to customize the struct.'
@@ -28,11 +29,7 @@ module RuboCop
         def on_class(node)
           return unless struct_constructor?(node.parent_class)
 
-          add_offense(node, location: node.parent_class.source_range)
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
+          add_offense(node.parent_class.source_range) do |corrector|
             corrector.remove(range_with_surrounding_space(range: node.loc.keyword, newlines: false))
             corrector.replace(node.loc.operator, '=')
 

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

@@ -27,11 +27,12 @@ module RuboCop
       #
       #   # bad
       #   %i[foo bar baz]
-      class SymbolArray < Cop
+      class SymbolArray < Base
         include ArrayMinSize
         include ArraySyntax
         include ConfigurableEnforcedStyle
         include PercentArray
+        extend AutoCorrector
 
         PERCENT_MSG = 'Use `%i` or `%I` for an array of symbols.'
         ARRAY_MSG = 'Use `[]` for an array of symbols.'
@@ -44,22 +45,12 @@ module RuboCop
           if bracketed_array_of?(:sym, node)
             return if symbols_contain_spaces?(node)
 
-            check_bracketed_array(node)
+            check_bracketed_array(node, 'i')
           elsif node.percent_literal?(:symbol)
             check_percent_array(node)
           end
         end
 
-        def autocorrect(node)
-          if style == :percent
-            PercentLiteralCorrector
-              .new(@config, @preferred_delimiters)
-              .correct(node, 'i')
-          else
-            correct_bracketed(node)
-          end
-        end
-
         private
 
         def symbols_contain_spaces?(node)
@@ -69,7 +60,7 @@ module RuboCop
           end
         end
 
-        def correct_bracketed(node)
+        def correct_bracketed(corrector, node)
           syms = node.children.map do |c|
             if c.dsym_type?
               string_literal = to_string_literal(c.source)
@@ -80,9 +71,7 @@ module RuboCop
             end
           end
 
-          lambda do |corrector|
-            corrector.replace(node, "[#{syms.join(', ')}]")
-          end
+          corrector.replace(node, "[#{syms.join(', ')}]")
         end
 
         def to_symbol_literal(string)

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

@@ -12,17 +12,15 @@ module RuboCop
       #
       #   # good
       #   :symbol
-      class SymbolLiteral < Cop
+      class SymbolLiteral < Base
+        extend AutoCorrector
+
         MSG = 'Do not use strings for word-like symbol literals.'
 
         def on_sym(node)
           return unless /\A:["'][A-Za-z_]\w*["']\z/.match?(node.source)
 
-          add_offense(node)
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
+          add_offense(node) do |corrector|
             corrector.replace(node, node.source.delete(%q('")))
           end
         end

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

@@ -11,9 +11,10 @@ module RuboCop
       #
       #   # good
       #   something.map(&:upcase)
-      class SymbolProc < Cop
+      class SymbolProc < Base
         include RangeHelp
         include IgnoredMethods
+        extend AutoCorrector
 
         MSG = 'Pass `&:%<method>s` as an argument to `%<block_method>s` ' \
               'instead of a block.'
@@ -49,30 +50,25 @@ module RuboCop
           argument_node.one? && argument_node.source.include?(',')
         end
 
-        def autocorrect(node)
-          lambda do |corrector|
-            if node.send_node.arguments?
-              autocorrect_with_args(corrector, node,
-                                    node.send_node.arguments,
-                                    node.body.method_name)
-            else
-              autocorrect_without_args(corrector, node)
-            end
-          end
-        end
-
         private
 
         def register_offense(node, method_name, block_method_name)
           block_start = node.loc.begin.begin_pos
           block_end = node.loc.end.end_pos
           range = range_between(block_start, block_end)
+          message = format(MSG, method: method_name, block_method: block_method_name)
+
+          add_offense(range, message: message) do |corrector|
+            autocorrect(corrector, node)
+          end
+        end
 
-          add_offense(node,
-                      location: range,
-                      message: format(MSG,
-                                      method: method_name,
-                                      block_method: block_method_name))
+        def autocorrect(corrector, node)
+          if node.send_node.arguments?
+            autocorrect_with_args(corrector, node, node.send_node.arguments, node.body.method_name)
+          else
+            autocorrect_without_args(corrector, node)
+          end
         end
 
         def autocorrect_without_args(corrector, node)