rubocop 1.44.1 → 1.78.0

data/lib/rubocop/cop/layout/line_length.rb

@@ -17,29 +17,29 @@ module RuboCop
       # split across lines. These include arrays, hashes, and
       # method calls with argument lists.
       #
-      # If autocorrection is enabled, the following Layout cops
+      # If autocorrection is enabled, the following cops
       # are recommended to further format the broken lines.
       # (Many of these are enabled by default.)
       #
-      # * ArgumentAlignment
-      # * ArrayAlignment
-      # * BlockAlignment
-      # * BlockDelimiters
-      # * BlockEndNewline
-      # * ClosingParenthesisIndentation
-      # * FirstArgumentIndentation
-      # * FirstArrayElementIndentation
-      # * FirstHashElementIndentation
-      # * FirstParameterIndentation
-      # * HashAlignment
-      # * IndentationWidth
-      # * MultilineArrayLineBreaks
-      # * MultilineBlockLayout
-      # * MultilineHashBraceLayout
-      # * MultilineHashKeyLineBreaks
-      # * MultilineMethodArgumentLineBreaks
-      # * MultilineMethodParameterLineBreaks
-      # * ParameterAlignment
+      # * `Layout/ArgumentAlignment`
+      # * `Layout/ArrayAlignment`
+      # * `Layout/BlockAlignment`
+      # * `Layout/BlockEndNewline`
+      # * `Layout/ClosingParenthesisIndentation`
+      # * `Layout/FirstArgumentIndentation`
+      # * `Layout/FirstArrayElementIndentation`
+      # * `Layout/FirstHashElementIndentation`
+      # * `Layout/FirstParameterIndentation`
+      # * `Layout/HashAlignment`
+      # * `Layout/IndentationWidth`
+      # * `Layout/MultilineArrayLineBreaks`
+      # * `Layout/MultilineBlockLayout`
+      # * `Layout/MultilineHashBraceLayout`
+      # * `Layout/MultilineHashKeyLineBreaks`
+      # * `Layout/MultilineMethodArgumentLineBreaks`
+      # * `Layout/MultilineMethodParameterLineBreaks`
+      # * `Layout/ParameterAlignment`
+      # * `Style/BlockDelimiters`
       #
       # Together, these cops will pretty print hashes, arrays,
       # method calls, etc. For example, let's say the max columns
@@ -60,7 +60,7 @@ module RuboCop
       #     bar: "0000000000",
       #     baz: "0000000000",
       #   }
-      class LineLength < Base
+      class LineLength < Base # rubocop:disable Metrics/ClassLength
         include CheckLineBreakable
         include AllowedPattern
         include RangeHelp
@@ -74,8 +74,16 @@ module RuboCop
         def on_block(node)
           check_for_breakable_block(node)
         end
-
         alias on_numblock on_block
+        alias on_itblock on_block
+
+        def on_str(node)
+          check_for_breakable_str(node)
+        end
+
+        def on_dstr(node)
+          check_for_breakable_dstr(node)
+        end
 
         def on_potential_breakable_node(node)
           check_for_breakable_node(node)
@@ -83,7 +91,9 @@ module RuboCop
         alias on_array on_potential_breakable_node
         alias on_hash on_potential_breakable_node
         alias on_send on_potential_breakable_node
+        alias on_csend on_potential_breakable_node
         alias on_def on_potential_breakable_node
+        alias on_defs on_potential_breakable_node
 
         def on_new_investigation
           return unless processed_source.raw_source.include?(';')
@@ -132,6 +142,42 @@ module RuboCop
           breakable_range_by_line_index[line_index] = range_between(pos, pos + 1)
         end
 
+        def check_for_breakable_str(node)
+          line_index = node.loc.line - 1
+          return if breakable_range_by_line_index[line_index]
+
+          return unless breakable_string?(node)
+          return unless (delimiter = string_delimiter(node))
+          return unless (pos = breakable_string_position(node))
+
+          breakable_range_by_line_index[line_index] = range_between(pos, pos + 1)
+          breakable_string_delimiters[line_index] = delimiter
+        end
+
+        def check_for_breakable_dstr(node) # rubocop:disable Metrics/AbcSize
+          line_index = node.loc.line - 1
+          return if breakable_range_by_line_index[line_index]
+
+          return unless breakable_dstr?(node)
+          return unless (delimiter = string_delimiter(node))
+
+          node.each_child_node(:begin).detect do |begin_node|
+            next unless (pos = breakable_dstr_begin_position(begin_node))
+
+            breakable_range_by_line_index[line_index] = range_between(pos, pos + 1)
+            breakable_string_delimiters[line_index] = delimiter
+          end
+        end
+
+        def breakable_string?(node)
+          allow_string_split? &&
+            node.single_line? &&
+            !node.heredoc? &&
+            # TODO: strings inside hashes, kwargs and arrays are currently ignored,
+            # but could be considered in the future
+            !node.parent&.type?(:pair, :kwoptarg, :array)
+        end
+
         def breakable_block_range(block_node)
           if block_node.arguments? && !block_node.lambda?
             block_node.arguments.loc.end
@@ -153,10 +199,47 @@ module RuboCop
           next_range
         end
 
+        def breakable_string_position(node)
+          source_range = node.source_range
+          return if source_range.last_column < max
+          return unless (pos = breakable_string_range(node))
+
+          pos.end_pos unless pos.end_pos == source_range.begin_pos
+        end
+
+        # Locate where to break a string that is too long, ensuring that escape characters
+        # are not bisected.
+        # If the string contains spaces, use them to determine a place for a clean break;
+        # otherwise, the string will be broken at the line length limit.
+        def breakable_string_range(node)
+          source_range = node.source_range
+          relevant_substr = largest_possible_string(node)
+
+          if (space_pos = relevant_substr.rindex(/\s/))
+            source_range.resize(space_pos + 1)
+          elsif (escape_pos = relevant_substr.rindex(/\\(u[\da-f]{0,4}|x[\da-f]{0,2})?\z/))
+            source_range.resize(escape_pos)
+          else
+            adjustment = max - source_range.last_column - 3
+            return if adjustment.abs > source_range.size
+
+            source_range.adjust(end_pos: adjustment)
+          end
+        end
+
+        def breakable_dstr_begin_position(node)
+          source_range = node.source_range
+          source_range.begin_pos if source_range.column < max && source_range.last_column >= max
+        end
+
         def breakable_range_by_line_index
           @breakable_range_by_line_index ||= {}
         end
 
+        def breakable_string_delimiters
+          @breakable_string_delimiters ||= {}
+        end
+
         def heredocs
           @heredocs ||= extract_heredocs(processed_source.ast)
         end
@@ -175,7 +258,7 @@ module RuboCop
           if ignore_cop_directives? && directive_on_source_line?(line_index)
             return check_directive_line(line, line_index)
           end
-          return check_uri_line(line, line_index) if allow_uri?
+          return check_line_for_exemptions(line, line_index) if allow_uri? || allow_qualified_name?
 
           register_offense(excess_range(nil, line, line_index), line, line_index)
         end
@@ -197,7 +280,14 @@ module RuboCop
 
           add_offense(loc, message: message) do |corrector|
             self.max = line_length(line)
-            corrector.insert_before(breakable_range, "\n") unless breakable_range.nil?
+
+            insertion = if (delimiter = breakable_string_delimiters[line_index])
+                          [delimiter, " \\\n", delimiter].join
+                        else
+                          "\n"
+                        end
+
+            corrector.insert_before(breakable_range, insertion) unless breakable_range.nil?
           end
         end
 
@@ -224,6 +314,10 @@ module RuboCop
           cop_config['AllowHeredoc']
         end
 
+        def allow_string_split?
+          cop_config['SplitStrings']
+        end
+
         def extract_heredocs(ast)
           return [] unless ast
 
@@ -264,11 +358,57 @@ module RuboCop
           )
         end
 
-        def check_uri_line(line, line_index)
-          uri_range = find_excessive_uri_range(line)
-          return if uri_range && allowed_uri_position?(line, uri_range)
+        def check_line_for_exemptions(line, line_index)
+          uri_range            = range_if_applicable(line, :uri)
+          qualified_name_range = range_if_applicable(line, :qualified_name)
+
+          return if allowed_combination?(line, uri_range, qualified_name_range)
+
+          range = uri_range || qualified_name_range
+          register_offense(excess_range(range, line, line_index), line, line_index)
+        end
+
+        def range_if_applicable(line, type)
+          return unless type == :uri ? allow_uri? : allow_qualified_name?
+
+          find_excessive_range(line, type)
+        end
+
+        def allowed_combination?(line, uri_range, qualified_name_range)
+          if uri_range && qualified_name_range
+            allowed_position?(line, uri_range) && allowed_position?(line, qualified_name_range)
+          elsif uri_range
+            allowed_position?(line, uri_range)
+          elsif qualified_name_range
+            allowed_position?(line, qualified_name_range)
+          else
+            false
+          end
+        end
+
+        def breakable_dstr?(node)
+          # If the `dstr` only contains one child, it cannot be broken
+          breakable_string?(node) && !node.child_nodes.one?
+        end
+
+        def string_delimiter(node)
+          delimiter = node.loc.begin
+          if node.parent&.dstr_type? && node.parent.loc.respond_to?(:begin)
+            delimiter ||= node.parent.loc.begin
+          end
+          delimiter = delimiter&.source
+
+          delimiter if %w[' "].include?(delimiter)
+        end
 
-          register_offense(excess_range(uri_range, line, line_index), line, line_index)
+        # Find the largest possible substring of a string node to retain before a break
+        def largest_possible_string(node)
+          # The maximum allowed length of a string value is:
+          # `Max` - end delimiter (quote) - continuation characters (space and slash)
+          max_length = max - 3
+          # If the string doesn't start at the beginning of the line, the max length is offset
+          max_length -= column_offset_between(node.loc, node.parent.loc) if node.parent
+          node.source[0...(max_length)]
         end
       end
     end

data/lib/rubocop/cop/layout/multiline_array_line_breaks.rb

@@ -6,7 +6,7 @@ module RuboCop
       # Ensures that each item in a multi-line array
       # starts on a separate line.
       #
-      # @example AllowMultilineFinalElement: false (default)
+      # @example
       #
       #   # bad
       #   [
@@ -14,11 +14,6 @@ module RuboCop
       #     c
       #   ]
       #
-      #   # bad
-      #   [ a, b, foo(
-      #     bar
-      #   )]
-      #
       #   # good
       #   [
       #     a,
@@ -35,34 +30,20 @@ module RuboCop
       #     )
       #   ]
       #
-      # @example AllowMultilineFinalElement: true
+      # @example AllowMultilineFinalElement: false (default)
       #
       #   # bad
-      #   [
-      #     a, b,
-      #     c
-      #   ]
-      #
-      #   # good
-      #   [ a, b, foo(
+      #   [a, b, foo(
       #     bar
       #   )]
       #
-      #   # good
-      #   [
-      #     a,
-      #     b,
-      #     c
-      #   ]
+      # @example AllowMultilineFinalElement: true
       #
       #   # good
-      #   [
-      #     a,
-      #     b,
-      #     foo(
-      #       bar
-      #     )
-      #   ]
+      #   [a, b, foo(
+      #     bar
+      #   )]
+      #
       class MultilineArrayLineBreaks < Base
         include MultilineElementLineBreaks
         extend AutoCorrector

data/lib/rubocop/cop/layout/multiline_block_layout.rb

@@ -69,6 +69,7 @@ module RuboCop
         end
 
         alias on_numblock on_block
+        alias on_itblock on_block
 
         private
 

data/lib/rubocop/cop/layout/multiline_hash_key_line_breaks.rb

@@ -6,7 +6,7 @@ module RuboCop
       # Ensures that each key in a multi-line hash
       # starts on a separate line.
       #
-      # @example AllowMultilineFinalElement: false (default)
+      # @example
       #
       #   # bad
       #   {
@@ -14,11 +14,6 @@ module RuboCop
       #     c: 3
       #   }
       #
-      #   # bad
-      #   { a: 1, b: {
-      #     c: 3,
-      #   }}
-      #
       #   # good
       #   {
       #     a: 1,
@@ -34,34 +29,20 @@ module RuboCop
       #     }
       #   }
       #
-      # @example AllowMultilineFinalElement: true
+      # @example AllowMultilineFinalElement: false (default)
       #
       #   # bad
-      #   {
-      #     a: 1, b: 2,
-      #     c: 3
-      #   }
-      #
-      #   # good
       #   { a: 1, b: {
       #     c: 3,
       #   }}
       #
-      #   # good
-      #   {
-      #     a: 1,
-      #     b: 2,
-      #     c: 3
-      #   }
-      #
+      # @example AllowMultilineFinalElement: true
       #
       #   # good
-      #   {
-      #     a: 1,
-      #     b: {
-      #       c: 3,
-      #     }
-      #   }
+      #   { a: 1, b: {
+      #     c: 3,
+      #   }}
+      #
       class MultilineHashKeyLineBreaks < Base
         include MultilineElementLineBreaks
         extend AutoCorrector
@@ -71,7 +52,7 @@ module RuboCop
         def on_hash(node)
           # This cop only deals with hashes wrapped by a set of curly
           # braces like {foo: 1}. That is, not a kwargs hashes.
-          # Style/MultilineMethodArgumentLineBreaks handles those.
+          # Layout/MultilineMethodArgumentLineBreaks handles those.
           return unless starts_with_curly_brace?(node)
           return unless node.loc.begin
 

data/lib/rubocop/cop/layout/multiline_method_argument_line_breaks.rb

@@ -9,7 +9,7 @@ module RuboCop
       # NOTE: This cop does not move the first argument, if you want that to
       # be on a separate line, see `Layout/FirstMethodArgumentLineBreak`.
       #
-      # @example AllowMultilineFinalElement: false (default)
+      # @example
       #
       #   # bad
       #   foo(a, b,
@@ -31,6 +31,20 @@ module RuboCop
       #   # good
       #   foo(a, b, c)
       #
+      # @example AllowMultilineFinalElement: false (default)
+      #
+      #   # bad
+      #   foo(a, b,
+      #     c
+      #   )
+      #
+      #   # bad
+      #   foo(
+      #     a, b, {
+      #       foo: "bar",
+      #     }
+      #   )
+      #
       #   # good
       #   foo(
       #     a,
@@ -48,21 +62,13 @@ module RuboCop
       #   )
       #
       #   # good
-      #   foo(a, b, {
-      #     foo: "bar",
-      #   })
-      #
-      #   # good
       #   foo(
-      #     a,
-      #     b,
-      #     c
+      #     a, b, {
+      #       foo: "bar",
+      #     }
       #   )
       #
       #   # good
-      #   foo(a, b, c)
-      #
-      #   # good
       #   foo(
       #     a,
       #     b,
@@ -70,6 +76,7 @@ module RuboCop
       #       foo: "bar",
       #     }
       #   )
+      #
       class MultilineMethodArgumentLineBreaks < Base
         include MultilineElementLineBreaks
         extend AutoCorrector
@@ -92,6 +99,7 @@ module RuboCop
 
           check_line_breaks(node, args, ignore_last: ignore_last_element?)
         end
+        alias on_csend on_send
 
         private
 

data/lib/rubocop/cop/layout/multiline_method_call_brace_layout.rb

@@ -12,7 +12,7 @@ module RuboCop
       # argument of the call, then the closing brace should be on the same
       # line as the last argument of the call.
       #
-      # If an method call's opening brace is on the line above the first
+      # If a method call's opening brace is on the line above the first
       # argument of the call, then the closing brace should be on the line
       # below the last argument of the call.
       #
@@ -109,6 +109,7 @@ module RuboCop
         def on_send(node)
           check_brace_layout(node)
         end
+        alias on_csend on_send
 
         private
 

data/lib/rubocop/cop/layout/multiline_method_call_indentation.rb

@@ -75,7 +75,7 @@ module RuboCop
         def right_hand_side(send_node)
           dot = send_node.loc.dot
           selector = send_node.loc.selector
-          if send_node.dot? && selector && same_line?(dot, selector)
+          if (send_node.dot? || send_node.safe_navigation?) && selector && same_line?(dot, selector)
             dot.join(selector)
           elsif selector
             selector
@@ -100,7 +100,7 @@ module RuboCop
 
         def extra_indentation(given_style, parent)
           if given_style == :indented_relative_to_receiver
-            if parent && (parent.splat_type? || parent.kwsplat_type?)
+            if parent&.type?(:splat, :kwsplat)
               configured_indentation_width - parent.loc.operator.length
             else
               configured_indentation_width
@@ -179,10 +179,10 @@ module RuboCop
         # a.b
         #  .c
         def semantic_alignment_base(node, rhs)
-          return unless rhs.source.start_with?('.')
+          return unless rhs.source.start_with?('.', '&.')
 
           node = semantic_alignment_node(node)
-          return unless node&.loc&.selector
+          return unless node&.loc&.selector && node.loc.dot
 
           node.loc.dot.join(node.loc.selector)
         end
@@ -204,6 +204,10 @@ module RuboCop
           dot_right_above = get_dot_right_above(node)
           return dot_right_above if dot_right_above
 
+          if (multiline_block_chain_node = find_multiline_block_chain_node(node))
+            return multiline_block_chain_node
+          end
+
           node = first_call_has_a_dot(node)
           return if node.loc.dot.line != node.first_line
 
@@ -212,19 +216,30 @@ module RuboCop
 
         def get_dot_right_above(node)
           node.each_ancestor.find do |a|
-            dot = a.loc.respond_to?(:dot) && a.loc.dot
+            dot = a.loc.dot if a.loc?(:dot)
             next unless dot
 
             dot.line == node.loc.dot.line - 1 && dot.column == node.loc.dot.column
           end
         end
 
+        def find_multiline_block_chain_node(node)
+          return unless (block_node = node.each_descendant(:any_block).first)
+          return unless block_node.multiline? && block_node.parent.call_type?
+
+          if node.receiver.call_type?
+            node.receiver
+          else
+            block_node.parent
+          end
+        end
+
         def first_call_has_a_dot(node)
           # descend to root of method chain
           node = node.receiver while node.receiver
           # ascend to first call which has a dot
           node = node.parent
-          node = node.parent until node.loc.respond_to?(:dot) && node.loc.dot
+          node = node.parent until node.loc?(:dot)
 
           node
         end

data/lib/rubocop/cop/layout/multiline_method_definition_brace_layout.rb

@@ -12,7 +12,7 @@ module RuboCop
       # first parameter of the definition, then the closing brace should be
       # on the same line as the last parameter of the definition.
       #
-      # If an method definition's opening brace is on the line above the first
+      # If a method definition's opening brace is on the line above the first
       # parameter of the definition, then the closing brace should be on the
       # line below the last parameter of the definition.
       #

data/lib/rubocop/cop/layout/multiline_method_parameter_line_breaks.rb

@@ -9,7 +9,7 @@ module RuboCop
       # NOTE: This cop does not move the first argument, if you want that to
       # be on a separate line, see `Layout/FirstMethodParameterLineBreak`.
       #
-      # @example AllowMultilineFinalElement: false (default)
+      # @example
       #
       #   # bad
       #   def foo(a, b,
@@ -17,12 +17,6 @@ module RuboCop
       #   )
       #   end
       #
-      #   # bad
-      #   def foo(a, b = {
-      #     foo: "bar",
-      #   })
-      #   end
-      #
       #   # good
       #   def foo(
       #     a,
@@ -44,40 +38,22 @@ module RuboCop
       #   def foo(a, b, c)
       #   end
       #
-      # @example AllowMultilineFinalElement: true
+      # @example AllowMultilineFinalElement: false (default)
       #
       #   # bad
-      #   def foo(a, b,
-      #     c
-      #   )
-      #   end
-      #
-      #   # good
       #   def foo(a, b = {
       #     foo: "bar",
       #   })
       #   end
       #
-      #   # good
-      #   def foo(
-      #     a,
-      #     b,
-      #     c
-      #   )
-      #   end
+      # @example AllowMultilineFinalElement: true
       #
       #   # good
-      #   def foo(
-      #     a,
-      #     b = {
-      #       foo: "bar",
-      #     }
-      #   )
+      #   def foo(a, b = {
+      #     foo: "bar",
+      #   })
       #   end
       #
-      #   # good
-      #   def foo(a, b, c)
-      #   end
       class MultilineMethodParameterLineBreaks < Base
         include MultilineElementLineBreaks
         extend AutoCorrector
@@ -89,6 +65,7 @@ module RuboCop
 
           check_line_breaks(node, node.arguments, ignore_last: ignore_last_element?)
         end
+        alias on_defs on_def
 
         private
 

data/lib/rubocop/cop/layout/multiline_operation_indentation.rb

@@ -76,9 +76,8 @@ module RuboCop
         end
 
         def check_and_or(node)
-          lhs, rhs = *node
-          range = offending_range(node, lhs, rhs.source_range, style)
-          check(range, node, lhs, rhs.source_range)
+          range = offending_range(node, node.lhs, node.rhs.source_range, style)
+          check(range, node, node.lhs, node.rhs.source_range)
         end
 
         def offending_range(node, lhs, rhs, given_style)
@@ -119,7 +118,7 @@ module RuboCop
         end
 
         def right_hand_side(send_node)
-          send_node.first_argument.source_range
+          send_node.first_argument&.source_range
         end
       end
     end