rubocop 1.41.1 → 1.45.1

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

@@ -134,22 +134,18 @@ module RuboCop
       #
       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)
@@ -168,7 +164,7 @@ module RuboCop
 
         # 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
@@ -221,7 +217,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
@@ -239,17 +235,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)
@@ -261,19 +260,28 @@ 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?
+
+          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)
 
-          Parser::Source::Range.new(buffer, begin_pos, end_pos)
+          node.arguments.any? { |arg| (arg.sym_type? || arg.str_type?) && arg.value == name }
         end
 
         def end_position_for(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/first_argument_indentation.rb

@@ -179,7 +179,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)'

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

@@ -22,6 +22,7 @@ module RuboCop
       #   RUBY
       #
       class HeredocIndentation < Base
+        include Alignment
         include Heredoc
         extend AutoCorrector
 
@@ -37,7 +38,7 @@ module RuboCop
           heredoc_indent_type = heredoc_indent_type(node)
 
           if heredoc_indent_type == '~'
-            expected_indent_level = base_indent_level(node) + indentation_width
+            expected_indent_level = base_indent_level(node) + configured_indentation_width
             return if expected_indent_level == body_indent_level
           else
             return unless body_indent_level.zero?
@@ -66,9 +67,9 @@ module RuboCop
           current_indent_type = "<<#{heredoc_indent_type}"
 
           if current_indent_type == '<<~'
-            width_message(indentation_width)
+            width_message(configured_indentation_width)
           else
-            type_message(indentation_width, current_indent_type)
+            type_message(configured_indentation_width, current_indent_type)
           end
         end
 
@@ -89,7 +90,7 @@ module RuboCop
 
           body = heredoc_body(node)
 
-          expected_indent = base_indent_level(node) + indentation_width
+          expected_indent = base_indent_level(node) + configured_indentation_width
           actual_indent = indent_level(body)
           increase_indent_level = expected_indent - actual_indent
 
@@ -122,7 +123,7 @@ module RuboCop
         def indented_body(node)
           body = heredoc_body(node)
           body_indent_level = indent_level(body)
-          correct_indent_level = base_indent_level(node) + indentation_width
+          correct_indent_level = base_indent_level(node) + configured_indentation_width
           body.gsub(/^[^\S\r\n]{#{body_indent_level}}/, ' ' * correct_indent_level)
         end
 
@@ -148,10 +149,6 @@ module RuboCop
           node.source[/^<<([~-])/, 1]
         end
 
-        def indentation_width
-          @config.for_cop('Layout/IndentationWidth')['Width'] || 2
-        end
-
         def heredoc_body(node)
           node.loc.heredoc_body.source
         end

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

@@ -40,10 +40,13 @@ module RuboCop
         MSG = '%<type>s detected in indentation.'
 
         def on_new_investigation
-          str_ranges = string_literal_ranges(processed_source.ast)
+          str_ranges = nil
 
           processed_source.lines.each.with_index(1) do |line, lineno|
             next unless (range = find_offense(line, lineno))
+
+            # Perform costly calculation only when needed.
+            str_ranges ||= string_literal_ranges(processed_source.ast)
             next if in_string_literal?(str_ranges, range)
 
             add_offense(range) { |corrector| autocorrect(corrector, range) }

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

@@ -31,15 +31,11 @@ module RuboCop
         include RangeHelp
         extend AutoCorrector
 
-        # rubocop:disable Metrics/AbcSize
         def on_new_investigation
           return unless processed_source.raw_source.include?('\\')
 
           last_line = last_line(processed_source)
 
-          @ignored_ranges = string_literal_ranges(processed_source.ast) +
-                            comment_ranges(processed_source.comments)
-
           processed_source.raw_source.lines.each_with_index do |line, index|
             break if index >= last_line
 
@@ -47,7 +43,6 @@ module RuboCop
             investigate(line, line_number)
           end
         end
-        # rubocop:enable Metrics/AbcSize
 
         private
 
@@ -120,7 +115,12 @@ module RuboCop
         end
 
         def ignore_range?(backtick_range)
-          @ignored_ranges.any? { |range| range.contains?(backtick_range) }
+          ignored_ranges.any? { |range| range.contains?(backtick_range) }
+        end
+
+        def ignored_ranges
+          @ignored_ranges ||= string_literal_ranges(processed_source.ast) +
+                              comment_ranges(processed_source.comments)
         end
 
         def no_space_style?

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

@@ -91,7 +91,7 @@ module RuboCop
           if node.source.lines.first.end_with?("|\n")
             PIPE_SIZE
           else
-            1 + (PIPE_SIZE * 2)
+            (PIPE_SIZE * 2) + 1
           end
         end
 

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

@@ -241,7 +241,7 @@ module RuboCop
         end
 
         def accept_namespace_operator?(range)
-          ACCEPT_NAMESPACE_OPERATOR == range.source
+          range.source == ACCEPT_NAMESPACE_OPERATOR
         end
 
         def safe_navigation_call?(range, pos)
@@ -256,7 +256,7 @@ module RuboCop
           # regular dotted method calls bind more tightly than operators
           # so we need to climb up the AST past them
           node.each_ancestor do |ancestor|
-            return true if ancestor.and_type? || ancestor.or_type?
+            return true if ancestor.and_type? || ancestor.or_type? || ancestor.range_type?
             return false unless ancestor.send_type?
             return true if ancestor.operator_method?
           end

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

@@ -177,7 +177,7 @@ module RuboCop
         end
 
         def autocorrect(corrector, range)
-          if /\*\*/.match?(range.source) && !space_around_exponent_operator?
+          if range.source.include?('**') && !space_around_exponent_operator?
             corrector.replace(range, '**')
           elsif range.source.end_with?("\n")
             corrector.replace(range, " #{range.source.strip}\n")

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

@@ -78,8 +78,11 @@ module RuboCop
         def on_array(node)
           return unless node.square_brackets?
 
-          left, right = array_brackets(node)
-          return empty_offenses(node, left, right, EMPTY_MSG) if empty_brackets?(left, right)
+          tokens, left, right = array_brackets(node)
+
+          if empty_brackets?(left, right, tokens: tokens)
+            return empty_offenses(node, left, right, EMPTY_MSG)
+          end
 
           start_ok = next_to_newline?(node, left)
           end_ok = node.single_line? ? false : end_has_own_line?(right)
@@ -90,9 +93,9 @@ module RuboCop
         private
 
         def autocorrect(corrector, node)
-          left, right = array_brackets(node)
+          tokens, left, right = array_brackets(node)
 
-          if empty_brackets?(left, right)
+          if empty_brackets?(left, right, tokens: tokens)
             SpaceCorrector.empty_corrections(processed_source, corrector, empty_config, left, right)
           elsif style == :no_space
             SpaceCorrector.remove_space(processed_source, corrector, left, right)
@@ -104,15 +107,12 @@ module RuboCop
         end
 
         def array_brackets(node)
-          [left_array_bracket(node), right_array_bracket(node)]
-        end
+          tokens = processed_source.tokens_within(node)
 
-        def left_array_bracket(node)
-          processed_source.tokens_within(node).find(&:left_array_bracket?)
-        end
+          left = tokens.find(&:left_array_bracket?)
+          right = tokens.reverse_each.find(&:right_bracket?)
 
-        def right_array_bracket(node)
-          processed_source.tokens_within(node).reverse.find(&:right_bracket?)
+          [tokens, left, right]
         end
 
         def empty_config
@@ -178,8 +178,6 @@ module RuboCop
         def multi_dimensional_array?(node, token, side: :right)
           offset = side == :right ? -1 : +1
           i = index_for(node, token) + offset
-          # TODO: change this type check once
-          # https://github.com/rubocop/rubocop-ast/pull/240 is merged
           i += offset while processed_source.tokens_within(node)[i].new_line?
           if side == :right
             processed_source.tokens_within(node)[i].right_bracket?

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

@@ -74,7 +74,7 @@ module RuboCop
 
           right_token = closing_bracket(tokens, left_token)
 
-          if empty_brackets?(left_token, right_token)
+          if empty_brackets?(left_token, right_token, tokens: tokens)
             return empty_offenses(node, left_token, right_token, EMPTY_MSG)
           end
 
@@ -90,9 +90,9 @@ module RuboCop
         private
 
         def autocorrect(corrector, node)
-          left, right = reference_brackets(node)
+          tokens, left, right = reference_brackets(node)
 
-          if empty_brackets?(left, right)
+          if empty_brackets?(left, right, tokens: tokens)
             SpaceCorrector.empty_corrections(processed_source, corrector, empty_config, left, right)
           elsif style == :no_space
             SpaceCorrector.remove_space(processed_source, corrector, left, right)
@@ -104,7 +104,7 @@ module RuboCop
         def reference_brackets(node)
           tokens = processed_source.tokens_within(node)
           left = left_ref_bracket(node, tokens)
-          [left, closing_bracket(tokens, left)]
+          [tokens, left, closing_bracket(tokens, left)]
         end
 
         def left_ref_bracket(node, tokens)

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

@@ -31,13 +31,14 @@ module RuboCop
         def on_interpolation(begin_node)
           return if begin_node.multiline?
 
-          delims = delimiters(begin_node)
-          return if empty_brackets?(*delims)
+          tokens = processed_source.tokens_within(begin_node)
+          left, right = delimiters(begin_node)
+          return if empty_brackets?(left, right, tokens: tokens)
 
           if style == :no_space
-            no_space_offenses(begin_node, *delims, NO_SPACE_MSG)
+            no_space_offenses(begin_node, left, right, NO_SPACE_MSG)
           else
-            space_offenses(begin_node, *delims, SPACE_MSG)
+            space_offenses(begin_node, left, right, SPACE_MSG)
           end
         end
 

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

@@ -47,7 +47,6 @@ module RuboCop
         MSG = 'Trailing whitespace detected.'
 
         def on_new_investigation
-          @heredocs = extract_heredocs(processed_source.ast)
           processed_source.lines.each_with_index do |line, index|
             next unless line.end_with?(' ', "\t")
 
@@ -102,10 +101,14 @@ module RuboCop
         end
 
         def find_heredoc(line_number)
-          @heredocs.each { |node, r| return node if r.include?(line_number) }
+          heredocs.each { |node, r| return node if r.include?(line_number) }
           nil
         end
 
+        def heredocs
+          @heredocs ||= extract_heredocs(processed_source.ast)
+        end
+
         def extract_heredocs(ast)
           return [] unless ast
 

data/lib/rubocop/cop/lint/ambiguous_operator.rb

@@ -38,6 +38,10 @@ module RuboCop
                      'a whitespace to the right of the `%<operator>s` if it ' \
                      'should be %<possible>s.'
 
+        def self.autocorrect_incompatible_with
+          [Naming::BlockForwarding]
+        end
+
         def on_new_investigation
           processed_source.diagnostics.each do |diagnostic|
             next unless diagnostic.reason == :ambiguous_prefix

data/lib/rubocop/cop/lint/debugger.rb

@@ -82,44 +82,25 @@ module RuboCop
         def debugger_methods
           @debugger_methods ||= begin
             config = cop_config.fetch('DebuggerMethods', [])
-            values = config.is_a?(Array) ? config : config.values.flatten
-            values.map do |v|
-              next unless v
-
-              *receiver, method_name = v.split('.')
-              {
-                receiver: receiver.empty? ? nil : receiver.map(&:to_sym),
-                method_name: method_name.to_sym
-              }
-            end.compact
+            config.is_a?(Array) ? config : config.values.flatten
           end
         end
 
         def debugger_method?(send_node)
-          method_name = send_node.method_name
-
-          debugger_methods.any? do |method|
-            next unless method[:method_name] == method_name
+          return if send_node.parent&.send_type? && send_node.parent.receiver == send_node
 
-            if method[:receiver].nil?
-              send_node.receiver.nil?
-            else
-              method[:receiver] == receiver_chain(send_node)
-            end
-          end
+          debugger_methods.include?(chained_method_name(send_node))
         end
 
-        def receiver_chain(send_node)
-          receivers = []
+        def chained_method_name(send_node)
+          chained_method_name = send_node.method_name.to_s
           receiver = send_node.receiver
-
           while receiver
-            name = receiver.send_type? ? receiver.method_name : receiver.const_name&.to_sym
-            receivers.unshift(name)
+            name = receiver.send_type? ? receiver.method_name : receiver.const_name
+            chained_method_name = "#{name}.#{chained_method_name}"
             receiver = receiver.receiver
           end
-
-          receivers
+          chained_method_name
         end
       end
     end