rubocop 1.24.1 → 1.64.1

data/lib/rubocop/cop/internal_affairs/useless_restrict_on_send.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module InternalAffairs
+      # Check for useless `RESTRICT_ON_SEND`.
+      #
+      # @example
+      #   # bad
+      #   class FooCop
+      #     RESTRICT_ON_SEND = %i[bad_method].freeze
+      #   end
+      #
+      #   # good
+      #   class FooCop
+      #     RESTRICT_ON_SEND = %i[bad_method].freeze
+      #     def on_send(node)
+      #       # ...
+      #     end
+      #   end
+      #
+      #   # good
+      #   class FooCop
+      #     RESTRICT_ON_SEND = %i[bad_method].freeze
+      #     def after_send(node)
+      #       # ...
+      #     end
+      #   end
+      #
+      class UselessRestrictOnSend < Base
+        extend AutoCorrector
+
+        MSG = 'Useless `RESTRICT_ON_SEND` is defined.'
+
+        # @!method defined_send_callback?(node)
+        def_node_search :defined_send_callback?, <<~PATTERN
+          {
+            (def {:on_send :after_send} ...)
+            (alias (sym {:on_send :after_send}) _source ...)
+            (send nil? :alias_method {(sym {:on_send :after_send}) (str {"on_send" "after_send"})} _source ...)
+          }
+        PATTERN
+
+        def on_casgn(node)
+          return if !restrict_on_send?(node) || defined_send_callback?(node.parent)
+
+          add_offense(node) do |corrector|
+            corrector.remove(node)
+          end
+        end
+
+        private
+
+        def restrict_on_send?(node)
+          node.name == :RESTRICT_ON_SEND
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/internal_affairs.rb

@@ -1,19 +1,33 @@
 # frozen_string_literal: true
 
+require_relative 'internal_affairs/cop_description'
+require_relative 'internal_affairs/create_empty_file'
 require_relative 'internal_affairs/empty_line_between_expect_offense_and_correction'
 require_relative 'internal_affairs/example_description'
+require_relative 'internal_affairs/example_heredoc_delimiter'
 require_relative 'internal_affairs/inherit_deprecated_cop_class'
+require_relative 'internal_affairs/lambda_or_proc'
+require_relative 'internal_affairs/location_expression'
 require_relative 'internal_affairs/location_line_equality_comparison'
+require_relative 'internal_affairs/method_name_end_with'
 require_relative 'internal_affairs/method_name_equal'
 require_relative 'internal_affairs/node_destructuring'
+require_relative 'internal_affairs/node_first_or_last_argument'
 require_relative 'internal_affairs/node_matcher_directive'
 require_relative 'internal_affairs/node_type_predicate'
+require_relative 'internal_affairs/numblock_handler'
 require_relative 'internal_affairs/offense_location_keyword'
+require_relative 'internal_affairs/processed_source_buffer_name'
+require_relative 'internal_affairs/redundant_context_config_parameter'
 require_relative 'internal_affairs/redundant_described_class_as_subject'
+require_relative 'internal_affairs/redundant_expect_offense_arguments'
 require_relative 'internal_affairs/redundant_let_rubocop_config_new'
 require_relative 'internal_affairs/redundant_location_argument'
 require_relative 'internal_affairs/redundant_message_argument'
 require_relative 'internal_affairs/redundant_method_dispatch_node'
+require_relative 'internal_affairs/redundant_source_range'
+require_relative 'internal_affairs/single_line_comparison'
 require_relative 'internal_affairs/style_detected_api_use'
 require_relative 'internal_affairs/undefined_config'
 require_relative 'internal_affairs/useless_message_assertion'
+require_relative 'internal_affairs/useless_restrict_on_send'

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

@@ -53,23 +53,55 @@ module RuboCop
                            'following the first line of a multi-line method call.'
 
         def on_send(node)
-          first_arg = node.first_argument
-          return if !multiple_arguments?(node, first_arg) || (node.send_type? && node.method?(:[]=))
+          return if !multiple_arguments?(node) || (node.send_type? && node.method?(:[]=)) ||
+                    autocorrect_incompatible_with_other_cops?
 
-          if first_arg.hash_type? && !first_arg.braces?
-            pairs = first_arg.pairs
-            check_alignment(pairs, base_column(node, pairs.first))
-          else
-            check_alignment(node.arguments, base_column(node, first_arg))
-          end
+          items = flattened_arguments(node)
+
+          check_alignment(items, base_column(node, items.first))
         end
+
         alias on_csend on_send
 
         private
 
-        def multiple_arguments?(node, first_argument)
+        def autocorrect_incompatible_with_other_cops?
+          with_first_argument_style? && enforce_hash_argument_with_separator?
+        end
+
+        def flattened_arguments(node)
+          if fixed_indentation?
+            arguments_with_last_arg_pairs(node)
+          else
+            arguments_or_first_arg_pairs(node)
+          end
+        end
+
+        def arguments_with_last_arg_pairs(node)
+          items = node.arguments[0..-2]
+          last_arg = node.last_argument
+
+          if last_arg.hash_type? && !last_arg.braces?
+            items += last_arg.pairs
+          else
+            items << last_arg
+          end
+          items
+        end
+
+        def arguments_or_first_arg_pairs(node)
+          first_arg = node.first_argument
+          if first_arg.hash_type? && !first_arg.braces?
+            first_arg.pairs
+          else
+            node.arguments
+          end
+        end
+
+        def multiple_arguments?(node)
           return true if node.arguments.size >= 2
 
+          first_argument = node.first_argument
           first_argument&.hash_type? && first_argument.pairs.count >= 2
         end
 
@@ -85,6 +117,10 @@ module RuboCop
           cop_config['EnforcedStyle'] == 'with_fixed_indentation'
         end
 
+        def with_first_argument_style?
+          cop_config['EnforcedStyle'] == 'with_first_argument'
+        end
+
         def base_column(node, first_argument)
           if fixed_indentation? || first_argument.nil?
             lineno = target_method_lineno(node)
@@ -104,6 +140,18 @@ module RuboCop
             node.loc.begin.line
           end
         end
+
+        def enforce_hash_argument_with_separator?
+          return false unless hash_argument_config['Enabled']
+
+          RuboCop::Cop::Layout::HashAlignment::SEPARATOR_ALIGNMENT_STYLES.any? do |style|
+            hash_argument_config[style]&.include?('separator')
+          end
+        end
+
+        def hash_argument_config
+          config.for_cop('Layout/HashAlignment')
+        end
       end
     end
   end

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

@@ -76,7 +76,7 @@ module RuboCop
         end
 
         def target_method_lineno(node)
-          node.loc.line
+          node.bracketed? ? node.loc.line : node.parent.loc.line
         end
       end
     end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Layout
-      # This cop checks the indentation of the first line of the
+      # Checks the indentation of the first line of the
       # right-hand-side of a multi-line assignment.
       #
       # @example

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Layout
-      # This cop checks whether the end keyword of `begin` is aligned properly.
+      # Checks whether the end keyword of `begin` is aligned properly.
       #
       # Two modes are supported through the `EnforcedStyleAlignWith` configuration
       # parameter. If it's set to `start_of_line` (which is the default), the

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Layout
-      # This cop checks whether the end keywords are aligned properly for do
+      # Checks whether the end keywords are aligned properly for do
       # end blocks.
       #
       # Three modes are supported through the `EnforcedStyleAlignWith`
@@ -22,23 +22,24 @@ module RuboCop
       #   # bad
       #
       #   foo.bar
-      #      .each do
-      #        baz
-      #          end
+      #     .each do
+      #       baz
+      #         end
       #
       #   # good
       #
-      #   variable = lambda do |i|
-      #     i
+      #   foo.bar
+      #     .each do
+      #       baz
       #   end
       #
       # @example EnforcedStyleAlignWith: start_of_block
       #   # bad
       #
       #   foo.bar
-      #      .each do
-      #        baz
-      #          end
+      #     .each do
+      #       baz
+      #         end
       #
       #   # good
       #
@@ -51,16 +52,17 @@ module RuboCop
       #   # bad
       #
       #   foo.bar
-      #      .each do
-      #        baz
-      #          end
+      #     .each do
+      #       baz
+      #         end
       #
       #   # good
       #
       #   foo.bar
       #     .each do
-      #        baz
+      #       baz
       #   end
+      #
       class BlockAlignment < Base
         include ConfigurableEnforcedStyle
         include RangeHelp
@@ -82,6 +84,8 @@ module RuboCop
           check_block_alignment(start_for_block_node(node), node)
         end
 
+        alias on_numblock on_block
+
         def style_parameter_name
           'EnforcedStyleAlignWith'
         end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Layout
-      # This cop checks whether the end statement of a do..end block
+      # Checks whether the end statement of a do..end block
       # is on its own line.
       #
       # @example
@@ -36,23 +36,45 @@ module RuboCop
           # If the end is on its own line, there is no offense
           return if begins_its_line?(node.loc.end)
 
-          add_offense(node.loc.end, message: message(node)) do |corrector|
-            corrector.replace(delimiter_range(node), "\n#{node.loc.end.source}#{offset(node)}")
-          end
+          offense_range = offense_range(node)
+          return if offense_range.source.lstrip.start_with?(';')
+
+          register_offense(node, offense_range)
         end
 
+        alias on_numblock on_block
+
         private
 
+        def register_offense(node, offense_range)
+          add_offense(node.loc.end, message: message(node)) do |corrector|
+            replacement = "\n#{offense_range.source.lstrip}"
+
+            if (heredoc = last_heredoc_argument(node.body))
+              corrector.remove(offense_range)
+              corrector.insert_after(heredoc.loc.heredoc_end, replacement)
+            else
+              corrector.replace(offense_range, replacement)
+            end
+          end
+        end
+
         def message(node)
           format(MSG, line: node.loc.end.line, column: node.loc.end.column + 1)
         end
 
-        def delimiter_range(node)
-          Parser::Source::Range.new(
-            node.loc.expression.source_buffer,
-            node.children.compact.last.loc.expression.end_pos,
-            node.loc.expression.end_pos
-          )
+        def last_heredoc_argument(node)
+          return unless node&.call_type?
+          return unless (arguments = node&.arguments)
+
+          heredoc = arguments.reverse.detect { |arg| arg.str_type? && arg.heredoc? }
+          return heredoc if heredoc
+
+          last_heredoc_argument(node.children.first)
+        end
+
+        def offense_range(node)
+          node.children.compact.last.source_range.end.join(node.loc.end)
         end
       end
     end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Layout
-      # This cop checks how the `when` and `in`s of a `case` expression
+      # Checks how the `when` and ``in``s of a `case` expression
       # are indented in relation to its `case` or `end` keyword.
       #
       # It will register a separate offense for each misaligned `when` and `in`.
@@ -119,18 +119,34 @@ module RuboCop
 
         def on_case(case_node)
           return if case_node.single_line?
+          return if enforced_style_end? && end_and_last_conditional_same_line?(case_node)
 
           case_node.each_when { |when_node| check_when(when_node, 'when') }
         end
 
         def on_case_match(case_match_node)
           return if case_match_node.single_line?
+          return if enforced_style_end? && end_and_last_conditional_same_line?(case_match_node)
 
           case_match_node.each_in_pattern { |in_pattern_node| check_when(in_pattern_node, 'in') }
         end
 
         private
 
+        def end_and_last_conditional_same_line?(node)
+          end_line = node.loc.end&.line
+          last_conditional_line = if node.loc.else
+                                    node.loc.else.line
+                                  else
+                                    node.child_nodes.last.loc.begin&.line
+                                  end
+          end_line && last_conditional_line && end_line == last_conditional_line
+        end
+
+        def enforced_style_end?
+          cop_config[style_parameter_name] == 'end'
+        end
+
         def check_when(when_node, branch_type)
           when_column = when_node.loc.keyword.column
           base_column = base_column(when_node.parent, style)

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

@@ -68,6 +68,13 @@ module RuboCop
       #        - extend
       # ----
       #
+      # @safety
+      #   Autocorrection is unsafe because class methods and module inclusion
+      #   can behave differently, based on which methods or constants have
+      #   already been defined.
+      #
+      #   Constants will only be moved when they are assigned with literals.
+      #
       # @example
       #   # bad
       #   # Expect extend be before constant
@@ -132,25 +139,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 +166,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 +225,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 +243,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 +268,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

@@ -3,7 +3,6 @@
 module RuboCop
   module Cop
     module Layout
-      #
       # Checks the indentation of here document closings.
       #
       # @example
@@ -73,7 +72,7 @@ module RuboCop
         end
 
         def argument_indentation_correct?(node)
-          return unless node.argument? || node.chained?
+          return false unless node.argument? || node.chained?
 
           opening_indentation(
             find_node_used_heredoc_argument(node.parent)
@@ -85,7 +84,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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Layout
-      # This cop checks the indentation of hanging closing parentheses in
+      # Checks the indentation of hanging closing parentheses in
       # method calls, method definitions, and grouped expressions. A hanging
       # closing parenthesis means `)` preceded by a line break.
       #
@@ -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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Layout
-      # This cop checks the indentation of comments.
+      # Checks the indentation of comments.
       #
       # @example
       #   # bad
@@ -139,7 +139,7 @@ module RuboCop
 
         def line_after_comment(comment)
           lines = processed_source.lines
-          lines[comment.loc.line..-1].find { |line| !line.blank? }
+          lines[comment.loc.line..].find { |line| !line.blank? }
         end
 
         def correct_indentation(next_line)
@@ -154,11 +154,13 @@ 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)
-          /^\s*(else|elsif|when|rescue|ensure)\b/.match?(line)
+          /^\s*(else|elsif|when|in|rescue|ensure)\b/.match?(line)
         end
       end
     end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Layout
-      # This cop checks for conditions that are not on the same line as
+      # Checks for conditions that are not on the same line as
       # if/while/until.
       #
       # @example

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Layout
-      # This cop checks whether the end keywords of method definitions are
+      # Checks whether the end keywords of method definitions are
       # aligned properly.
       #
       # Two modes are supported through the EnforcedStyleAlignWith configuration