rubocop 1.31.1 → 1.51.0

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

@@ -8,18 +8,61 @@ module RuboCop
       #
       # @example
       #
-      #     # bad
-      #     method(foo, bar,
-      #       baz)
+      #   # bad
+      #   method(foo, bar,
+      #     baz)
       #
-      #     # good
-      #     method(
-      #       foo, bar,
-      #       baz)
+      #   # good
+      #   method(
+      #     foo, bar,
+      #     baz)
       #
       #     # ignored
       #     method foo, bar,
       #       baz
+      #
+      # @example AllowMultilineFinalElement: false (default)
+      #
+      #   # bad
+      #   method(foo, bar, {
+      #     baz: "a",
+      #     qux: "b",
+      #   })
+      #
+      #   # good
+      #   method(
+      #     foo, bar, {
+      #     baz: "a",
+      #     qux: "b",
+      #   })
+      #
+      # @example AllowMultilineFinalElement: true
+      #
+      #   # bad
+      #   method(foo,
+      #     bar,
+      #     {
+      #       baz: "a",
+      #       qux: "b",
+      #     }
+      #   )
+      #
+      #   # good
+      #   method(foo, bar, {
+      #     baz: "a",
+      #     qux: "b",
+      #   })
+      #
+      #   # good
+      #   method(
+      #     foo,
+      #     bar,
+      #     {
+      #       baz: "a",
+      #       qux: "b",
+      #     }
+      #   )
+      #
       class FirstMethodArgumentLineBreak < Base
         include FirstElementLineBreak
         extend AutoCorrector
@@ -38,10 +81,16 @@ module RuboCop
           last_arg = args.last
           args.concat(args.pop.children) if last_arg&.hash_type? && !last_arg&.braces?
 
-          check_method_line_break(node, args)
+          check_method_line_break(node, args, ignore_last: ignore_last_element?)
         end
         alias on_csend on_send
         alias on_super on_send
+
+        private
+
+        def ignore_last_element?
+          !!cop_config['AllowMultilineFinalElement']
+        end
       end
     end
   end

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

@@ -8,24 +8,51 @@ module RuboCop
       #
       # @example
       #
-      #     # bad
-      #     def method(foo, bar,
-      #         baz)
-      #       do_something
-      #     end
-      #
-      #     # good
-      #     def method(
-      #         foo, bar,
-      #         baz)
-      #       do_something
-      #     end
-      #
-      #     # ignored
-      #     def method foo,
-      #         bar
-      #       do_something
-      #     end
+      #   # bad
+      #   def method(foo, bar,
+      #       baz)
+      #     do_something
+      #   end
+      #
+      #   # good
+      #   def method(
+      #       foo, bar,
+      #       baz)
+      #     do_something
+      #   end
+      #
+      #   # ignored
+      #   def method foo,
+      #       bar
+      #     do_something
+      #   end
+      #
+      # @example AllowMultilineFinalElement: false (default)
+      #
+      #   # bad
+      #   def method(foo, bar, baz = {
+      #     :a => "b",
+      #   })
+      #     do_something
+      #   end
+      #
+      #   # good
+      #   def method(
+      #     foo, bar, baz = {
+      #     :a => "b",
+      #   })
+      #     do_something
+      #   end
+      #
+      # @example AllowMultilineFinalElement: true
+      #
+      #   # good
+      #   def method(foo, bar, baz = {
+      #     :a => "b",
+      #   })
+      #     do_something
+      #   end
+      #
       class FirstMethodParameterLineBreak < Base
         include FirstElementLineBreak
         extend AutoCorrector
@@ -33,9 +60,15 @@ module RuboCop
         MSG = 'Add a line break before the first parameter of a multi-line method parameter list.'
 
         def on_def(node)
-          check_method_line_break(node, node.arguments)
+          check_method_line_break(node, node.arguments, ignore_last: ignore_last_element?)
         end
         alias on_defs on_def
+
+        private
+
+        def ignore_last_element?
+          !!cop_config['AllowMultilineFinalElement']
+        end
       end
     end
   end

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

@@ -67,8 +67,7 @@ module RuboCop
 
           outermost_send = outermost_send_on_same_line(heredoc_arg)
           return unless outermost_send
-          return unless outermost_send.loc.end
-          return unless heredoc_arg.first_line != outermost_send.loc.end.line
+          return if end_keyword_before_closing_parenthesis?(node)
           return if subsequent_closing_parentheses_in_same_line?(outermost_send)
           return if exist_argument_between_heredoc_end_and_closing_parentheses?(node)
 
@@ -160,6 +159,12 @@ module RuboCop
 
         # Closing parenthesis helpers.
 
+        def end_keyword_before_closing_parenthesis?(parenthesized_send_node)
+          parenthesized_send_node.ancestors.any? do |ancestor|
+            ancestor.loc.respond_to?(:end) && ancestor.loc.end&.source == 'end'
+          end
+        end
+
         def subsequent_closing_parentheses_in_same_line?(outermost_send)
           last_arg_of_outer_send = outermost_send.last_argument
           return false unless last_arg_of_outer_send&.loc.respond_to?(:end) &&
@@ -215,6 +220,7 @@ module RuboCop
         end
 
         def exist_argument_between_heredoc_end_and_closing_parentheses?(node)
+          return true unless node.loc.end
           return false unless (heredoc_end = find_most_bottom_of_heredoc_end(node.arguments))
 
           heredoc_end < node.loc.end.begin_pos &&
@@ -222,9 +228,9 @@ module RuboCop
         end
 
         def find_most_bottom_of_heredoc_end(arguments)
-          arguments.map do |argument|
+          arguments.filter_map do |argument|
             argument.loc.heredoc_end.end_pos if argument.loc.respond_to?(:heredoc_end)
-          end.compact.max
+          end.max
         end
 
         # Internal trailing comma helpers.

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

@@ -22,6 +22,7 @@ module RuboCop
       #   RUBY
       #
       class HeredocIndentation < Base
+        include Alignment
         include Heredoc
         extend AutoCorrector
 
@@ -37,7 +38,7 @@ module RuboCop
           heredoc_indent_type = heredoc_indent_type(node)
 
           if heredoc_indent_type == '~'
-            expected_indent_level = base_indent_level(node) + indentation_width
+            expected_indent_level = base_indent_level(node) + configured_indentation_width
             return if expected_indent_level == body_indent_level
           else
             return unless body_indent_level.zero?
@@ -66,9 +67,9 @@ module RuboCop
           current_indent_type = "<<#{heredoc_indent_type}"
 
           if current_indent_type == '<<~'
-            width_message(indentation_width)
+            width_message(configured_indentation_width)
           else
-            type_message(indentation_width, current_indent_type)
+            type_message(configured_indentation_width, current_indent_type)
           end
         end
 
@@ -89,7 +90,7 @@ module RuboCop
 
           body = heredoc_body(node)
 
-          expected_indent = base_indent_level(node) + indentation_width
+          expected_indent = base_indent_level(node) + configured_indentation_width
           actual_indent = indent_level(body)
           increase_indent_level = expected_indent - actual_indent
 
@@ -114,7 +115,7 @@ module RuboCop
         end
 
         def adjust_minus(corrector, node)
-          heredoc_beginning = node.loc.expression.source
+          heredoc_beginning = node.source
           corrected = heredoc_beginning.sub(/<<-?/, '<<~')
           corrector.replace(node, corrected)
         end
@@ -122,7 +123,7 @@ module RuboCop
         def indented_body(node)
           body = heredoc_body(node)
           body_indent_level = indent_level(body)
-          correct_indent_level = base_indent_level(node) + indentation_width
+          correct_indent_level = base_indent_level(node) + configured_indentation_width
           body.gsub(/^[^\S\r\n]{#{body_indent_level}}/, ' ' * correct_indent_level)
         end
 
@@ -138,7 +139,7 @@ module RuboCop
         end
 
         def base_indent_level(node)
-          base_line_num = node.loc.expression.line
+          base_line_num = node.source_range.line
           base_line = processed_source.lines[base_line_num - 1]
           indent_level(base_line)
         end
@@ -148,10 +149,6 @@ module RuboCop
           node.source[/^<<([~-])/, 1]
         end
 
-        def indentation_width
-          @config.for_cop('Layout/IndentationWidth')['Width'] || 2
-        end
-
         def heredoc_body(node)
           node.loc.heredoc_body.source
         end

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

@@ -40,10 +40,13 @@ module RuboCop
         MSG = '%<type>s detected in indentation.'
 
         def on_new_investigation
-          str_ranges = string_literal_ranges(processed_source.ast)
+          str_ranges = nil
 
           processed_source.lines.each.with_index(1) do |line, lineno|
             next unless (range = find_offense(line, lineno))
+
+            # Perform costly calculation only when needed.
+            str_ranges ||= string_literal_ranges(processed_source.ast)
             next if in_string_literal?(str_ranges, range)
 
             add_offense(range) { |corrector| autocorrect(corrector, range) }
@@ -90,7 +93,8 @@ module RuboCop
           # which lines start inside a string literal?
           return [] if ast.nil?
 
-          ast.each_node(:str, :dstr).each_with_object(Set.new) do |str, ranges|
+          ranges = Set.new
+          ast.each_node(:str, :dstr) do |str|
             loc = str.location
 
             if str.heredoc?
@@ -99,6 +103,7 @@ module RuboCop
               ranges << loc.expression
             end
           end
+          ranges
         end
 
         def message(_node)

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

@@ -90,6 +90,8 @@ module RuboCop
           check_members(end_loc, [node.body])
         end
 
+        alias on_numblock on_block
+
         def on_class(node)
           base = node.loc.keyword
           return if same_line?(base, node.body)
@@ -146,7 +148,9 @@ module RuboCop
             check_indentation(in_pattern_node.loc.keyword, in_pattern_node.body)
           end
 
-          check_indentation(case_match.in_pattern_branches.last.loc.keyword, case_match.else_branch)
+          else_branch = case_match.else_branch&.empty_else_type? ? nil : case_match.else_branch
+
+          check_indentation(case_match.in_pattern_branches.last.loc.keyword, else_branch)
         end
 
         def on_if(node, base = node)
@@ -339,7 +343,7 @@ module RuboCop
         end
 
         def skip_check?(base_loc, body_node)
-          return true if ignored_line?(base_loc)
+          return true if allowed_line?(base_loc)
           return true unless body_node
 
           # Don't check if expression is on same line as "then" keyword, etc.

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

@@ -34,7 +34,7 @@ module RuboCop
         private
 
         def first_token
-          processed_source.find_token { |t| !t.text.start_with?('#') }
+          processed_source.tokens.find { |t| !t.text.start_with?('#') }
         end
 
         def space_before(token)

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

@@ -63,7 +63,7 @@ module RuboCop
             next if gemfile_ruby_comment?(comment)
 
             add_offense(comment) do |corrector|
-              expr = comment.loc.expression
+              expr = comment.source_range
 
               corrector.insert_after(hash_mark(expr), ' ')
             end

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

@@ -4,9 +4,10 @@ module RuboCop
   module Cop
     module Layout
       # Checks that strings broken over multiple lines (by a backslash) contain
-      # trailing spaces instead of leading spaces.
+      # trailing spaces instead of leading spaces (default) or leading spaces
+      # instead of trailing spaces.
       #
-      # @example
+      # @example EnforcedStyle: trailing (default)
       #   # bad
       #   'this text contains a lot of' \
       #   '               spaces'
@@ -23,18 +24,49 @@ module RuboCop
       #   '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
 
-        MSG = 'Move leading spaces to the end of previous line.'
+        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)
-          range_start = node.loc.expression.begin_pos - node.loc.expression.column
+          # 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
 
           raw_lines(node).each_cons(2) do |raw_line_one, raw_line_two|
-            range_start += raw_line_one.length
+            end_of_first_line += raw_line_one.length
 
-            investigate(raw_line_one, raw_line_two, range_start)
+            next unless continuation?(raw_line_one)
+
+            if enforced_style_leading?
+              investigate_leading_style(raw_line_one, raw_line_two, end_of_first_line)
+            else
+              investigate_trailing_style(raw_line_one, raw_line_two, end_of_first_line)
+            end
           end
         end
 
@@ -44,24 +76,60 @@ module RuboCop
           processed_source.raw_source.lines[node.first_line - 1, line_range(node).size]
         end
 
-        def investigate(first_line, second_line, range_start)
-          return unless continuation?(first_line)
+        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
 
-          matches = second_line.match(/\A(?<indent>\s*['"])(?<leading_spaces>\s+)/)
+        def investigate_trailing_style(first_line, second_line, end_of_first_line)
+          matches = second_line.match(TRAILING_STYLE_OFFENSE)
           return if matches.nil?
 
-          add_offense(offense_range(range_start, matches))
+          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.end_with?("\\\n")
         end
 
-        def offense_range(range_start, matches)
-          begin_pos = range_start + matches[:indent].length
+        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

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

@@ -32,10 +32,9 @@ module RuboCop
         extend AutoCorrector
 
         def on_new_investigation
-          last_line = last_line(processed_source)
+          return unless processed_source.raw_source.include?('\\')
 
-          @ignored_ranges = string_literal_ranges(processed_source.ast) +
-                            comment_ranges(processed_source.comments)
+          last_line = last_line(processed_source)
 
           processed_source.raw_source.lines.each_with_index do |line, index|
             break if index >= last_line
@@ -88,20 +87,26 @@ module RuboCop
           corrector.replace(range, correction)
         end
 
-        def string_literal_ranges(ast)
+        # 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).each_with_object(Set.new) do |str, ranges|
-            loc = str.location
+          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?
 
-            if str.heredoc?
+              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(&:loc).map(&:expression)
@@ -114,7 +119,12 @@ module RuboCop
         end
 
         def ignore_range?(backtick_range)
-          @ignored_ranges.any? { |range| range.contains?(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?

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