rubocop 1.44.1 → 1.78.0

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

@@ -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)
 
@@ -76,6 +75,7 @@ module RuboCop
             autocorrect(corrector, outermost_send)
           end
         end
+        alias on_csend on_send
 
         private
 
@@ -160,6 +160,12 @@ module RuboCop
 
         # Closing parenthesis helpers.
 
+        def end_keyword_before_closing_parenthesis?(parenthesized_send_node)
+          parenthesized_send_node.ancestors.any? do |ancestor|
+            ancestor.loc_is?(:end, '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 +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)
@@ -215,6 +221,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 +229,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 +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`.'
@@ -115,7 +118,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
@@ -139,7 +142,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

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/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

@@ -49,21 +49,73 @@ 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.loc.expression
+              expr = comment.source_range
 
               corrector.insert_after(hash_mark(expr), ' ')
             end
@@ -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

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

@@ -51,26 +51,30 @@ module RuboCop
         private_constant :LINE_1_ENDING, :LINE_2_BEGINNING,
                          :LEADING_STYLE_OFFENSE, :TRAILING_STYLE_OFFENSE
 
-        # rubocop:disable Metrics/AbcSize
+        # When both cops are activated and run in the same iteration of the correction loop,
+        # `Style/StringLiterals` undoes the moving of spaces that
+        # `Layout/LineContinuationLeadingSpace` performs. This is because `Style/StringLiterals`
+        # takes the original string content and transforms it, rather than just modifying the
+        # delimiters, in order to handle escaping for quotes within the string.
+        def self.autocorrect_incompatible_with
+          [Style::StringLiterals]
+        end
+
         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
+          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|
+          lines = raw_lines(node)
+          lines.each_cons(2).with_index(node.first_line) do |(raw_line_one, raw_line_two), line_num|
             end_of_first_line += raw_line_one.length
 
-            next unless continuation?(raw_line_one)
+            next unless continuation?(raw_line_one, line_num, node)
 
-            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
+            investigate(raw_line_one, raw_line_two, end_of_first_line)
           end
         end
-        # rubocop:enable Metrics/AbcSize
 
         private
 
@@ -78,6 +82,14 @@ module RuboCop
           processed_source.raw_source.lines[node.first_line - 1, line_range(node).size]
         end
 
+        def investigate(first_line, second_line, end_of_first_line)
+          if enforced_style_leading?
+            investigate_leading_style(first_line, second_line, end_of_first_line)
+          else
+            investigate_trailing_style(first_line, second_line, end_of_first_line)
+          end
+        end
+
         def investigate_leading_style(first_line, second_line, end_of_first_line)
           matches = first_line.match(LEADING_STYLE_OFFENSE)
           return if matches.nil?
@@ -100,8 +112,11 @@ module RuboCop
           end
         end
 
-        def continuation?(line)
-          line.end_with?("\\\n")
+        def continuation?(line, line_num, node)
+          return false unless line.end_with?("\\\n")
+
+          # Ensure backslash isn't part of a token spanning to the next line.
+          node.children.none? { |c| (c.first_line...c.last_line).cover?(line_num) && c.multiline? }
         end
 
         def autocorrect(corrector, offense_range, insert_pos, spaces)
@@ -123,9 +138,9 @@ module RuboCop
 
         def message(_range)
           if enforced_style_leading?
-            'Move trailing spaces to the start of next line.'
+            'Move trailing spaces to the start of the next line.'
           else
-            'Move leading spaces to the end of previous line.'
+            'Move leading spaces to the end of the previous line.'
           end
         end
 

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

@@ -87,25 +87,29 @@ 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?
 
-          ranges = Set.new
-          ast.each_node(:str, :dstr) do |str|
-            loc = str.location
+          ast.each_node(:str, :dstr, :array).with_object(Set.new) do |literal, ranges|
+            loc = literal.location
 
-            if str.heredoc?
+            if literal.array_type?
+              next unless literal.percent_literal?
+
+              ranges << loc.expression
+            elsif literal.heredoc?
               ranges << loc.heredoc_body
-            elsif loc.respond_to?(:begin) && loc.begin
+            elsif (loc.respond_to?(:begin) && loc.begin) || ignored_parent?(literal)
               ranges << loc.expression
             end
           end
-          ranges
         end
+        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         def comment_ranges(comments)
-          comments.map(&:loc).map(&:expression)
+          comments.map(&:source_range)
         end
 
         def last_line(processed_source)
@@ -119,10 +123,16 @@ module RuboCop
         end
 
         def ignored_ranges
-          @ignored_ranges ||= string_literal_ranges(processed_source.ast) +
+          @ignored_ranges ||= ignored_literal_ranges(processed_source.ast) +
                               comment_ranges(processed_source.comments)
         end
 
+        def ignored_parent?(node)
+          return false unless node.parent
+
+          node.parent.type?(:regexp, :xstr)
+        end
+
         def no_space_style?
           cop_config['EnforcedStyle'] == 'no_space'
         end

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

@@ -84,6 +84,8 @@ module RuboCop
           return unless strings_concatenated_with_backslash?(node)
 
           children = node.children
+          return if children.empty?
+
           if style == :aligned && !always_indented?(node)
             check_aligned(children, 1)
           else
@@ -100,7 +102,7 @@ module RuboCop
 
         def strings_concatenated_with_backslash?(dstr_node)
           dstr_node.multiline? &&
-            dstr_node.children.all? { |c| c.str_type? || c.dstr_type? } &&
+            dstr_node.children.all? { |c| c.type?(:str, :dstr) } &&
             dstr_node.children.none?(&:multiline?)
         end
 
@@ -125,7 +127,7 @@ module RuboCop
 
         def base_column(child)
           grandparent = child.parent.parent
-          if grandparent&.type == :pair
+          if grandparent&.pair_type?
             grandparent.loc.column
           else
             child.source_range.source_line =~ /\S/