rubocop 0.73.0 → 0.77.0

data/lib/rubocop/cop/layout/{align_arguments.rb → argument_alignment.rb}

@@ -37,7 +37,7 @@ module RuboCop
       #
       #   foo :bar,
       #       :baz
-      class AlignArguments < Cop
+      class ArgumentAlignment < Cop
         include Alignment
 
         ALIGN_PARAMS_MSG = 'Align the arguments of a method call if ' \

data/lib/rubocop/cop/layout/{align_array.rb → array_alignment.rb}

@@ -20,7 +20,7 @@ module RuboCop
       #   a = ['run',
       #        'forrest',
       #        'run']
-      class AlignArray < Cop
+      class ArrayAlignment < Cop
         include Alignment
 
         MSG = 'Align the elements of an array literal if they span more ' \

data/lib/rubocop/cop/layout/{indent_assignment.rb → assignment_indentation.rb}

@@ -21,7 +21,7 @@ module RuboCop
       #
       # The indentation of the remaining lines can be corrected with
       # other cops such as `IndentationConsistency` and `EndAlignment`.
-      class IndentAssignment < Cop
+      class AssignmentIndentation < Cop
         include CheckAssignment
         include Alignment
 
@@ -33,13 +33,22 @@ module RuboCop
           return unless node.loc.operator
           return if node.loc.operator.line == rhs.first_line
 
-          base = display_column(node.source_range)
+          base = display_column(leftmost_multiple_assignment(node).source_range)
           check_alignment([rhs], base + configured_indentation_width)
         end
 
         def autocorrect(node)
           AlignmentCorrector.correct(processed_source, node, column_delta)
         end
+
+        def leftmost_multiple_assignment(node)
+          return node unless same_line?(node, node.parent) &&
+                             node.parent.assignment?
+
+          leftmost_multiple_assignment(node.parent)
+
+          node.parent
+        end
       end
     end
   end

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

@@ -44,8 +44,8 @@ module RuboCop
       #
       #   foo.bar
       #     .each do
-      #        baz
-      #      end
+      #       baz
+      #     end
       #
       # @example EnforcedStyleAlignWith: start_of_line
       #   # bad

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

@@ -191,7 +191,7 @@ module RuboCop
         end
 
         def indentation_width
-          @config.for_cop('IndentationWidth')['Width'] || 2
+          @config.for_cop('Layout/IndentationWidth')['Width'] || 2
         end
 
         def line_break_after_left_paren?(left_paren, elements)

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

@@ -55,23 +55,20 @@ module RuboCop
         # of correcting, saving the file, parsing and inspecting again, and
         # then correcting one more line, and so on.
         def autocorrect_preceding_comments(comment)
-          corrections = []
-          line_no = comment.loc.line
-          column = comment.loc.column
           comments = processed_source.comments
-          (comments.index(comment) - 1).downto(0) do |ix|
-            previous_comment = comments[ix]
-            break unless should_correct?(previous_comment, column, line_no - 1)
+          index = comments.index(comment)
 
-            corrections << autocorrect_one(previous_comment)
-            line_no -= 1
-          end
-          corrections
+          comments[0..index]
+            .reverse_each
+            .each_cons(2)
+            .take_while { |below, above| should_correct?(above, below) }
+            .map { |_, above| autocorrect_one(above) }
         end
 
-        def should_correct?(comment, column, line_no)
-          loc = comment.loc
-          loc.line == line_no && loc.column == column
+        def should_correct?(preceding_comment, reference_comment)
+          loc = preceding_comment.loc
+          ref_loc = reference_comment.loc
+          loc.line == ref_loc.line - 1 && loc.column == ref_loc.column
         end
 
         def autocorrect_one(comment)

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

@@ -103,19 +103,12 @@ module RuboCop
         private
 
         def concat_consecutive_comments(comments)
-          prev_line = nil
+          consecutive_comments =
+            comments.chunk_while { |i, j| i.loc.line.succ == j.loc.line }
 
-          comments.each_with_object([]) do |comment, concatenated_comments|
-            if prev_line && comment.loc.line == prev_line.next
-              last_concatenated_comment = concatenated_comments.last
-
-              last_concatenated_comment[0] << comment_text(comment)
-              last_concatenated_comment[1] << comment
-            else
-              concatenated_comments << [comment_text(comment).dup, [comment]]
-            end
-
-            prev_line = comment.loc.line
+          consecutive_comments.map do |chunk|
+            joined_text = chunk.map { |c| comment_text(c) }.join
+            [joined_text, chunk]
           end
         end
 
@@ -141,11 +134,9 @@ module RuboCop
           cop_config['AllowMarginComment']
         end
 
-        def current_token(node)
+        def current_token(comment)
           processed_source.find_token do |token|
-            token.pos.column == node.loc.column &&
-              token.pos.last_column == node.loc.last_column &&
-              token.line == node.loc.line
+            token.pos == comment.loc.expression
           end
         end
 

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

@@ -45,7 +45,7 @@ module RuboCop
           return if correct_style?(node)
 
           if node.modifier_form? && last_argument_is_heredoc?(node)
-            heredoc_node = last_argument(node)
+            heredoc_node = last_heredoc_argument(node)
 
             return if next_line_empty?(heredoc_line(node, heredoc_node))
 
@@ -109,16 +109,27 @@ module RuboCop
 
         def last_argument_is_heredoc?(node)
           last_children = node.if_branch
-
           return false unless last_children&.send_type?
 
-          last_argument = last_argument(node)
-
-          last_argument.respond_to?(:heredoc?) && last_argument.heredoc?
+          heredoc?(last_heredoc_argument(node))
         end
 
-        def last_argument(node)
-          node.if_branch.children.last
+        def last_heredoc_argument(node)
+          n = if node.respond_to?(:if_branch)
+                node.if_branch.children.last
+              else
+                node
+              end
+
+          return n if heredoc?(n)
+          return unless n.respond_to?(:arguments)
+
+          n.arguments.each do |argument|
+            node = last_heredoc_argument(argument)
+            return node if node
+          end
+
+          return last_heredoc_argument(n.receiver) if n.respond_to?(:receiver)
         end
 
         def heredoc_line(node, heredoc_node)
@@ -129,6 +140,10 @@ module RuboCop
           node.last_line + num_of_heredoc_lines + END_OF_HEREDOC_LINE
         end
 
+        def heredoc?(node)
+          node.respond_to?(:heredoc?) && node.heredoc?
+        end
+
         def offense_location(node)
           if node.loc.respond_to?(:end) && node.loc.end
             :end

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

@@ -55,8 +55,8 @@ module RuboCop
           source
             .comments
             .take_while { |comment| comment.loc.line < source.ast.loc.line }
-            .select     { |comment| MagicComment.parse(comment.text).any?  }
-            .last
+            .reverse
+            .find { |comment| MagicComment.parse(comment.text).any? }
         end
       end
     end

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

@@ -36,7 +36,7 @@ module RuboCop
       #
       #   end
       #
-      # @example Enforcedstyle: beginning_only
+      # @example EnforcedStyle: beginning_only
       #   # good
       #
       #   class Foo
@@ -46,7 +46,7 @@ module RuboCop
       #     end
       #   end
       #
-      # @example Enforcedstyle: ending_only
+      # @example EnforcedStyle: ending_only
       #   # good
       #
       #   class Foo

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

@@ -45,9 +45,7 @@ module RuboCop
         MSG_MISSING = 'Carriage return character missing.'
 
         def investigate(processed_source)
-          last_token = processed_source.tokens.last
-          last_line =
-            last_token ? last_token.line : processed_source.lines.length
+          last_line = last_line(processed_source)
 
           processed_source.raw_source.each_line.with_index do |line, index|
             break if index >= last_line
@@ -81,6 +79,13 @@ module RuboCop
           else MSG_MISSING if line !~ /\r$/
           end
         end
+
+        private
+
+        def last_line(processed_source)
+          last_token = processed_source.tokens.last
+          last_token ? last_token.line : processed_source.lines.length
+        end
       end
     end
   end

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

@@ -41,12 +41,7 @@ module RuboCop
         def investigate(processed_source)
           return if processed_source.blank?
 
-          if force_equal_sign_alignment?
-            @asgn_tokens = assignment_tokens
-            @asgn_lines  = @asgn_tokens.map(&:line)
-            # Don't attempt to correct the same = more than once
-            @corrected   = Set.new
-          end
+          @corrected = Set.new if force_equal_sign_alignment?
 
           processed_source.tokens.each_cons(2) do |token1, token2|
             check_tokens(processed_source.ast, token1, token2)
@@ -65,24 +60,10 @@ module RuboCop
 
         private
 
-        def assignment_tokens
-          tokens = processed_source.tokens.select(&:equal_sign?)
-          # we don't want to operate on equals signs which are part of an
-          #   optarg in a method definition
-          # e.g.: def method(optarg = default_val); end
-          tokens = remove_optarg_equals(tokens, processed_source)
-
-          # Only attempt to align the first = on each line
-          Set.new(tokens.uniq(&:line))
-        end
-
         def check_tokens(ast, token1, token2)
           return if token2.type == :tNL
 
-          if force_equal_sign_alignment? &&
-             @asgn_tokens.include?(token2) &&
-             (@asgn_lines.include?(token2.line - 1) ||
-              @asgn_lines.include?(token2.line + 1))
+          if force_equal_sign_alignment? && assignment_tokens.include?(token2)
             check_assignment(token2)
           else
             check_other(token1, token2, ast)
@@ -90,32 +71,18 @@ module RuboCop
         end
 
         def check_assignment(token)
-          assignment_line = ''
-          message = ''
-          if should_aligned_with_preceding_line?(token)
-            assignment_line = processed_source.preceding_line(token)
-            message = format(MSG_UNALIGNED_ASGN, location: 'preceding')
-          else
-            assignment_line = processed_source.following_line(token)
-            message = format(MSG_UNALIGNED_ASGN, location: 'following')
-          end
-          return if aligned_assignment?(token.pos, assignment_line)
+          return unless aligned_with_preceding_assignment(token) == :no
 
+          message = format(MSG_UNALIGNED_ASGN, location: 'preceding')
           add_offense(token.pos, location: token.pos, message: message)
         end
 
-        def should_aligned_with_preceding_line?(token)
-          @asgn_lines.include?(token.line - 1)
-        end
-
         def check_other(token1, token2, ast)
           return false if allow_for_trailing_comments? &&
                           token2.text.start_with?('#')
 
           extra_space_range(token1, token2) do |range|
-            # Unary + doesn't appear as a token and needs special handling.
             next if ignored_range?(ast, range.begin_pos)
-            next if unary_plus_non_offense?(range)
 
             add_offense(range, location: range, message: MSG_UNNECESSARY)
           end
@@ -145,13 +112,9 @@ module RuboCop
           ignored_ranges(ast).any? { |r| r.include?(start_pos) }
         end
 
-        def unary_plus_non_offense?(range)
-          range.resize(range.size + 1).source =~ /^ ?\+$/
-        end
-
         # Returns an array of ranges that should not be reported. It's the
         # extra spaces between the keys and values in a multiline hash,
-        # since those are handled by the Style/AlignHash cop.
+        # since those are handled by the Layout/HashAlignment cop.
         def ignored_ranges(ast)
           return [] unless ast
 
@@ -188,8 +151,8 @@ module RuboCop
         end
 
         def align_equal_signs(range, corrector)
-          lines  = contiguous_assignment_lines(range)
-          tokens = @asgn_tokens.select { |t| lines.include?(t.line) }
+          lines  = all_relevant_assignment_lines(range.line)
+          tokens = assignment_tokens.select { |t| lines.include?(t.line) }
 
           columns  = tokens.map { |t| align_column(t) }
           align_to = columns.max
@@ -209,17 +172,15 @@ module RuboCop
           end
         end
 
-        def contiguous_assignment_lines(range)
-          result = [range.line]
+        def all_relevant_assignment_lines(line_number)
+          last_line_number = processed_source.lines.size
 
-          range.line.downto(1) do |lineno|
-            @asgn_lines.include?(lineno) ? result << lineno : break
-          end
-          range.line.upto(processed_source.lines.size) do |lineno|
-            @asgn_lines.include?(lineno) ? result << lineno : break
-          end
-
-          result.sort!
+          (
+            relevant_assignment_lines(line_number.downto(1)) +
+            relevant_assignment_lines(line_number.upto(last_line_number))
+          )
+            .uniq
+            .sort
         end
 
         def align_column(asgn_token)
@@ -231,12 +192,6 @@ module RuboCop
           asgn_token.pos.last_column - spaces + 1
         end
 
-        def remove_optarg_equals(asgn_tokens, processed_source)
-          optargs    = processed_source.ast.each_node(:optarg)
-          optarg_eql = optargs.map { |o| o.loc.operator.begin_pos }.to_set
-          asgn_tokens.reject { |t| optarg_eql.include?(t.begin_pos) }
-        end
-
         def allow_for_trailing_comments?
           cop_config['AllowBeforeTrailingComments']
         end

data/lib/rubocop/cop/layout/{indent_first_argument.rb → first_argument_indentation.rb}

@@ -5,11 +5,11 @@ module RuboCop
     # rubocop:disable Metrics/LineLength
     module Layout
       # This cop checks the indentation of the first argument in a method call.
-      # Arguments after the first one are checked by Layout/AlignArguments,
+      # Arguments after the first one are checked by Layout/ArgumentAlignment,
       # not by this cop.
       #
       # For indenting the first parameter of method *definitions*, check out
-      # Layout/IndentFirstParameter.
+      # Layout/FirstParameterIndentation.
       #
       # @example
       #
@@ -142,7 +142,7 @@ module RuboCop
       #     nested_first_param),
       #   second_param
       #
-      class IndentFirstArgument < Cop
+      class FirstArgumentIndentation < Cop
         # rubocop:enable Metrics/LineLength
         include Alignment
         include ConfigurableEnforcedStyle
@@ -228,19 +228,21 @@ module RuboCop
         # containing the previous line that's not a comment line or a blank
         # line.
         def previous_code_line(line_number)
-          @comment_lines ||=
-            processed_source
-            .comments
-            .select { |c| begins_its_line?(c.loc.expression) }
-            .map { |c| c.loc.line }
-
           line = ''
-          while line.blank? || @comment_lines.include?(line_number)
+          while line.blank? || comment_lines.include?(line_number)
             line_number -= 1
             line = processed_source.lines[line_number - 1]
           end
           line
         end
+
+        def comment_lines
+          @comment_lines ||=
+            processed_source
+            .comments
+            .select { |c| begins_its_line?(c.loc.expression) }
+            .map { |c| c.loc.line }
+        end
       end
     end
   end

data/lib/rubocop/cop/layout/{indent_first_array_element.rb → first_array_element_indentation.rb}

@@ -5,7 +5,7 @@ module RuboCop
     module Layout
       # This cop 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 AlignArray cop.
+      # The other elements' indentations are handled by the ArrayAlignment cop.
       #
       # 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
@@ -22,7 +22,7 @@ module RuboCop
       # @example EnforcedStyle: special_inside_parentheses (default)
       #   # The `special_inside_parentheses` style enforces that the first
       #   # element in an array literal where the opening bracket and first
-      #   # element are on seprate lines is indented one step (two spaces) more
+      #   # element are on separate lines is indented one step (two spaces) more
       #   # than the position inside the opening parenthesis.
       #
       #   #bad
@@ -44,7 +44,7 @@ module RuboCop
       # @example EnforcedStyle: consistent
       #   # The `consistent` style enforces that the first element in an array
       #   # literal where the opening bracket and the first element are on
-      #   # seprate lines is indented the same as an array literal which is not
+      #   # separate lines is indented the same as an array literal which is not
       #   # defined inside a method call.
       #
       #   #bad
@@ -79,7 +79,7 @@ module RuboCop
       #   and_now_for_something = [
       #                             :completely_different
       #                           ]
-      class IndentFirstArrayElement < Cop
+      class FirstArrayElementIndentation < Cop
         include Alignment
         include ConfigurableEnforcedStyle
         include MultilineElementIndentation