rubocop-minitest 0.4.0 → 0.6.1

data/lib/rubocop/cop/minitest/assert_truthy.rb

@@ -16,6 +16,8 @@ module RuboCop
       #   assert(actual, 'the message')
       #
       class AssertTruthy < Cop
+        include ArgumentRangeHelper
+
         MSG = 'Prefer using `assert(%<arguments>s)` over ' \
               '`assert_equal(true, %<arguments>s)`.'
 
@@ -35,9 +37,12 @@ module RuboCop
 
         def autocorrect(node)
           lambda do |corrector|
-            arguments = node.arguments.reject(&:true_type?)
-            replacement = arguments.map(&:source).join(', ')
-            corrector.replace(node.loc.expression, "assert(#{replacement})")
+            assert_equal_with_truthy(node) do |actual|
+              corrector.replace(node.loc.selector, 'assert')
+              corrector.replace(
+                first_and_second_arguments_range(node), actual.source
+              )
+            end
           end
         end
       end

data/lib/rubocop/cop/minitest/refute_empty.rb

@@ -16,6 +16,8 @@ module RuboCop
       #   refute_empty(object, 'the message')
       #
       class RefuteEmpty < Cop
+        include ArgumentRangeHelper
+
         MSG = 'Prefer using `refute_empty(%<arguments>s)` over ' \
               '`refute(%<receiver>s)`.'
 
@@ -37,11 +39,9 @@ module RuboCop
 
         def autocorrect(node)
           lambda do |corrector|
-            refute_with_empty(node) do |_first_receiver_arg, object, rest_receiver_arg|
-              message = rest_receiver_arg.first
-
-              replacement = [object.source, message&.source].compact.join(', ')
-              corrector.replace(node.loc.expression, "refute_empty(#{replacement})")
+            refute_with_empty(node) do |_, actual_arg|
+              corrector.replace(node.loc.selector, 'refute_empty')
+              corrector.replace(first_argument_range(node), actual_arg.source)
             end
           end
         end

data/lib/rubocop/cop/minitest/refute_equal.rb

@@ -15,6 +15,8 @@ module RuboCop
       #   refute_equal("rubocop-minitest", actual)
       #
       class RefuteEqual < Cop
+        include ArgumentRangeHelper
+
         MSG = 'Prefer using `refute_equal(%<preferred>s)` over ' \
               '`assert(%<over>s)`.'
 
@@ -32,20 +34,17 @@ module RuboCop
 
         def autocorrect(node)
           lambda do |corrector|
-            assert_not_equal(node) do |_, first_arg, second_arg, rest_args|
-              autocorrect_node(node, corrector, first_arg, second_arg, rest_args)
+            assert_not_equal(node) do |_, expected, actual|
+              corrector.replace(node.loc.selector, 'refute_equal')
+
+              replacement = [expected, actual].map(&:source).join(', ')
+              corrector.replace(first_argument_range(node), replacement)
             end
           end
         end
 
         private
 
-        def autocorrect_node(node, corrector, first_arg, second_arg, rest_args)
-          custom_message = rest_args.first
-          replacement = preferred_usage(first_arg, second_arg, custom_message)
-          corrector.replace(node.loc.expression, "refute_equal(#{replacement})")
-        end
-
         def preferred_usage(first_arg, second_arg, custom_message = nil)
           [first_arg, second_arg, custom_message]
             .compact.map(&:source).join(', ')

data/lib/rubocop/cop/minitest/refute_false.rb

@@ -11,33 +11,62 @@ module RuboCop
       #   assert_equal(false, actual)
       #   assert_equal(false, actual, 'the message')
       #
+      #   assert(!test)
+      #   assert(!test, 'the message')
+      #
       #   # good
       #   refute(actual)
       #   refute(actual, 'the message')
       #
       class RefuteFalse < Cop
-        MSG = 'Prefer using `refute(%<arguments>s)` over ' \
+        include ArgumentRangeHelper
+
+        MSG_FOR_ASSERT_EQUAL = 'Prefer using `refute(%<arguments>s)` over ' \
               '`assert_equal(false, %<arguments>s)`.'
+        MSG_FOR_ASSERT = 'Prefer using `refute(%<arguments>s)` over ' \
+              '`assert(!%<arguments>s)`.'
 
         def_node_matcher :assert_equal_with_false, <<~PATTERN
           (send nil? :assert_equal false $_ $...)
         PATTERN
 
+        def_node_matcher :assert_with_bang_argument, <<~PATTERN
+          (send nil? :assert (send $_ :!) $...)
+        PATTERN
+
         def on_send(node)
-          assert_equal_with_false(node) do |actual, rest_receiver_arg|
-            message = rest_receiver_arg.first
+          actual, rest_receiver_arg = assert_equal_with_false(node) ||
+                                      assert_with_bang_argument(node)
+          return unless actual
 
-            arguments = [actual.source, message&.source].compact.join(', ')
+          message_argument = rest_receiver_arg.first
 
-            add_offense(node, message: format(MSG, arguments: arguments))
-          end
+          arguments = [actual.source, message_argument&.source].compact.join(', ')
+
+          message = if node.method?(:assert_equal)
+                      MSG_FOR_ASSERT_EQUAL
+                    else
+                      MSG_FOR_ASSERT
+                    end
+
+          add_offense(node, message: format(message, arguments: arguments))
         end
 
         def autocorrect(node)
           lambda do |corrector|
-            arguments = node.arguments.reject(&:false_type?)
-            replacement = arguments.map(&:source).join(', ')
-            corrector.replace(node.loc.expression, "refute(#{replacement})")
+            corrector.replace(node.loc.selector, 'refute')
+
+            assert_equal_with_false(node) do |actual|
+              corrector.replace(
+                first_and_second_arguments_range(node), actual.source
+              )
+            end
+
+            assert_with_bang_argument(node) do |actual|
+              corrector.replace(
+                first_argument_range(node), actual.source
+              )
+            end
           end
         end
       end

data/lib/rubocop/cop/minitest/refute_includes.rb

@@ -16,44 +16,9 @@ module RuboCop
       #   refute_includes(collection, object, 'the message')
       #
       class RefuteIncludes < Cop
-        MSG = 'Prefer using `refute_includes(%<arguments>s)` over ' \
-              '`refute(%<receiver>s)`.'
+        extend IncludesCopRule
 
-        def_node_matcher :refute_with_includes, <<~PATTERN
-          (send nil? :refute $(send $_ :include? $_) $...)
-        PATTERN
-
-        def on_send(node)
-          refute_with_includes(node) do
-            |first_receiver_arg, collection, object, rest_receiver_arg|
-
-            message = rest_receiver_arg.first
-            arguments = node_arguments(collection, object, message)
-            receiver = [first_receiver_arg.source, message&.source].compact.join(', ')
-
-            offense_message = format(MSG, arguments: arguments, receiver: receiver)
-
-            add_offense(node, message: offense_message)
-          end
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
-            refute_with_includes(node) do
-              |_receiver, collection, object, rest_receiver_arg|
-
-              message = rest_receiver_arg.first
-              replacement = node_arguments(collection, object, message)
-              corrector.replace(node.loc.expression, "refute_includes(#{replacement})")
-            end
-          end
-        end
-
-        private
-
-        def node_arguments(collection, object, message)
-          [collection.source, object.source, message&.source].compact.join(', ')
-        end
+        rule target_method: :refute, prefer_method: :refute_includes
       end
     end
   end

data/lib/rubocop/cop/minitest/refute_instance_of.rb

@@ -16,6 +16,8 @@ module RuboCop
       #   refute_instance_of(Class, object, 'the message')
       #
       class RefuteInstanceOf < Cop
+        include ArgumentRangeHelper
+
         MSG = 'Prefer using `refute_instance_of(%<arguments>s)` over ' \
               '`refute(%<receiver>s)`.'
 
@@ -24,9 +26,7 @@ module RuboCop
         PATTERN
 
         def on_send(node)
-          refute_with_instance_of(node) do
-            |first_receiver_arg, object, method, rest_args|
-
+          refute_with_instance_of(node) do |first_receiver_arg, object, method, rest_args|
             message = rest_args.first
             arguments = node_arguments(object, method, message)
             receiver = [first_receiver_arg.source, message&.source].compact.join(', ')
@@ -39,12 +39,11 @@ module RuboCop
 
         def autocorrect(node)
           lambda do |corrector|
-            refute_with_instance_of(node) do |_, object, method, rest_args|
-              message = rest_args.first
-              arguments = node_arguments(object, method, message)
+            refute_with_instance_of(node) do |_, object, method|
+              corrector.replace(node.loc.selector, 'refute_instance_of')
 
-              replacement = "refute_instance_of(#{arguments})"
-              corrector.replace(node.loc.expression, replacement)
+              replacement = [method, object].map(&:source).join(', ')
+              corrector.replace(first_argument_range(node), replacement)
             end
           end
         end

data/lib/rubocop/cop/minitest/refute_match.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Minitest
+      # This cop enforces the test to use `refute_match`
+      # instead of using `refute(matcher.match(string))`.
+      #
+      # @example
+      #   # bad
+      #   refute(matcher.match(string))
+      #   refute(matcher.match(string), 'the message')
+      #
+      #   # good
+      #   refute_match(matcher, string)
+      #   refute_match(matcher, string, 'the message')
+      #
+      class RefuteMatch < Cop
+        include ArgumentRangeHelper
+
+        MSG = 'Prefer using `refute_match(%<arguments>s)` over ' \
+              '`refute(%<receiver>s)`.'
+
+        def_node_matcher :refute_with_match, <<~PATTERN
+          (send nil? :refute $(send $_ :match $_) $...)
+        PATTERN
+
+        def on_send(node)
+          refute_with_match(node) do
+            |first_receiver_arg, matcher, actual, rest_receiver_arg|
+            message = rest_receiver_arg.first
+            arguments = node_arguments(matcher, actual, message)
+            receiver = [first_receiver_arg.source, message&.source].compact.join(', ')
+
+            offense_message = format(MSG, arguments: arguments, receiver: receiver)
+
+            add_offense(node, message: offense_message)
+          end
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            refute_with_match(node) do |_, matcher, actual|
+              corrector.replace(node.loc.selector, 'refute_match')
+
+              replacement = [matcher, actual].map(&:source).join(', ')
+              corrector.replace(first_argument_range(node), replacement)
+            end
+          end
+        end
+
+        private
+
+        def node_arguments(matcher, actual, message)
+          [matcher.source, actual.source, message&.source].compact.join(', ')
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/minitest/refute_nil.rb

@@ -16,6 +16,8 @@ module RuboCop
       #   refute_nil(actual, 'the message')
       #
       class RefuteNil < Cop
+        include ArgumentRangeHelper
+
         MSG = 'Prefer using `refute_nil(%<arguments>s)` over ' \
               '`refute_equal(nil, %<arguments>s)`.'
 
@@ -35,9 +37,12 @@ module RuboCop
 
         def autocorrect(node)
           lambda do |corrector|
-            arguments = node.arguments.reject(&:nil_type?)
-            replacement = arguments.map(&:source).join(', ')
-            corrector.replace(node.loc.expression, "refute_nil(#{replacement})")
+            refute_equal_with_nil(node) do |actual|
+              corrector.replace(node.loc.selector, 'refute_nil')
+              corrector.replace(
+                first_and_second_arguments_range(node), actual.source
+              )
+            end
           end
         end
       end

data/lib/rubocop/cop/minitest/refute_respond_to.rb

@@ -10,12 +10,16 @@ module RuboCop
       #   # bad
       #   refute(object.respond_to?(:some_method))
       #   refute(object.respond_to?(:some_method), 'the message')
+      #   refute(respond_to?(:some_method))
       #
       #   # good
       #   refute_respond_to(object, :some_method)
       #   refute_respond_to(object, :some_method, 'the message')
+      #   refute_respond_to(self, :some_method)
       #
       class RefuteRespondTo < Cop
+        include ArgumentRangeHelper
+
         MSG = 'Prefer using `refute_respond_to(%<preferred>s)` over ' \
               '`refute(%<over>s)`.'
 
@@ -26,9 +30,8 @@ module RuboCop
         def on_send(node)
           refute_with_respond_to(node) do |over, object, method, rest_args|
             custom_message = rest_args.first
-            preferred = [object, method, custom_message]
-                        .compact.map(&:source).join(', ')
-            over      = [over, custom_message].compact.map(&:source).join(', ')
+            preferred = build_preferred_arguments(object, method, custom_message)
+            over = [over, custom_message].compact.map(&:source).join(', ')
             message = format(MSG, preferred: preferred, over: over)
             add_offense(node, message: message)
           end
@@ -36,15 +39,23 @@ module RuboCop
 
         def autocorrect(node)
           lambda do |corrector|
-            refute_with_respond_to(node) do |_, object, method, rest_args|
-              custom_message = rest_args.first
-              preferred = [object, method, custom_message]
-                          .compact.map(&:source).join(', ')
-              replacement = "refute_respond_to(#{preferred})"
-              corrector.replace(node.loc.expression, replacement)
+            refute_with_respond_to(node) do |_, object, method|
+              corrector.replace(node.loc.selector, 'refute_respond_to')
+
+              object = object ? object.source : 'self'
+              replacement = [object, method.source].join(', ')
+              corrector.replace(first_argument_range(node), replacement)
             end
           end
         end
+
+        private
+
+        def build_preferred_arguments(receiver, method, message)
+          receiver = receiver ? receiver.source : 'self'
+
+          [receiver, method.source, message&.source].compact.join(', ')
+        end
       end
     end
   end

data/lib/rubocop/cop/minitest_cops.rb

@@ -1,10 +1,14 @@
 # frozen_string_literal: true
 
+require_relative 'mixin/argument_range_helper'
+require_relative 'mixin/includes_cop_rule'
 require_relative 'minitest/assert_empty'
+require_relative 'minitest/assert_empty_literal'
 require_relative 'minitest/assert_equal'
 require_relative 'minitest/assert_nil'
 require_relative 'minitest/assert_includes'
 require_relative 'minitest/assert_instance_of'
+require_relative 'minitest/assert_match'
 require_relative 'minitest/assert_respond_to'
 require_relative 'minitest/assert_truthy'
 require_relative 'minitest/refute_empty'
@@ -12,5 +16,6 @@ require_relative 'minitest/refute_false'
 require_relative 'minitest/refute_equal'
 require_relative 'minitest/refute_nil'
 require_relative 'minitest/refute_includes'
+require_relative 'minitest/refute_match'
 require_relative 'minitest/refute_instance_of'
 require_relative 'minitest/refute_respond_to'

data/lib/rubocop/cop/mixin/argument_range_helper.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Methods that calculate and return `Parser::Source::Ranges`.
+    module ArgumentRangeHelper
+      include RangeHelp
+
+      private
+
+      def first_argument_range(node)
+        first_argument = node.first_argument
+
+        range_between(
+          first_argument.source_range.begin_pos,
+          first_argument.source_range.end_pos
+        )
+      end
+
+      def first_and_second_arguments_range(node)
+        first_argument = node.first_argument
+        second_argument = node.arguments[1]
+
+        range_between(
+          first_argument.source_range.begin_pos,
+          second_argument.source_range.end_pos
+        )
+      end
+    end
+  end
+end

data/lib/rubocop/cop/mixin/includes_cop_rule.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Define the rule for `Minitest/AssertIncludes` and `Minitest/RefuteIncludes` cops.
+    module IncludesCopRule
+      def rule(target_method:, prefer_method:)
+        class_eval(<<~RUBY, __FILE__, __LINE__ + 1)
+          include ArgumentRangeHelper
+
+          MSG = 'Prefer using `#{prefer_method}(%<new_arguments>s)` over ' \
+                '`#{target_method}(%<original_arguments>s)`.'
+
+          def on_send(node)
+            return unless node.method?(:#{target_method})
+            return unless (arguments = peel_redundant_parentheses_from(node.arguments))
+            return unless arguments.first.method?(:include?)
+
+            add_offense(node, message: offense_message(arguments))
+          end
+
+          def autocorrect(node)
+            lambda do |corrector|
+              corrector.replace(node.loc.selector, '#{prefer_method}')
+
+              arguments = peel_redundant_parentheses_from(node.arguments)
+
+              new_arguments = [
+                arguments.first.receiver.source,
+                arguments.first.arguments.map(&:source)
+              ].join(', ')
+
+              if enclosed_in_redundant_parentheses?(node)
+                new_arguments = '(' + new_arguments + ')'
+              end
+
+              corrector.replace(first_argument_range(node), new_arguments)
+            end
+          end
+
+          private
+
+          def peel_redundant_parentheses_from(arguments)
+            return arguments unless arguments.first.begin_type?
+
+            peel_redundant_parentheses_from(arguments.first.children)
+          end
+
+          def offense_message(arguments)
+            new_arguments = new_arguments(arguments)
+
+            original_arguments = arguments.map(&:source).join(', ')
+
+            format(
+              MSG,
+              new_arguments: new_arguments,
+              original_arguments: original_arguments
+            )
+          end
+
+          def new_arguments(arguments)
+            message_argument = arguments.last if arguments.first != arguments.last
+
+            [
+              arguments.first.receiver,
+              arguments.first.arguments.first,
+              message_argument
+            ].compact.map(&:source).join(', ')
+          end
+
+          def enclosed_in_redundant_parentheses?(node)
+            node.arguments.first.begin_type?
+          end
+        RUBY
+      end
+    end
+  end
+end