rubocop 0.89.0 → 0.92.0

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

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

@@ -6,6 +6,11 @@ module RuboCop
       # This cop checks for places where string concatenation
       # can be replaced with string interpolation.
       #
+      # The cop can autocorrect simple cases but will skip autocorrecting
+      # more complex cases where the resulting code would be harder to read.
+      # In those cases, it might be useful to extract statements to local
+      # variables or methods which you can then interpolate in a string.
+      #
       # @example
       #   # bad
       #   email_with_name = user.name + ' <' + user.email + '>'
@@ -19,6 +24,7 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Prefer string interpolation to string concatenation.'
+        RESTRICT_ON_SEND = %i[+].freeze
 
         def_node_matcher :string_concatenation?, <<~PATTERN
           {
@@ -28,7 +34,6 @@ module RuboCop
         PATTERN
 
         def on_send(node)
-          return unless node.method?(:+)
           return unless string_concatenation?(node)
 
           topmost_plus_node = find_topmost_plus_node(node)
@@ -37,7 +42,9 @@ module RuboCop
           collect_parts(topmost_plus_node, parts)
 
           add_offense(topmost_plus_node) do |corrector|
-            corrector.replace(topmost_plus_node, replacement(parts))
+            if parts.none? { |part| uncorrectable?(part) }
+              corrector.replace(topmost_plus_node, replacement(parts))
+            end
           end
         end
 
@@ -66,6 +73,13 @@ module RuboCop
           node.send_type? && node.method?(:+)
         end
 
+        def uncorrectable?(part)
+          part.multiline? ||
+            part.dstr_type? ||
+            (part.str_type? && part.heredoc?) ||
+            part.each_descendant(:block).any?
+        end
+
         def replacement(parts)
           interpolated_parts =
             parts.map do |part|

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,10 +13,12 @@ module RuboCop
       #
       #   # good
       #   'abc'.strip
-      class Strip < Cop
+      class Strip < Base
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Use `strip` instead of `%<methods>s`.'
+        RESTRICT_ON_SEND = %i[lstrip rstrip].freeze
 
         def_node_matcher :lstrip_rstrip, <<~PATTERN
           {(send $(send _ $:rstrip) $:lstrip)
@@ -25,20 +27,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)