rubocop 1.42.0 → 1.64.1

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

@@ -51,6 +51,8 @@ module RuboCop
         MSG_BEFORE_FOR_ONLY_BEFORE = 'Keep a blank line before `%<modifier>s`.'
         MSG_AFTER_FOR_ONLY_BEFORE = 'Remove a blank line after `%<modifier>s`.'
 
+        RESTRICT_ON_SEND = %i[public protected private module_function].freeze
+
         def initialize(config = nil, options = nil)
           super
 

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

@@ -68,6 +68,8 @@ module RuboCop
           check_body(node.body, node.loc.line)
         end
         alias on_defs on_def
+        alias on_block on_def
+        alias on_numblock on_def
 
         def on_kwbegin(node)
           body, = *node

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

@@ -20,7 +20,9 @@ module RuboCop
       # This `Layout/EndAlignment` cop aligns with keywords (e.g. `if`, `while`, `case`)
       # by default. On the other hand, `Layout/BeginEndAlignment` cop aligns with
       # `EnforcedStyleAlignWith: start_of_line` by default due to `||= begin` tends
-      # to align with the start of the line. These style can be configured by each cop.
+      # to align with the start of the line. `Layout/DefEndAlignment` cop also aligns with
+      # `EnforcedStyleAlignWith: start_of_line` by default.
+      # These style can be configured by each cop.
       #
       # @example EnforcedStyleAlignWith: keyword (default)
       #   # bad
@@ -82,6 +84,14 @@ module RuboCop
           check_other_alignment(node)
         end
 
+        def on_sclass(node)
+          if node.parent&.assignment?
+            check_asgn_alignment(node.parent, node)
+          else
+            check_other_alignment(node)
+          end
+        end
+
         def on_module(node)
           check_other_alignment(node)
         end
@@ -105,6 +115,7 @@ module RuboCop
             check_other_alignment(node)
           end
         end
+        alias on_case_match on_case
 
         private
 
@@ -158,14 +169,23 @@ module RuboCop
           when :keyword
             node
           when :variable
-            alignment_node_for_variable_style(node)
+            align_to = alignment_node_for_variable_style(node)
+
+            while (parent = align_to.parent) && parent.send_type? && same_line?(align_to, parent)
+              align_to = parent
+            end
+
+            align_to
           else
             start_line_range(node)
           end
         end
 
         def alignment_node_for_variable_style(node)
-          return node.parent if node.case_type? && node.argument? && same_line?(node, node.parent)
+          if (node.case_type? || node.case_match_type?) && node.argument? &&
+             same_line?(node, node.parent)
+            return node.parent
+          end
 
           assignment = assignment_or_operator_method(node)
 

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

@@ -52,10 +52,9 @@ module RuboCop
         def aligned_locations(locs)
           return [] if locs.empty?
 
-          aligned = Set[locs.first.line, locs.last.line]
-          locs.each_cons(3) do |before, loc, after|
-            col = loc.column
-            aligned << loc.line if col == before.column || col == after.column
+          aligned = Set.new
+          locs.each_cons(2) do |loc1, loc2|
+            aligned << loc1.line << loc2.line if loc1.column == loc2.column
           end
           aligned
         end

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

@@ -153,9 +153,10 @@ module RuboCop
         MSG = 'Indent the first argument one step more than %<base>s.'
 
         def on_send(node)
+          return unless should_check?(node)
+          return if same_line?(node, node.first_argument)
           return if style != :consistent && enforce_first_argument_with_fixed_indentation? &&
                     !enable_layout_first_method_argument_line_break?
-          return if !node.arguments? || bare_operator?(node) || node.setter_method?
 
           indent = base_indentation(node) + configured_indentation_width
 
@@ -166,6 +167,10 @@ module RuboCop
 
         private
 
+        def should_check?(node)
+          node.arguments? && !bare_operator?(node) && !node.setter_method?
+        end
+
         def autocorrect(corrector, node)
           AlignmentCorrector.correct(corrector, processed_source, node, column_delta)
         end
@@ -179,7 +184,7 @@ module RuboCop
 
           send_node = arg_node.parent
           text = base_range(send_node, arg_node).source.strip
-          base = if !/\n/.match?(text) && special_inner_call_indentation?(send_node)
+          base = if !text.include?("\n") && special_inner_call_indentation?(send_node)
                    "`#{text}`"
                  elsif comment_line?(text.lines.reverse_each.first)
                    'the start of the previous line (not counting the comment)'
@@ -255,7 +260,7 @@ module RuboCop
           @comment_lines ||=
             processed_source
             .comments
-            .select { |c| begins_its_line?(c.loc.expression) }
+            .select { |c| begins_its_line?(c.source_range) }
             .map { |c| c.loc.line }
         end
 

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

@@ -5,7 +5,10 @@ module RuboCop
     module Layout
       # Checks the indentation of the first element in an array literal
       # where the opening bracket and the first element are on separate lines.
-      # The other elements' indentations are handled by the ArrayAlignment cop.
+      # The other elements' indentations are handled by `Layout/ArrayAlignment` cop.
+      #
+      # This cop will respect `Layout/ArrayAlignment` and will not work when
+      # `EnforcedStyle: with_fixed_indentation` is specified for `Layout/ArrayAlignment`.
       #
       # By default, array literals that are arguments in a method call with
       # parentheses, and where the opening square bracket of the array is on the
@@ -25,7 +28,7 @@ module RuboCop
       #   # element are on separate lines is indented one step (two spaces) more
       #   # than the position inside the opening parenthesis.
       #
-      #   #bad
+      #   # bad
       #   array = [
       #     :value
       #   ]
@@ -33,7 +36,7 @@ module RuboCop
       #     :no_difference
       #                        ])
       #
-      #   #good
+      #   # good
       #   array = [
       #     :value
       #   ]
@@ -47,7 +50,7 @@ module RuboCop
       #   # separate lines is indented the same as an array literal which is not
       #   # defined inside a method call.
       #
-      #   #bad
+      #   # bad
       #   # consistent
       #   array = [
       #     :value
@@ -56,7 +59,7 @@ module RuboCop
       #                          :its_like_this
       #   ])
       #
-      #   #good
+      #   # good
       #   array = [
       #     :value
       #   ]
@@ -68,13 +71,13 @@ module RuboCop
       #   # The `align_brackets` style enforces that the opening and closing
       #   # brackets are indented to the same position.
       #
-      #   #bad
+      #   # bad
       #   # align_brackets
       #   and_now_for_something = [
       #                             :completely_different
       #   ]
       #
-      #   #good
+      #   # good
       #   # align_brackets
       #   and_now_for_something = [
       #                             :completely_different
@@ -89,10 +92,14 @@ module RuboCop
               'in an array, relative to %<base_description>s.'
 
         def on_array(node)
+          return if style != :consistent && enforce_first_argument_with_fixed_indentation?
+
           check(node, nil) if node.loc.begin
         end
 
         def on_send(node)
+          return if style != :consistent && enforce_first_argument_with_fixed_indentation?
+
           each_argument_node(node, :array) do |array_node, left_parenthesis|
             check(array_node, left_parenthesis)
           end
@@ -174,6 +181,16 @@ module RuboCop
             'where the left bracket is.'
           end
         end
+
+        def enforce_first_argument_with_fixed_indentation?
+          return false unless array_alignment_config['Enabled']
+
+          array_alignment_config['EnforcedStyle'] == 'with_fixed_indentation'
+        end
+
+        def array_alignment_config
+          config.for_cop('Layout/ArrayAlignment')
+        end
       end
     end
   end

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

@@ -6,49 +6,40 @@ module RuboCop
       # Checks for a line break before the first element in a
       # multi-line array.
       #
-      # @example AllowMultilineFinalElement: false (default)
+      # @example
       #
-      #     # bad
-      #     [ :a,
-      #       :b]
+      #   # bad
+      #   [ :a,
+      #     :b]
       #
-      #     # bad
-      #     [ :a, {
-      #       :b => :c
-      #     }]
+      #   # good
+      #   [
+      #     :a,
+      #     :b]
       #
-      #     # good
-      #     [:a, :b]
+      #   # good
+      #   [:a, :b]
       #
-      #     # good
-      #     [
-      #       :a,
-      #       :b]
+      # @example AllowMultilineFinalElement: false (default)
       #
-      #     # good
-      #     [
-      #       :a, {
-      #       :b => :c
-      #     }]
+      #   # bad
+      #   [ :a, {
+      #     :b => :c
+      #   }]
       #
-      # @example AllowMultilineFinalElement: true
+      #   # good
+      #   [
+      #     :a, {
+      #     :b => :c
+      #   }]
       #
-      #     # bad
-      #     [ :a,
-      #       :b]
-      #
-      #     # good
-      #     [ :a, {
-      #       :b => :c
-      #     }]
+      # @example AllowMultilineFinalElement: true
       #
-      #     # good
-      #     [
-      #       :a,
-      #       :b]
+      #   # good
+      #   [:a, {
+      #     :b => :c
+      #   }]
       #
-      #     # good
-      #     [:a, :b]
       class FirstArrayElementLineBreak < Base
         include FirstElementLineBreak
         extend AutoCorrector

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

@@ -6,17 +6,12 @@ module RuboCop
       # Checks for a line break before the first element in a
       # multi-line hash.
       #
-      # @example AllowMultilineFinalElement: false (default)
+      # @example
       #
       #     # bad
       #     { a: 1,
       #       b: 2}
       #
-      #     # bad
-      #     { a: 1, b: {
-      #       c: 3
-      #     }}
-      #
       #     # good
       #     {
       #       a: 1,
@@ -28,11 +23,14 @@ module RuboCop
       #       c: 3
       #     }}
       #
-      # @example AllowMultilineFinalElement: true
+      # @example AllowMultilineFinalElement: false (default)
       #
       #     # bad
-      #     { a: 1,
-      #       b: 2}
+      #     { a: 1, b: {
+      #       c: 3
+      #     }}
+      #
+      # @example AllowMultilineFinalElement: true
       #
       #     # bad
       #     { a: 1,
@@ -45,16 +43,6 @@ module RuboCop
       #       c: 3
       #     }}
       #
-      #     # good
-      #     {
-      #       a: 1,
-      #       b: 2 }
-      #
-      #     # good
-      #     {
-      #       a: 1, b: {
-      #       c: 3
-      #     }}
       class FirstHashElementLineBreak < Base
         include FirstElementLineBreak
         extend AutoCorrector

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

@@ -6,73 +6,63 @@ module RuboCop
       # Checks for a line break before the first argument in a
       # multi-line method call.
       #
-      # @example AllowMultilineFinalElement: false (default)
-      #
-      #     # bad
-      #     method(foo, bar,
-      #       baz)
-      #
-      #     # bad
-      #     method(foo, bar, {
-      #       baz: "a",
-      #       qux: "b",
-      #     })
+      # @example
       #
-      #     # good
-      #     method(
-      #       foo, bar,
-      #       baz)
+      #   # bad
+      #   method(foo, bar,
+      #     baz)
       #
-      #     # good
-      #     method(
-      #       foo, bar, {
-      #       baz: "a",
-      #       qux: "b",
-      #     })
+      #   # good
+      #   method(
+      #     foo, bar,
+      #     baz)
       #
       #     # ignored
       #     method foo, bar,
       #       baz
       #
-      # @example AllowMultilineFinalElement: true
+      # @example AllowMultilineFinalElement: false (default)
+      #
+      #   # bad
+      #   method(foo, bar, {
+      #     baz: "a",
+      #     qux: "b",
+      #   })
       #
-      #     # bad
-      #     method(foo, bar,
-      #       baz)
+      #   # good
+      #   method(
+      #     foo, bar, {
+      #     baz: "a",
+      #     qux: "b",
+      #   })
       #
-      #     # bad
-      #     method(foo,
-      #       bar,
-      #       {
-      #         baz: "a",
-      #         qux: "b",
-      #       }
-      #     )
+      # @example AllowMultilineFinalElement: true
       #
-      #     # good
-      #     method(foo, bar, {
+      #   # bad
+      #   method(foo,
+      #     bar,
+      #     {
       #       baz: "a",
       #       qux: "b",
-      #     })
+      #     }
+      #   )
       #
-      #     # good
-      #     method(
-      #       foo, bar,
-      #       baz)
+      #   # good
+      #   method(foo, bar, {
+      #     baz: "a",
+      #     qux: "b",
+      #   })
       #
-      #     # good
-      #     method(
-      #       foo,
-      #       bar,
-      #       {
-      #         baz: "a",
-      #         qux: "b",
-      #       }
-      #     )
+      #   # good
+      #   method(
+      #     foo,
+      #     bar,
+      #     {
+      #       baz: "a",
+      #       qux: "b",
+      #     }
+      #   )
       #
-      #     # ignored
-      #     method foo, bar,
-      #       baz
       class FirstMethodArgumentLineBreak < Base
         include FirstElementLineBreak
         extend AutoCorrector

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

@@ -6,69 +6,52 @@ module RuboCop
       # Checks for a line break before the first parameter in a
       # multi-line method parameter definition.
       #
-      # @example AllowMultilineFinalElement: false (default)
-      #
-      #     # bad
-      #     def method(foo, bar,
-      #         baz)
-      #       do_something
-      #     end
-      #
-      #     # bad
-      #     def method(foo, bar, baz = {
-      #       :a => "b",
-      #     })
-      #       do_something
-      #     end
+      # @example
       #
-      #     # good
-      #     def method(
-      #         foo, bar,
-      #         baz)
-      #       do_something
-      #     end
+      #   # 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
+      #   # ignored
+      #   def method foo,
+      #       bar
+      #     do_something
+      #   end
       #
-      # @example AllowMultilineFinalElement: true
+      # @example AllowMultilineFinalElement: false (default)
       #
-      #     # bad
-      #     def method(foo, bar,
-      #         baz)
-      #       do_something
-      #     end
+      #   # bad
+      #   def method(foo, bar, baz = {
+      #     :a => "b",
+      #   })
+      #     do_something
+      #   end
       #
-      #     # good
-      #     def method(foo, bar, baz = {
-      #       :a => "b",
-      #     })
-      #       do_something
-      #     end
+      #   # good
+      #   def method(
+      #     foo, bar, baz = {
+      #     :a => "b",
+      #   })
+      #     do_something
+      #   end
       #
-      #     # good
-      #     def method(
-      #         foo, bar,
-      #         baz)
-      #       do_something
-      #     end
+      # @example AllowMultilineFinalElement: true
       #
-      #     # ignored
-      #     def method foo,
-      #         bar
-      #       do_something
-      #     end
+      #   # good
+      #   def method(foo, bar, baz = {
+      #     :a => "b",
+      #   })
+      #     do_something
+      #   end
       #
       class FirstMethodParameterLineBreak < Base
         include FirstElementLineBreak

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

@@ -72,7 +72,7 @@ module RuboCop
           return if ignored_node?(def_node)
 
           left_parenthesis = def_node.arguments.loc.begin
-          first_elem = def_node.arguments.first
+          first_elem = def_node.first_argument
           return unless first_elem
           return if same_line?(first_elem, left_parenthesis)
 

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) &&
@@ -177,7 +182,7 @@ module RuboCop
         end
 
         def add_correct_closing_paren(node, corrector)
-          corrector.insert_after(node.arguments.last, ')')
+          corrector.insert_after(node.last_argument, ')')
         end
 
         def remove_incorrect_closing_paren(node, corrector)
@@ -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.
@@ -265,7 +271,7 @@ module RuboCop
         def add_correct_external_trailing_comma(node, corrector)
           return unless external_trailing_comma?(node)
 
-          corrector.insert_after(node.arguments.last, ',')
+          corrector.insert_after(node.last_argument, ',')
         end
 
         def remove_incorrect_external_trailing_comma(node, corrector)