rubocop 1.31.1 → 1.51.0

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

@@ -132,25 +132,20 @@ module RuboCop
       #     end
       #   end
       #
-      # @see https://rubystyle.guide#consistent-classes
       class ClassStructure < Base
         include VisibilityHelp
+        include CommentsHelp
         extend AutoCorrector
 
         HUMANIZED_NODE_TYPE = {
           casgn: :constants,
-          defs: :class_methods,
+          defs: :public_class_methods,
           def: :public_methods,
           sclass: :class_singleton
         }.freeze
 
         MSG = '`%<category>s` is supposed to appear before `%<previous>s`.'
 
-        # @!method dynamic_constant?(node)
-        def_node_matcher :dynamic_constant?, <<~PATTERN
-          (casgn nil? _ (send ...))
-        PATTERN
-
         # Validates code style on class declaration.
         # Add offense when find a node out of expected order.
         def on_class(class_node)
@@ -164,12 +159,13 @@ module RuboCop
             previous = index
           end
         end
+        alias on_sclass on_class
 
         private
 
         # Autocorrect by swapping between two nodes autocorrecting them
         def autocorrect(corrector, node)
-          previous = node.left_siblings.find do |sibling|
+          previous = node.left_siblings.reverse.find do |sibling|
             !ignore_for_autocorrect?(node, sibling)
           end
           return unless previous
@@ -222,7 +218,7 @@ module RuboCop
         def walk_over_nested_class_definition(class_node)
           class_elements(class_node).each do |node|
             classification = classify(node)
-            next if ignore?(classification)
+            next if ignore?(node, classification)
 
             yield node, classification
           end
@@ -240,17 +236,20 @@ module RuboCop
           end
         end
 
-        def ignore?(classification)
+        def ignore?(node, classification)
           classification.nil? ||
             classification.to_s.end_with?('=') ||
-            expected_order.index(classification).nil?
+            expected_order.index(classification).nil? ||
+            private_constant?(node)
         end
 
         def ignore_for_autocorrect?(node, sibling)
           classification = classify(node)
           sibling_class = classify(sibling)
 
-          ignore?(sibling_class) || classification == sibling_class || dynamic_constant?(node)
+          ignore?(sibling, sibling_class) ||
+            classification == sibling_class ||
+            dynamic_constant?(node)
         end
 
         def humanize_node(node)
@@ -262,26 +261,37 @@ module RuboCop
           HUMANIZED_NODE_TYPE[node.type] || node.type
         end
 
-        def source_range_with_comment(node)
-          begin_pos, end_pos =
-            if (node.def_type? && !node.method?(:initialize)) ||
-               (node.send_type? && node.def_modifier?)
-              start_node = find_visibility_start(node) || node
-              end_node = find_visibility_end(node) || node
-              [begin_pos_with_comment(start_node),
-               end_position_for(end_node) + 1]
-            else
-              [begin_pos_with_comment(node), end_position_for(node)]
-            end
+        def dynamic_constant?(node)
+          return false unless node.casgn_type? && node.namespace.nil?
 
-          Parser::Source::Range.new(buffer, begin_pos, end_pos)
+          expression = node.expression
+          expression.send_type? &&
+            !(expression.method?(:freeze) && expression.receiver&.recursive_basic_literal?)
+        end
+
+        def private_constant?(node)
+          return false unless node.casgn_type? && node.namespace.nil?
+          return false unless (parent = node.parent)
+
+          parent.each_child_node(:send) do |child_node|
+            return true if marked_as_private_constant?(child_node, node.name)
+          end
+          false
+        end
+
+        def marked_as_private_constant?(node, name)
+          return false unless node.method?(:private_constant)
+
+          node.arguments.any? { |arg| (arg.sym_type? || arg.str_type?) && arg.value == name }
         end
 
         def end_position_for(node)
-          heredoc = find_heredoc(node)
-          return heredoc.location.heredoc_end.end_pos + 1 if heredoc
+          if node.casgn_type?
+            heredoc = find_heredoc(node)
+            return heredoc.location.heredoc_end.end_pos + 1 if heredoc
+          end
 
-          end_line = buffer.line_for_position(node.loc.expression.end_pos)
+          end_line = buffer.line_for_position(node.source_range.end_pos)
           buffer.line_range(end_line).end_pos
         end
 

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

@@ -85,7 +85,7 @@ module RuboCop
         end
 
         def heredoc_opening(node)
-          node.loc.expression.source_line
+          node.source_range.source_line
         end
 
         def heredoc_closing(node)

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

@@ -144,7 +144,7 @@ module RuboCop
         def expected_column(left_paren, elements)
           if line_break_after_left_paren?(left_paren, elements)
             source_indent = processed_source.line_indentation(first_argument_line(elements))
-            new_indent    = source_indent - indentation_width
+            new_indent    = source_indent - configured_indentation_width
 
             new_indent.negative? ? 0 : new_indent
           elsif all_elements_aligned?(elements)
@@ -157,7 +157,7 @@ module RuboCop
         def all_elements_aligned?(elements)
           elements.flat_map do |e|
             if e.hash_type?
-              e.each_pair.map { |pair| pair.loc.column }
+              e.each_child_node.map { |child| child.loc.column }
             else
               e.loc.column
             end
@@ -184,10 +184,6 @@ module RuboCop
           end
         end
 
-        def indentation_width
-          @config.for_cop('Layout/IndentationWidth')['Width'] || 2
-        end
-
         def line_break_after_left_paren?(left_paren, elements)
           elements.first && elements.first.loc.line > left_paren.line
         end

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

@@ -154,7 +154,9 @@ module RuboCop
         end
 
         def less_indented?(line)
-          /^\s*(end\b|[)}\]])/.match?(line)
+          rule = config.for_cop('Layout/AccessModifierIndentation')['EnforcedStyle'] == 'outdent'
+          access_modifier = 'private|protected|public'
+          /\A\s*(end\b|[)}\]])/.match?(line) || (rule && /\A\s*(#{access_modifier})\b/.match?(line))
         end
 
         def two_alternatives?(line)

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

@@ -97,9 +97,9 @@ module RuboCop
         def autocorrect(corrector, node)
           previous_token = previous_token(node)
           range = if previous_token && same_line?(node, previous_token)
-                    range_with_surrounding_space(node.loc.expression, newlines: false)
+                    range_with_surrounding_space(node.source_range, newlines: false)
                   else
-                    range_by_whole_lines(node.loc.expression, include_final_newline: true)
+                    range_by_whole_lines(node.source_range, include_final_newline: true)
                   end
 
           corrector.remove(range)
@@ -137,7 +137,7 @@ module RuboCop
         end
 
         def current_token(comment)
-          processed_source.find_token { |token| token.pos == comment.loc.expression }
+          processed_source.tokens.find { |token| token.pos == comment.source_range }
         end
 
         def previous_token(node)

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

@@ -235,7 +235,7 @@ module RuboCop
 
         def end_loc(node)
           if (node.def_type? || node.defs_type?) && node.endless?
-            node.loc.expression.end
+            node.source_range.end
           else
             node.loc.end
           end

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

@@ -27,9 +27,11 @@ module RuboCop
 
         def on_new_investigation
           return if processed_source.tokens.empty?
+          # Quick check if we possibly have consecutive blank lines.
+          return unless processed_source.raw_source.include?("\n\n\n")
 
           lines = Set.new
-          processed_source.each_token { |token| lines << token.line }
+          processed_source.tokens.each { |token| lines << token.line }
 
           each_extra_empty_line(lines.sort) do |range|
             add_offense(range) do |corrector|

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

@@ -51,6 +51,8 @@ module RuboCop
         MSG_BEFORE_FOR_ONLY_BEFORE = 'Keep a blank line before `%<modifier>s`.'
         MSG_AFTER_FOR_ONLY_BEFORE = 'Remove a blank line after `%<modifier>s`.'
 
+        RESTRICT_ON_SEND = %i[public protected private module_function].freeze
+
         def initialize(config = nil, options = nil)
           super
 
@@ -80,8 +82,11 @@ module RuboCop
           @block_line = node.source_range.first_line
         end
 
-        def on_send(node)
-          return unless node.bare_access_modifier? && !node.parent&.block_type?
+        alias on_numblock on_block
+
+        def on_send(node) # rubocop:disable Metrics/CyclomaticComplexity
+          return unless node.bare_access_modifier? &&
+                        !(node.parent&.block_type? || node.parent&.numblock_type?)
           return if expected_empty_lines?(node)
 
           message = message(node)

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

@@ -32,6 +32,8 @@ module RuboCop
 
           check(node, node.body, adjusted_first_line: first_line)
         end
+
+        alias on_numblock on_block
       end
     end
   end

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

@@ -82,6 +82,10 @@ module RuboCop
           check_other_alignment(node)
         end
 
+        def on_sclass(node)
+          check_other_alignment(node)
+        end
+
         def on_module(node)
           check_other_alignment(node)
         end
@@ -105,6 +109,7 @@ module RuboCop
             check_other_alignment(node)
           end
         end
+        alias on_case_match on_case
 
         private
 
@@ -165,7 +170,10 @@ module RuboCop
         end
 
         def alignment_node_for_variable_style(node)
-          return node.parent if node.case_type? && node.argument? && same_line?(node, node.parent)
+          if (node.case_type? || node.case_match_type?) && node.argument? &&
+             same_line?(node, node.parent)
+            return node.parent
+          end
 
           assignment = assignment_or_operator_method(node)
 

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

@@ -22,20 +22,20 @@ module RuboCop
       #   # all platforms.
       #
       #   # bad
-      #   puts 'Hello' # Return character is CR+LF on all platfoms.
+      #   puts 'Hello' # Return character is CR+LF on all platforms.
       #
       #   # good
-      #   puts 'Hello' # Return character is LF on all platfoms.
+      #   puts 'Hello' # Return character is LF on all platforms.
       #
       # @example EnforcedStyle: crlf
       #   # The `crlf` style means that CR+LF (Carriage Return + Line Feed) is
       #   # enforced on all platforms.
       #
       #   # bad
-      #   puts 'Hello' # Return character is LF on all platfoms.
+      #   puts 'Hello' # Return character is LF on all platforms.
       #
       #   # good
-      #   puts 'Hello' # Return character is CR+LF on all platfoms.
+      #   puts 'Hello' # Return character is CR+LF on all platforms.
       #
       class EndOfLine < Base
         include ConfigurableEnforcedStyle

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

@@ -49,7 +49,7 @@ module RuboCop
 
         private
 
-        def aligned_locations(locs)
+        def aligned_locations(locs) # rubocop:disable Metrics/AbcSize
           return [] if locs.empty?
 
           aligned = Set[locs.first.line, locs.last.line]
@@ -57,6 +57,11 @@ module RuboCop
             col = loc.column
             aligned << loc.line if col == before.column || col == after.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
 
@@ -119,12 +124,16 @@ module RuboCop
         def ignored_ranges(ast)
           return [] unless ast
 
-          @ignored_ranges ||= on_node(:pair, ast).map do |pair|
-            next if pair.parent.single_line?
+          @ignored_ranges ||= begin
+            ranges = []
+            on_node(:pair, ast) do |pair|
+              next if pair.parent.single_line?
 
-            key, value = *pair
-            key.source_range.end_pos...value.source_range.begin_pos
-          end.compact
+              key, value = *pair
+              ranges << (key.source_range.end_pos...value.source_range.begin_pos)
+            end
+            ranges
+          end
         end
 
         def force_equal_sign_alignment?

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

@@ -153,17 +153,24 @@ module RuboCop
         MSG = 'Indent the first argument one step more than %<base>s.'
 
         def on_send(node)
-          return if style != :consistent && enforce_first_argument_with_fixed_indentation?
-          return if !node.arguments? || bare_operator?(node) || node.setter_method?
+          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?
 
           indent = base_indentation(node) + configured_indentation_width
 
           check_alignment([node.first_argument], indent)
         end
         alias on_csend on_send
+        alias on_super on_send
 
         private
 
+        def should_check?(node)
+          node.arguments? && !bare_operator?(node) && !node.setter_method?
+        end
+
         def autocorrect(corrector, node)
           AlignmentCorrector.correct(corrector, processed_source, node, column_delta)
         end
@@ -177,7 +184,7 @@ module RuboCop
 
           send_node = arg_node.parent
           text = base_range(send_node, arg_node).source.strip
-          base = if !/\n/.match?(text) && special_inner_call_indentation?(send_node)
+          base = if !text.include?("\n") && special_inner_call_indentation?(send_node)
                    "`#{text}`"
                  elsif comment_line?(text.lines.reverse_each.first)
                    'the start of the previous line (not counting the comment)'
@@ -253,7 +260,7 @@ module RuboCop
           @comment_lines ||=
             processed_source
             .comments
-            .select { |c| begins_its_line?(c.loc.expression) }
+            .select { |c| begins_its_line?(c.source_range) }
             .map { |c| c.loc.line }
         end
 
@@ -267,6 +274,10 @@ module RuboCop
           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')
         end

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

@@ -120,14 +120,15 @@ module RuboCop
             check_first(first_elem, left_bracket, left_parenthesis, 0)
           end
 
-          check_right_bracket(array_node.loc.end, left_bracket, left_parenthesis)
+          check_right_bracket(array_node.loc.end, first_elem, left_bracket, left_parenthesis)
         end
 
-        def check_right_bracket(right_bracket, left_bracket, left_parenthesis)
+        def check_right_bracket(right_bracket, first_elem, left_bracket, left_parenthesis)
           # if the right bracket is on the same line as the last value, accept
           return if /\S/.match?(right_bracket.source_line[0...right_bracket.column])
 
-          expected_column, indent_base_type = indent_base(left_bracket, left_parenthesis)
+          expected_column, indent_base_type = indent_base(left_bracket, first_elem,
+                                                          left_parenthesis)
           @column_delta = expected_column - right_bracket.column
           return if @column_delta.zero?
 
@@ -142,7 +143,7 @@ module RuboCop
           case indent_base_type
           when :left_brace_or_bracket
             'the position of the opening bracket'
-          when :first_colmn_after_left_parenthesis
+          when :first_column_after_left_parenthesis
             'the first position after the preceding left parenthesis'
           when :parent_hash_key
             'the parent hash key'
@@ -163,7 +164,7 @@ module RuboCop
           case indent_base_type
           when :left_brace_or_bracket
             'Indent the right bracket the same as the left bracket.'
-          when :first_colmn_after_left_parenthesis
+          when :first_column_after_left_parenthesis
             'Indent the right bracket the same as the first position ' \
             'after the preceding left parenthesis.'
           when :parent_hash_key

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

@@ -8,14 +8,37 @@ module RuboCop
       #
       # @example
       #
-      #     # bad
-      #     [ :a,
-      #       :b]
+      #   # bad
+      #   [ :a,
+      #     :b]
       #
-      #     # good
-      #     [
-      #       :a,
-      #       :b]
+      #   # good
+      #   [
+      #     :a,
+      #     :b]
+      #
+      #   # good
+      #   [:a, :b]
+      #
+      # @example AllowMultilineFinalElement: false (default)
+      #
+      #   # bad
+      #   [ :a, {
+      #     :b => :c
+      #   }]
+      #
+      #   # good
+      #   [
+      #     :a, {
+      #     :b => :c
+      #   }]
+      #
+      # @example AllowMultilineFinalElement: true
+      #
+      #   # good
+      #   [:a, {
+      #     :b => :c
+      #   }]
       #
       class FirstArrayElementLineBreak < Base
         include FirstElementLineBreak
@@ -26,7 +49,7 @@ module RuboCop
         def on_array(node)
           return if !node.loc.begin && !assignment_on_same_line?(node)
 
-          check_children_line_break(node, node.children)
+          check_children_line_break(node, node.children, ignore_last: ignore_last_element?)
         end
 
         private
@@ -35,6 +58,10 @@ module RuboCop
           source = node.source_range.source_line[0...node.loc.column]
           /\s*=\s*$/.match?(source)
         end
+
+        def ignore_last_element?
+          !!cop_config['AllowMultilineFinalElement']
+        end
       end
     end
   end

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

@@ -158,14 +158,14 @@ module RuboCop
             end
           end
 
-          check_right_brace(hash_node.loc.end, left_brace, left_parenthesis)
+          check_right_brace(hash_node.loc.end, first_pair, left_brace, left_parenthesis)
         end
 
-        def check_right_brace(right_brace, left_brace, left_parenthesis)
+        def check_right_brace(right_brace, first_pair, left_brace, left_parenthesis)
           # if the right brace is on the same line as the last value, accept
           return if /\S/.match?(right_brace.source_line[0...right_brace.column])
 
-          expected_column, indent_base_type = indent_base(left_brace, left_parenthesis)
+          expected_column, indent_base_type = indent_base(left_brace, first_pair, left_parenthesis)
           @column_delta = expected_column - right_brace.column
           return if @column_delta.zero?
 
@@ -192,7 +192,7 @@ module RuboCop
           case indent_base_type
           when :left_brace_or_bracket
             'the position of the opening brace'
-          when :first_colmn_after_left_parenthesis
+          when :first_column_after_left_parenthesis
             'the first position after the preceding left parenthesis'
           when :parent_hash_key
             'the parent hash key'
@@ -213,7 +213,7 @@ module RuboCop
           case indent_base_type
           when :left_brace_or_bracket
             'Indent the right brace the same as the left brace.'
-          when :first_colmn_after_left_parenthesis
+          when :first_column_after_left_parenthesis
             'Indent the right brace the same as the first position ' \
             'after the preceding left parenthesis.'
           when :parent_hash_key

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

@@ -16,6 +16,33 @@ module RuboCop
       #     {
       #       a: 1,
       #       b: 2 }
+      #
+      #     # good
+      #     {
+      #       a: 1, b: {
+      #       c: 3
+      #     }}
+      #
+      # @example AllowMultilineFinalElement: false (default)
+      #
+      #     # bad
+      #     { a: 1, b: {
+      #       c: 3
+      #     }}
+      #
+      # @example AllowMultilineFinalElement: true
+      #
+      #     # bad
+      #     { a: 1,
+      #       b: {
+      #       c: 3
+      #     }}
+      #
+      #     # good
+      #     { a: 1, b: {
+      #       c: 3
+      #     }}
+      #
       class FirstHashElementLineBreak < Base
         include FirstElementLineBreak
         extend AutoCorrector
@@ -25,7 +52,15 @@ 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
-          check_children_line_break(node, node.children) if node.loc.begin
+          return unless node.loc.begin
+
+          check_children_line_break(node, node.children, ignore_last: ignore_last_element?)
+        end
+
+        private
+
+        def ignore_last_element?
+          !!cop_config['AllowMultilineFinalElement']
         end
       end
     end