rubocop-rspec 2.27.1 → 2.28.0

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::RSpecRails::Base; end
+        MinitestAssertions = ::RuboCop::Cop::RSpecRails::MinitestAssertions
       end
     end
   end

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

@@ -4,98 +4,35 @@ module RuboCop
   module Cop
     module RSpec
       module Rails
-        # Enforces use of `be_invalid` or `not_to` for negated be_valid.
-        #
-        # @safety
-        #   This cop is unsafe because it cannot guarantee that
-        #   the test target is an instance of `ActiveModel::Validations``.
-        #
-        # @example EnforcedStyle: not_to (default)
-        #   # bad
-        #   expect(foo).to be_invalid
-        #
-        #   # good
-        #   expect(foo).not_to be_valid
-        #
-        #   # good (with method chain)
-        #   expect(foo).to be_invalid.and be_odd
-        #
-        # @example EnforcedStyle: be_invalid
-        #   # bad
-        #   expect(foo).not_to be_valid
-        #
-        #   # good
-        #   expect(foo).to be_invalid
-        #
-        #   # good (with method chain)
-        #   expect(foo).to be_invalid.or be_even
-        #
-        class NegationBeValid < Base
-          extend AutoCorrector
-          include ConfigurableEnforcedStyle
-
-          MSG = 'Use `expect(...).%<runner>s %<matcher>s`.'
-          RESTRICT_ON_SEND = %i[be_valid be_invalid].freeze
-
-          # @!method not_to?(node)
-          def_node_matcher :not_to?, <<~PATTERN
-            (send ... :not_to (send nil? :be_valid ...))
-          PATTERN
-
-          # @!method be_invalid?(node)
-          def_node_matcher :be_invalid?, <<~PATTERN
-            (send ... :to (send nil? :be_invalid ...))
-          PATTERN
-
-          def on_send(node)
-            return unless offense?(node.parent)
-
-            add_offense(offense_range(node),
-                        message: message(node.method_name)) do |corrector|
-              corrector.replace(node.parent.loc.selector, replaced_runner)
-              corrector.replace(node.loc.selector, replaced_matcher)
-            end
-          end
-
-          private
-
-          def offense?(node)
-            case style
-            when :not_to
-              be_invalid?(node)
-            when :be_invalid
-              not_to?(node)
-            end
-          end
-
-          def offense_range(node)
-            node.parent.loc.selector.with(end_pos: node.loc.selector.end_pos)
-          end
-
-          def message(_matcher)
-            format(MSG,
-                   runner: replaced_runner,
-                   matcher: replaced_matcher)
-          end
-
-          def replaced_runner
-            case style
-            when :not_to
-              'not_to'
-            when :be_invalid
-              'to'
-            end
-          end
-
-          def replaced_matcher
-            case style
-            when :not_to
-              'be_valid'
-            when :be_invalid
-              'be_invalid'
-            end
-          end
-        end
+        # @!parse
+        #   # Enforces use of `be_invalid` or `not_to` for negated be_valid.
+        #   #
+        #   # @safety
+        #   #   This cop is unsafe because it cannot guarantee that
+        #   #   the test target is an instance of `ActiveModel::Validations``.
+        #   #
+        #   # @example EnforcedStyle: not_to (default)
+        #   #   # bad
+        #   #   expect(foo).to be_invalid
+        #   #
+        #   #   # good
+        #   #   expect(foo).not_to be_valid
+        #   #
+        #   #   # good (with method chain)
+        #   #   expect(foo).to be_invalid.and be_odd
+        #   #
+        #   # @example EnforcedStyle: be_invalid
+        #   #   # bad
+        #   #   expect(foo).not_to be_valid
+        #   #
+        #   #   # good
+        #   #   expect(foo).to be_invalid
+        #   #
+        #   #   # good (with method chain)
+        #   #   expect(foo).to be_invalid.or be_even
+        #   #
+        #   class NegationBeValid < RuboCop::Cop::RSpecRails::Base; end
+        NegationBeValid = ::RuboCop::Cop::RSpecRails::NegationBeValid
       end
     end
   end

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

@@ -4,88 +4,30 @@ module RuboCop
   module Cop
     module RSpec
       module Rails
-        # Prefer to travel in `before` rather than `around`.
-        #
-        # @safety
-        #   This cop is unsafe because the automatic `travel_back` is only run
-        #   on test cases that are considered as Rails related.
-        #
-        #   And also, this cop's autocorrection is unsafe because the order of
-        #   execution will change if other steps exist before traveling in
-        #   `around`.
-        #
-        # @example
-        #   # bad
-        #   around do |example|
-        #     freeze_time do
-        #       example.run
-        #     end
-        #   end
-        #
-        #   # good
-        #   before { freeze_time }
-        class TravelAround < Base
-          extend AutoCorrector
-
-          MSG = 'Prefer to travel in `before` rather than `around`.'
-
-          TRAVEL_METHOD_NAMES = %i[
-            freeze_time
-            travel
-            travel_to
-          ].to_set.freeze
-
-          # @!method extract_run_in_travel(node)
-          def_node_matcher :extract_run_in_travel, <<~PATTERN
-            (block
-              $(send nil? TRAVEL_METHOD_NAMES ...)
-              (args ...)
-              (send _ :run)
-            )
-          PATTERN
-
-          # @!method match_around_each?(node)
-          def_node_matcher :match_around_each?, <<~PATTERN
-            (block
-              (send _ :around (sym :each)?)
-              ...
-            )
-          PATTERN
-
-          def on_block(node)
-            run_node = extract_run_in_travel(node)
-            return unless run_node
-
-            around_node = extract_surrounding_around_block(run_node)
-            return unless around_node
-
-            add_offense(node) do |corrector|
-              autocorrect(corrector, node, run_node, around_node)
-            end
-          end
-          alias on_numblock on_block
-
-          private
-
-          def autocorrect(corrector, node, run_node, around_node)
-            corrector.replace(
-              node,
-              node.body.source
-            )
-            corrector.insert_before(
-              around_node,
-              "before { #{run_node.source} }\n\n"
-            )
-          end
-
-          # @param node [RuboCop::AST::BlockNode]
-          # @return [RuboCop::AST::BlockNode, nil]
-          def extract_surrounding_around_block(node)
-            node.each_ancestor(:block).find do |ancestor|
-              match_around_each?(ancestor)
-            end
-          end
-        end
+        # @!parse
+        #   # Prefer to travel in `before` rather than `around`.
+        #   #
+        #   # @safety
+        #   #   This cop is unsafe because the automatic `travel_back` is only
+        #   #   run on test cases that are considered as Rails related.
+        #   #
+        #   #   And also, this cop's autocorrection is unsafe because the order
+        #   #   of execution will change if other steps exist before traveling
+        #   #   in `around`.
+        #   #
+        #   # @example
+        #   #   # bad
+        #   #   around do |example|
+        #   #     freeze_time do
+        #   #       example.run
+        #   #     end
+        #   #   end
+        #   #
+        #   #   # good
+        #   #   before { freeze_time }
+        #   #
+        #   class TravelAround < RuboCop::Cop::RSpecRails::Base; end
+        TravelAround = ::RuboCop::Cop::RSpecRails::TravelAround
       end
     end
   end

data/lib/rubocop/cop/rspec_cops.rb

@@ -18,14 +18,10 @@ require_relative 'rspec/factory_bot/syntax_methods'
 
 require_relative 'rspec/rails/avoid_setup_hook'
 require_relative 'rspec/rails/have_http_status'
-require_relative 'rspec/rails/negation_be_valid'
-begin
-  require_relative 'rspec/rails/http_status'
-rescue LoadError
-  # Rails/HttpStatus cannot be loaded if rack/utils is unavailable.
-end
+require_relative 'rspec/rails/http_status'
 require_relative 'rspec/rails/inferred_spec_type'
 require_relative 'rspec/rails/minitest_assertions'
+require_relative 'rspec/rails/negation_be_valid'
 require_relative 'rspec/rails/travel_around'
 
 require_relative 'rspec/align_left_let_brace'

data/lib/rubocop/rspec/config_formatter.rb

@@ -22,6 +22,13 @@ module RuboCop
         RSpec/FactoryBot/FactoryClassName
         RSpec/FactoryBot/FactoryNameStyle
         RSpec/FactoryBot/SyntaxMethods
+        RSpec/Rails/AvoidSetupHook
+        RSpec/Rails/HaveHttpStatus
+        RSpec/Rails/HttpStatus
+        RSpec/Rails/InferredSpecType
+        RSpec/Rails/MinitestAssertions
+        RSpec/Rails/NegationBeValid
+        RSpec/Rails/TravelAround
       )
       AMENDMENTS = %(Metrics/BlockLength)
       COP_DOC_BASE_URL = 'https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/'

data/lib/rubocop/rspec/version.rb

@@ -4,7 +4,7 @@ module RuboCop
   module RSpec
     # Version information for the RSpec RuboCop plugin.
     module Version
-      STRING = '2.27.1'
+      STRING = '2.28.0'
     end
   end
 end

data/lib/rubocop-rspec.rb

@@ -39,6 +39,9 @@ require_relative 'rubocop/rspec/example'
 require_relative 'rubocop/rspec/example_group'
 require_relative 'rubocop/rspec/hook'
 
+# need after `require 'rubocop/cop/rspec/base'``
+require 'rubocop-rspec_rails'
+
 RuboCop::RSpec::Inject.defaults!
 
 require_relative 'rubocop/cop/rspec_cops'