rubocop 1.30.1 → 1.64.0

data/lib/rubocop/cop/generator.rb

@@ -62,6 +62,10 @@ module RuboCop
                 # For example
                 MSG = 'Use `#good_method` instead of `#bad_method`.'
 
+                # TODO: Don't call `on_send` unless the method name is in this list
+                # If you don't need `on_send` in the cop you created, remove it.
+                RESTRICT_ON_SEND = %%i[bad_method].freeze
+
                 # @!method bad_method?(node)
                 def_node_matcher :bad_method?, <<~PATTERN
                   (send nil? :bad_method ...)
@@ -162,7 +166,7 @@ module RuboCop
         end
 
         dir = File.dirname(path)
-        FileUtils.mkdir_p(dir) unless File.exist?(dir)
+        FileUtils.mkdir_p(dir)
 
         File.write(path, contents)
         output.puts "[create] #{path}"
@@ -202,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,26 +37,37 @@ 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',
+          /\Aregisters no offense/ => 'registers an offense',
+          /\A(accepts|register)\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
+        # @!method offense_example(node)
+        def_node_matcher :offense_example, <<~PATTERN
           (block
-            (send _ {:it :specify} $_description)
+            (send _ {:it :specify} $...)
             _args
             `(send nil? %RESTRICT_ON_SEND ...)
           )
@@ -66,21 +75,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)&.first)
 
           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/method_name_end_with.rb

@@ -30,6 +30,7 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Use `%<method_name>s` instead of `%<method_suffix>s`.'
+        RESTRICT_ON_SEND = %i[end_with?].freeze
         SUGGEST_METHOD_FOR_SUFFIX = {
           '=' => 'assignment_method?',
           '!' => 'bang_method?',
@@ -51,14 +52,15 @@ module RuboCop
 
         def on_send(node)
           method_name_end_with?(node) do |method_name_node, end_with_arg|
+            next unless method_name_node.receiver
+
+            preferred_method = SUGGEST_METHOD_FOR_SUFFIX[end_with_arg.value]
             range = range(method_name_node, node)
-            message = format(
-              MSG,
-              method_name: SUGGEST_METHOD_FOR_SUFFIX[end_with_arg.value],
-              method_suffix: range.source
-            )
+            message = format(MSG, method_name: preferred_method, method_suffix: range.source)
 
-            add_offense(range, message: message)
+            add_offense(range, message: message) do |corrector|
+              corrector.replace(range, preferred_method)
+            end
           end
         end
         alias on_csend on_send

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

@@ -12,38 +12,37 @@ module RuboCop
       #   # good
       #   node.method?(:do_something)
       #
+      #   # bad
+      #   node.method_name != :do_something
+      #
+      #   # good
+      #   !node.method?(:do_something)
+      #
       class MethodNameEqual < Base
-        include RangeHelp
         extend AutoCorrector
 
-        MSG = 'Use `method?(%<method_name>s)` instead of `method_name == %<method_name>s`.'
-        RESTRICT_ON_SEND = %i[==].freeze
+        MSG = 'Use `%<prefer>s` instead.'
+        RESTRICT_ON_SEND = %i[== !=].freeze
 
-        # @!method method_name?(node)
-        def_node_matcher :method_name?, <<~PATTERN
+        # @!method method_name(node)
+        def_node_matcher :method_name, <<~PATTERN
           (send
-            $(send
-              (...) :method_name) :==
-            $...)
+            (send
+              (...) :method_name) {:== :!=}
+            $_)
         PATTERN
 
         def on_send(node)
-          method_name?(node) do |method_name_node, method_name_arg|
-            message = format(MSG, method_name: method_name_arg.first.source)
+          method_name(node) do |method_name_arg|
+            bang = node.method?(:!=) ? '!' : ''
+            prefer = "#{bang}#{node.receiver.receiver.source}.method?(#{method_name_arg.source})"
+            message = format(MSG, prefer: prefer)
 
-            range = range(method_name_node, node)
-
-            add_offense(range, message: message) do |corrector|
-              corrector.replace(range, "method?(#{method_name_arg.first.source})")
+            add_offense(node, message: message) do |corrector|
+              corrector.replace(node, prefer)
             end
           end
         end
-
-        private
-
-        def range(method_name_node, node)
-          range_between(method_name_node.loc.selector.begin_pos, node.source_range.end_pos)
-        end
       end
     end
   end

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

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module InternalAffairs
+      # Checks for the use of `node.arguments.first` or `node.arguments.last` and
+      # suggests the use of `node.first_argument` or `node.last_argument` instead.
+      #
+      # @example
+      #   # bad
+      #   node.arguments.first
+      #   node.arguments[0]
+      #   node.arguments.last
+      #   node.arguments[-1]
+      #
+      #   # good
+      #   node.first_argument
+      #   node.last_argument
+      #
+      class NodeFirstOrLastArgument < Base
+        extend AutoCorrector
+        include RangeHelp
+
+        MSG = 'Use `#%<correct>s` instead of `#%<incorrect>s`.'
+        RESTRICT_ON_SEND = %i[arguments].freeze
+
+        # @!method arguments_first_or_last?(node)
+        def_node_matcher :arguments_first_or_last?, <<~PATTERN
+          {
+            (send (send !nil? :arguments) ${:first :last})
+            (send (send !nil? :arguments) :[] (int ${0 -1}))
+          }
+        PATTERN
+
+        def on_send(node)
+          arguments_first_or_last?(node.parent) do |end_or_index|
+            range = range_between(node.loc.selector.begin_pos, node.parent.source_range.end_pos)
+            correct = case end_or_index
+                      when :first, 0 then 'first_argument'
+                      when :last, -1 then 'last_argument'
+                      else raise "Unknown end_or_index: #{end_or_index}"
+                      end
+            message = format(MSG, correct: correct, incorrect: range.source)
+
+            add_offense(range, message: message) do |corrector|
+              corrector.replace(range, correct)
+            end
+          end
+        end
+      end
+    end
+  end
+end