rubocop 0.93.1 → 1.79.2

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for places where string concatenation
+      # Checks for places where string concatenation
       # can be replaced with string interpolation.
       #
       # The cop can autocorrect simple cases but will skip autocorrecting
@@ -11,21 +11,52 @@ module RuboCop
       # In those cases, it might be useful to extract statements to local
       # variables or methods which you can then interpolate in a string.
       #
-      # @example
+      # NOTE: When concatenation between two strings is broken over multiple
+      # lines, this cop does not register an offense; instead,
+      # `Style/LineEndConcatenation` will pick up the offense if enabled.
+      #
+      # Two modes are supported:
+      # 1. `aggressive` style checks and corrects all occurrences of `+` where
+      # either the left or right side of `+` is a string literal.
+      # 2. `conservative` style on the other hand, checks and corrects only if
+      # left side (receiver of `+` method call) is a string literal.
+      # This is useful when the receiver is some expression that returns string like `Pathname`
+      # instead of a string literal.
+      #
+      # @safety
+      #   This cop is unsafe in `aggressive` mode, as it cannot be guaranteed that
+      #   the receiver is actually a string, which can result in a false positive.
+      #
+      # @example Mode: aggressive (default)
       #   # bad
       #   email_with_name = user.name + ' <' + user.email + '>'
+      #   Pathname.new('/') + 'test'
       #
       #   # good
       #   email_with_name = "#{user.name} <#{user.email}>"
       #   email_with_name = format('%s <%s>', user.name, user.email)
+      #   "#{Pathname.new('/')}test"
+      #
+      #   # accepted, line-end concatenation
+      #   name = 'First' +
+      #     'Last'
+      #
+      # @example Mode: conservative
+      #   # bad
+      #   'Hello' + user.name
+      #
+      #   # good
+      #   "Hello #{user.name}"
+      #   user.name + '!!'
+      #   Pathname.new('/') + 'test'
       #
       class StringConcatenation < Base
-        include Util
         extend AutoCorrector
 
         MSG = 'Prefer string interpolation to string concatenation.'
         RESTRICT_ON_SEND = %i[+].freeze
 
+        # @!method string_concatenation?(node)
         def_node_matcher :string_concatenation?, <<~PATTERN
           {
             (send str_type? :+ _)
@@ -33,22 +64,44 @@ module RuboCop
           }
         PATTERN
 
+        def on_new_investigation
+          @corrected_nodes = nil
+        end
+
         def on_send(node)
           return unless string_concatenation?(node)
+          return if line_end_concatenation?(node)
 
           topmost_plus_node = find_topmost_plus_node(node)
+          parts = collect_parts(topmost_plus_node)
+          return if mode == :conservative && !parts.first.str_type?
 
-          parts = []
-          collect_parts(topmost_plus_node, parts)
+          register_offense(topmost_plus_node, parts)
+        end
 
+        private
+
+        def register_offense(topmost_plus_node, parts)
           add_offense(topmost_plus_node) do |corrector|
-            if parts.none? { |part| uncorrectable?(part) }
+            correctable_parts = parts.none? { |part| uncorrectable?(part) }
+            if correctable_parts && !corrected_ancestor?(topmost_plus_node)
               corrector.replace(topmost_plus_node, replacement(parts))
+
+              @corrected_nodes ||= Set.new.compare_by_identity
+              @corrected_nodes.add(topmost_plus_node)
             end
           end
         end
 
-        private
+        def line_end_concatenation?(node)
+          # If the concatenation happens at the end of the line,
+          # and both the receiver and argument are strings, allow
+          # `Style/LineEndConcatenation` to handle it instead.
+          node.receiver.str_type? &&
+            node.first_argument.str_type? &&
+            node.multiline? &&
+            node.source =~ /\+\s*\n/
+        end
 
         def find_topmost_plus_node(node)
           current = node
@@ -58,7 +111,7 @@ module RuboCop
           current
         end
 
-        def collect_parts(node, parts)
+        def collect_parts(node, parts = [])
           return unless node
 
           if plus_node?(node)
@@ -74,32 +127,51 @@ module RuboCop
         end
 
         def uncorrectable?(part)
-          part.multiline? ||
-            part.dstr_type? ||
-            (part.str_type? && part.heredoc?) ||
-            part.each_descendant(:block).any?
+          part.multiline? || heredoc?(part) || part.each_descendant(:any_block).any?
+        end
+
+        def heredoc?(node)
+          return false unless node.type?(:str, :dstr)
+
+          node.heredoc?
+        end
+
+        def corrected_ancestor?(node)
+          node.each_ancestor(:send).any? { |ancestor| @corrected_nodes&.include?(ancestor) }
         end
 
         def replacement(parts)
-          interpolated_parts =
-            parts.map do |part|
-              if part.str_type?
-                if single_quoted?(part)
-                  part.value.gsub('\\') { '\\\\' }
-                else
-                  part.value.inspect[1..-2]
-                end
-              else
-                "\#{#{part.source}}"
-              end
+          interpolated_parts = parts.map do |part|
+            case part.type
+            when :str
+              adjust_str(part)
+            when :dstr
+              part.children.all?(&:str_type?) ? adjust_str(part) : part.value
+            else
+              "\#{#{part.source}}"
             end
+          end
 
-          "\"#{interpolated_parts.join}\""
+          "\"#{handle_quotes(interpolated_parts).join}\""
+        end
+
+        def adjust_str(node)
+          single_quoted?(node) ? node.value.gsub(/(\\|")/, '\\\\\&') : node.value.inspect[1..-2]
+        end
+
+        def handle_quotes(parts)
+          parts.map do |part|
+            part == '"' ? '\"' : part
+          end
         end
 
         def single_quoted?(str_node)
           str_node.source.start_with?("'")
         end
+
+        def mode
+          cop_config['Mode'].to_sym
+        end
       end
     end
   end

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

@@ -3,9 +3,13 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for the use of strings as keys in hashes. The use of
+      # Checks for the use of strings as keys in hashes. The use of
       # symbols is preferred instead.
       #
+      # @safety
+      #   This cop is unsafe because while symbols are preferred for hash keys,
+      #   there are instances when string keys are required.
+      #
       # @example
       #   # bad
       #   { 'one' => 1, 'two' => 2, 'three' => 3 }
@@ -17,10 +21,12 @@ module RuboCop
 
         MSG = 'Prefer symbols instead of strings as hash keys.'
 
+        # @!method string_hash_key?(node)
         def_node_matcher :string_hash_key?, <<~PATTERN
           (pair (str _) _)
         PATTERN
 
+        # @!method receive_environments_method?(node)
         def_node_matcher :receive_environments_method?, <<~PATTERN
           {
             ^^(send (const {nil? cbase} :IO) :popen ...)
@@ -35,10 +41,13 @@ module RuboCop
 
         def on_pair(node)
           return unless string_hash_key?(node)
+
+          key_content = node.key.str_content
+          return unless key_content.valid_encoding?
           return if receive_environments_method?(node)
 
           add_offense(node.key) do |corrector|
-            symbol_content = node.key.str_content.to_sym.inspect
+            symbol_content = key_content.to_sym.inspect
 
             corrector.replace(node.key, symbol_content)
           end

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

@@ -26,9 +26,11 @@ module RuboCop
       #   "Just some text"
       #   "No special chars or interpolation"
       #   "Every string in #{project} uses double_quotes"
-      class StringLiterals < Cop
+      class StringLiterals < Base
         include ConfigurableEnforcedStyle
         include StringLiteralsHelp
+        include StringHelp
+        extend AutoCorrector
 
         MSG_INCONSISTENT = 'Inconsistent quote style.'
 
@@ -46,7 +48,7 @@ module RuboCop
           quote_styles = detect_quote_styles(node)
 
           if quote_styles.size > 1
-            add_offense(node, message: MSG_INCONSISTENT)
+            register_offense(node, message: MSG_INCONSISTENT)
           else
             check_multiline_quote_style(node, quote_styles[0])
           end
@@ -54,14 +56,20 @@ module RuboCop
           ignore_node(node)
         end
 
-        def autocorrect(node)
-          StringLiteralCorrector.correct(node, style)
+        private
+
+        def autocorrect(corrector, node)
+          StringLiteralCorrector.correct(corrector, node, style)
         end
 
-        private
+        def register_offense(node, message: nil)
+          add_offense(node, message: message || message(node)) do |corrector|
+            autocorrect(corrector, node)
+          end
+        end
 
         def all_string_literals?(nodes)
-          nodes.all? { |n| n.str_type? || n.dstr_type? }
+          nodes.all? { |n| n.type?(:str, :dstr) }
         end
 
         def detect_quote_styles(node)
@@ -79,19 +87,15 @@ module RuboCop
         def message(_node)
           if style == :single_quotes
             "Prefer single-quoted strings when you don't need string " \
-            'interpolation or special symbols.'
+              'interpolation or special symbols.'
           else
             'Prefer double-quoted strings unless you need single quotes to ' \
-            'avoid extra backslashes for escaping.'
+              'avoid extra backslashes for escaping.'
           end
         end
 
         def offense?(node)
-          # If it's a string within an interpolation, then it's not an offense
-          # for this cop.
-          return false if inside_interpolation?(node)
-
-          wrong_quotes?(node)
+          wrong_quotes?(node) && !inside_interpolation?(node)
         end
 
         def consistent_multiline?
@@ -99,14 +103,12 @@ module RuboCop
         end
 
         def check_multiline_quote_style(node, quote)
-          range = node.source_range
           children = node.children
           if unexpected_single_quotes?(quote)
             all_children_with_quotes = children.all? { |c| wrong_quotes?(c) }
-            add_offense(node, location: range) if all_children_with_quotes
-          elsif unexpected_double_quotes?(quote) &&
-                !accept_child_double_quotes?(children)
-            add_offense(node, location: range)
+            register_offense(node) if all_children_with_quotes
+          elsif unexpected_double_quotes?(quote) && !accept_child_double_quotes?(children)
+            register_offense(node)
           end
         end
 
@@ -119,9 +121,7 @@ module RuboCop
         end
 
         def accept_child_double_quotes?(nodes)
-          nodes.any? do |n|
-            n.dstr_type? || double_quotes_required?(n.source)
-          end
+          nodes.any? { |n| n.dstr_type? || double_quotes_required?(n.source) }
         end
       end
     end

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

@@ -3,30 +3,57 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks that quotes inside the string interpolation
+      # Checks that quotes inside string, symbol, and regexp interpolations
       # match the configured preference.
       #
       # @example EnforcedStyle: single_quotes (default)
       #   # bad
-      #   result = "Tests #{success ? "PASS" : "FAIL"}"
+      #   string = "Tests #{success ? "PASS" : "FAIL"}"
+      #   symbol = :"Tests #{success ? "PASS" : "FAIL"}"
+      #   heredoc = <<~TEXT
+      #     Tests #{success ? "PASS" : "FAIL"}
+      #   TEXT
+      #   regexp = /Tests #{success ? "PASS" : "FAIL"}/
       #
       #   # good
-      #   result = "Tests #{success ? 'PASS' : 'FAIL'}"
+      #   string = "Tests #{success ? 'PASS' : 'FAIL'}"
+      #   symbol = :"Tests #{success ? 'PASS' : 'FAIL'}"
+      #   heredoc = <<~TEXT
+      #     Tests #{success ? 'PASS' : 'FAIL'}
+      #   TEXT
+      #   regexp = /Tests #{success ? 'PASS' : 'FAIL'}/
       #
       # @example EnforcedStyle: double_quotes
       #   # bad
-      #   result = "Tests #{success ? 'PASS' : 'FAIL'}"
+      #   string = "Tests #{success ? 'PASS' : 'FAIL'}"
+      #   symbol = :"Tests #{success ? 'PASS' : 'FAIL'}"
+      #   heredoc = <<~TEXT
+      #     Tests #{success ? 'PASS' : 'FAIL'}
+      #   TEXT
+      #   regexp = /Tests #{success ? 'PASS' : 'FAIL'}/
       #
       #   # good
-      #   result = "Tests #{success ? "PASS" : "FAIL"}"
-      class StringLiteralsInInterpolation < Cop
+      #   string = "Tests #{success ? "PASS" : "FAIL"}"
+      #   symbol = :"Tests #{success ? "PASS" : "FAIL"}"
+      #   heredoc = <<~TEXT
+      #     Tests #{success ? "PASS" : "FAIL"}
+      #   TEXT
+      #   regexp = /Tests #{success ? "PASS" : "FAIL"}/
+      class StringLiteralsInInterpolation < Base
         include ConfigurableEnforcedStyle
         include StringLiteralsHelp
+        include StringHelp
+        extend AutoCorrector
 
-        def autocorrect(node)
-          StringLiteralCorrector.correct(node, style)
+        def autocorrect(corrector, node)
+          StringLiteralCorrector.correct(corrector, node, style)
         end
 
+        # Cop classes that include the StringHelp module usually ignore regexp
+        # nodes. Not so for this cop, which is why we override the on_regexp
+        # definition with an empty one.
+        def on_regexp(node); end
+
         private
 
         def message(_node)

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

@@ -3,8 +3,8 @@
 module RuboCop
   module Cop
     module Style
-      # This cop enforces the use of consistent method names
-      # from the String class.
+      # Enforces the use of consistent method names
+      # from the `String` class.
       #
       # @example
       #   # bad

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop identifies places where `lstrip.rstrip` can be replaced by
+      # Identifies places where `lstrip.rstrip` can be replaced by
       # `strip`.
       #
       # @example
@@ -20,21 +20,25 @@ module RuboCop
         MSG = 'Use `strip` instead of `%<methods>s`.'
         RESTRICT_ON_SEND = %i[lstrip rstrip].freeze
 
+        # @!method lstrip_rstrip(node)
         def_node_matcher :lstrip_rstrip, <<~PATTERN
-          {(send $(send _ $:rstrip) $:lstrip)
-           (send $(send _ $:lstrip) $:rstrip)}
+          {
+            (call $(call _ :rstrip) :lstrip)
+            (call $(call _ :lstrip) :rstrip)
+          }
         PATTERN
 
         def on_send(node)
-          lstrip_rstrip(node) do |first_send, method_one, method_two|
+          lstrip_rstrip(node) do |first_send|
             range = range_between(first_send.loc.selector.begin_pos, node.source_range.end_pos)
-            message = format(MSG, methods: "#{method_one}.#{method_two}")
+            message = format(MSG, methods: range.source)
 
             add_offense(range, message: message) do |corrector|
               corrector.replace(range, 'strip')
             end
           end
         end
+        alias on_csend on_send
       end
     end
   end

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

@@ -3,7 +3,12 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for inheritance from Struct.new.
+      # Checks for inheritance from `Struct.new`. Inheriting from `Struct.new`
+      # adds a superfluous level in inheritance tree.
+      #
+      # @safety
+      #   Autocorrection is unsafe because it will change the inheritance
+      #   tree (e.g. return value of `Module#ancestors`) of the constant.
       #
       # @example
       #   # bad
@@ -13,12 +18,18 @@ module RuboCop
       #     end
       #   end
       #
+      #   Person.ancestors
+      #   # => [Person, #<Class:0x000000010b4e14a0>, Struct, (...)]
+      #
       #   # good
       #   Person = Struct.new(:first_name, :last_name) do
       #     def age
       #       42
       #     end
       #   end
+      #
+      #   Person.ancestors
+      #   # => [Person, Struct, (...)]
       class StructInheritance < Base
         include RangeHelp
         extend AutoCorrector
@@ -29,14 +40,15 @@ module RuboCop
         def on_class(node)
           return unless struct_constructor?(node.parent_class)
 
-          add_offense(node.parent_class.source_range) do |corrector|
-            corrector.remove(range_with_surrounding_space(range: node.loc.keyword, newlines: false))
+          add_offense(node.parent_class) do |corrector|
+            corrector.remove(range_with_surrounding_space(node.loc.keyword, newlines: false))
             corrector.replace(node.loc.operator, '=')
 
             correct_parent(node.parent_class, corrector)
           end
         end
 
+        # @!method struct_constructor?(node)
         def_node_matcher :struct_constructor?, <<~PATTERN
           {(send (const {nil? cbase} :Struct) :new ...)
            (block (send (const {nil? cbase} :Struct) :new ...) ...)}
@@ -46,9 +58,19 @@ module RuboCop
 
         def correct_parent(parent, corrector)
           if parent.block_type?
-            corrector.remove(range_with_surrounding_space(range: parent.loc.end, newlines: false))
+            corrector.remove(range_with_surrounding_space(parent.loc.end, newlines: false))
+          elsif (class_node = parent.parent).body.nil?
+            corrector.remove(range_for_empty_class_body(class_node, parent))
+          else
+            corrector.insert_after(parent, ' do')
+          end
+        end
+
+        def range_for_empty_class_body(class_node, struct_new)
+          if class_node.single_line?
+            range_between(struct_new.source_range.end_pos, class_node.source_range.end_pos)
           else
-            corrector.insert_after(parent.loc.expression, ' do')
+            range_by_whole_lines(class_node.loc.end, include_final_newline: true)
           end
         end
       end