rubocop 1.52.1 → 1.79.2

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

@@ -27,7 +27,14 @@ module RuboCop
         KIND = 'method'
 
         def on_def(node)
-          check(node, node.body)
+          if node.endless?
+            return unless offending_endless_method?(node)
+
+            register_offense_for_endless_method(node)
+          else
+            first_line = node.arguments.source_range&.last_line
+            check(node, node.body, adjusted_first_line: first_line)
+          end
         end
         alias on_defs on_def
 
@@ -36,6 +43,21 @@ module RuboCop
         def style
           :no_empty_lines
         end
+
+        def offending_endless_method?(node)
+          node.body.first_line > node.loc.assignment.line + 1 &&
+            processed_source.lines[node.loc.assignment.line].empty?
+        end
+
+        def register_offense_for_endless_method(node)
+          range = processed_source.buffer.line_range(node.loc.assignment.line + 1).resize(1)
+
+          msg = message(MSG_EXTRA, 'beginning')
+
+          add_offense(range, message: msg) do |corrector|
+            corrector.remove(range)
+          end
+        end
       end
     end
   end

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
@@ -83,7 +85,11 @@ module RuboCop
         end
 
         def on_sclass(node)
-          check_other_alignment(node)
+          if node.parent&.assignment?
+            check_asgn_alignment(node.parent, node)
+          else
+            check_other_alignment(node)
+          end
         end
 
         def on_module(node)
@@ -163,14 +169,20 @@ 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)
-          if (node.case_type? || node.case_match_type?) && node.argument? &&
+          if node.type?(:case, :case_match) && node.argument? &&
              same_line?(node, node.parent)
             return node.parent
           end

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

@@ -49,19 +49,13 @@ module RuboCop
 
         private
 
-        def aligned_locations(locs) # rubocop:disable Metrics/AbcSize
+        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
-
-          # if locs.size > 2 and the size of variable `aligned`
-          # has not increased from its initial value, there are not aligned lines.
-          return [] if locs.size > 2 && aligned.size == 2
-
           aligned
         end
 
@@ -76,7 +70,7 @@ module RuboCop
         end
 
         def check_assignment(token)
-          return unless aligned_with_preceding_assignment(token) == :no
+          return unless aligned_with_preceding_equals_operator(token) == :no
 
           message = format(MSG_UNALIGNED_ASGN, location: 'preceding')
           add_offense(token.pos, message: message) do |corrector|

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

@@ -118,8 +118,8 @@ module RuboCop
       #
       # @example EnforcedStyle: special_for_inner_method_call
       #   # The first argument should normally be indented one step more than
-      #   # the preceding line, but if it's a argument for a method call that
-      #   # is itself a argument in a method call, then the inner argument
+      #   # the preceding line, but if it's an argument for a method call that
+      #   # is itself an argument in a method call, then the inner argument
       #   # should be indented relative to the inner method.
       #
       #   # good
@@ -155,7 +155,7 @@ module RuboCop
         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? &&
+          return if enforce_first_argument_with_fixed_indentation? &&
                     !enable_layout_first_method_argument_line_break?
 
           indent = base_indentation(node) + configured_indentation_width
@@ -225,7 +225,7 @@ module RuboCop
 
         def base_range(send_node, arg_node)
           parent = send_node.parent
-          start_node = if parent && (parent.splat_type? || parent.kwsplat_type?)
+          start_node = if parent&.type?(:splat, :kwsplat)
                          send_node.parent
                        else
                          send_node
@@ -269,17 +269,12 @@ module RuboCop
         end
 
         def enforce_first_argument_with_fixed_indentation?
-          return false unless argument_alignment_config['Enabled']
-
+          argument_alignment_config = config.for_enabled_cop('Layout/ArgumentAlignment')
           argument_alignment_config['EnforcedStyle'] == 'with_fixed_indentation'
         end
 
         def enable_layout_first_method_argument_line_break?
-          config.for_cop('Layout/FirstMethodArgumentLineBreak')['Enabled']
-        end
-
-        def argument_alignment_config
-          config.for_cop('Layout/ArgumentAlignment')
+          config.cop_enabled?('Layout/FirstMethodArgumentLineBreak')
         end
       end
     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,8 +50,7 @@ module RuboCop
       #   # separate lines is indented the same as an array literal which is not
       #   # defined inside a method call.
       #
-      #   #bad
-      #   # consistent
+      #   # bad
       #   array = [
       #     :value
       #   ]
@@ -56,7 +58,7 @@ module RuboCop
       #                          :its_like_this
       #   ])
       #
-      #   #good
+      #   # good
       #   array = [
       #     :value
       #   ]
@@ -68,14 +70,12 @@ module RuboCop
       #   # The `align_brackets` style enforces that the opening and closing
       #   # brackets are indented to the same position.
       #
-      #   #bad
-      #   # align_brackets
+      #   # bad
       #   and_now_for_something = [
       #                             :completely_different
       #   ]
       #
-      #   #good
-      #   # align_brackets
+      #   # good
       #   and_now_for_something = [
       #                             :completely_different
       #                           ]
@@ -89,10 +89,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 +178,11 @@ module RuboCop
             'where the left bracket is.'
           end
         end
+
+        def enforce_first_argument_with_fixed_indentation?
+          argument_alignment_config = config.for_enabled_cop('Layout/ArrayAlignment')
+          argument_alignment_config['EnforcedStyle'] == 'with_fixed_indentation'
+        end
       end
     end
   end

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

@@ -7,7 +7,7 @@ module RuboCop
       # where the opening brace and the first key are on separate lines. The
       # other keys' indentations are handled by the HashAlignment cop.
       #
-      # By default, Hash literals that are arguments in a method call with
+      # By default, `Hash` literals that are arguments in a method call with
       # parentheses, and where the opening curly brace of the hash is on the
       # same line as the opening parenthesis of the method call, shall have
       # their first key indented one step (two spaces) more than the position
@@ -225,14 +225,9 @@ module RuboCop
         end
 
         def enforce_first_argument_with_fixed_indentation?
-          return false unless argument_alignment_config['Enabled']
-
+          argument_alignment_config = config.for_enabled_cop('Layout/ArgumentAlignment')
           argument_alignment_config['EnforcedStyle'] == 'with_fixed_indentation'
         end
-
-        def argument_alignment_config
-          config.for_cop('Layout/ArgumentAlignment')
-        end
       end
     end
   end

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

@@ -51,7 +51,7 @@ 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
+          # If it doesn't, Layout/FirstMethodArgumentLineBreak will handle it
           return unless node.loc.begin
 
           check_children_line_break(node, node.children, ignore_last: ignore_last_element?)

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

@@ -63,13 +63,21 @@ module RuboCop
       #     }
       #   )
       #
+      # @example AllowedMethods: ['some_method']
+      #
+      #   # good
+      #   some_method(foo, bar,
+      #     baz)
       class FirstMethodArgumentLineBreak < Base
         include FirstElementLineBreak
+        include AllowedMethods
         extend AutoCorrector
 
         MSG = 'Add a line break before the first argument of a multi-line method argument list.'
 
         def on_send(node)
+          return if allowed_method?(node.method_name)
+
           args = node.arguments.dup
 
           # If there is a trailing hash arg without explicit braces, like this:

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

@@ -5,10 +5,10 @@ module RuboCop
     module Layout
       # 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.
+      # `Layout/ParameterAlignment`, not by this cop.
       #
       # For indenting the first argument of method _calls_, check out
-      # Layout/FirstArgumentIndentation, which supports options related to
+      # `Layout/FirstArgumentIndentation`, which supports options related to
       # nesting that are irrelevant for method _definitions_.
       #
       # @example
@@ -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/hash_alignment.rb

@@ -19,7 +19,7 @@ module RuboCop
       # * ignore_implicit (without curly braces)
       #
       # Alternatively you can specify multiple allowed styles. That's done by
-      # passing a list of styles to EnforcedStyles.
+      # passing a list of styles to EnforcedHashRocketStyle and EnforcedColonStyle.
       #
       # @example EnforcedHashRocketStyle: key (default)
       #   # bad
@@ -202,6 +202,7 @@ module RuboCop
 
           ignore_node(last_argument)
         end
+        alias on_csend on_send
         alias on_super on_send
         alias on_yield on_send
 
@@ -227,6 +228,7 @@ module RuboCop
           left_sibling = argument_before_hash(node)
           parent_loc = node.parent.loc
           selector = left_sibling || parent_loc.selector || parent_loc.expression
+
           same_line?(selector, node.pairs.first)
         end
 
@@ -248,7 +250,7 @@ module RuboCop
           reset!
 
           alignment_for(first_pair).each do |alignment|
-            delta = alignment.deltas_for_first_pair(first_pair, node)
+            delta = alignment.deltas_for_first_pair(first_pair)
             check_delta delta, node: first_pair, alignment: alignment
           end
 
@@ -382,13 +384,13 @@ module RuboCop
         end
 
         def enforce_first_argument_with_fixed_indentation?
-          return false unless argument_alignment_config['Enabled']
-
+          argument_alignment_config = config.for_enabled_cop('Layout/ArgumentAlignment')
           argument_alignment_config['EnforcedStyle'] == 'with_fixed_indentation'
         end
 
-        def argument_alignment_config
-          config.for_cop('Layout/ArgumentAlignment')
+        def same_line?(node1, node2)
+          # Override `Util#same_line?`
+          super || node1.last_line == line(node2)
         end
       end
     end

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

@@ -75,6 +75,7 @@ module RuboCop
             autocorrect(corrector, outermost_send)
           end
         end
+        alias on_csend on_send
 
         private
 
@@ -161,7 +162,7 @@ module RuboCop
 
         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'
+            ancestor.loc_is?(:end, 'end')
           end
         end
 
@@ -182,7 +183,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)
@@ -271,7 +272,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)

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

@@ -6,9 +6,9 @@ module RuboCop
       # Checks the indentation of the here document bodies. The bodies
       # are indented one step.
       #
-      # Note: When ``Layout/LineLength``'s `AllowHeredoc` is false (not default),
+      # NOTE: When ``Layout/LineLength``'s `AllowHeredoc` is false (not default),
       #       this cop does not add any offenses for long here documents to
-      #       avoid `Layout/LineLength`'s offenses.
+      #       avoid ``Layout/LineLength``'s offenses.
       #
       # @example
       #   # bad
@@ -25,6 +25,9 @@ module RuboCop
         include Alignment
         include Heredoc
         extend AutoCorrector
+        extend TargetRubyVersion
+
+        minimum_target_ruby_version 2.3
 
         TYPE_MSG = 'Use %<indentation_width>d spaces for indentation in a ' \
                    'heredoc by using `<<~` instead of `%<current_indent_type>s`.'

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

@@ -76,7 +76,7 @@ module RuboCop
 
         def autocorrect_lambda_for_tabs(corrector, range)
           spaces = ' ' * configured_indentation_width
-          corrector.replace(range, range.source.gsub(/\t/, spaces))
+          corrector.replace(range, range.source.gsub("\t", spaces))
         end
 
         def autocorrect_lambda_for_spaces(corrector, range)

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

@@ -3,13 +3,12 @@
 module RuboCop
   module Cop
     module Layout
-      # Checks for indentation that doesn't use the specified number
-      # of spaces.
+      # Checks for indentation that doesn't use the specified number of spaces.
+      # The indentation width can be configured using the `Width` setting. The default width is 2.
       #
-      # See also the IndentationConsistency cop which is the companion to this
-      # one.
+      # See also the `Layout/IndentationConsistency` cop which is the companion to this one.
       #
-      # @example
+      # @example Width: 2 (default)
       #   # bad
       #   class A
       #    def test
@@ -59,16 +58,17 @@ module RuboCop
         PATTERN
 
         def on_rescue(node)
-          _begin_node, *_rescue_nodes, else_node = *node
-          check_indentation(node.loc.else, else_node)
+          check_indentation(node.loc.else, node.else_branch)
         end
 
-        def on_ensure(node)
+        def on_resbody(node)
           check_indentation(node.loc.keyword, node.body)
         end
+        alias on_for on_resbody
 
-        alias on_resbody on_ensure
-        alias on_for     on_ensure
+        def on_ensure(node)
+          check_indentation(node.loc.keyword, node.branch)
+        end
 
         def on_kwbegin(node)
           # Check indentation against end keyword but only if it's first on its
@@ -91,6 +91,7 @@ module RuboCop
         end
 
         alias on_numblock on_block
+        alias on_itblock on_block
 
         def on_class(node)
           base = node.loc.keyword
@@ -136,7 +137,7 @@ module RuboCop
         alias on_until on_while
 
         def on_case(case_node)
-          case_node.each_when do |when_node|
+          case_node.when_branches.each do |when_node|
             check_indentation(when_node.loc.keyword, when_node.body)
           end
 
@@ -326,8 +327,7 @@ module RuboCop
           if body_node.rescue_type?
             check_rescue?(body_node)
           elsif body_node.ensure_type?
-            block_body, = *body_node
-
+            block_body, = *body_node # rubocop:disable InternalAffairs/NodeDestructuring
             if block_body&.rescue_type?
               check_rescue?(block_body)
             else
@@ -354,7 +354,7 @@ module RuboCop
           # Don't check indentation if the line doesn't start with the body.
           # For example, lines like "else do_something".
           first_char_pos_on_line = body_node.source_range.source_line =~ /\S/
-          return true unless body_node.loc.column == first_char_pos_on_line
+          body_node.loc.column != first_char_pos_on_line
         end
 
         def offending_range(body_node, indentation)
@@ -366,10 +366,10 @@ module RuboCop
         end
 
         def starts_with_access_modifier?(body_node)
-          return unless body_node.begin_type?
+          return false unless body_node.begin_type?
 
           starting_node = body_node.children.first
-          return unless starting_node
+          return false unless starting_node
 
           starting_node.send_type? && starting_node.bare_access_modifier?
         end

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

@@ -49,18 +49,70 @@ module RuboCop
       #   #ruby=2.7.0
       #   #ruby-gemset=myproject
       #
+      # @example AllowRBSInlineAnnotation: false (default)
+      #
+      #   # bad
+      #
+      #   include Enumerable #[Integer]
+      #
+      #   attr_reader :name #: String
+      #   attr_reader :age  #: Integer?
+      #
+      #   #: (
+      #   #|   Integer,
+      #   #|   String
+      #   #| ) -> void
+      #   def foo; end
+      #
+      # @example AllowRBSInlineAnnotation: true
+      #
+      #   # good
+      #
+      #   include Enumerable #[Integer]
+      #
+      #   attr_reader :name #: String
+      #   attr_reader :age  #: Integer?
+      #
+      #   #: (
+      #   #|   Integer,
+      #   #|   String
+      #   #| ) -> void
+      #   def foo; end
+      #
+      # @example AllowSteepAnnotation: false (default)
+      #
+      #   # bad
+      #   [1, 2, 3].each_with_object([]) do |n, list| #$ Array[Integer]
+      #     list << n
+      #   end
+      #
+      #   name = 'John'      #: String
+      #
+      # @example AllowSteepAnnotation: true
+      #
+      #   # good
+      #
+      #   [1, 2, 3].each_with_object([]) do |n, list| #$ Array[Integer]
+      #     list << n
+      #   end
+      #
+      #   name = 'John'      #: String
+      #
       class LeadingCommentSpace < Base
         include RangeHelp
         extend AutoCorrector
 
         MSG = 'Missing space after `#`.'
 
-        def on_new_investigation
+        def on_new_investigation # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
           processed_source.comments.each do |comment|
-            next unless /\A#+[^#\s=+-]/.match?(comment.text)
+            next unless /\A(?!#\+\+|#--)(#+[^#\s=])/.match?(comment.text)
             next if comment.loc.line == 1 && allowed_on_first_line?(comment)
+            next if shebang_continuation?(comment)
             next if doxygen_comment_style?(comment)
             next if gemfile_ruby_comment?(comment)
+            next if rbs_inline_annotation?(comment)
+            next if steep_annotation?(comment)
 
             add_offense(comment) do |corrector|
               expr = comment.source_range
@@ -84,6 +136,20 @@ module RuboCop
           comment.text.start_with?('#!')
         end
 
+        def shebang_continuation?(comment)
+          return false unless shebang?(comment)
+          return true if comment.loc.line == 1
+
+          previous_line_comment = processed_source.comment_at_line(comment.loc.line - 1)
+          return false unless previous_line_comment
+
+          # If the comment is a shebang but not on the first line, check if the previous
+          # line has a shebang comment that wasn't marked as an offense; if so, this comment
+          # continues the shebang and is acceptable.
+          shebang?(previous_line_comment) &&
+            !current_offense_locations.include?(previous_line_comment.source_range)
+        end
+
         def rackup_options?(comment)
           comment.text.start_with?('#\\')
         end
@@ -115,6 +181,22 @@ module RuboCop
         def gemfile_ruby_comment?(comment)
           allow_gemfile_ruby_comment? && ruby_comment_in_gemfile?(comment)
         end
+
+        def allow_rbs_inline_annotation?
+          cop_config['AllowRBSInlineAnnotation']
+        end
+
+        def rbs_inline_annotation?(comment)
+          allow_rbs_inline_annotation? && comment.text.start_with?(/#:|#\[.+\]|#\|/)
+        end
+
+        def allow_steep_annotation?
+          cop_config['AllowSteepAnnotation']
+        end
+
+        def steep_annotation?(comment)
+          allow_steep_annotation? && comment.text.start_with?(/#[$:]/)
+        end
       end
     end
   end