rubocop 1.24.1 → 1.64.1

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

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # Checks that strings broken over multiple lines (by a backslash) contain
+      # trailing spaces instead of leading spaces (default) or leading spaces
+      # instead of trailing spaces.
+      #
+      # @example EnforcedStyle: trailing (default)
+      #   # bad
+      #   'this text contains a lot of' \
+      #   '               spaces'
+      #
+      #   # good
+      #   'this text contains a lot of               ' \
+      #   'spaces'
+      #
+      #   # bad
+      #   'this text is too' \
+      #   ' long'
+      #
+      #   # good
+      #   'this text is too ' \
+      #   'long'
+      #
+      # @example EnforcedStyle: leading
+      #   # bad
+      #   'this text contains a lot of               ' \
+      #   'spaces'
+      #
+      #   # good
+      #   'this text contains a lot of' \
+      #   '               spaces'
+      #
+      #   # bad
+      #   'this text is too ' \
+      #   'long'
+      #
+      #   # good
+      #   'this text is too' \
+      #   ' long'
+      class LineContinuationLeadingSpace < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        LINE_1_ENDING = /['"]\s*\\\n/.freeze
+        LINE_2_BEGINNING = /\A\s*['"]/.freeze
+        LEADING_STYLE_OFFENSE = /(?<trailing_spaces>\s+)(?<ending>#{LINE_1_ENDING})/.freeze
+        TRAILING_STYLE_OFFENSE = /(?<beginning>#{LINE_2_BEGINNING})(?<leading_spaces>\s+)/.freeze
+        private_constant :LINE_1_ENDING, :LINE_2_BEGINNING,
+                         :LEADING_STYLE_OFFENSE, :TRAILING_STYLE_OFFENSE
+
+        def on_dstr(node)
+          # Quick check if we possibly have line continuations.
+          return unless node.source.include?('\\')
+
+          end_of_first_line = node.source_range.begin_pos - node.source_range.column
+
+          lines = raw_lines(node)
+          lines.each_cons(2).with_index(node.first_line) do |(raw_line_one, raw_line_two), line_num|
+            end_of_first_line += raw_line_one.length
+
+            next unless continuation?(raw_line_one, line_num, node)
+
+            investigate(raw_line_one, raw_line_two, end_of_first_line)
+          end
+        end
+
+        private
+
+        def raw_lines(node)
+          processed_source.raw_source.lines[node.first_line - 1, line_range(node).size]
+        end
+
+        def investigate(first_line, second_line, end_of_first_line)
+          if enforced_style_leading?
+            investigate_leading_style(first_line, second_line, end_of_first_line)
+          else
+            investigate_trailing_style(first_line, second_line, end_of_first_line)
+          end
+        end
+
+        def investigate_leading_style(first_line, second_line, end_of_first_line)
+          matches = first_line.match(LEADING_STYLE_OFFENSE)
+          return if matches.nil?
+
+          offense_range = leading_offense_range(end_of_first_line, matches)
+          add_offense(offense_range) do |corrector|
+            insert_pos = end_of_first_line + second_line[LINE_2_BEGINNING].length
+            autocorrect(corrector, offense_range, insert_pos, matches[:trailing_spaces])
+          end
+        end
+
+        def investigate_trailing_style(first_line, second_line, end_of_first_line)
+          matches = second_line.match(TRAILING_STYLE_OFFENSE)
+          return if matches.nil?
+
+          offense_range = trailing_offense_range(end_of_first_line, matches)
+          add_offense(offense_range) do |corrector|
+            insert_pos = end_of_first_line - first_line[LINE_1_ENDING].length
+            autocorrect(corrector, offense_range, insert_pos, matches[:leading_spaces])
+          end
+        end
+
+        def continuation?(line, line_num, node)
+          return false unless line.end_with?("\\\n")
+
+          # Ensure backslash isn't part of a token spanning to the next line.
+          node.children.none? { |c| (c.first_line...c.last_line).cover?(line_num) && c.multiline? }
+        end
+
+        def autocorrect(corrector, offense_range, insert_pos, spaces)
+          corrector.remove(offense_range)
+          corrector.replace(range_between(insert_pos, insert_pos), spaces)
+        end
+
+        def leading_offense_range(end_of_first_line, matches)
+          end_pos = end_of_first_line - matches[:ending].length
+          begin_pos = end_pos - matches[:trailing_spaces].length
+          range_between(begin_pos, end_pos)
+        end
+
+        def trailing_offense_range(end_of_first_line, matches)
+          begin_pos = end_of_first_line + matches[:beginning].length
+          end_pos = begin_pos + matches[:leading_spaces].length
+          range_between(begin_pos, end_pos)
+        end
+
+        def message(_range)
+          if enforced_style_leading?
+            'Move trailing spaces to the start of next line.'
+          else
+            'Move leading spaces to the end of previous line.'
+          end
+        end
+
+        def enforced_style_leading?
+          cop_config['EnforcedStyle'] == 'leading'
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,140 @@
+# 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
+              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 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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Layout
-      # This cop checks the indentation of the next line after a line that ends with a string
+      # 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
@@ -84,6 +84,8 @@ module RuboCop
           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
@@ -110,7 +112,7 @@ module RuboCop
 
         def check_aligned(children, start_index)
           base_column = children[start_index - 1].loc.column
-          children[start_index..-1].each do |child|
+          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

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.
@@ -22,6 +22,7 @@ module RuboCop
       # (Many of these are enabled by default.)
       #
       # * ArgumentAlignment
+      # * ArrayAlignment
       # * BlockAlignment
       # * BlockDelimiters
       # * BlockEndNewline
@@ -37,6 +38,7 @@ module RuboCop
       # * MultilineHashBraceLayout
       # * MultilineHashKeyLineBreaks
       # * MultilineMethodArgumentLineBreaks
+      # * MultilineMethodParameterLineBreaks
       # * ParameterAlignment
       #
       # Together, these cops will pretty print hashes, arrays,
@@ -60,7 +62,7 @@ module RuboCop
       #   }
       class LineLength < Base
         include CheckLineBreakable
-        include IgnoredPattern
+        include AllowedPattern
         include RangeHelp
         include LineLengthHelp
         extend AutoCorrector
@@ -73,14 +75,19 @@ module RuboCop
           check_for_breakable_block(node)
         end
 
+        alias on_numblock on_block
+
         def on_potential_breakable_node(node)
           check_for_breakable_node(node)
         end
         alias on_array on_potential_breakable_node
         alias on_hash on_potential_breakable_node
         alias on_send on_potential_breakable_node
+        alias on_def on_potential_breakable_node
 
         def on_new_investigation
+          return unless processed_source.raw_source.include?(';')
+
           check_for_breakable_semicolons(processed_source)
         end
 
@@ -129,7 +136,7 @@ module RuboCop
           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
 
@@ -163,7 +170,7 @@ 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)
@@ -173,8 +180,8 @@ module RuboCop
           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))
         end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Layout
-      # This cop checks that the closing brace in an array literal is either
+      # Checks that the closing brace in an array literal is either
       # on the same line as the last array element or on a new line.
       #
       # When using the `symmetrical` (default) style:

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Layout
-      # This cop ensures that each item in a multi-line array
+      # Ensures that each item in a multi-line array
       # starts on a separate line.
       #
       # @example
@@ -20,6 +20,30 @@ module RuboCop
       #     b,
       #     c
       #   ]
+      #
+      #   # good
+      #   [
+      #     a,
+      #     b,
+      #     foo(
+      #       bar
+      #     )
+      #   ]
+      #
+      # @example AllowMultilineFinalElement: false (default)
+      #
+      #   # bad
+      #   [a, b, foo(
+      #     bar
+      #   )]
+      #
+      # @example AllowMultilineFinalElement: true
+      #
+      #   # good
+      #   [a, b, foo(
+      #     bar
+      #   )]
+      #
       class MultilineArrayLineBreaks < Base
         include MultilineElementLineBreaks
         extend AutoCorrector
@@ -27,7 +51,13 @@ module RuboCop
         MSG = 'Each item in a multi-line array must start on a separate line.'
 
         def on_array(node)
-          check_line_breaks(node, node.children)
+          check_line_breaks(node, node.children, ignore_last: ignore_last_element?)
+        end
+
+        private
+
+        def ignore_last_element?
+          !!cop_config['AllowMultilineFinalElement']
         end
       end
     end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Layout
-      # This cop checks whether the multiline assignments have a newline
+      # Checks whether the multiline assignments have a newline
       # after the assignment operator.
       #
       # @example EnforcedStyle: new_line (default)
@@ -73,7 +73,7 @@ module RuboCop
           return if node.send_type? && node.loc.operator&.source != '='
           return unless rhs
           return unless supported_types.include?(rhs.type)
-          return if rhs.first_line == rhs.last_line
+          return if rhs.single_line?
 
           check_by_enforced_style(node, rhs)
         end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Layout
-      # This cop checks whether the multiline do end blocks have a newline
+      # Checks whether the multiline do end blocks have a newline
       # after the start of the block. Additionally, it checks whether the block
       # arguments, if any, are on the same line as the start of the
       # block. Putting block arguments on separate lines, because the whole
@@ -68,6 +68,8 @@ module RuboCop
           add_offense_for_expression(node, node.body, MSG)
         end
 
+        alias on_numblock on_block
+
         private
 
         def args_on_beginning_line?(node)
@@ -89,7 +91,7 @@ module RuboCop
           if node.source.lines.first.end_with?("|\n")
             PIPE_SIZE
           else
-            1 + (PIPE_SIZE * 2)
+            (PIPE_SIZE * 2) + 1
           end
         end
 
@@ -117,7 +119,7 @@ module RuboCop
 
         def autocorrect_arguments(corrector, node)
           end_pos = range_with_surrounding_space(
-            range: node.arguments.source_range,
+            node.arguments.source_range,
             side: :right,
             newlines: false
           ).end_pos

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Layout
-      # This cop checks that the closing brace in a hash literal is either
+      # Checks that the closing brace in a hash literal is either
       # on the same line as the last hash element, or a new line.
       #
       # When using the `symmetrical` (default) style:

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Layout
-      # This cop ensures that each key in a multi-line hash
+      # Ensures that each key in a multi-line hash
       # starts on a separate line.
       #
       # @example
@@ -20,6 +20,29 @@ module RuboCop
       #     b: 2,
       #     c: 3
       #   }
+      #
+      #   # good
+      #   {
+      #     a: 1,
+      #     b: {
+      #       c: 3,
+      #     }
+      #   }
+      #
+      # @example AllowMultilineFinalElement: false (default)
+      #
+      #   # bad
+      #   { a: 1, b: {
+      #     c: 3,
+      #   }}
+      #
+      # @example AllowMultilineFinalElement: true
+      #
+      #   # good
+      #   { a: 1, b: {
+      #     c: 3,
+      #   }}
+      #
       class MultilineHashKeyLineBreaks < Base
         include MultilineElementLineBreaks
         extend AutoCorrector
@@ -31,8 +54,9 @@ module RuboCop
           # braces like {foo: 1}. That is, not a kwargs hashes.
           # Style/MultilineMethodArgumentLineBreaks handles those.
           return unless starts_with_curly_brace?(node)
+          return unless node.loc.begin
 
-          check_line_breaks(node, node.children) if node.loc.begin
+          check_line_breaks(node, node.children, ignore_last: ignore_last_element?)
         end
 
         private
@@ -40,6 +64,10 @@ module RuboCop
         def starts_with_curly_brace?(node)
           node.loc.begin
         end
+
+        def ignore_last_element?
+          !!cop_config['AllowMultilineFinalElement']
+        end
       end
     end
   end

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

@@ -3,10 +3,10 @@
 module RuboCop
   module Cop
     module Layout
-      # This cop ensures that each argument in a multi-line method call
+      # Ensures that each argument in a multi-line method call
       # starts on a separate line.
       #
-      # NOTE: this cop does not move the first argument, if you want that to
+      # NOTE: This cop does not move the first argument, if you want that to
       # be on a separate line, see `Layout/FirstMethodArgumentLineBreak`.
       #
       # @example
@@ -16,12 +16,43 @@ module RuboCop
       #     c
       #   )
       #
+      #   # bad
+      #   foo(a, b, {
+      #     foo: "bar",
+      #   })
+      #
       #   # good
       #   foo(
       #     a,
       #     b,
       #     c
       #   )
+      #
+      #   # good
+      #   foo(a, b, c)
+      #
+      # @example AllowMultilineFinalElement: false (default)
+      #
+      #   # good
+      #   foo(
+      #     a,
+      #     b,
+      #     {
+      #       foo: "bar",
+      #     }
+      #   )
+      #
+      # @example AllowMultilineFinalElement: true
+      #
+      #   # good
+      #   foo(
+      #     a,
+      #     b,
+      #     {
+      #       foo: "bar",
+      #     }
+      #   )
+      #
       class MultilineMethodArgumentLineBreaks < Base
         include MultilineElementLineBreaks
         extend AutoCorrector
@@ -42,7 +73,13 @@ module RuboCop
           last_arg = args.last
           args = args[0...-1] + last_arg.children if last_arg&.hash_type? && !last_arg&.braces?
 
-          check_line_breaks(node, args)
+          check_line_breaks(node, args, ignore_last: ignore_last_element?)
+        end
+
+        private
+
+        def ignore_last_element?
+          !!cop_config['AllowMultilineFinalElement']
         end
       end
     end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Layout
-      # This cop checks that the closing brace in a method call is either
+      # Checks that the closing brace in a method call is either
       # on the same line as the last method argument, or a new line.
       #
       # When using the `symmetrical` (default) style: