rubocop-minitest 0.6.2 → 0.7.0

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

@@ -9,14 +9,14 @@ module RuboCop
       # @example
       #   # bad
       #   assert_equal(false, actual)
-      #   assert_equal(false, actual, 'the message')
+      #   assert_equal(false, actual, 'message')
       #
       #   assert(!test)
-      #   assert(!test, 'the message')
+      #   assert(!test, 'message')
       #
       #   # good
       #   refute(actual)
-      #   refute(actual, 'the message')
+      #   refute(actual, 'message')
       #
       class RefuteFalse < Cop
         include ArgumentRangeHelper

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

@@ -9,16 +9,16 @@ module RuboCop
       # @example
       #   # bad
       #   refute(collection.include?(object))
-      #   refute(collection.include?(object), 'the message')
+      #   refute(collection.include?(object), 'message')
       #
       #   # good
       #   refute_includes(collection, object)
-      #   refute_includes(collection, object, 'the message')
+      #   refute_includes(collection, object, 'message')
       #
       class RefuteIncludes < Cop
-        extend IncludesCopRule
+        extend MinitestCopRule
 
-        rule target_method: :refute, prefer_method: :refute_includes
+        define_rule :refute, target_method: :include?, preferred_method: :refute_includes
       end
     end
   end

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

@@ -9,50 +9,16 @@ module RuboCop
       # @example
       #   # bad
       #   refute(object.instance_of?(Class))
-      #   refute(object.instance_of?(Class), 'the message')
+      #   refute(object.instance_of?(Class), 'message')
       #
       #   # good
       #   refute_instance_of(Class, object)
-      #   refute_instance_of(Class, object, 'the message')
+      #   refute_instance_of(Class, object, 'message')
       #
       class RefuteInstanceOf < Cop
-        include ArgumentRangeHelper
+        extend MinitestCopRule
 
-        MSG = 'Prefer using `refute_instance_of(%<arguments>s)` over ' \
-              '`refute(%<receiver>s)`.'
-
-        def_node_matcher :refute_with_instance_of, <<~PATTERN
-          (send nil? :refute $(send $_ :instance_of? $_) $...)
-        PATTERN
-
-        def on_send(node)
-          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(', ')
-
-            offense_message = format(MSG, arguments: arguments, receiver: receiver)
-
-            add_offense(node, message: offense_message)
-          end
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
-            refute_with_instance_of(node) do |_, object, method|
-              corrector.replace(node.loc.selector, 'refute_instance_of')
-
-              replacement = [method, object].map(&:source).join(', ')
-              corrector.replace(first_argument_range(node), replacement)
-            end
-          end
-        end
-
-        private
-
-        def node_arguments(object, method, message)
-          [method, object, message].compact.map(&:source).join(', ')
-        end
+        define_rule :refute, target_method: :instance_of?, inverse: true
       end
     end
   end

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

@@ -9,51 +9,16 @@ module RuboCop
       # @example
       #   # bad
       #   refute(matcher.match(string))
-      #   refute(matcher.match(string), 'the message')
+      #   refute(matcher.match(string), 'message')
       #
       #   # good
       #   refute_match(matcher, string)
-      #   refute_match(matcher, string, 'the message')
+      #   refute_match(matcher, string, 'message')
       #
       class RefuteMatch < Cop
-        include ArgumentRangeHelper
+        extend MinitestCopRule
 
-        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
+        define_rule :refute, target_method: :match
       end
     end
   end

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

@@ -9,11 +9,11 @@ module RuboCop
       # @example
       #   # bad
       #   refute_equal(nil, actual)
-      #   refute_equal(nil, actual, 'the message')
+      #   refute_equal(nil, actual, 'message')
       #
       #   # good
       #   refute_nil(actual)
-      #   refute_nil(actual, 'the message')
+      #   refute_nil(actual, 'message')
       #
       class RefuteNil < Cop
         include ArgumentRangeHelper

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

@@ -3,59 +3,24 @@
 module RuboCop
   module Cop
     module Minitest
-      # This cop enforces the test to use `refute_respond_to(object, :some_method)`
-      # over `refute(object.respond_to?(:some_method))`.
+      # This cop enforces the test to use `refute_respond_to(object, :do_something)`
+      # over `refute(object.respond_to?(:do_something))`.
       #
       # @example
       #   # bad
-      #   refute(object.respond_to?(:some_method))
-      #   refute(object.respond_to?(:some_method), 'the message')
-      #   refute(respond_to?(:some_method))
+      #   refute(object.respond_to?(:do_something))
+      #   refute(object.respond_to?(:do_something), 'message')
+      #   refute(respond_to?(:do_something))
       #
       #   # good
-      #   refute_respond_to(object, :some_method)
-      #   refute_respond_to(object, :some_method, 'the message')
-      #   refute_respond_to(self, :some_method)
+      #   refute_respond_to(object, :do_something)
+      #   refute_respond_to(object, :do_something, 'message')
+      #   refute_respond_to(self, :do_something)
       #
       class RefuteRespondTo < Cop
-        include ArgumentRangeHelper
+        extend MinitestCopRule
 
-        MSG = 'Prefer using `refute_respond_to(%<preferred>s)` over ' \
-              '`refute(%<over>s)`.'
-
-        def_node_matcher :refute_with_respond_to, <<~PATTERN
-          (send nil? :refute $(send $_ :respond_to? $_) $...)
-        PATTERN
-
-        def on_send(node)
-          refute_with_respond_to(node) do |over, object, method, rest_args|
-            custom_message = rest_args.first
-            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
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
-            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
+        define_rule :refute, target_method: :respond_to?
       end
     end
   end

data/lib/rubocop/cop/minitest_cops.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require_relative 'mixin/argument_range_helper'
-require_relative 'mixin/includes_cop_rule'
+require_relative 'mixin/minitest_cop_rule'
 require_relative 'minitest/assert_empty'
 require_relative 'minitest/assert_empty_literal'
 require_relative 'minitest/assert_equal'
@@ -11,6 +11,7 @@ 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/global_expectations'
 require_relative 'minitest/refute_empty'
 require_relative 'minitest/refute_false'
 require_relative 'minitest/refute_equal'

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

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Provide a method to define offense rule for Minitest cops.
+    module MinitestCopRule
+      #
+      # Define offense rule for Minitest cops.
+      #
+      # @example
+      #   define_rule :assert, target_method: :match
+      #   define_rule :refute, target_method: :match
+      #   define_rule :assert, target_method: :include?, preferred_method: :assert_includes
+      #   define_rule :assert, target_method: :instance_of?, inverse: true
+      #
+      # @param assertion_method [Symbol] Assertion method like `assert` or `refute`.
+      # @param target_method [Symbol] Method name offensed by assertion method arguments.
+      # @param preferred_method [Symbol] An optional param. Custom method name replaced by
+      #                                  auto-correction. The preferred method name that connects
+      #                                  `assertion_method` and `target_method` with `_` is
+      #                                  the default name.
+      # @param inverse [Boolean] An optional param. Order of arguments replaced by auto-correction.
+      #
+      def define_rule(assertion_method, target_method:, preferred_method: nil, inverse: false)
+        if preferred_method.nil?
+          preferred_method = "#{assertion_method}_#{target_method.to_s.delete('?')}"
+        end
+
+        class_eval(<<~RUBY, __FILE__, __LINE__ + 1)
+          include ArgumentRangeHelper
+
+          MSG = 'Prefer using `#{preferred_method}(%<new_arguments>s)` over ' \
+                '`#{assertion_method}(%<original_arguments>s)`.'
+
+          def on_send(node)
+            return unless node.method?(:#{assertion_method})
+            return unless (arguments = peel_redundant_parentheses_from(node.arguments))
+            return unless arguments.first.respond_to?(:method?) && arguments.first.method?(:#{target_method})
+
+            add_offense(node, message: offense_message(arguments))
+          end
+
+          def autocorrect(node)
+            lambda do |corrector|
+              corrector.replace(node.loc.selector, '#{preferred_method}')
+
+              arguments = peel_redundant_parentheses_from(node.arguments)
+
+              new_arguments = new_arguments(arguments).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)
+            message_argument = arguments.last if arguments.first != arguments.last
+
+            new_arguments = [
+              new_arguments(arguments),
+              message_argument&.source
+            ].flatten.compact.join(', ')
+
+            original_arguments = arguments.map(&:source).join(', ')
+
+            format(
+              MSG,
+              new_arguments: new_arguments,
+              original_arguments: original_arguments
+            )
+          end
+
+          def new_arguments(arguments)
+            receiver = correct_receiver(arguments.first.receiver)
+            method_argument = arguments.first.arguments.first&.source
+
+            new_arguments = [receiver, method_argument].compact
+            new_arguments.reverse! if #{inverse}
+            new_arguments
+          end
+
+          def enclosed_in_redundant_parentheses?(node)
+            node.arguments.first.begin_type?
+          end
+
+          def correct_receiver(receiver)
+            receiver ? receiver.source : 'self'
+          end
+        RUBY
+      end
+    end
+  end
+end

data/lib/rubocop/minitest/version.rb

@@ -2,6 +2,6 @@
 
 module RuboCop
   module Minitest
-    VERSION = '0.6.2'
+    VERSION = '0.7.0'
   end
 end

data/manual/cops.md

@@ -10,6 +10,7 @@
 * [Minitest/AssertNil](cops_minitest.md#minitestassertnil)
 * [Minitest/AssertRespondTo](cops_minitest.md#minitestassertrespondto)
 * [Minitest/AssertTruthy](cops_minitest.md#minitestasserttruthy)
+* [Minitest/GlobalExpectations](cops_minitest.md#minitestglobalexpectations)
 * [Minitest/RefuteEmpty](cops_minitest.md#minitestrefuteempty)
 * [Minitest/RefuteEqual](cops_minitest.md#minitestrefuteequal)
 * [Minitest/RefuteFalse](cops_minitest.md#minitestrefutefalse)

data/manual/cops_minitest.md

@@ -14,11 +14,11 @@ instead of using `assert(object.empty?)`.
 ```ruby
 # bad
 assert(object.empty?)
-assert(object.empty?, 'the message')
+assert(object.empty?, 'message')
 
 # good
 assert_empty(object)
-assert_empty(object, 'the message')
+assert_empty(object, 'message')
 ```
 
 ### References
@@ -82,11 +82,11 @@ instead of using `assert(collection.include?(object))`.
 ```ruby
 # bad
 assert(collection.include?(object))
-assert(collection.include?(object), 'the message')
+assert(collection.include?(object), 'message')
 
 # good
 assert_includes(collection, object)
-assert_includes(collection, object, 'the message')
+assert_includes(collection, object, 'message')
 ```
 
 ### References
@@ -107,11 +107,11 @@ over `assert(object.instance_of?(Class))`.
 ```ruby
 # bad
 assert(object.instance_of?(Class))
-assert(object.instance_of?(Class), 'the message')
+assert(object.instance_of?(Class), 'message')
 
 # good
 assert_instance_of(Class, object)
-assert_instance_of(Class, object, 'the message')
+assert_instance_of(Class, object, 'message')
 ```
 
 ### References
@@ -132,11 +132,11 @@ instead of using `assert(matcher.match(string))`.
 ```ruby
 # bad
 assert(matcher.match(string))
-assert(matcher.match(string), 'the message')
+assert(matcher.match(string), 'message')
 
 # good
 assert_match(regex, string)
-assert_match(matcher, string, 'the message')
+assert_match(matcher, string, 'message')
 ```
 
 ### References
@@ -157,11 +157,11 @@ instead of using `assert_equal(nil, something)`.
 ```ruby
 # bad
 assert_equal(nil, actual)
-assert_equal(nil, actual, 'the message')
+assert_equal(nil, actual, 'message')
 
 # good
 assert_nil(actual)
-assert_nil(actual, 'the message')
+assert_nil(actual, 'message')
 ```
 
 ### References
@@ -174,21 +174,21 @@ Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChan
 --- | --- | --- | --- | ---
 Enabled | Yes | Yes  | 0.3 | -
 
-This cop enforces the use of `assert_respond_to(object, :some_method)`
-over `assert(object.respond_to?(:some_method))`.
+This cop enforces the use of `assert_respond_to(object, :do_something)`
+over `assert(object.respond_to?(:do_something))`.
 
 ### Examples
 
 ```ruby
 # bad
-assert(object.respond_to?(:some_method))
-assert(object.respond_to?(:some_method), 'the message')
-assert(respond_to?(:some_method))
+assert(object.respond_to?(:do_something))
+assert(object.respond_to?(:do_something), 'message')
+assert(respond_to?(:do_something))
 
 # good
-assert_respond_to(object, :some_method)
-assert_respond_to(object, :some_method, 'the message')
-assert_respond_to(self, some_method)
+assert_respond_to(object, :do_something)
+assert_respond_to(object, :do_something, 'message')
+assert_respond_to(self, :do_something)
 ```
 
 ### References
@@ -209,17 +209,38 @@ instead of using `assert_equal(true, actual)`.
 ```ruby
 # bad
 assert_equal(true, actual)
-assert_equal(true, actual, 'the message')
+assert_equal(true, actual, 'message')
 
 # good
 assert(actual)
-assert(actual, 'the message')
+assert(actual, 'message')
 ```
 
 ### References
 
 * [https://github.com/rubocop-hq/minitest-style-guide#assert-truthy](https://github.com/rubocop-hq/minitest-style-guide#assert-truthy)
 
+## Minitest/GlobalExpectations
+
+Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
+--- | --- | --- | --- | ---
+Enabled | Yes | Yes  | 0.7 | -
+
+This Cop checks for deprecated global expectations
+and autocorrects them to use expect format.
+
+### Examples
+
+```ruby
+# bad
+n.must_equal 42
+n.wont_match b
+
+# good
+_(n).must_equal 42
+_(n).wont_match b
+```
+
 ## Minitest/RefuteEmpty
 
 Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
@@ -234,11 +255,11 @@ using `refute(object.empty?)`.
 ```ruby
 # bad
 refute(object.empty?)
-refute(object.empty?, 'the message')
+refute(object.empty?, 'message')
 
 # good
 refute_empty(object)
-refute_empty(object, 'the message')
+refute_empty(object, 'message')
 ```
 
 ### References
@@ -283,14 +304,14 @@ over `assert_equal(false, object)`.
 ```ruby
 # bad
 assert_equal(false, actual)
-assert_equal(false, actual, 'the message')
+assert_equal(false, actual, 'message')
 
 assert(!test)
-assert(!test, 'the message')
+assert(!test, 'message')
 
 # good
 refute(actual)
-refute(actual, 'the message')
+refute(actual, 'message')
 ```
 
 ### References
@@ -311,11 +332,11 @@ instead of using `refute(collection.include?(object))`.
 ```ruby
 # bad
 refute(collection.include?(object))
-refute(collection.include?(object), 'the message')
+refute(collection.include?(object), 'message')
 
 # good
 refute_includes(collection, object)
-refute_includes(collection, object, 'the message')
+refute_includes(collection, object, 'message')
 ```
 
 ### References
@@ -336,11 +357,11 @@ over `refute(object.instance_of?(Class))`.
 ```ruby
 # bad
 refute(object.instance_of?(Class))
-refute(object.instance_of?(Class), 'the message')
+refute(object.instance_of?(Class), 'message')
 
 # good
 refute_instance_of(Class, object)
-refute_instance_of(Class, object, 'the message')
+refute_instance_of(Class, object, 'message')
 ```
 
 ### References
@@ -361,11 +382,11 @@ instead of using `refute(matcher.match(string))`.
 ```ruby
 # bad
 refute(matcher.match(string))
-refute(matcher.match(string), 'the message')
+refute(matcher.match(string), 'message')
 
 # good
 refute_match(matcher, string)
-refute_match(matcher, string, 'the message')
+refute_match(matcher, string, 'message')
 ```
 
 ### References
@@ -386,11 +407,11 @@ instead of using `refute_equal(nil, something)`.
 ```ruby
 # bad
 refute_equal(nil, actual)
-refute_equal(nil, actual, 'the message')
+refute_equal(nil, actual, 'message')
 
 # good
 refute_nil(actual)
-refute_nil(actual, 'the message')
+refute_nil(actual, 'message')
 ```
 
 ### References
@@ -403,21 +424,21 @@ Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChan
 --- | --- | --- | --- | ---
 Enabled | Yes | Yes  | 0.4 | -
 
-This cop enforces the test to use `refute_respond_to(object, :some_method)`
-over `refute(object.respond_to?(:some_method))`.
+This cop enforces the test to use `refute_respond_to(object, :do_something)`
+over `refute(object.respond_to?(:do_something))`.
 
 ### Examples
 
 ```ruby
 # bad
-refute(object.respond_to?(:some_method))
-refute(object.respond_to?(:some_method), 'the message')
-refute(respond_to?(:some_method))
+refute(object.respond_to?(:do_something))
+refute(object.respond_to?(:do_something), 'message')
+refute(respond_to?(:do_something))
 
 # good
-refute_respond_to(object, :some_method)
-refute_respond_to(object, :some_method, 'the message')
-refute_respond_to(self, :some_method)
+refute_respond_to(object, :do_something)
+refute_respond_to(object, :do_something, 'message')
+refute_respond_to(self, :do_something)
 ```
 
 ### References