rubocop 1.30.1 → 1.64.0

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

@@ -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

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

@@ -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,
@@ -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
 

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

@@ -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

@@ -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

@@ -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_key_line_breaks.rb

@@ -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

@@ -6,7 +6,7 @@ module RuboCop
       # 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_indentation.rb

@@ -56,8 +56,8 @@ module RuboCop
           return unless style == :aligned && cop_config['IndentationWidth']
 
           raise ValidationError,
-                'The `Layout/MultilineMethodCallIndentation`' \
-                ' cop only accepts an `IndentationWidth` ' \
+                'The `Layout/MultilineMethodCallIndentation` ' \
+                'cop only accepts an `IndentationWidth` ' \
                 'configuration parameter when ' \
                 '`EnforcedStyle` is `indented`.'
         end
@@ -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
@@ -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
 
@@ -219,6 +223,17 @@ module RuboCop
           end
         end
 
+        def find_multiline_block_chain_node(node)
+          return unless (block_node = node.each_descendant(:block, :numblock).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

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

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # Ensures that each parameter in a multi-line method definition
+      # starts on a separate line.
+      #
+      # NOTE: This cop does not move the first argument, if you want that to
+      # be on a separate line, see `Layout/FirstMethodParameterLineBreak`.
+      #
+      # @example
+      #
+      #   # bad
+      #   def foo(a, b,
+      #     c
+      #   )
+      #   end
+      #
+      #   # good
+      #   def foo(
+      #     a,
+      #     b,
+      #     c
+      #   )
+      #   end
+      #
+      #   # good
+      #   def foo(
+      #     a,
+      #     b = {
+      #       foo: "bar",
+      #     }
+      #   )
+      #   end
+      #
+      #   # good
+      #   def foo(a, b, c)
+      #   end
+      #
+      # @example AllowMultilineFinalElement: false (default)
+      #
+      #   # bad
+      #   def foo(a, b = {
+      #     foo: "bar",
+      #   })
+      #   end
+      #
+      # @example AllowMultilineFinalElement: true
+      #
+      #   # good
+      #   def foo(a, b = {
+      #     foo: "bar",
+      #   })
+      #   end
+      #
+      class MultilineMethodParameterLineBreaks < Base
+        include MultilineElementLineBreaks
+        extend AutoCorrector
+
+        MSG = 'Each parameter in a multi-line method definition must start on a separate line.'
+
+        def on_def(node)
+          return if node.arguments.empty?
+
+          check_line_breaks(node, node.arguments, ignore_last: ignore_last_element?)
+        end
+
+        private
+
+        def ignore_last_element?
+          !!cop_config['AllowMultilineFinalElement']
+        end
+      end
+    end
+  end
+end

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

@@ -57,8 +57,8 @@ module RuboCop
         def validate_config
           return unless style == :aligned && cop_config['IndentationWidth']
 
-          raise ValidationError, 'The `Layout/MultilineOperationIndentation`' \
-                                 ' cop only accepts an `IndentationWidth` ' \
+          raise ValidationError, 'The `Layout/MultilineOperationIndentation` ' \
+                                 'cop only accepts an `IndentationWidth` ' \
                                  'configuration parameter when ' \
                                  '`EnforcedStyle` is `indented`.'
         end

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

@@ -48,19 +48,28 @@ module RuboCop
 
         MSG = 'Redundant line break detected.'
 
+        def on_lvasgn(node)
+          super unless end_with_percent_blank_string?(processed_source)
+        end
+
         def on_send(node)
           # Include "the whole expression".
-          node = node.parent while convertible_block?(node) ||
-                                   node.parent.is_a?(RuboCop::AST::BinaryOperatorNode) ||
-                                   node.parent&.send_type?
+          node = node.parent while node.parent&.send_type? ||
+                                   convertible_block?(node) ||
+                                   node.parent.is_a?(RuboCop::AST::BinaryOperatorNode)
 
           return unless offense?(node) && !part_of_ignored_node?(node)
 
           register_offense(node)
         end
+        alias on_csend on_send
 
         private
 
+        def end_with_percent_blank_string?(processed_source)
+          processed_source.buffer.source.end_with?("%\n\n")
+        end
+
         def check_assignment(node, _rhs)
           return unless offense?(node)
 
@@ -69,26 +78,37 @@ module RuboCop
 
         def register_offense(node)
           add_offense(node) do |corrector|
-            corrector.replace(node.source_range, to_single_line(node.source).strip)
+            corrector.replace(node, to_single_line(node.source).strip)
           end
           ignore_node(node)
         end
 
         def offense?(node)
-          return false if configured_to_not_be_inspected?(node)
+          return false if !node.multiline? || too_long?(node) || !suitable_as_single_line?(node)
+          return require_backslash?(node) if node.and_type? || node.or_type?
+
+          !index_access_call_chained?(node) && !configured_to_not_be_inspected?(node)
+        end
 
-          node.multiline? && !too_long?(node) && suitable_as_single_line?(node)
+        def require_backslash?(node)
+          processed_source.lines[node.loc.operator.line - 1].end_with?('\\')
+        end
+
+        def index_access_call_chained?(node)
+          return false unless node.send_type? && node.method?(:[])
+
+          node.children.first.send_type? && node.children.first.method?(:[])
         end
 
         def configured_to_not_be_inspected?(node)
           return true if other_cop_takes_precedence?(node)
 
           !cop_config['InspectBlocks'] && (node.block_type? ||
-                                           node.each_descendant(:block).any?(&:multiline?))
+                                           any_descendant?(node, :block, &:multiline?))
         end
 
         def other_cop_takes_precedence?(node)
-          single_line_block_chain_enabled? && node.each_descendant(:block).any? do |block_node|
+          single_line_block_chain_enabled? && any_descendant?(node, :block) do |block_node|
             block_node.parent.send_type? && block_node.parent.loc.dot && !block_node.multiline?
           end
         end
@@ -99,9 +119,9 @@ module RuboCop
 
         def suitable_as_single_line?(node)
           !comment_within?(node) &&
-            node.each_descendant(:if, :case, :kwbegin, :def).none? &&
-            node.each_descendant(:dstr, :str).none?(&:heredoc?) &&
-            node.each_descendant(:begin).none? { |b| b.first_line != b.last_line }
+            node.each_descendant(:if, :case, :kwbegin, :def, :defs).none? &&
+            node.each_descendant(:dstr, :str).none? { |n| n.heredoc? || n.value.include?("\n") } &&
+            node.each_descendant(:begin, :sym).none? { |b| !b.single_line? }
         end
 
         def convertible_block?(node)
@@ -111,7 +131,9 @@ module RuboCop
         end
 
         def comment_within?(node)
-          processed_source.comments.map(&:loc).map(&:line).any? do |comment_line_number|
+          comment_line_numbers = processed_source.comments.map { |comment| comment.loc.line }
+
+          comment_line_numbers.any? do |comment_line_number|
             comment_line_number >= node.first_line && comment_line_number <= node.last_line
           end
         end
@@ -126,7 +148,7 @@ module RuboCop
             .gsub(/" *\\\n\s*'/, %q(" + ')) # Double quote, backslash, and then single quote
             .gsub(/' *\\\n\s*"/, %q(' + ")) # Single quote, backslash, and then double quote
             .gsub(/(["']) *\\\n\s*\1/, '')  # Double or single quote, backslash, then same quote
-            .gsub(/\n\s*(?=\.\w)/, '')      # Extra space within method chaining
+            .gsub(/\n\s*(?=(&)?\.\w)/, '')  # Extra space within method chaining which includes `&.`
             .gsub(/\s*\\?\n\s*/, ' ')       # Any other line break, with or without backslash
         end
 

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

@@ -29,7 +29,7 @@ module RuboCop
         MSG = '`%<kw_loc>s` at %<kw_loc_line>d, %<kw_loc_column>d is not ' \
               'aligned with `%<beginning>s` at ' \
               '%<begin_loc_line>d, %<begin_loc_column>d.'
-        ANCESTOR_TYPES = %i[kwbegin def defs class module block].freeze
+        ANCESTOR_TYPES = %i[kwbegin def defs class module block numblock].freeze
         ANCESTOR_TYPES_WITH_ACCESS_MODIFIERS = %i[def defs].freeze
         ALTERNATIVE_ACCESS_MODIFIERS = %i[public_class_method private_class_method].freeze
 
@@ -95,17 +95,17 @@ module RuboCop
         def alignment_source(node, starting_loc)
           ending_loc =
             case node.type
-            when :block, :kwbegin
+            when :block, :numblock, :kwbegin
               node.loc.begin
             when :def, :defs, :class, :module,
                  :lvasgn, :ivasgn, :cvasgn, :gvasgn, :casgn
               node.loc.name
             when :masgn
               mlhs_node, = *node
-              mlhs_node.loc.expression
+              mlhs_node.source_range
             else
-              # It is a wrapper with access modifier.
-              node.child_nodes.first.loc.name
+              # It is a wrapper with receiver of object attribute or access modifier.
+              node.receiver&.source_range || node.child_nodes.first.loc.name
             end
 
           range_between(starting_loc.begin_pos, ending_loc.end_pos).source
@@ -196,7 +196,7 @@ module RuboCop
           if begin_end_alignment_style == 'start_of_line'
             start_line_range(alignment_node)
           else
-            alignment_node.loc.expression
+            alignment_node.source_range
           end
         end