rubocop 0.72.0 → 0.76.0

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,10 +112,6 @@ 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.
@@ -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_assignment.rb

@@ -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/indent_first_argument.rb

@@ -204,7 +204,7 @@ module RuboCop
           node.source_range.begin_pos > parent.source_range.begin_pos
         end
 
-        def_node_matcher :eligible_method_call?, <<-PATTERN
+        def_node_matcher :eligible_method_call?, <<~PATTERN
           (send _ !:[]= ...)
         PATTERN
 
@@ -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_hash_element.rb

@@ -113,7 +113,7 @@ module RuboCop
           first_pair = hash_node.pairs.first
 
           if first_pair
-            return if first_pair.source_range.line == left_brace.line
+            return if first_pair.first_line == left_brace.line
 
             if separator_style?(first_pair)
               check_based_on_longest_key(hash_node, left_brace,

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

@@ -37,7 +37,7 @@ module RuboCop
       #   # good
       #   # When EnforcedStyle is powerpack, bad code is auto-corrected to
       #   # the following code.
-      #   <<~RUBY
+      #   <<-RUBY.strip_indent
       #     something
       #   RUBY
       #
@@ -206,7 +206,8 @@ module RuboCop
           body = heredoc_body(node)
           body_indent_level = indent_level(body)
           correct_indent_level = base_indent_level(node) + indentation_width
-          body.gsub(/^\s{#{body_indent_level}}/, ' ' * correct_indent_level)
+          body.gsub(/^[^\S\r\n]{#{body_indent_level}}/,
+                    ' ' * correct_indent_level)
         end
 
         def indented_end(node)
@@ -239,7 +240,7 @@ module RuboCop
         end
 
         def indentation_width
-          @config.for_cop('IndentationWidth')['Width'] || 2
+          @config.for_cop('Layout/IndentationWidth')['Width'] || 2
         end
 
         def heredoc_body(node)

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

@@ -52,7 +52,7 @@ module RuboCop
         MSG = 'Use %<configured_indentation_width>d (not %<indentation>d) ' \
               'spaces for%<name>s indentation.'
 
-        def_node_matcher :access_modifier?, <<-PATTERN
+        def_node_matcher :access_modifier?, <<~PATTERN
           [(send ...) access_modifier?]
         PATTERN
 
@@ -158,11 +158,7 @@ module RuboCop
           if indentation_consistency_style == 'indented_internal_methods'
             check_members_for_indented_internal_methods_style(members)
           else
-            members.first.children.each do |member|
-              next if member.send_type? && member.access_modifier?
-
-              check_indentation(base, member)
-            end
+            check_members_for_normal_style(base, members)
           end
         end
 
@@ -170,6 +166,8 @@ module RuboCop
           return unless member
 
           if access_modifier?(member.children.first)
+            return if access_modifier_indentation_style == 'outdent'
+
             member.children.first
           else
             member
@@ -183,6 +181,14 @@ module RuboCop
           end
         end
 
+        def check_members_for_normal_style(base, members)
+          members.first.children.each do |member|
+            next if member.send_type? && member.access_modifier?
+
+            check_indentation(base, member)
+          end
+        end
+
         def each_member(members)
           previous_modifier = nil
           members.first.children.each do |member|
@@ -199,6 +205,14 @@ module RuboCop
           indentation_consistency_style == 'indented_internal_methods'
         end
 
+        def special_modifier?(node)
+          node.bare_access_modifier? && SPECIAL_MODIFIERS.include?(node.source)
+        end
+
+        def access_modifier_indentation_style
+          config.for_cop('Layout/AccessModifierIndentation')['EnforcedStyle']
+        end
+
         def indentation_consistency_style
           config.for_cop('Layout/IndentationConsistency')['EnforcedStyle']
         end

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

@@ -16,6 +16,25 @@ module RuboCop
       #
       #   # good
       #   # Some comment
+      #
+      # @example AllowDoxygenCommentStyle: false (default)
+      #
+      #   # bad
+      #
+      #   #**
+      #   # Some comment
+      #   # Another line of comment
+      #   #*
+      #
+      # @example AllowDoxygenCommentStyle: true
+      #
+      #   # good
+      #
+      #   #**
+      #   # Some comment
+      #   # Another line of comment
+      #   #*
+      #
       class LeadingCommentSpace < Cop
         include RangeHelp
 
@@ -25,6 +44,7 @@ module RuboCop
           processed_source.each_comment do |comment|
             next unless comment.text =~ /\A#+[^#\s=:+-]/
             next if comment.loc.line == 1 && allowed_on_first_line?(comment)
+            next if allow_doxygen_comment? && doxygen_comment_style?(comment)
 
             add_offense(comment)
           end
@@ -54,6 +74,14 @@ module RuboCop
         def rackup_config_file?
           File.basename(processed_source.file_path).eql?('config.ru')
         end
+
+        def allow_doxygen_comment?
+          cop_config['AllowDoxygenCommentStyle']
+        end
+
+        def doxygen_comment_style?(comment)
+          comment.text.start_with?('#*')
+        end
       end
     end
   end

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

@@ -43,7 +43,7 @@ module RuboCop
           'on the same line as the assignment operator `=`.'
 
         def check_assignment(node, rhs)
-          return if node.send_type?
+          return if node.send_type? && node.loc.operator&.source != '='
           return unless rhs
           return unless supported_types.include?(rhs.type)
           return if rhs.first_line == rhs.last_line

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

@@ -5,7 +5,9 @@ module RuboCop
     module Layout
       # This cop checks whether the multiline do end blocks have a newline
       # after the start of the block. Additionally, it checks whether the block
-      # arguments, if any, are on the same line as the start of the block.
+      # arguments, if any, are on the same line as the start of the
+      # block. Putting block arguments on separate lines, because the whole
+      # line would otherwise be too long, is accepted.
       #
       # @example
       #   # bad
@@ -35,6 +37,17 @@ module RuboCop
       #     foo(i)
       #     bar(i)
       #   }
+      #
+      #   # good
+      #   blah { |
+      #     long_list,
+      #     of_parameters,
+      #     that_would_not,
+      #     fit_on_one_line
+      #   |
+      #     foo(i)
+      #     bar(i)
+      #   }
       class MultilineBlockLayout < Cop
         include RangeHelp
 
@@ -42,11 +55,13 @@ module RuboCop
               'the block start.'
         ARG_MSG = 'Block argument expression is not on the same line as the ' \
                   'block start.'
+        PIPE_SIZE = '|'.length
 
         def on_block(node)
           return if node.single_line?
 
-          unless args_on_beginning_line?(node)
+          unless args_on_beginning_line?(node) ||
+                 line_break_necessary_in_args?(node)
             add_offense_for_expression(node, node.arguments, ARG_MSG)
           end
 
@@ -79,6 +94,13 @@ module RuboCop
             node.loc.begin.line == node.arguments.loc.last_line
         end
 
+        def line_break_necessary_in_args?(node)
+          needed_length = node.source_range.column +
+                          node.source.lines.first.length +
+                          block_arg_string(node.arguments).length + PIPE_SIZE
+          needed_length > max_line_length
+        end
+
         def add_offense_for_expression(node, expr, msg)
           expression = expr.source_range
           range = range_between(expression.begin_pos, expression.end_pos)

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

@@ -30,6 +30,8 @@ module RuboCop
         ANCESTOR_TYPES = %i[kwbegin def defs class module].freeze
         RUBY_2_5_ANCESTOR_TYPES = (ANCESTOR_TYPES + %i[block]).freeze
         ANCESTOR_TYPES_WITH_ACCESS_MODIFIERS = %i[def defs].freeze
+        ALTERNATIVE_ACCESS_MODIFIERS = %i[public_class_method
+                                          private_class_method].freeze
 
         def on_resbody(node)
           check(node) unless modifier?(node)
@@ -94,13 +96,18 @@ module RuboCop
           )
         end
 
+        # rubocop:disable Metrics/AbcSize
         def alignment_source(node, starting_loc)
           ending_loc =
             case node.type
             when :block, :kwbegin
               node.loc.begin
-            when :def, :defs, :class, :module
+            when :def, :defs, :class, :module,
+                 :lvasgn, :ivasgn, :cvasgn, :gvasgn, :casgn
               node.loc.name
+            when :masgn
+              mlhs_node, = *node
+              mlhs_node.loc.expression
             else
               # It is a wrapper with access modifier.
               node.child_nodes.first.loc.name
@@ -108,6 +115,7 @@ module RuboCop
 
           range_between(starting_loc.begin_pos, ending_loc.end_pos).source
         end
+        # rubocop:enable Metrics/AbcSize
 
         # We will use ancestor or wrapper with access modifier.
 
@@ -150,9 +158,7 @@ module RuboCop
             ANCESTOR_TYPES_WITH_ACCESS_MODIFIERS.include?(node.type)
 
           access_modifier_node = node.ancestors.first
-          return nil unless
-            access_modifier_node.respond_to?(:access_modifier?) &&
-            access_modifier_node.access_modifier?
+          return nil unless access_modifier?(access_modifier_node)
 
           access_modifier_node
         end
@@ -169,6 +175,16 @@ module RuboCop
 
           range_between(begin_pos - current_column, begin_pos)
         end
+
+        def access_modifier?(node)
+          return true if node.respond_to?(:access_modifier?) &&
+                         node.access_modifier?
+
+          return true if node.respond_to?(:method_name) &&
+                         ALTERNATIVE_ACCESS_MODIFIERS.include?(node.method_name)
+
+          false
+        end
       end
     end
   end