rubocop 1.39.0 → 1.41.0

data/lib/rubocop/cop/correctors/multiline_literal_brace_corrector.rb

@@ -28,7 +28,10 @@ module RuboCop
           # put the comment.
           return if new_line_needed_before_closing_brace?(node)
 
-          correct_next_line_brace(corrector)
+          end_range = last_element_range_with_trailing_comma(node).end
+
+          correct_next_line_brace(corrector, end_range)
+          correct_heredoc_argument_method_chain(corrector, end_range)
         end
       end
 
@@ -40,13 +43,19 @@ module RuboCop
         corrector.insert_before(node.loc.end, "\n")
       end
 
-      def correct_next_line_brace(corrector)
+      def correct_next_line_brace(corrector, end_range)
         corrector.remove(range_with_surrounding_space(node.loc.end, side: :left))
+        corrector.insert_before(end_range, content_if_comment_present(corrector, node))
+      end
 
-        corrector.insert_before(
-          last_element_range_with_trailing_comma(node).end,
-          content_if_comment_present(corrector, node)
-        )
+      def correct_heredoc_argument_method_chain(corrector, end_range)
+        return unless (parent = node.parent)
+        return unless use_heredoc_argument_method_chain?(parent)
+
+        chained_method = range_between(parent.loc.dot.begin_pos, parent.loc.expression.end_pos)
+
+        corrector.remove(chained_method)
+        corrector.insert_after(end_range, chained_method.source)
       end
 
       def content_if_comment_present(corrector, node)
@@ -61,6 +70,13 @@ module RuboCop
         end
       end
 
+      def use_heredoc_argument_method_chain?(parent)
+        return false unless node.respond_to?(:first_argument)
+        return false unless (first_argument = node.first_argument)
+
+        parent.call_type? && first_argument.str_type? && first_argument.heredoc?
+      end
+
       def select_content_to_be_inserted_after_last_element(corrector, node)
         range = range_between(
           node.loc.end.begin_pos,

data/lib/rubocop/cop/internal_affairs/cop_description.rb

@@ -28,8 +28,9 @@ module RuboCop
           /^\s+# This cop (?<special>#{SPECIAL_WORDS.join('|')})?\s*(?<word>.+?) .*/.freeze
         REPLACEMENT_REGEX = /^\s+# This cop (#{SPECIAL_WORDS.join('|')})?\s*(.+?) /.freeze
 
+        # rubocop:disable Metrics/CyclomaticComplexity
         def on_class(node)
-          return unless (module_node = node.parent)
+          return unless (module_node = node.parent) && node.parent_class
 
           description_beginning = first_comment_line(module_node)
           return unless description_beginning
@@ -48,6 +49,7 @@ module RuboCop
             end
           end
         end
+        # rubocop:enable Metrics/CyclomaticComplexity
 
         private
 

data/lib/rubocop/cop/internal_affairs/lambda_or_proc.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module InternalAffairs
+      # Enforces the use of `node.lambda_or_proc?` instead of `node.lambda? || node.proc?`.
+      #
+      # @example
+      #   # bad
+      #   node.lambda? || node.proc?
+      #   node.proc? || node.lambda?
+      #
+      #   # good
+      #   node.lambda_or_proc?
+      #
+      class LambdaOrProc < Base
+        extend AutoCorrector
+
+        MSG = 'Use `%<prefer>s`.'
+
+        # @!method lambda_or_proc(node)
+        def_node_matcher :lambda_or_proc, <<~PATTERN
+          {
+            (or $(send _node :lambda?) $(send _node :proc?))
+            (or $(send _node :proc?) $(send _node :lambda?))
+            (or
+              (or _ $(send _node :lambda?)) $(send _node :proc?))
+            (or
+              (or _ $(send _node :proc?)) $(send _node :lambda?))
+          }
+        PATTERN
+
+        def on_or(node)
+          return unless (lhs, rhs = lambda_or_proc(node))
+
+          offense = lhs.receiver.source_range.join(rhs.source_range.end)
+          prefer = "#{lhs.receiver.source}.lambda_or_proc?"
+
+          add_offense(offense, message: format(MSG, prefer: prefer)) do |corrector|
+            corrector.replace(offense, prefer)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/internal_affairs.rb

@@ -6,6 +6,7 @@ require_relative 'internal_affairs/empty_line_between_expect_offense_and_correct
 require_relative 'internal_affairs/example_description'
 require_relative 'internal_affairs/example_heredoc_delimiter'
 require_relative 'internal_affairs/inherit_deprecated_cop_class'
+require_relative 'internal_affairs/lambda_or_proc'
 require_relative 'internal_affairs/location_line_equality_comparison'
 require_relative 'internal_affairs/method_name_end_with'
 require_relative 'internal_affairs/method_name_equal'

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

@@ -27,6 +27,8 @@ module RuboCop
 
         def on_new_investigation
           return if processed_source.tokens.empty?
+          # Quick check if we possibly have consecutive blank lines.
+          return unless processed_source.raw_source.include?("\n\n\n")
 
           lines = Set.new
           processed_source.each_token { |token| lines << token.line }

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

@@ -119,12 +119,16 @@ module RuboCop
         def ignored_ranges(ast)
           return [] unless ast
 
-          @ignored_ranges ||= on_node(:pair, ast).map do |pair|
-            next if pair.parent.single_line?
-
-            key, value = *pair
-            key.source_range.end_pos...value.source_range.begin_pos
-          end.compact
+          @ignored_ranges ||= begin
+            ranges = []
+            on_node(:pair, ast) do |pair|
+              next if pair.parent.single_line?
+
+              key, value = *pair
+              ranges << (key.source_range.end_pos...value.source_range.begin_pos)
+            end
+            ranges
+          end
         end
 
         def force_equal_sign_alignment?

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

@@ -6,17 +6,49 @@ module RuboCop
       # Checks for a line break before the first element in a
       # multi-line array.
       #
-      # @example
+      # @example AllowMultilineFinalElement: false (default)
+      #
+      #     # bad
+      #     [ :a,
+      #       :b]
+      #
+      #     # bad
+      #     [ :a, {
+      #       :b => :c
+      #     }]
+      #
+      #     # good
+      #     [:a, :b]
+      #
+      #     # good
+      #     [
+      #       :a,
+      #       :b]
+      #
+      #     # good
+      #     [
+      #       :a, {
+      #       :b => :c
+      #     }]
+      #
+      # @example AllowMultilineFinalElement: true
       #
       #     # bad
       #     [ :a,
       #       :b]
       #
       #     # good
+      #     [ :a, {
+      #       :b => :c
+      #     }]
+      #
+      #     # good
       #     [
       #       :a,
       #       :b]
       #
+      #     # good
+      #     [:a, :b]
       class FirstArrayElementLineBreak < Base
         include FirstElementLineBreak
         extend AutoCorrector
@@ -26,7 +58,7 @@ module RuboCop
         def on_array(node)
           return if !node.loc.begin && !assignment_on_same_line?(node)
 
-          check_children_line_break(node, node.children)
+          check_children_line_break(node, node.children, ignore_last: ignore_last_element?)
         end
 
         private
@@ -35,6 +67,10 @@ module RuboCop
           source = node.source_range.source_line[0...node.loc.column]
           /\s*=\s*$/.match?(source)
         end
+
+        def ignore_last_element?
+          !!cop_config['AllowMultilineFinalElement']
+        end
       end
     end
   end

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

@@ -6,16 +6,55 @@ module RuboCop
       # Checks for a line break before the first element in a
       # multi-line hash.
       #
-      # @example
+      # @example AllowMultilineFinalElement: false (default)
       #
       #     # bad
       #     { a: 1,
       #       b: 2}
       #
+      #     # bad
+      #     { a: 1, b: {
+      #       c: 3
+      #     }}
+      #
       #     # good
       #     {
       #       a: 1,
       #       b: 2 }
+      #
+      #     # good
+      #     {
+      #       a: 1, b: {
+      #       c: 3
+      #     }}
+      #
+      # @example AllowMultilineFinalElement: true
+      #
+      #     # bad
+      #     { a: 1,
+      #       b: 2}
+      #
+      #     # bad
+      #     { a: 1,
+      #       b: {
+      #       c: 3
+      #     }}
+      #
+      #     # good
+      #     { a: 1, b: {
+      #       c: 3
+      #     }}
+      #
+      #     # good
+      #     {
+      #       a: 1,
+      #       b: 2 }
+      #
+      #     # good
+      #     {
+      #       a: 1, b: {
+      #       c: 3
+      #     }}
       class FirstHashElementLineBreak < Base
         include FirstElementLineBreak
         extend AutoCorrector
@@ -25,7 +64,15 @@ module RuboCop
         def on_hash(node)
           # node.loc.begin tells us whether the hash opens with a {
           # If it doesn't, Style/FirstMethodArgumentLineBreak will handle it
-          check_children_line_break(node, node.children) if node.loc.begin
+          return unless node.loc.begin
+
+          check_children_line_break(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/first_method_argument_line_break.rb

@@ -6,17 +6,70 @@ module RuboCop
       # Checks for a line break before the first argument in a
       # multi-line method call.
       #
-      # @example
+      # @example AllowMultilineFinalElement: false (default)
       #
       #     # bad
       #     method(foo, bar,
       #       baz)
       #
+      #     # bad
+      #     method(foo, bar, {
+      #       baz: "a",
+      #       qux: "b",
+      #     })
+      #
       #     # good
       #     method(
       #       foo, bar,
       #       baz)
       #
+      #     # good
+      #     method(
+      #       foo, bar, {
+      #       baz: "a",
+      #       qux: "b",
+      #     })
+      #
+      #     # ignored
+      #     method foo, bar,
+      #       baz
+      #
+      # @example AllowMultilineFinalElement: true
+      #
+      #     # bad
+      #     method(foo, bar,
+      #       baz)
+      #
+      #     # bad
+      #     method(foo,
+      #       bar,
+      #       {
+      #         baz: "a",
+      #         qux: "b",
+      #       }
+      #     )
+      #
+      #     # good
+      #     method(foo, bar, {
+      #       baz: "a",
+      #       qux: "b",
+      #     })
+      #
+      #     # good
+      #     method(
+      #       foo, bar,
+      #       baz)
+      #
+      #     # good
+      #     method(
+      #       foo,
+      #       bar,
+      #       {
+      #         baz: "a",
+      #         qux: "b",
+      #       }
+      #     )
+      #
       #     # ignored
       #     method foo, bar,
       #       baz
@@ -38,10 +91,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

@@ -6,7 +6,7 @@ module RuboCop
       # Checks for a line break before the first parameter in a
       # multi-line method parameter definition.
       #
-      # @example
+      # @example AllowMultilineFinalElement: false (default)
       #
       #     # bad
       #     def method(foo, bar,
@@ -14,6 +14,13 @@ module RuboCop
       #       do_something
       #     end
       #
+      #     # bad
+      #     def method(foo, bar, baz = {
+      #       :a => "b",
+      #     })
+      #       do_something
+      #     end
+      #
       #     # good
       #     def method(
       #         foo, bar,
@@ -21,11 +28,48 @@ module RuboCop
       #       do_something
       #     end
       #
+      #     # good
+      #     def method(
+      #       foo, bar, baz = {
+      #       :a => "b",
+      #     })
+      #       do_something
+      #     end
+      #
       #     # ignored
       #     def method foo,
       #         bar
       #       do_something
       #     end
+      #
+      # @example AllowMultilineFinalElement: true
+      #
+      #     # bad
+      #     def method(foo, bar,
+      #         baz)
+      #       do_something
+      #     end
+      #
+      #     # good
+      #     def method(foo, bar, baz = {
+      #       :a => "b",
+      #     })
+      #       do_something
+      #     end
+      #
+      #     # good
+      #     def method(
+      #         foo, bar,
+      #         baz)
+      #       do_something
+      #     end
+      #
+      #     # ignored
+      #     def method foo,
+      #         bar
+      #       do_something
+      #     end
+      #
       class FirstMethodParameterLineBreak < Base
         include FirstElementLineBreak
         extend AutoCorrector
@@ -33,9 +77,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/indentation_style.rb

@@ -90,7 +90,8 @@ module RuboCop
           # which lines start inside a string literal?
           return [] if ast.nil?
 
-          ast.each_node(:str, :dstr).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 +100,7 @@ module RuboCop
               ranges << loc.expression
             end
           end
+          ranges
         end
 
         def message(_node)

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

@@ -51,7 +51,11 @@ module RuboCop
         private_constant :LINE_1_ENDING, :LINE_2_BEGINNING,
                          :LEADING_STYLE_OFFENSE, :TRAILING_STYLE_OFFENSE
 
+        # rubocop:disable Metrics/AbcSize
         def on_dstr(node)
+          # Quick check if we possibly have line continuations.
+          return unless node.source.include?('\\')
+
           end_of_first_line = node.loc.expression.begin_pos - node.loc.expression.column
 
           raw_lines(node).each_cons(2) do |raw_line_one, raw_line_two|
@@ -66,6 +70,7 @@ module RuboCop
             end
           end
         end
+        # rubocop:enable Metrics/AbcSize
 
         private
 

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

@@ -31,7 +31,10 @@ module RuboCop
         include RangeHelp
         extend AutoCorrector
 
+        # rubocop:disable Metrics/AbcSize
         def on_new_investigation
+          return unless processed_source.raw_source.include?('\\')
+
           last_line = last_line(processed_source)
 
           @ignored_ranges = string_literal_ranges(processed_source.ast) +
@@ -44,6 +47,7 @@ module RuboCop
             investigate(line, line_number)
           end
         end
+        # rubocop:enable Metrics/AbcSize
 
         private
 
@@ -92,7 +96,8 @@ module RuboCop
           # which lines start inside a string literal?
           return [] if ast.nil?
 
-          ast.each_node(:str, :dstr).with_object(Set.new) do |str, ranges|
+          ranges = Set.new
+          ast.each_node(:str, :dstr) do |str|
             loc = str.location
 
             if str.heredoc?
@@ -101,6 +106,7 @@ module RuboCop
               ranges << loc.expression
             end
           end
+          ranges
         end
 
         def comment_ranges(comments)

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

@@ -86,6 +86,8 @@ module RuboCop
         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
 

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
+      # @example AllowMultilineFinalElement: false (default)
       #
       #   # bad
       #   [
@@ -14,12 +14,55 @@ module RuboCop
       #     c
       #   ]
       #
+      #   # bad
+      #   [ a, b, foo(
+      #     bar
+      #   )]
+      #
       #   # good
       #   [
       #     a,
       #     b,
       #     c
       #   ]
+      #
+      #   # good
+      #   [
+      #     a,
+      #     b,
+      #     foo(
+      #       bar
+      #     )
+      #   ]
+      #
+      # @example AllowMultilineFinalElement: true
+      #
+      #   # bad
+      #   [
+      #     a, b,
+      #     c
+      #   ]
+      #
+      #   # good
+      #   [ a, b, foo(
+      #     bar
+      #   )]
+      #
+      #   # good
+      #   [
+      #     a,
+      #     b,
+      #     c
+      #   ]
+      #
+      #   # good
+      #   [
+      #     a,
+      #     b,
+      #     foo(
+      #       bar
+      #     )
+      #   ]
       class MultilineArrayLineBreaks < Base
         include MultilineElementLineBreaks
         extend AutoCorrector
@@ -27,7 +70,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