rubocop 0.93.1 → 1.79.2

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

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # Checks that the backslash of a line continuation is separated from
+      # preceding text by exactly one space (default) or zero spaces.
+      #
+      # @example EnforcedStyle: space (default)
+      #   # bad
+      #   'a'\
+      #   'b'  \
+      #   'c'
+      #
+      #   # good
+      #   'a' \
+      #   'b' \
+      #   'c'
+      #
+      # @example EnforcedStyle: no_space
+      #   # bad
+      #   'a' \
+      #   'b'  \
+      #   'c'
+      #
+      #   # good
+      #   'a'\
+      #   'b'\
+      #   'c'
+      class LineContinuationSpacing < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        def on_new_investigation
+          return unless processed_source.raw_source.include?('\\')
+
+          last_line = last_line(processed_source)
+
+          processed_source.raw_source.lines.each_with_index do |line, index|
+            break if index >= last_line
+
+            line_number = index + 1
+            investigate(line, line_number)
+          end
+        end
+
+        private
+
+        def investigate(line, line_number)
+          offensive_spacing = find_offensive_spacing(line)
+          return unless offensive_spacing
+
+          range = source_range(
+            processed_source.buffer,
+            line_number,
+            line.length - offensive_spacing.length - 1,
+            offensive_spacing.length
+          )
+
+          return if ignore_range?(range)
+
+          add_offense(range) { |corrector| autocorrect(corrector, range) }
+        end
+
+        def find_offensive_spacing(line)
+          if no_space_style?
+            line[/\s+\\$/, 0]
+          elsif space_style?
+            line[/((?<!\s)|\s{2,})\\$/, 0]
+          end
+        end
+
+        def message(_range)
+          if no_space_style?
+            'Use zero spaces in front of backslash.'
+          elsif space_style?
+            'Use one space in front of backslash.'
+          end
+        end
+
+        def autocorrect(corrector, range)
+          correction = if no_space_style?
+                         '\\'
+                       elsif space_style?
+                         ' \\'
+                       end
+          corrector.replace(range, correction)
+        end
+
+        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        def ignored_literal_ranges(ast)
+          # which lines start inside a string literal?
+          return [] if ast.nil?
+
+          ast.each_node(:str, :dstr, :array).with_object(Set.new) do |literal, ranges|
+            loc = literal.location
+
+            if literal.array_type?
+              next unless literal.percent_literal?
+
+              ranges << loc.expression
+            elsif literal.heredoc?
+              ranges << loc.heredoc_body
+            elsif (loc.respond_to?(:begin) && loc.begin) || ignored_parent?(literal)
+              ranges << loc.expression
+            end
+          end
+        end
+        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
+        def comment_ranges(comments)
+          comments.map(&:source_range)
+        end
+
+        def last_line(processed_source)
+          last_token = processed_source.tokens.last
+
+          last_token ? last_token.line : processed_source.lines.length
+        end
+
+        def ignore_range?(backtick_range)
+          ignored_ranges.any? { |range| range.contains?(backtick_range) }
+        end
+
+        def ignored_ranges
+          @ignored_ranges ||= ignored_literal_ranges(processed_source.ast) +
+                              comment_ranges(processed_source.comments)
+        end
+
+        def ignored_parent?(node)
+          return false unless node.parent
+
+          node.parent.type?(:regexp, :xstr)
+        end
+
+        def no_space_style?
+          cop_config['EnforcedStyle'] == 'no_space'
+        end
+
+        def space_style?
+          cop_config['EnforcedStyle'] == 'space'
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # Checks the indentation of the next line after a line that ends with a string
+      # literal and a backslash.
+      #
+      # If `EnforcedStyle: aligned` is set, the concatenated string parts shall be aligned with the
+      # first part. There are some exceptions, such as implicit return values, where the
+      # concatenated string parts shall be indented regardless of `EnforcedStyle` configuration.
+      #
+      # If `EnforcedStyle: indented` is set, it's the second line that shall be indented one step
+      # more than the first line. Lines 3 and forward shall be aligned with line 2.
+      #
+      # @example
+      #   # bad
+      #   def some_method
+      #     'x' \
+      #     'y' \
+      #     'z'
+      #   end
+      #
+      #   my_hash = {
+      #     first: 'a message' \
+      #       'in two parts'
+      #   }
+      #
+      #   # good
+      #   def some_method
+      #     'x' \
+      #       'y' \
+      #       'z'
+      #   end
+      #
+      # @example EnforcedStyle: aligned (default)
+      #   # bad
+      #   puts 'x' \
+      #     'y'
+      #
+      #   my_hash = {
+      #     first: 'a message' \
+      #       'in two parts'
+      #   }
+      #
+      #   # good
+      #   puts 'x' \
+      #        'y'
+      #
+      #   my_hash = {
+      #     first: 'a message' \
+      #            'in two parts'
+      #   }
+      #
+      # @example EnforcedStyle: indented
+      #   # bad
+      #   result = 'x' \
+      #            'y'
+      #
+      #   my_hash = {
+      #     first: 'a message' \
+      #            'in two parts'
+      #   }
+      #
+      #   # good
+      #   result = 'x' \
+      #     'y'
+      #
+      #   my_hash = {
+      #     first: 'a message' \
+      #       'in two parts'
+      #   }
+      #
+      class LineEndStringConcatenationIndentation < Base
+        include ConfigurableEnforcedStyle
+        include Alignment
+        extend AutoCorrector
+
+        MSG_ALIGN = 'Align parts of a string concatenated with backslash.'
+        MSG_INDENT = 'Indent the first part of a string concatenated with backslash.'
+        PARENT_TYPES_FOR_INDENTED = [nil, :block, :begin, :def, :defs, :if].freeze
+
+        def on_dstr(node)
+          return unless strings_concatenated_with_backslash?(node)
+
+          children = node.children
+          return if children.empty?
+
+          if style == :aligned && !always_indented?(node)
+            check_aligned(children, 1)
+          else
+            check_indented(children)
+            check_aligned(children, 2)
+          end
+        end
+
+        def autocorrect(corrector, node)
+          AlignmentCorrector.correct(corrector, processed_source, node, @column_delta)
+        end
+
+        private
+
+        def strings_concatenated_with_backslash?(dstr_node)
+          dstr_node.multiline? &&
+            dstr_node.children.all? { |c| c.type?(:str, :dstr) } &&
+            dstr_node.children.none?(&:multiline?)
+        end
+
+        def always_indented?(dstr_node)
+          PARENT_TYPES_FOR_INDENTED.include?(dstr_node.parent&.type)
+        end
+
+        def check_aligned(children, start_index)
+          base_column = children[start_index - 1].loc.column
+          children[start_index..].each do |child|
+            @column_delta = base_column - child.loc.column
+            add_offense_and_correction(child, MSG_ALIGN) if @column_delta != 0
+            base_column = child.loc.column
+          end
+        end
+
+        def check_indented(children)
+          @column_delta = base_column(children[0]) + configured_indentation_width -
+                          children[1].loc.column
+          add_offense_and_correction(children[1], MSG_INDENT) if @column_delta != 0
+        end
+
+        def base_column(child)
+          grandparent = child.parent.parent
+          if grandparent&.pair_type?
+            grandparent.loc.column
+          else
+            child.source_range.source_line =~ /\S/
+          end
+        end
+
+        def add_offense_and_correction(node, message)
+          add_offense(node, message: message) { |corrector| autocorrect(corrector, node) }
+        end
+      end
+    end
+  end
+end

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

@@ -5,7 +5,7 @@ require 'uri'
 module RuboCop
   module Cop
     module Layout
-      # This cop checks the length of lines in the source code.
+      # Checks the length of lines in the source code.
       # The maximum length is configurable.
       # The tab size is configured in the `IndentationWidth`
       # of the `Layout/IndentationStyle` cop.
@@ -17,27 +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
-      # * BlockAlignment
-      # * BlockDelimiters
-      # * BlockEndNewline
-      # * ClosingParenthesisIndentation
-      # * FirstArgumentIndentation
-      # * FirstArrayElementIndentation
-      # * FirstHashElementIndentation
-      # * FirstParameterIndentation
-      # * HashAlignment
-      # * IndentationWidth
-      # * MultilineArrayLineBreaks
-      # * MultilineBlockLayout
-      # * MultilineHashBraceLayout
-      # * MultilineHashKeyLineBreaks
-      # * MultilineMethodArgumentLineBreaks
-      # * 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
@@ -58,18 +60,30 @@ module RuboCop
       #     bar: "0000000000",
       #     baz: "0000000000",
       #   }
-      class LineLength < Cop
+      class LineLength < Base # rubocop:disable Metrics/ClassLength
         include CheckLineBreakable
-        include ConfigurableMax
-        include IgnoredPattern
+        include AllowedPattern
         include RangeHelp
         include LineLengthHelp
+        extend AutoCorrector
+
+        exclude_limit 'Max'
 
         MSG = 'Line is too long. [%<length>d/%<max>d]'
 
         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)
@@ -77,27 +91,26 @@ 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?(';')
 
-        def investigate(processed_source)
           check_for_breakable_semicolons(processed_source)
         end
 
-        def investigate_post_walk(processed_source)
+        def on_investigation_end
           processed_source.lines.each_with_index do |line, line_index|
             check_line(line, line_index)
           end
         end
 
-        def autocorrect(range)
-          return if range.nil?
-
-          lambda do |corrector|
-            corrector.insert_before(range, "\n")
-          end
-        end
-
         private
 
+        attr_accessor :breakable_range
+
         def check_for_breakable_node(node)
           breakable_node = extract_breakable_node(node, max)
           return if breakable_node.nil?
@@ -126,15 +139,50 @@ module RuboCop
           range = breakable_block_range(block_node)
           pos = range.begin_pos + 1
 
-          breakable_range_by_line_index[line_index] =
-            range_between(pos, pos + 1)
+          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
           else
-            block_node.loc.begin
+            block_node.braces? ? block_node.loc.begin : block_node.loc.begin.adjust(begin_pos: 1)
           end
         end
 
@@ -142,7 +190,7 @@ module RuboCop
           range = semicolon_token.pos
           end_pos = range.end_pos
           next_range = range_between(end_pos, end_pos + 1)
-          return nil unless next_range.line == range.line
+          return nil unless same_line?(next_range, range)
 
           next_char = next_range.source
           return nil if /[\r\n]/.match?(next_char)
@@ -151,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
@@ -168,36 +253,41 @@ module RuboCop
 
         def check_line(line, line_index)
           return if line_length(line) <= max
-          return if ignored_line?(line, line_index)
+          return if allowed_line?(line, line_index)
 
           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
-          )
+          register_offense(excess_range(nil, line, line_index), line, line_index)
         end
 
-        def ignored_line?(line, line_index)
-          matches_ignored_pattern?(line) ||
+        def allowed_line?(line, line_index)
+          matches_allowed_pattern?(line) ||
             shebang?(line, line_index) ||
-            heredocs && line_in_permitted_heredoc?(line_index.succ)
+            (heredocs && line_in_permitted_heredoc?(line_index.succ))
         end
 
         def shebang?(line, line_index)
           line_index.zero? && line.start_with?('#!')
         end
 
-        def register_offense(loc, line, line_index)
-          message = format(MSG, length: line_length(line), max: max)
+        def register_offense(loc, line, line_index, length: line_length(line))
+          message = format(MSG, length: length, max: max)
 
-          breakable_range = breakable_range_by_line_index[line_index]
-          add_offense(breakable_range, location: loc, message: message) do
+          self.breakable_range = breakable_range_by_line_index[line_index]
+
+          add_offense(loc, message: message) do |corrector|
             self.max = line_length(line)
+
+            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
 
@@ -244,15 +338,14 @@ module RuboCop
         end
 
         def line_in_heredoc?(line_number)
-          heredocs.any? do |range, _delimiter|
-            range.cover?(line_number)
-          end
+          heredocs.any? { |range, _delimiter| range.cover?(line_number) }
         end
 
         def check_directive_line(line, line_index)
-          return if line_length_without_directive(line) <= max
+          length_without_directive = line_length_without_directive(line)
+          return if length_without_directive <= max
 
-          range = max..(line_length_without_directive(line) - 1)
+          range = max..(length_without_directive - 1)
           register_offense(
             source_range(
               processed_source.buffer,
@@ -260,19 +353,62 @@ module RuboCop
               range
             ),
             line,
-            line_index
+            line_index,
+            length: length_without_directive
           )
         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)
 
-          register_offense(
-            excess_range(uri_range, line, line_index),
-            line,
-            line_index
-          )
+          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
+
+        # 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