rubocop 1.29.1 → 1.46.0

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

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module InternalAffairs
+      # Enforces the cop description to start with a word such as verb.
+      #
+      # @example
+      #   # bad
+      #   # This cop checks ....
+      #   class SomeCop < Base
+      #     ....
+      #   end
+      #
+      #   # good
+      #   # Checks ...
+      #   class SomeCop < Base
+      #     ...
+      #   end
+      #
+      class CopDescription < Base
+        extend AutoCorrector
+
+        MSG = 'Description should be started with %<suggestion>s instead of `This cop ...`.'
+
+        SPECIAL_WORDS = %w[is can could should will would must may].freeze
+        COP_DESC_OFFENSE_REGEX = \
+          /^\s+# This cop (?<special>#{SPECIAL_WORDS.join('|')})?\s*(?<word>.+?) .*/.freeze
+        REPLACEMENT_REGEX = /^\s+# This cop (#{SPECIAL_WORDS.join('|')})?\s*(.+?) /.freeze
+
+        # rubocop:disable Metrics/CyclomaticComplexity
+        def on_class(node)
+          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
+
+          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)
+
+          add_offense(range, message: message) do |corrector|
+            if suggestion && !start_with_subject['special']
+              replace_with_suggestion(corrector, range, suggestion, description_beginning)
+            end
+          end
+        end
+        # rubocop:enable Metrics/CyclomaticComplexity
+
+        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
+
+          begin_pos = node.loc.expression.begin_pos
+          begin_pos += comment_index(node, comment_line)
+          end_pos = begin_pos + comment_body(comment_line).length
+
+          Parser::Source::Range.new(source_buffer, begin_pos, end_pos)
+        end
+
+        def suggestion_for_message(suggestion, match_data)
+          if suggestion && !match_data['special']
+            "`#{suggestion}`"
+          else
+            'a word such as verb'
+          end
+        end
+
+        def first_comment_line(node)
+          node.loc.expression.source.lines.find { |line| comment_line?(line) }
+        end
+
+        def comment_body(comment_line)
+          comment_line.gsub(/^\s*# /, '')
+        end
+
+        def comment_index(node, comment_line)
+          body = comment_body(comment_line)
+          node.loc.expression.source.index(body)
+        end
+
+        def relevant_file?(file)
+          file.match?(%r{/cop/.*\.rb\z})
+        end
+      end
+    end
+  end
+end

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/empty_line_between_expect_offense_and_correction.rb

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module InternalAffairs
-      # This cop checks whether `expect_offense` and correction expectation methods
+      # Checks whether `expect_offense` and correction expectation methods
       # (i.e. `expect_correction` and `expect_no_corrections`) are separated by empty line.
       #
       # @example

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_openning_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_openning_delimiter_range_from(node)
+          match_data = node.source.match(Heredoc::OPENING_DELIMITER)
+          node.location.expression.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/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_line_equality_comparison.rb

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module InternalAffairs
-      # This cop enforces the use of `same_line?` instead of location line comparison for equality.
+      # Enforces the use of `same_line?` instead of location line comparison for equality.
       #
       # @example
       #   # bad

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module InternalAffairs
-      # This cop checks potentially usage of method identifier predicates
+      # Checks potentially usage of method identifier predicates
       # defined in rubocop-ast instead of `method_name.end_with?`.
       #
       # @example

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

@@ -99,11 +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(
-            range: node.loc.expression,
-            side: :left,
-            newlines: false
-          )
+          range = range_with_surrounding_space(node.loc.expression, 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)

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.loc.expression.end)
+
+          add_offense(offense_range) do |corrector|
+            corrector.replace(offense_range, 'file_path')
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module InternalAffairs
-      # This cop checks for redundant `subject(:cop) { described_class.new }`.
+      # Checks for redundant `subject(:cop) { described_class.new }`.
       #
       # @example
       #   # bad

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module InternalAffairs
-      # This cop checks that `let` is `RuboCop::Config.new` with no arguments.
+      # Checks that `let` is `RuboCop::Config.new` with no arguments.
       #
       # @example
       #   # bad
@@ -31,9 +31,17 @@ module RuboCop
             (send nil? :let
               (sym :config))
             (args)
-            (send
-              (const
-                (const nil? :RuboCop) :Config) :new))
+            {
+              (send
+                (const
+                  (const nil? :RuboCop) :Config) :new)
+              (send
+                (const
+                  (const nil? :RuboCop) :Config) :new
+                    (hash (pair (send (send (send nil? :described_class) :badge) :to_s)
+                      (send nil? :cop_config))))
+            }
+          )
         PATTERN
 
         def on_block(node)

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

@@ -43,7 +43,7 @@ module RuboCop
         private
 
         def offending_range(node)
-          with_space = range_with_surrounding_space(range: node.loc.expression)
+          with_space = range_with_surrounding_space(node.loc.expression)
 
           range_with_surrounding_comma(with_space, :left)
         end

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

@@ -56,7 +56,7 @@ module RuboCop
         private
 
         def offending_range(node)
-          with_space = range_with_surrounding_space(range: node.loc.expression)
+          with_space = range_with_surrounding_space(node.loc.expression)
 
           range_with_surrounding_comma(with_space, :left)
         end

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

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module InternalAffairs
+      # Enforces the use of `node.single_line?` instead of
+      # comparing `first_line` and `last_line` for equality.
+      #
+      # @example
+      #   # bad
+      #   node.loc.first_line == node.loc.last_line
+      #
+      #   # bad
+      #   node.loc.last_line == node.loc.first_line
+      #
+      #   # bad
+      #   node.loc.line == node.loc.last_line
+      #
+      #   # bad
+      #   node.loc.last_line == node.loc.line
+      #
+      #   # bad
+      #   node.first_line == node.last_line
+      #
+      #   # good
+      #   node.single_line?
+      #
+      class SingleLineComparison < Base
+        extend AutoCorrector
+
+        MSG = 'Use `%<preferred>s`.'
+        RESTRICT_ON_SEND = %i[== !=].freeze
+
+        # @!method single_line_comparison(node)
+        def_node_matcher :single_line_comparison, <<~PATTERN
+          {
+            (send (send $_receiver {:line :first_line}) {:== :!=} (send _receiver :last_line))
+            (send (send $_receiver :last_line) {:== :!=} (send _receiver {:line :first_line}))
+          }
+        PATTERN
+
+        def on_send(node)
+          return unless (receiver = single_line_comparison(node))
+
+          bang = node.method?(:!=) ? '!' : ''
+          preferred = "#{bang}#{extract_receiver(receiver)}.single_line?"
+
+          add_offense(node, message: format(MSG, preferred: preferred)) do |corrector|
+            corrector.replace(node, preferred)
+          end
+        end
+
+        private
+
+        def extract_receiver(node)
+          node = node.receiver if node.send_type? && %i[loc source_range].include?(node.method_name)
+          node.source
+        end
+      end
+    end
+  end
+end

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,21 +1,29 @@
 # 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_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_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_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/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'