rubocop 1.29.1 → 1.48.0

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

@@ -3,20 +3,52 @@
 module RuboCop
   module Cop
     module Layout
-      # This cop checks for a line break before the first element in a
+      # 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_indentation.rb

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Layout
-      # This cop checks the indentation of the first key in a hash literal
+      # Checks the indentation of the first key in a hash literal
       # where the opening brace and the first key are on separate lines. The
       # other keys' indentations are handled by the HashAlignment cop.
       #
@@ -32,6 +32,14 @@ module RuboCop
       #   and_in_a_method_call({
       #     no: :difference
       #                        })
+      #   takes_multi_pairs_hash(x: {
+      #     a: 1,
+      #     b: 2
+      #   },
+      #                          y: {
+      #                            c: 1,
+      #                            d: 2
+      #                          })
       #
       #   # good
       #   special_inside_parentheses
@@ -41,6 +49,14 @@ module RuboCop
       #   but_in_a_method_call({
       #                          its_like: :this
       #                        })
+      #   takes_multi_pairs_hash(x: {
+      #                            a: 1,
+      #                            b: 2
+      #                          },
+      #                          y: {
+      #                            c: 1,
+      #                            d: 2
+      #                          })
       #
       # @example EnforcedStyle: consistent
       #   # The `consistent` style enforces that the first key in a hash
@@ -64,6 +80,7 @@ module RuboCop
       #     no: :difference
       #   })
       #
+      #
       # @example EnforcedStyle: align_braces
       #   # The `align_brackets` style enforces that the opening and closing
       #   # braces are indented to the same position.
@@ -72,11 +89,27 @@ module RuboCop
       #   and_now_for_something = {
       #                             completely: :different
       #   }
+      #   takes_multi_pairs_hash(x: {
+      #     a: 1,
+      #     b: 2
+      #   },
+      #                           y: {
+      #                                c: 1,
+      #                                d: 2
+      #                              })
       #
       #   # good
       #   and_now_for_something = {
       #                             completely: :different
       #                           }
+      #   takes_multi_pairs_hash(x: {
+      #                               a: 1,
+      #                               b: 2
+      #                             },
+      #                          y: {
+      #                               c: 1,
+      #                               d: 2
+      #                             })
       class FirstHashElementIndentation < Base
         include Alignment
         include ConfigurableEnforcedStyle
@@ -125,18 +158,18 @@ module RuboCop
             end
           end
 
-          check_right_brace(hash_node.loc.end, left_brace, left_parenthesis)
+          check_right_brace(hash_node.loc.end, first_pair, left_brace, left_parenthesis)
         end
 
-        def check_right_brace(right_brace, left_brace, left_parenthesis)
+        def check_right_brace(right_brace, first_pair, left_brace, left_parenthesis)
           # if the right brace is on the same line as the last value, accept
           return if /\S/.match?(right_brace.source_line[0...right_brace.column])
 
-          expected_column = base_column(left_brace, left_parenthesis)
+          expected_column, indent_base_type = indent_base(left_brace, first_pair, left_parenthesis)
           @column_delta = expected_column - right_brace.column
           return if @column_delta.zero?
 
-          message = message_for_right_brace(left_parenthesis)
+          message = message_for_right_brace(indent_base_type)
           add_offense(right_brace, message: message) do |corrector|
             autocorrect(corrector, right_brace)
           end
@@ -155,11 +188,14 @@ module RuboCop
         end
 
         # Returns the description of what the correct indentation is based on.
-        def base_description(left_parenthesis)
-          if style == :align_braces
+        def base_description(indent_base_type)
+          case indent_base_type
+          when :left_brace_or_bracket
             'the position of the opening brace'
-          elsif left_parenthesis && style == :special_inside_parentheses
+          when :first_column_after_left_parenthesis
             'the first position after the preceding left parenthesis'
+          when :parent_hash_key
+            'the parent hash key'
           else
             'the start of the line where the left curly brace is'
           end
@@ -173,15 +209,18 @@ module RuboCop
           )
         end
 
-        def message_for_right_brace(left_parenthesis)
-          if style == :align_braces
+        def message_for_right_brace(indent_base_type)
+          case indent_base_type
+          when :left_brace_or_bracket
             'Indent the right brace the same as the left brace.'
-          elsif style == :special_inside_parentheses && left_parenthesis
+          when :first_column_after_left_parenthesis
             'Indent the right brace the same as the first position ' \
-              'after the preceding left parenthesis.'
+            'after the preceding left parenthesis.'
+          when :parent_hash_key
+            'Indent the right brace the same as the parent hash key.'
           else
             'Indent the right brace the same as the start of the line ' \
-              'where the left brace is.'
+            'where the left brace is.'
           end
         end
 

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

@@ -3,19 +3,58 @@
 module RuboCop
   module Cop
     module Layout
-      # This cop checks for a line break before the first element in a
+      # 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

@@ -3,20 +3,73 @@
 module RuboCop
   module Cop
     module Layout
-      # This cop checks for a line break before the first argument in a
+      # 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

@@ -3,10 +3,10 @@
 module RuboCop
   module Cop
     module Layout
-      # This cop checks for a line break before the first parameter in a
+      # 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/first_parameter_indentation.rb

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Layout
-      # This cop checks the indentation of the first parameter in a method
+      # Checks the indentation of the first parameter in a method
       # definition. Parameters after the first one are checked by
       # Layout/ParameterAlignment, not by this cop.
       #

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

@@ -190,6 +190,8 @@ module RuboCop
                                    'more than one line.'
         }.freeze
 
+        SEPARATOR_ALIGNMENT_STYLES = %w[EnforcedColonStyle EnforcedHashRocketStyle].freeze
+
         def on_send(node)
           return if double_splat?(node)
           return unless node.arguments?

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Layout
-      # This cop checks for the placement of the closing parenthesis
+      # Checks for the placement of the closing parenthesis
       # in a method call that passes a HEREDOC string as an argument.
       # It should be placed at the end of the line containing the
       # opening HEREDOC tag.
@@ -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_parentesis?(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_parentesis?(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 &&

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Layout
-      # This cop checks the indentation of the here document bodies. The bodies
+      # Checks the indentation of the here document bodies. The bodies
       # are indented one step.
       #
       # Note: When ``Layout/LineLength``'s `AllowHeredoc` is false (not default),
@@ -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_consistency.rb

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Layout
-      # This cop checks for inconsistent indentation.
+      # Checks for inconsistent indentation.
       #
       # The difference between `indented_internal_methods` and `normal` is
       # that the `indented_internal_methods` style prescribes that in

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Layout
-      # This cop checks that the indentation method is consistent.
+      # Checks that the indentation method is consistent.
       # Either tabs only or spaces only are used for indentation.
       #
       # @example EnforcedStyle: spaces (default)
@@ -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)