rubocop-rspec 2.27.1 → 2.29.0

data/lib/rubocop/cop/rspec/rails/inferred_spec_type.rb

@@ -4,141 +4,58 @@ module RuboCop
   module Cop
     module RSpec
       module Rails
-        # Identifies redundant spec type.
-        #
-        # After setting up rspec-rails, you will have enabled
-        # `config.infer_spec_type_from_file_location!` by default in
-        # spec/rails_helper.rb. This cop works in conjunction with this config.
-        # If you disable this config, disable this cop as well.
-        #
-        # @safety
-        #   This cop is marked as unsafe because
-        #   `config.infer_spec_type_from_file_location!` may not be enabled.
-        #
-        # @example
-        #   # bad
-        #   # spec/models/user_spec.rb
-        #   RSpec.describe User, type: :model do
-        #   end
-        #
-        #   # good
-        #   # spec/models/user_spec.rb
-        #   RSpec.describe User do
-        #   end
-        #
-        #   # good
-        #   # spec/models/user_spec.rb
-        #   RSpec.describe User, type: :common do
-        #   end
-        #
-        # @example `Inferences` configuration
-        #   # .rubocop.yml
-        #   # RSpec/Rails/InferredSpecType:
-        #   #   Inferences:
-        #   #     services: service
-        #
-        #   # bad
-        #   # spec/services/user_spec.rb
-        #   RSpec.describe User, type: :service do
-        #   end
-        #
-        #   # good
-        #   # spec/services/user_spec.rb
-        #   RSpec.describe User do
-        #   end
-        #
-        #   # good
-        #   # spec/services/user_spec.rb
-        #   RSpec.describe User, type: :common do
-        #   end
-        class InferredSpecType < Base
-          extend AutoCorrector
-
-          MSG = 'Remove redundant spec type.'
-
-          # @param [RuboCop::AST::BlockNode] node
-          def on_block(node)
-            return unless example_group?(node)
-
-            pair_node = describe_with_type(node)
-            return unless pair_node
-            return unless inferred_type?(pair_node)
-
-            removable_node = detect_removable_node(pair_node)
-            add_offense(removable_node) do |corrector|
-              autocorrect(corrector, removable_node)
-            end
-          end
-          alias on_numblock on_block
-
-          private
-
-          # @!method describe_with_type(node)
-          #   @param [RuboCop::AST::BlockNode] node
-          #   @return [RuboCop::AST::PairNode, nil]
-          def_node_matcher :describe_with_type, <<~PATTERN
-            (block
-              (send #rspec? #ExampleGroups.all
-                ...
-                (hash <$(pair (sym :type) sym) ...>)
-              )
-              ...
-            )
-          PATTERN
-
-          # @param [RuboCop::AST::Corrector] corrector
-          # @param [RuboCop::AST::Node] node
-          def autocorrect(corrector, node)
-            corrector.remove(remove_range(node))
-          end
-
-          # @param [RuboCop::AST::Node] node
-          # @return [Parser::Source::Range]
-          def remove_range(node)
-            if node.left_sibling
-              node.source_range.with(
-                begin_pos: node.left_sibling.source_range.end_pos
-              )
-            elsif node.right_sibling
-              node.source_range.with(
-                end_pos: node.right_sibling.source_range.begin_pos
-              )
-            end
-          end
-
-          # @param [RuboCop::AST::PairNode] node
-          # @return [RuboCop::AST::Node]
-          def detect_removable_node(node)
-            if node.parent.pairs.size == 1
-              node.parent
-            else
-              node
-            end
-          end
-
-          # @return [String]
-          def file_path
-            processed_source.file_path
-          end
-
-          # @param [RuboCop::AST::PairNode] node
-          # @return [Boolean]
-          def inferred_type?(node)
-            inferred_type_from_file_path.inspect == node.value.source
-          end
-
-          # @return [Symbol, nil]
-          def inferred_type_from_file_path
-            inferences.find do |prefix, type|
-              break type.to_sym if file_path.include?("spec/#{prefix}/")
-            end
-          end
-
-          # @return [Hash]
-          def inferences
-            cop_config['Inferences'] || {}
-          end
-        end
+        # @!parse
+        #   # Identifies redundant spec type.
+        #   #
+        #   # After setting up rspec-rails, you will have enabled
+        #   # `config.infer_spec_type_from_file_location!` by default in
+        #   # spec/rails_helper.rb. This cop works in conjunction with
+        #   # this config.
+        #   # If you disable this config, disable this cop as well.
+        #   #
+        #   # @safety
+        #   #   This cop is marked as unsafe because
+        #   #   `config.infer_spec_type_from_file_location!` may not be enabled.
+        #   #
+        #   # @example
+        #   #   # bad
+        #   #   # spec/models/user_spec.rb
+        #   #   RSpec.describe User, type: :model do
+        #   #   end
+        #   #
+        #   #   # good
+        #   #   # spec/models/user_spec.rb
+        #   #   RSpec.describe User do
+        #   #   end
+        #   #
+        #   #   # good
+        #   #   # spec/models/user_spec.rb
+        #   #   RSpec.describe User, type: :common do
+        #   #   end
+        #   #
+        #   # @example `Inferences` configuration
+        #   #   # .rubocop.yml
+        #   #   # RSpec/Rails/InferredSpecType:
+        #   #   #   Inferences:
+        #   #   #     services: service
+        #   #
+        #   #   # bad
+        #   #   # spec/services/user_spec.rb
+        #   #   RSpec.describe User, type: :service do
+        #   #   end
+        #   #
+        #   #   # good
+        #   #   # spec/services/user_spec.rb
+        #   #   RSpec.describe User do
+        #   #   end
+        #   #
+        #   #   # good
+        #   #   # spec/services/user_spec.rb
+        #   #   RSpec.describe User, type: :common do
+        #   #   end
+        #   #
+        #   class InferredSpecType < RuboCop::Cop::RSpec::Base; end
+        InferredSpecType = ::RuboCop::Cop::RSpecRails::InferredSpecType
       end
     end
   end

data/lib/rubocop/cop/rspec/rails/minitest_assertions.rb

@@ -4,348 +4,35 @@ module RuboCop
   module Cop
     module RSpec
       module Rails
-        # Check if using Minitest-like matchers.
-        #
-        # Check the use of minitest-like matchers
-        # starting with `assert_` or `refute_`.
-        #
-        # @example
-        #   # bad
-        #   assert_equal(a, b)
-        #   assert_equal a, b, "must be equal"
-        #   assert_not_includes a, b
-        #   refute_equal(a, b)
-        #   assert_nil a
-        #   refute_empty(b)
-        #   assert_true(a)
-        #   assert_false(a)
-        #
-        #   # good
-        #   expect(b).to eq(a)
-        #   expect(b).to(eq(a), "must be equal")
-        #   expect(a).not_to include(b)
-        #   expect(b).not_to eq(a)
-        #   expect(a).to eq(nil)
-        #   expect(a).not_to be_empty
-        #   expect(a).to be(true)
-        #   expect(a).to be(false)
-        #
-        class MinitestAssertions < Base
-          extend AutoCorrector
-
-          # :nodoc:
-          class BasicAssertion
-            extend NodePattern::Macros
-
-            attr_reader :expected, :actual, :failure_message
-
-            def self.minitest_assertion
-              raise NotImplementedError
-            end
-
-            def initialize(expected, actual, failure_message)
-              @expected = expected&.source
-              @actual = actual.source
-              @failure_message = failure_message&.source
-            end
-
-            def replaced(node)
-              runner = negated?(node) ? 'not_to' : 'to'
-              if failure_message.nil?
-                "expect(#{actual}).#{runner} #{assertion}"
-              else
-                "expect(#{actual}).#{runner}(#{assertion}, #{failure_message})"
-              end
-            end
-
-            def negated?(node)
-              node.method_name.start_with?('assert_not_', 'refute_')
-            end
-
-            def assertion
-              raise NotImplementedError
-            end
-          end
-
-          # :nodoc:
-          class EqualAssertion < BasicAssertion
-            MATCHERS = %i[
-              assert_equal
-              assert_not_equal
-              refute_equal
-            ].freeze
-
-            # @!method self.minitest_assertion(node)
-            def_node_matcher 'self.minitest_assertion', <<~PATTERN # rubocop:disable InternalAffairs/NodeMatcherDirective
-              (send nil? {:assert_equal :assert_not_equal :refute_equal} $_ $_ $_?)
-            PATTERN
-
-            def self.match(expected, actual, failure_message)
-              new(expected, actual, failure_message.first)
-            end
-
-            def assertion
-              "eq(#{expected})"
-            end
-          end
-
-          # :nodoc:
-          class KindOfAssertion < BasicAssertion
-            MATCHERS = %i[
-              assert_kind_of
-              assert_not_kind_of
-              refute_kind_of
-            ].freeze
-
-            # @!method self.minitest_assertion(node)
-            def_node_matcher 'self.minitest_assertion', <<~PATTERN # rubocop:disable InternalAffairs/NodeMatcherDirective
-              (send nil? {:assert_kind_of :assert_not_kind_of :refute_kind_of} $_ $_ $_?)
-            PATTERN
-
-            def self.match(expected, actual, failure_message)
-              new(expected, actual, failure_message.first)
-            end
-
-            def assertion
-              "be_a_kind_of(#{expected})"
-            end
-          end
-
-          # :nodoc:
-          class InstanceOfAssertion < BasicAssertion
-            MATCHERS = %i[
-              assert_instance_of
-              assert_not_instance_of
-              refute_instance_of
-            ].freeze
-
-            # @!method self.minitest_assertion(node)
-            def_node_matcher 'self.minitest_assertion', <<~PATTERN # rubocop:disable InternalAffairs/NodeMatcherDirective
-              (send nil? {:assert_instance_of :assert_not_instance_of :refute_instance_of} $_ $_ $_?)
-            PATTERN
-
-            def self.match(expected, actual, failure_message)
-              new(expected, actual, failure_message.first)
-            end
-
-            def assertion
-              "be_an_instance_of(#{expected})"
-            end
-          end
-
-          # :nodoc:
-          class IncludesAssertion < BasicAssertion
-            MATCHERS = %i[
-              assert_includes
-              assert_not_includes
-              refute_includes
-            ].freeze
-
-            # @!method self.minitest_assertion(node)
-            def_node_matcher 'self.minitest_assertion', <<~PATTERN # rubocop:disable InternalAffairs/NodeMatcherDirective
-              (send nil? {:assert_includes :assert_not_includes :refute_includes} $_ $_ $_?)
-            PATTERN
-
-            def self.match(collection, expected, failure_message)
-              new(expected, collection, failure_message.first)
-            end
-
-            def assertion
-              "include(#{expected})"
-            end
-          end
-
-          # :nodoc:
-          class InDeltaAssertion < BasicAssertion
-            MATCHERS = %i[
-              assert_in_delta
-              assert_not_in_delta
-              refute_in_delta
-            ].freeze
-
-            # @!method self.minitest_assertion(node)
-            def_node_matcher 'self.minitest_assertion', <<~PATTERN # rubocop:disable InternalAffairs/NodeMatcherDirective
-              (send nil? {:assert_in_delta :assert_not_in_delta :refute_in_delta} $_ $_ $_? $_?)
-            PATTERN
-
-            def self.match(expected, actual, delta, failure_message)
-              new(expected, actual, delta.first, failure_message.first)
-            end
-
-            def initialize(expected, actual, delta, fail_message)
-              super(expected, actual, fail_message)
-
-              @delta = delta&.source || '0.001'
-            end
-
-            def assertion
-              "be_within(#{@delta}).of(#{expected})"
-            end
-          end
-
-          # :nodoc:
-          class PredicateAssertion < BasicAssertion
-            MATCHERS = %i[
-              assert_predicate
-              assert_not_predicate
-              refute_predicate
-            ].freeze
-
-            # @!method self.minitest_assertion(node)
-            def_node_matcher 'self.minitest_assertion', <<~PATTERN # rubocop:disable InternalAffairs/NodeMatcherDirective
-              (send nil? {:assert_predicate :assert_not_predicate :refute_predicate} $_ ${sym} $_?)
-            PATTERN
-
-            def self.match(subject, predicate, failure_message)
-              return nil unless predicate.value.end_with?('?')
-
-              new(predicate, subject, failure_message.first)
-            end
-
-            def assertion
-              "be_#{expected.delete_prefix(':').delete_suffix('?')}"
-            end
-          end
-
-          # :nodoc:
-          class MatchAssertion < BasicAssertion
-            MATCHERS = %i[
-              assert_match
-              refute_match
-            ].freeze
-
-            # @!method self.minitest_assertion(node)
-            def_node_matcher 'self.minitest_assertion', <<~PATTERN # rubocop:disable InternalAffairs/NodeMatcherDirective
-              (send nil? {:assert_match :refute_match} $_ $_ $_?)
-            PATTERN
-
-            def self.match(matcher, actual, failure_message)
-              new(matcher, actual, failure_message.first)
-            end
-
-            def assertion
-              "match(#{expected})"
-            end
-          end
-
-          # :nodoc:
-          class NilAssertion < BasicAssertion
-            MATCHERS = %i[
-              assert_nil
-              assert_not_nil
-              refute_nil
-            ].freeze
-
-            # @!method self.minitest_assertion(node)
-            def_node_matcher 'self.minitest_assertion', <<~PATTERN # rubocop:disable InternalAffairs/NodeMatcherDirective
-              (send nil? {:assert_nil :assert_not_nil :refute_nil} $_ $_?)
-            PATTERN
-
-            def self.match(actual, failure_message)
-              new(nil, actual, failure_message.first)
-            end
-
-            def assertion
-              'eq(nil)'
-            end
-          end
-
-          # :nodoc:
-          class EmptyAssertion < BasicAssertion
-            MATCHERS = %i[
-              assert_empty
-              assert_not_empty
-              refute_empty
-            ].freeze
-
-            # @!method self.minitest_assertion(node)
-            def_node_matcher 'self.minitest_assertion', <<~PATTERN # rubocop:disable InternalAffairs/NodeMatcherDirective
-              (send nil? {:assert_empty :assert_not_empty :refute_empty} $_ $_?)
-            PATTERN
-
-            def self.match(actual, failure_message)
-              new(nil, actual, failure_message.first)
-            end
-
-            def assertion
-              'be_empty'
-            end
-          end
-
-          # :nodoc:
-          class TrueAssertion < BasicAssertion
-            MATCHERS = %i[
-              assert_true
-            ].freeze
-
-            # @!method self.minitest_assertion(node)
-            def_node_matcher 'self.minitest_assertion', <<~PATTERN # rubocop:disable InternalAffairs/NodeMatcherDirective
-              (send nil? {:assert_true} $_ $_?)
-            PATTERN
-
-            def self.match(actual, failure_message)
-              new(nil, actual, failure_message.first)
-            end
-
-            def assertion
-              'be(true)'
-            end
-          end
-
-          # :nodoc:
-          class FalseAssertion < BasicAssertion
-            MATCHERS = %i[
-              assert_false
-            ].freeze
-
-            # @!method self.minitest_assertion(node)
-            def_node_matcher 'self.minitest_assertion', <<~PATTERN # rubocop:disable InternalAffairs/NodeMatcherDirective
-              (send nil? {:assert_false} $_ $_?)
-            PATTERN
-
-            def self.match(actual, failure_message)
-              new(nil, actual, failure_message.first)
-            end
-
-            def assertion
-              'be(false)'
-            end
-          end
-
-          MSG = 'Use `%<prefer>s`.'
-
-          # TODO: replace with `BasicAssertion.subclasses` in Ruby 3.1+
-          ASSERTION_MATCHERS = constants(false).filter_map do |c|
-            const = const_get(c)
-
-            const if const.is_a?(Class) && const.superclass == BasicAssertion
-          end
-
-          RESTRICT_ON_SEND = ASSERTION_MATCHERS.flat_map { |m| m::MATCHERS }
-
-          def on_send(node)
-            ASSERTION_MATCHERS.each do |m|
-              m.minitest_assertion(node) do |*args|
-                assertion = m.match(*args)
-
-                next if assertion.nil?
-
-                on_assertion(node, assertion)
-              end
-            end
-          end
-
-          def on_assertion(node, assertion)
-            preferred = assertion.replaced(node)
-            add_offense(node, message: message(preferred)) do |corrector|
-              corrector.replace(node, preferred)
-            end
-          end
-
-          def message(preferred)
-            format(MSG, prefer: preferred)
-          end
-        end
+        # @!parse
+        #   # Check if using Minitest-like matchers.
+        #   #
+        #   # Check the use of minitest-like matchers
+        #   # starting with `assert_` or `refute_`.
+        #   #
+        #   # @example
+        #   #   # bad
+        #   #   assert_equal(a, b)
+        #   #   assert_equal a, b, "must be equal"
+        #   #   assert_not_includes a, b
+        #   #   refute_equal(a, b)
+        #   #   assert_nil a
+        #   #   refute_empty(b)
+        #   #   assert_true(a)
+        #   #   assert_false(a)
+        #   #
+        #   #   # good
+        #   #   expect(b).to eq(a)
+        #   #   expect(b).to(eq(a), "must be equal")
+        #   #   expect(a).not_to include(b)
+        #   #   expect(b).not_to eq(a)
+        #   #   expect(a).to eq(nil)
+        #   #   expect(a).not_to be_empty
+        #   #   expect(a).to be(true)
+        #   #   expect(a).to be(false)
+        #   #
+        #   class MinitestAssertions < RuboCop::Cop::RSpec::Base; end
+        MinitestAssertions = ::RuboCop::Cop::RSpecRails::MinitestAssertions
       end
     end
   end