rubocop 1.31.2 → 1.57.1

data/lib/rubocop/cop/gemspec/ordered_dependencies.rb

@@ -45,7 +45,15 @@ module RuboCop
       #
       #   spec.add_runtime_dependency 'rspec'
       #
-      #   # good only if TreatCommentsAsGroupSeparators is true
+      # @example TreatCommentsAsGroupSeparators: true (default)
+      #   # good
+      #   # For code quality
+      #   spec.add_dependency 'rubocop'
+      #   # For tests
+      #   spec.add_dependency 'rspec'
+      #
+      # @example TreatCommentsAsGroupSeparators: false
+      #   # bad
       #   # For code quality
       #   spec.add_dependency 'rubocop'
       #   # For tests

data/lib/rubocop/cop/gemspec/require_mfa.rb

@@ -84,7 +84,7 @@ module RuboCop
           (str "true")
         PATTERN
 
-        def on_block(node) # rubocop:disable Metrics/MethodLength
+        def on_block(node) # rubocop:disable Metrics/MethodLength, InternalAffairs/NumblockHandler
           gem_specification(node) do |block_var|
             metadata_value = metadata(node)
             mfa_value = mfa_value(metadata_value)

data/lib/rubocop/cop/generator/require_file_injector.rb

@@ -55,8 +55,8 @@ module RuboCop
           end
         end
 
-        def require_path_fragments(require_directove)
-          path = require_directove.match(REQUIRE_PATH)
+        def require_path_fragments(require_directive)
+          path = require_directive.match(REQUIRE_PATH)
 
           path ? path.captures.first.split('/') : []
         end
@@ -67,7 +67,7 @@ module RuboCop
 
         def require_path
           path = source_path.relative_path_from(root_file_path.dirname)
-          path.to_s.sub('.rb', '')
+          path.to_s.delete_suffix('.rb')
         end
       end
     end

data/lib/rubocop/cop/generator.rb

@@ -206,9 +206,8 @@ module RuboCop
       end
 
       def snake_case(camel_case_string)
-        return 'rspec' if camel_case_string == 'RSpec'
-
         camel_case_string
+          .gsub('RSpec', 'Rspec')
           .gsub(%r{([^A-Z/])([A-Z]+)}, '\1_\2')
           .gsub(%r{([A-Z])([A-Z][^A-Z\d/]+)}, '\1_\2')
           .downcase

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

@@ -12,6 +12,13 @@ module RuboCop
       #     ....
       #   end
       #
+      #   # bad
+      #   #
+      #   # Checks ...
+      #   class SomeCop < Base
+      #     ...
+      #   end
+      #
       #   # good
       #   # Checks ...
       #   class SomeCop < Base
@@ -21,26 +28,47 @@ module RuboCop
       class CopDescription < Base
         extend AutoCorrector
 
-        MSG = 'Description should be started with %<suggestion>s instead of `This cop ...`.'
+        MSG_STARTS_WITH_WRONG_WORD =
+          'Description should be started with %<suggestion>s instead of `This cop ...`.'
+        MSG_STARTS_WITH_EMPTY_COMMENT_LINE =
+          'Description should not start with an empty comment line.'
 
         SPECIAL_WORDS = %w[is can could should will would must may].freeze
-        COP_DESC_OFFENSE_REGEX = \
+        COP_DESC_OFFENSE_REGEX =
           /^\s+# This cop (?<special>#{SPECIAL_WORDS.join('|')})?\s*(?<word>.+?) .*/.freeze
         REPLACEMENT_REGEX = /^\s+# This cop (#{SPECIAL_WORDS.join('|')})?\s*(.+?) /.freeze
+        EMPTY_COMMENT_LINE_REGEX = /\A\s*#\s*\n\z/.freeze
 
         def on_class(node)
-          return unless (module_node = node.parent)
+          return unless (module_node = node.parent) && node.parent_class
 
           description_beginning = first_comment_line(module_node)
           return unless description_beginning
 
-          start_with_subject = description_beginning.match(COP_DESC_OFFENSE_REGEX)
-          return unless start_with_subject
+          if description_beginning.match?(EMPTY_COMMENT_LINE_REGEX)
+            register_offense_for_empty_comment_line(module_node, description_beginning)
+          else
+            start_with_subject = description_beginning.match(COP_DESC_OFFENSE_REGEX)
+            return unless start_with_subject
+
+            register_offense_for_wrong_word(module_node, description_beginning, start_with_subject)
+          end
+        end
+
+        private
 
+        def register_offense_for_empty_comment_line(module_node, description_beginning)
+          range = range(module_node, description_beginning)
+          add_offense(range, message: MSG_STARTS_WITH_EMPTY_COMMENT_LINE) do |corrector|
+            corrector.remove(range)
+          end
+        end
+
+        def register_offense_for_wrong_word(module_node, description_beginning, start_with_subject)
           suggestion = start_with_subject['word']&.capitalize
           range = range(module_node, description_beginning)
           suggestion_for_message = suggestion_for_message(suggestion, start_with_subject)
-          message = format(MSG, suggestion: suggestion_for_message)
+          message = format(MSG_STARTS_WITH_WRONG_WORD, suggestion: suggestion_for_message)
 
           add_offense(range, message: message) do |corrector|
             if suggestion && !start_with_subject['special']
@@ -49,17 +77,15 @@ module RuboCop
           end
         end
 
-        private
-
         def replace_with_suggestion(corrector, range, suggestion, description_beginning)
           replacement = description_beginning.gsub(REPLACEMENT_REGEX, "#{suggestion} ")
           corrector.replace(range, replacement)
         end
 
         def range(node, comment_line)
-          source_buffer = node.loc.expression.source_buffer
+          source_buffer = node.source_range.source_buffer
 
-          begin_pos = node.loc.expression.begin_pos
+          begin_pos = node.source_range.begin_pos
           begin_pos += comment_index(node, comment_line)
           end_pos = begin_pos + comment_body(comment_line).length
 
@@ -75,7 +101,7 @@ module RuboCop
         end
 
         def first_comment_line(node)
-          node.loc.expression.source.lines.find { |line| comment_line?(line) }
+          node.source.lines.find { |line| comment_line?(line) }
         end
 
         def comment_body(comment_line)
@@ -84,7 +110,7 @@ module RuboCop
 
         def comment_index(node, comment_line)
           body = comment_body(comment_line)
-          node.loc.expression.source.index(body)
+          node.source.index(body)
         end
 
         def relevant_file?(file)

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module InternalAffairs
+      # Checks for uses of `create_file` with empty string second argument.
+      #
+      # @example
+      #
+      #   # bad
+      #   create_file(path, '')
+      #
+      #   # good
+      #   create_empty_file(path)
+      #
+      class CreateEmptyFile < Base
+        extend AutoCorrector
+
+        MSG = 'Use `%<replacement>s`.'
+        RESTRICT_ON_SEND = %i[create_file].freeze
+
+        def on_send(node)
+          return if node.receiver
+          return unless (argument = node.arguments[1])
+          return unless argument.str_type? && argument.value.empty?
+
+          replacement = "create_empty_file(#{node.first_argument.source})"
+          message = format(MSG, replacement: replacement)
+
+          add_offense(node, message: message) do |corrector|
+            corrector.replace(node, replacement)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -26,9 +26,7 @@ module RuboCop
       #     expect_no_offenses('...')
       #   end
       class ExampleDescription < Base
-        class << self
-          attr_accessor :descriptions
-        end
+        extend AutoCorrector
 
         MSG = 'Description does not match use of `%<method_name>s`.'
 
@@ -39,21 +37,31 @@ module RuboCop
           expect_no_corrections
         ].to_set.freeze
 
-        EXPECT_NO_OFFENSES_INCORRECT_DESCRIPTIONS = [
-          /^(adds|registers|reports|finds) (an? )?offense/,
-          /^(flags|handles|works)\b/
-        ].freeze
+        EXPECT_NO_OFFENSES_DESCRIPTION_MAPPING = {
+          /\A(adds|registers|reports|finds) (an? )?offense/ => 'does not register an offense',
+          /\A(flags|handles|works)\b/ => 'does not register'
+        }.freeze
+
+        EXPECT_OFFENSE_DESCRIPTION_MAPPING = {
+          /\A(does not|doesn't) (register|find|flag|report)/ => 'registers',
+          /\A(does not|doesn't) add (a|an|any )?offense/ => 'registers an offense',
+          /\Aaccepts\b/ => 'registers'
+        }.freeze
 
-        EXPECT_OFFENSE_INCORRECT_DESCRIPTIONS = [
-          /^(does not|doesn't) (register|find|flag|report)/,
-          /^(does not|doesn't) add (a|an|any )?offense/
-        ].freeze
+        EXPECT_NO_CORRECTIONS_DESCRIPTION_MAPPING = {
+          /\A(auto[- ]?)?correct/ => 'does not correct'
+        }.freeze
 
-        EXPECT_NO_CORRECTIONS_INCORRECT_DESCRIPTIONS = [/^(auto[- ]?)?correct/].freeze
+        EXPECT_CORRECTION_DESCRIPTION_MAPPING = {
+          /\b(does not|doesn't) (auto[- ]?)?correct/ => 'autocorrects'
+        }.freeze
 
-        EXPECT_CORRECTION_INCORRECT_DESCRIPTIONS = [
-          /\b(does not|doesn't) (auto[- ]?)?correct/
-        ].freeze
+        EXAMPLE_DESCRIPTION_MAPPING = {
+          expect_no_offenses: EXPECT_NO_OFFENSES_DESCRIPTION_MAPPING,
+          expect_offense: EXPECT_OFFENSE_DESCRIPTION_MAPPING,
+          expect_no_corrections: EXPECT_NO_CORRECTIONS_DESCRIPTION_MAPPING,
+          expect_correction: EXPECT_CORRECTION_DESCRIPTION_MAPPING
+        }.freeze
 
         # @!method offense_example?(node)
         def_node_matcher :offense_example?, <<~PATTERN
@@ -66,21 +74,34 @@ module RuboCop
 
         def on_send(node)
           parent = node.each_ancestor(:block).first
-          return unless parent && (description = offense_example?(parent))
+          return unless parent && (current_description = offense_example?(parent))
 
           method_name = node.method_name
           message = format(MSG, method_name: method_name)
 
-          regexp_group = self.class.const_get("#{method_name}_incorrect_descriptions".upcase)
-          check_description(description, regexp_group, message)
+          description_map = EXAMPLE_DESCRIPTION_MAPPING[method_name]
+          check_description(current_description, description_map, message)
         end
 
         private
 
-        def check_description(description, regexps, message)
-          return unless regexps.any? { |regexp| regexp.match?(string_contents(description)) }
+        def check_description(current_description, description_map, message)
+          description_text = string_contents(current_description)
+          return unless (new_description = correct_description(description_text, description_map))
+
+          add_offense(current_description, message: message) do |corrector|
+            corrector.replace(current_description, "'#{new_description}'")
+          end
+        end
+
+        def correct_description(current_description, description_map)
+          description_map.each do |incorrect_description_pattern, preferred_description|
+            if incorrect_description_pattern.match?(current_description)
+              return current_description.gsub(incorrect_description_pattern, preferred_description)
+            end
+          end
 
-          add_offense(description, message: message)
+          nil
         end
 
         def string_contents(node)

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

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module InternalAffairs
+      # Use `RUBY` for heredoc delimiter of example Ruby code.
+      #
+      # Some editors may apply better syntax highlighting by using appropriate language names for
+      # the delimiter.
+      #
+      # @example
+      #  # bad
+      #  expect_offense(<<~CODE)
+      #    example_ruby_code
+      #  CODE
+      #
+      #  # good
+      #  expect_offense(<<~RUBY)
+      #    example_ruby_code
+      #  RUBY
+      class ExampleHeredocDelimiter < Base
+        extend AutoCorrector
+
+        EXPECTED_HEREDOC_DELIMITER = 'RUBY'
+
+        MSG = 'Use `RUBY` for heredoc delimiter of example Ruby code.'
+
+        RESTRICT_ON_SEND = %i[
+          expect_correction
+          expect_no_corrections
+          expect_no_offenses
+          expect_offense
+        ].freeze
+
+        # @param node [RuboCop::AST::SendNode]
+        # @return [void]
+        def on_send(node)
+          heredoc_node = heredoc_node_from(node)
+          return unless heredoc_node
+          return if expected_heredoc_delimiter?(heredoc_node)
+          return if expected_heredoc_delimiter_in_body?(heredoc_node)
+
+          add_offense(heredoc_node) do |corrector|
+            autocorrect(corrector, heredoc_node)
+          end
+        end
+
+        private
+
+        # @param corrector [RuboCop::Cop::Corrector]
+        # @param node [RuboCop::AST::StrNode]
+        # @return [void]
+        def autocorrect(corrector, node)
+          [
+            heredoc_opening_delimiter_range_from(node),
+            heredoc_closing_delimiter_range_from(node)
+          ].each do |range|
+            corrector.replace(range, EXPECTED_HEREDOC_DELIMITER)
+          end
+        end
+
+        # @param node [RuboCop::AST::StrNode]
+        # @return [Boolean]
+        def expected_heredoc_delimiter_in_body?(node)
+          node.location.heredoc_body.source.lines.any? do |line|
+            line.strip == EXPECTED_HEREDOC_DELIMITER
+          end
+        end
+
+        # @param node [RuboCop::AST::StrNode]
+        # @return [Boolean]
+        def expected_heredoc_delimiter?(node)
+          heredoc_delimiter_string_from(node) == EXPECTED_HEREDOC_DELIMITER
+        end
+
+        # @param node [RuboCop::AST::SendNode]
+        # @return [RuboCop::AST::StrNode, nil]
+        def heredoc_node_from(node)
+          return unless node.first_argument.respond_to?(:heredoc?)
+          return unless node.first_argument.heredoc?
+
+          node.first_argument
+        end
+
+        # @param node [RuboCop::AST::StrNode]
+        # @return [String]
+        def heredoc_delimiter_string_from(node)
+          node.source[Heredoc::OPENING_DELIMITER, 2]
+        end
+
+        # @param node [RuboCop::AST::StrNode]
+        # @return [Parser::Source::Range]
+        def heredoc_opening_delimiter_range_from(node)
+          match_data = node.source.match(Heredoc::OPENING_DELIMITER)
+          node.source_range.begin.adjust(
+            begin_pos: match_data.begin(2),
+            end_pos: match_data.end(2)
+          )
+        end
+
+        # @param node [RuboCop::AST::StrNode]
+        # @return [Parser::Source::Range]
+        def heredoc_closing_delimiter_range_from(node)
+          node.location.heredoc_end.end.adjust(
+            begin_pos: -heredoc_delimiter_string_from(node).length
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module InternalAffairs
-      # `RuboCop::Cop::Cop` is deprecated and will be removed in Rubocop 2.0.
+      # `RuboCop::Cop::Cop` is deprecated and will be removed in RuboCop 2.0.
       # Your custom cop class should inherit from `RuboCop::Cop::Base` instead of
       # `RuboCop::Cop::Cop`.
       #

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module InternalAffairs
+      # Enforces the use of `node.lambda_or_proc?` instead of `node.lambda? || node.proc?`.
+      #
+      # @example
+      #   # bad
+      #   node.lambda? || node.proc?
+      #   node.proc? || node.lambda?
+      #
+      #   # good
+      #   node.lambda_or_proc?
+      #
+      class LambdaOrProc < Base
+        extend AutoCorrector
+
+        MSG = 'Use `%<prefer>s`.'
+
+        # @!method lambda_or_proc(node)
+        def_node_matcher :lambda_or_proc, <<~PATTERN
+          {
+            (or $(send _node :lambda?) $(send _node :proc?))
+            (or $(send _node :proc?) $(send _node :lambda?))
+            (or
+              (or _ $(send _node :lambda?)) $(send _node :proc?))
+            (or
+              (or _ $(send _node :proc?)) $(send _node :lambda?))
+          }
+        PATTERN
+
+        def on_or(node)
+          return unless (lhs, rhs = lambda_or_proc(node))
+
+          offense = lhs.receiver.source_range.join(rhs.source_range.end)
+          prefer = "#{lhs.receiver.source}.lambda_or_proc?"
+
+          add_offense(offense, message: format(MSG, prefer: prefer)) do |corrector|
+            corrector.replace(offense, prefer)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module InternalAffairs
+      # Enforces the use of `node.source_range` instead of `node.location.expression`.
+      #
+      # @example
+      #
+      #   # bad
+      #   node.location.expression
+      #   node.loc.expression
+      #
+      #   # good
+      #   node.source_range
+      #
+      class LocationExpression < Base
+        extend AutoCorrector
+
+        MSG = 'Use `source_range` instead.'
+        RESTRICT_ON_SEND = %i[loc location].freeze
+
+        def on_send(node)
+          return unless (parent = node.parent)
+          return unless parent.send_type? && parent.method?(:expression)
+          return unless parent.receiver.receiver
+
+          offense = node.loc.selector.join(parent.source_range.end)
+
+          add_offense(offense) do |corrector|
+            corrector.replace(offense, 'source_range')
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -51,7 +51,9 @@ module RuboCop
 
         def extract_receiver(node)
           receiver = node.receiver
-          receiver = receiver.receiver if receiver.method?(:loc) || receiver.method?(:source_range)
+          if receiver.send_type? && (receiver.method?(:loc) || receiver.method?(:source_range))
+            receiver = receiver.receiver
+          end
           receiver.source
         end
       end

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

@@ -59,12 +59,12 @@ module RuboCop
         def method_directives(node)
           comments = processed_source.ast_with_comments[node]
 
-          comments.map do |comment|
+          comments.filter_map do |comment|
             match = comment.text.match(REGEXP)
             next unless match
 
             { node: comment, method_name: match[:method_name], args: match[:args] }
-          end.compact
+          end
         end
 
         def too_many_directives(node)
@@ -99,7 +99,7 @@ module RuboCop
           # If the pattern matcher uses arguments (`%1`, `%2`, etc.), include them in the directive
           arguments = pattern_arguments(node.arguments[1].source)
 
-          range = range_with_surrounding_space(node.loc.expression, side: :left, newlines: false)
+          range = range_with_surrounding_space(node.source_range, side: :left, newlines: false)
           indentation = range.source.match(/^\s*/)[0]
           directive = "#{indentation}# @!method #{actual_name}(#{arguments.join(', ')})\n"
           directive = "\n#{directive}" if add_newline?(node)
@@ -117,11 +117,11 @@ module RuboCop
         def add_newline?(node)
           # Determine if a blank line should be inserted before the new directive
           # in order to spread out pattern matchers
-          return if node.sibling_index&.zero?
-          return unless node.parent
+          return false if node.sibling_index&.zero?
+          return false unless node.parent
 
           prev_sibling = node.parent.child_nodes[node.sibling_index - 1]
-          return unless prev_sibling && pattern_matcher?(prev_sibling)
+          return false unless prev_sibling && pattern_matcher?(prev_sibling)
 
           node.loc.line == last_line(prev_sibling) + 1
         end

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

@@ -30,7 +30,7 @@ module RuboCop
 
             message = format(MSG, type: node_type)
             add_offense(node, message: message) do |corrector|
-              range = node.loc.expression.with(begin_pos: receiver.loc.expression.end_pos + 1)
+              range = node.source_range.with(begin_pos: receiver.source_range.end_pos + 1)
               corrector.replace(range, "#{node_type}_type?")
             end
           end

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

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module InternalAffairs
+      # Checks for missing `numblock handlers. The blocks with numbered
+      # arguments introduced in Ruby 2.7 are parsed with a node type of
+      # `numblock` instead of block. Cops that define `block` handlers
+      # need to define `numblock` handlers or disable this cope for them.
+      #
+      # @example
+      #
+      #   # bad
+      #   class BlockRelatedCop < Base
+      #     def on_block(node)
+      #     end
+      #   end
+      #
+      #   # good
+      #   class BlockRelatedCop < Base
+      #     def on_block(node)
+      #     end
+      #
+      #     alias on_numblock on_block
+      #   end
+      #
+      #   class BlockRelatedCop < Base
+      #     def on_block(node)
+      #     end
+      #
+      #     alias_method :on_numblock, :on_block
+      #   end
+      #
+      #   class BlockRelatedCop < Base
+      #     def on_block(node)
+      #     end
+      #
+      #     def on_numblock(node)
+      #     end
+      #   end
+      class NumblockHandler < Base
+        MSG = 'Define on_numblock to handle blocks with numbered arguments.'
+
+        def on_def(node)
+          return unless block_handler?(node)
+          return unless node.parent
+
+          add_offense(node) unless numblock_handler?(node.parent)
+        end
+
+        private
+
+        # @!method block_handler?(node)
+        def_node_matcher :block_handler?, <<~PATTERN
+          (def :on_block (args (arg :node)) ...)
+        PATTERN
+
+        # @!method numblock_handler?(node)
+        def_node_matcher :numblock_handler?, <<~PATTERN
+          {
+            `(def :on_numblock (args (arg :node)) ...)
+            `(alias (sym :on_numblock) (sym :on_block))
+            `(send nil? :alias_method (sym :on_numblock) (sym :on_block))
+          }
+        PATTERN
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module InternalAffairs
+      # Enforces the use of `processed_source.file_path` instead of `processed_source.buffer.name`.
+      #
+      # @example
+      #
+      #   # bad
+      #   processed_source.buffer.name
+      #
+      #   # good
+      #   processed_source.file_path
+      #
+      class ProcessedSourceBufferName < Base
+        extend AutoCorrector
+
+        MSG = 'Use `file_path` instead.'
+
+        RESTRICT_ON_SEND = %i[name].freeze
+
+        # @!method processed_source_buffer_name?(node)
+        def_node_matcher :processed_source_buffer_name?, <<~PATTERN
+          (send
+            (send
+              {(lvar :processed_source) (send nil? :processed_source)} :buffer) :name)
+        PATTERN
+
+        def on_send(node)
+          return unless processed_source_buffer_name?(node)
+
+          offense_range = node.children.first.loc.selector.begin.join(node.source_range.end)
+
+          add_offense(offense_range) do |corrector|
+            corrector.replace(offense_range, 'file_path')
+          end
+        end
+      end
+    end
+  end
+end