rubocop 1.53.0 → 1.90.0

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

@@ -41,6 +41,7 @@ module RuboCop
 
           @aligned_comments = aligned_locations(processed_source.comments.map(&:loc))
           @corrected = Set.new if force_equal_sign_alignment?
+          prepare_alignment_data
 
           processed_source.tokens.each_cons(2) do |token1, token2|
             check_tokens(processed_source.ast, token1, token2)
@@ -49,19 +50,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 +71,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|
@@ -101,19 +96,120 @@ module RuboCop
           end_pos = token2.begin_pos - 1
           return if end_pos <= start_pos
 
-          return if allow_for_alignment? && aligned_tok?(token2)
+          return if allow_for_alignment? && aligned_tok?(token1, token2)
 
           yield range_between(start_pos, end_pos)
         end
 
-        def aligned_tok?(token)
+        def aligned_tok?(previous_token, token)
           if token.comment?
             @aligned_comments.include?(token.line)
           else
-            aligned_with_something?(token.pos)
+            aligned_with_something?(token.pos) &&
+              (ASSIGNMENT_OR_COMPARISON_TOKENS.include?(token.type) ||
+               spacing_varies?(previous_token, token))
           end
         end
 
+        def spacing_varies?(previous_token, token)
+          by_column, typed = group_profile(token.line)
+          column = token.pos.column
+          lines, spacings = typed[[column, token.type]]
+          entries = by_column[column]
+
+          if lines.size > 1
+            uniform_alignment_allowed?(token, lines, spacings)
+          elsif entries.size > 1
+            distinct_spacings(entries).size > 1
+          else
+            nearest_spacing_varies?(previous_token, token)
+          end
+        end
+
+        def uniform_alignment_allowed?(token, lines, spacings)
+          return @alignment_verdicts[lines] if @alignment_verdicts.key?(lines)
+
+          @alignment_verdicts[lines] =
+            spacings.uniq.size > 1 || aligned_on_other_column?(token, lines)
+        end
+
+        def aligned_on_other_column?(token, lines)
+          line_set = Set.new(lines)
+          by_column, = group_profile(token.line)
+
+          by_column.any? do |column, entries|
+            next false if column == token.pos.column
+
+            shared = entries.filter_map { |line, spacing| spacing if line_set.include?(line) }
+            shared.uniq.size > 1
+          end
+        end
+
+        def distinct_spacings(entries)
+          entries.map(&:last).uniq
+        end
+
+        def group_profile(line_number)
+          group = alignment_lines(line_number)
+
+          @group_profiles[group] ||= build_group_profile(group)
+        end
+
+        def build_group_profile(group)
+          by_column = Hash.new { |hash, key| hash[key] = [] }
+          typed = Hash.new { |hash, key| hash[key] = [[], []] }
+
+          group.each { |line| record_line_spacings(by_column, typed, line) }
+
+          [by_column, typed]
+        end
+
+        def record_line_spacings(by_column, typed, line)
+          @tokens_by_line[line]&.each_cons(2) do |previous_token, token|
+            spacing = token.begin_pos - previous_token.end_pos
+            by_column[token.pos.column] << [line, spacing]
+            lines, spacings = typed[[token.pos.column, token.type]]
+            lines << line
+            spacings << spacing
+          end
+        end
+
+        def nearest_spacing_varies?(previous_token, token)
+          spacing = token.begin_pos - previous_token.end_pos
+          line_ranges = [(token.line - 1).downto(1),
+                         (token.line + 1).upto(processed_source.lines.length)]
+
+          line_ranges.any? do |line_numbers|
+            nearest_spacing_differs?(line_numbers, token, spacing)
+          end
+        end
+
+        def nearest_spacing_differs?(line_numbers, token, spacing)
+          line_numbers.each do |line|
+            break if definition_boundary_lines.include?(line)
+            next if aligned_comment_lines.include?(line)
+
+            other_spacing = spacing_before_token_at(line, token.pos.column)
+            return other_spacing != spacing if other_spacing
+          end
+
+          false
+        end
+
+        def spacing_before_token_at(line_number, column)
+          tokens = @tokens_by_line[line_number]
+          index = tokens&.index { |token| token.pos.column == column }
+          return unless index&.positive?
+
+          tokens[index].begin_pos - tokens[index - 1].end_pos
+        end
+
+        def prepare_alignment_data
+          @group_profiles = {}.compare_by_identity
+          @alignment_verdicts = {}.compare_by_identity
+          @tokens_by_line = processed_source.tokens.group_by(&:line)
+        end
+
         def ignored_range?(ast, start_pos)
           ignored_ranges(ast).any? { |r| r.include?(start_pos) }
         end

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,8 +155,9 @@ 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? &&
-                    !enable_layout_first_method_argument_line_break?
+          return if enforce_first_argument_with_fixed_indentation? &&
+                    (!enable_layout_first_method_argument_line_break? ||
+                     conflicts_with_fixed_indentation_alignment?(node))
 
           indent = base_indentation(node) + configured_indentation_width
 
@@ -172,7 +173,40 @@ module RuboCop
         end
 
         def autocorrect(corrector, node)
-          AlignmentCorrector.correct(corrector, processed_source, node, column_delta)
+          return unless node
+
+          send_node = node.parent
+          return unless send_node
+
+          top_level_send = find_top_level_send(send_node)
+          node_to_correct =
+            should_correct_entire_chain?(send_node, top_level_send) ? top_level_send : node
+
+          AlignmentCorrector.correct(corrector, processed_source, node_to_correct, column_delta)
+        end
+
+        def should_correct_entire_chain?(send_node, top_level_send)
+          return false unless style == :special_for_inner_method_call_in_parentheses
+          return false unless inner_call?(top_level_send)
+          return false unless display_column(send_node.source_range) < column_delta.abs
+
+          top_level_send != send_node || begins_its_line?(top_level_send.loc.end)
+        end
+
+        def inner_call?(top_level_send)
+          outer_call = top_level_send.parent
+
+          outer_call&.send_type? && outer_call.parenthesized?
+        end
+
+        def find_top_level_send(send_node)
+          top_level_send = send_node
+          while top_level_send.parent&.send_type? &&
+                top_level_send.parent.receiver == top_level_send &&
+                top_level_send.parent.loc.dot
+            top_level_send = top_level_send.parent
+          end
+          top_level_send
         end
 
         def bare_operator?(node)
@@ -225,7 +259,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 +303,31 @@ 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']
+          config.cop_enabled?('Layout/FirstMethodArgumentLineBreak')
+        end
+
+        def conflicts_with_fixed_indentation_alignment?(node)
+          return false unless special_inner_call_indentation?(node)
+          return false unless argument_alignment_applies?(node)
+
+          base_indentation(node) != indentation_of_method_line(node)
+        end
+
+        def argument_alignment_applies?(node)
+          return false if !node.call_type? || node.method?(:[]=)
+
+          node.arguments.size >= 2 ||
+            (node.first_argument.hash_type? && node.first_argument.pairs.count >= 2)
         end
 
-        def argument_alignment_config
-          config.for_cop('Layout/ArgumentAlignment')
+        def indentation_of_method_line(node)
+          lineno = node.loc.selector ? node.loc.selector.line : node.loc.begin.line
+          processed_source.lines[lineno - 1] =~ /\S/
         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
@@ -168,12 +172,17 @@ module RuboCop
             'Indent the right bracket the same as the first position ' \
             'after the preceding left parenthesis.'
           when :parent_hash_key
-            'Indent the right bracket the same as the parent hash key.' \
+            'Indent the right bracket the same as the parent hash key.'
           else
             'Indent the right bracket the same as the start of the line ' \
             '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_array_element_line_break.rb

@@ -20,6 +20,27 @@ module RuboCop
       #   # good
       #   [:a, :b]
       #
+      # @example AllowImplicitArrayLiterals: false (default)
+      #
+      #   # bad
+      #   a = b,
+      #       c
+      #
+      #   # good
+      #   a =
+      #     b,
+      #     c
+      #
+      # @example AllowImplicitArrayLiterals: true
+      #
+      #   # good
+      #   a = b,
+      #       c
+      #
+      #   a =
+      #     b,
+      #     c
+      #
       # @example AllowMultilineFinalElement: false (default)
       #
       #   # bad
@@ -48,6 +69,7 @@ module RuboCop
 
         def on_array(node)
           return if !node.loc.begin && !assignment_on_same_line?(node)
+          return if allow_implicit_array_brackets? && !node.bracketed?
 
           check_children_line_break(node, node.children, ignore_last: ignore_last_element?)
         end
@@ -59,6 +81,10 @@ module RuboCop
           /\s*=\s*$/.match?(source)
         end
 
+        def allow_implicit_array_brackets?
+          !!cop_config['AllowImplicitArrayLiterals']
+        end
+
         def ignore_last_element?
           !!cop_config['AllowMultilineFinalElement']
         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
@@ -28,10 +28,10 @@ module RuboCop
       #   # bad
       #   hash = {
       #     key: :value
-      #   }
-      #   and_in_a_method_call({
-      #     no: :difference
-      #                        })
+      #          }
+      #   in_a_method_call({
+      #     foo: :bar
+      #   })
       #   takes_multi_pairs_hash(x: {
       #     a: 1,
       #     b: 2
@@ -42,13 +42,12 @@ module RuboCop
       #                          })
       #
       #   # good
-      #   special_inside_parentheses
       #   hash = {
       #     key: :value
       #   }
-      #   but_in_a_method_call({
-      #                          its_like: :this
-      #                        })
+      #   in_a_method_call({
+      #                      foo: :bar
+      #                    })
       #   takes_multi_pairs_hash(x: {
       #                            a: 1,
       #                            b: 2
@@ -67,17 +66,17 @@ module RuboCop
       #   # bad
       #   hash = {
       #     key: :value
-      #   }
-      #   but_in_a_method_call({
-      #                          its_like: :this
-      #                         })
+      #          }
+      #   in_a_method_call({
+      #                     foo: :bar
+      #                   })
       #
       #   # good
       #   hash = {
       #     key: :value
       #   }
-      #   and_in_a_method_call({
-      #     no: :difference
+      #   in_a_method_call({
+      #     foo: :bar
       #   })
       #
       #
@@ -135,7 +134,13 @@ module RuboCop
         private
 
         def autocorrect(corrector, node)
-          AlignmentCorrector.correct(corrector, processed_source, node, @column_delta)
+          line_range = if !node.is_a?(AST::Node) || node.value.first_line <= node.key.first_line
+                         node
+                       else
+                         processed_source.buffer.line_range(node.loc.line)
+                       end
+
+          AlignmentCorrector.correct(corrector, processed_source, line_range, @column_delta)
         end
 
         def brace_alignment_style
@@ -225,14 +230,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

@@ -8,40 +8,40 @@ module RuboCop
       #
       # @example
       #
-      #     # bad
-      #     { a: 1,
-      #       b: 2}
+      #   # bad
+      #   { a: 1,
+      #     b: 2}
       #
-      #     # good
-      #     {
-      #       a: 1,
-      #       b: 2 }
+      #   # good
+      #   {
+      #     a: 1,
+      #     b: 2 }
       #
-      #     # good
-      #     {
-      #       a: 1, b: {
-      #       c: 3
-      #     }}
+      #   # good
+      #   {
+      #     a: 1, b: {
+      #     c: 3
+      #   }}
       #
       # @example AllowMultilineFinalElement: false (default)
       #
-      #     # bad
-      #     { a: 1, b: {
-      #       c: 3
-      #     }}
+      #   # bad
+      #   { a: 1, b: {
+      #     c: 3
+      #   }}
       #
       # @example AllowMultilineFinalElement: true
       #
-      #     # bad
-      #     { a: 1,
-      #       b: {
-      #       c: 3
-      #     }}
+      #   # bad
+      #   { a: 1,
+      #     b: {
+      #     c: 3
+      #   }}
       #
-      #     # good
-      #     { a: 1, b: {
-      #       c: 3
-      #     }}
+      #   # good
+      #   { a: 1, b: {
+      #     c: 3
+      #   }}
       #
       class FirstHashElementLineBreak < Base
         include FirstElementLineBreak
@@ -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)