rubocop 0.88.0 → 0.91.1

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

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # 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 + '>'
+      #
+      #   # good
+      #   email_with_name = "#{user.name} <#{user.email}>"
+      #   email_with_name = format('%s <%s>', user.name, user.email)
+      #
+      class StringConcatenation < Base
+        include Util
+        extend AutoCorrector
+
+        MSG = 'Prefer string interpolation to string concatenation.'
+        RESTRICT_ON_SEND = %i[+].freeze
+
+        def_node_matcher :string_concatenation?, <<~PATTERN
+          {
+            (send str_type? :+ _)
+            (send _ :+ str_type?)
+          }
+        PATTERN
+
+        def on_send(node)
+          return unless string_concatenation?(node)
+
+          topmost_plus_node = find_topmost_plus_node(node)
+
+          parts = []
+          collect_parts(topmost_plus_node, parts)
+
+          add_offense(topmost_plus_node) do |corrector|
+            if parts.none? { |part| uncorrectable?(part) }
+              corrector.replace(topmost_plus_node, replacement(parts))
+            end
+          end
+        end
+
+        private
+
+        def find_topmost_plus_node(node)
+          current = node
+          while (parent = current.parent) && plus_node?(parent)
+            current = parent
+          end
+          current
+        end
+
+        def collect_parts(node, parts)
+          return unless node
+
+          if plus_node?(node)
+            collect_parts(node.receiver, parts)
+            collect_parts(node.first_argument, parts)
+          else
+            parts << node
+          end
+        end
+
+        def plus_node?(node)
+          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|
+              if part.str_type?
+                if single_quoted?(part)
+                  part.value.gsub('\\') { '\\\\' }
+                else
+                  escape_string(part.value)
+                end
+              else
+                "\#{#{part.source}}"
+              end
+            end
+
+          "\"#{interpolated_parts.join}\""
+        end
+
+        def single_quoted?(str_node)
+          str_node.source.start_with?("'")
+        end
+      end
+    end
+  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,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,12 +29,8 @@ 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|
-            corrector.remove(range_with_surrounding_space(range: node.loc.keyword))
+          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, '=')
 
             correct_parent(node.parent_class, corrector)

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,20 +60,18 @@ 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)
 
-              ':' + trim_string_interporation_escape_character(string_literal)
+              ":#{trim_string_interporation_escape_character(string_literal)}"
             else
               to_symbol_literal(c.value.to_s)
             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)
@@ -84,7 +80,7 @@ module RuboCop
           arg_range = args.last.source_range
           arg_range = range_with_surrounding_comma(arg_range, :right)
           replacement = " &:#{method_name}"
-          replacement = ',' + replacement unless arg_range.source.end_with?(',')
+          replacement = ",#{replacement}" unless arg_range.source.end_with?(',')
           corrector.insert_after(arg_range, replacement)
           corrector.remove(block_range_with_space(node))
         end

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

@@ -54,10 +54,11 @@ module RuboCop
       #   # bad
       #   foo = (bar = baz) ? a : b
       #
-      class TernaryParentheses < Cop
+      class TernaryParentheses < Base
         include SafeAssignment
         include ConfigurableEnforcedStyle
         include SurroundingSpace
+        extend AutoCorrector
 
         VARIABLE_TYPES = AST::Node::VARIABLES
         NON_COMPLEX_TYPES = [*VARIABLE_TYPES, :const, :defined?, :yield].freeze
@@ -70,14 +71,20 @@ module RuboCop
           return if only_closing_parenthesis_is_last_line?(node.condition)
           return unless node.ternary? && !infinite_loop? && offense?(node)
 
-          add_offense(node, location: node.source_range)
+          message = message(node)
+
+          add_offense(node.source_range, message: message) do |corrector|
+            autocorrect(corrector, node)
+          end
         end
 
         def only_closing_parenthesis_is_last_line?(condition)
           condition.source.split("\n").last == ')'
         end
 
-        def autocorrect(node)
+        private
+
+        def autocorrect(corrector, node)
           condition = node.condition
 
           return nil if parenthesized?(condition) &&
@@ -85,14 +92,12 @@ module RuboCop
                         unsafe_autocorrect?(condition))
 
           if parenthesized?(condition)
-            correct_parenthesized(condition)
+            correct_parenthesized(corrector, condition)
           else
-            correct_unparenthesized(condition)
+            correct_unparenthesized(corrector, condition)
           end
         end
 
-        private
-
         def offense?(node)
           condition = node.condition
 
@@ -191,27 +196,22 @@ module RuboCop
            (send {_ nil?} $_ _ ...)}
         PATTERN
 
-        def correct_parenthesized(condition)
-          lambda do |corrector|
-            corrector.remove(condition.loc.begin)
-            corrector.remove(condition.loc.end)
+        def correct_parenthesized(corrector, condition)
+          corrector.remove(condition.loc.begin)
+          corrector.remove(condition.loc.end)
 
-            # Ruby allows no space between the question mark and parentheses.
-            # If we remove the parentheses, we need to add a space or we'll
-            # generate invalid code.
-            corrector.insert_after(condition.loc.end, ' ') unless whitespace_after?(condition)
-          end
+          # Ruby allows no space between the question mark and parentheses.
+          # If we remove the parentheses, we need to add a space or we'll
+          # generate invalid code.
+          corrector.insert_after(condition.loc.end, ' ') unless whitespace_after?(condition)
         end
 
-        def correct_unparenthesized(condition)
-          lambda do |corrector|
-            corrector.wrap(condition, '(', ')')
-          end
+        def correct_unparenthesized(corrector, condition)
+          corrector.wrap(condition, '(', ')')
         end
 
         def whitespace_after?(node)
-          index = index_of_last_token(node)
-          last_token = processed_source.tokens[index]
+          last_token = processed_source.last_token_of(node)
           last_token.space_after?
         end
       end