rubocop-minitest 0.2.1

data/Rakefile

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'bundler'
+require 'bundler/gem_tasks'
+
+Dir['tasks/**/*.rake'].each { |t| load t }
+
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  warn e.message
+  warn 'Run `bundle install` to install missing gems'
+  exit e.status_code
+end
+
+require 'rubocop/rake_task'
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs << 'test'
+  t.libs << 'lib'
+  t.test_files = FileList['test/**/*_test.rb']
+end
+
+desc 'Run RuboCop over itself'
+RuboCop::RakeTask.new(:internal_investigation).tap do |task|
+  if RUBY_ENGINE == 'ruby' &&
+     RbConfig::CONFIG['host_os'] !~ /mswin|msys|mingw|cygwin|bccwin|wince|emc/
+    task.options = %w[--parallel]
+  end
+end
+
+task default: %i[
+  documentation_syntax_check
+  generate_cops_documentation
+  test
+  internal_investigation
+]

data/bin/console

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'rubocop/minitest'
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require 'irb'
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/config/default.yml

@@ -0,0 +1,33 @@
+Minitest:
+  Include:
+    - '**/test/**/*'
+
+Minitest/AssertNil:
+  Description: 'Check if your test uses `assert_nil` instead of `assert_equal(nil, something)`.'
+  StyleGuide: 'https://github.com/rubocop-hq/minitest-style-guide#assert-nil'
+  Enabled: true
+  VersionAdded: '0.1'
+
+Minitest/AssertEmpty:
+  Description: 'Check if your test uses `assert_empty` instead of `assert(actual.empty?)`.'
+  StyleGuide: 'https://github.com/rubocop-hq/minitest-style-guide#assert-empty'
+  Enabled: true
+  VersionAdded: '0.2'
+
+Minitest/AssertIncludes:
+  Description: 'Check if your test uses `assert_includes` instead of `assert(collection.includes?(actual))`.'
+  StyleGuide: 'https://github.com/rubocop-hq/minitest-style-guide#assert-includes'
+  Enabled: true
+  VersionAdded: '0.2'
+
+Minitest/AssertTruthy:
+  Description: 'Check if your test uses `assert(actual)` instead of `assert_equal(true, actual)`.'
+  StyleGuide: 'https://github.com/rubocop-hq/minitest-style-guide#assert-truthy'
+  Enabled: true
+  VersionAdded: '0.2'
+
+Minitest/RefuteNil:
+  Description: 'Check if your test uses `refute_nil` instead of `refute_equal(nil, something)`.'
+  StyleGuide: 'https://github.com/rubocop-hq/minitest-style-guide#refute-nil'
+  Enabled: true
+  VersionAdded: '0.2'

data/lib/rubocop-minitest.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require 'pathname'
+require 'yaml'
+
+require 'rubocop'
+
+require_relative 'rubocop/minitest'
+require_relative 'rubocop/minitest/version'
+require_relative 'rubocop/minitest/inject'
+
+RuboCop::Minitest::Inject.defaults!
+
+require_relative 'rubocop/cop/minitest_cops'

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Minitest
+      # Check if your test uses `assert_empty` instead of `assert(actual.empty?)`.
+      #
+      # @example
+      #   # bad
+      #   assert(actual.empty?)
+      #   assert(actual.empty?, 'the message')
+      #
+      #   # good
+      #   assert_empty(actual)
+      #   assert_empty(actual, 'the message')
+      #
+      class AssertEmpty < Cop
+        MSG = 'Prefer using `assert_empty(%<arguments>s)` over ' \
+              '`assert(%<receiver>s)`.'
+
+        def_node_matcher :assert_with_empty, <<~PATTERN
+          (send nil? :assert $(send $_ :empty?) $...)
+        PATTERN
+
+        def on_send(node)
+          assert_with_empty(node) do |first_receiver_arg, actual, rest_receiver_arg|
+            message = rest_receiver_arg.first
+
+            arguments = [actual.source, message&.source].compact.join(', ')
+            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|
+            assert_with_empty(node) do |_first_receiver_arg, actual, rest_receiver_arg|
+              message = rest_receiver_arg.first
+
+              replacement = [actual.source, message&.source].compact.join(', ')
+              corrector.replace(node.loc.expression, "assert_empty(#{replacement})")
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Minitest
+      # Check if your test uses `assert_includes`
+      # instead of `assert(collection.includes?(actual))`.
+      #
+      # @example
+      #   # bad
+      #   assert(collection.includes?(actual))
+      #   assert(collection.includes?(actual), 'the message')
+      #
+      #   # good
+      #   assert_includes(collection, actual)
+      #   assert_includes(collection, actual, 'the message')
+      #
+      class AssertIncludes < Cop
+        MSG = 'Prefer using `assert_includes(%<arguments>s)` over ' \
+              '`assert(%<receiver>s)`.'
+
+        def_node_matcher :assert_with_includes, <<~PATTERN
+          (send nil? :assert $(send $_ :includes? $_) $...)
+        PATTERN
+
+        def on_send(node)
+          assert_with_includes(node) do
+            |first_receiver_arg, collection, actual, rest_receiver_arg|
+
+            message = rest_receiver_arg.first
+            arguments = node_arguments(collection, 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|
+            assert_with_includes(node) do
+              |_receiver, collection, actual, rest_receiver_arg|
+
+              message = rest_receiver_arg.first
+              replacement = node_arguments(collection, actual, message)
+              corrector.replace(node.loc.expression, "assert_includes(#{replacement})")
+            end
+          end
+        end
+
+        private
+
+        def node_arguments(collection, actual, message)
+          [collection.source, actual.source, message&.source].compact.join(', ')
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Minitest
+      # Check if your test uses `assert_nil` instead of `assert_equal(nil, something)`.
+      #
+      # @example
+      #   # bad
+      #   assert_equal(nil, actual)
+      #   assert_equal(nil, actual, 'the message')
+      #
+      #   # good
+      #   assert_nil(actual)
+      #   assert_nil(actual, 'the message')
+      #
+      class AssertNil < Cop
+        MSG = 'Prefer using `assert_nil(%<arguments>s)` over ' \
+              '`assert_equal(nil, %<arguments>s)`.'
+
+        def_node_matcher :assert_equal_with_nil, <<~PATTERN
+          (send nil? :assert_equal nil $_ $...)
+        PATTERN
+
+        def on_send(node)
+          assert_equal_with_nil(node) do |actual, message|
+            message = message.first
+
+            arguments = [actual.source, message&.source].compact.join(', ')
+
+            add_offense(node, message: format(MSG, arguments: arguments))
+          end
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            arguments = node.arguments.reject(&:nil_type?)
+            replacement = arguments.map(&:source).join(', ')
+            corrector.replace(node.loc.expression, "assert_nil(#{replacement})")
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Minitest
+      # Check if your test uses `assert(actual)`
+      # instead of `assert_equal(true, actual)`.
+      #
+      # @example
+      #   # bad
+      #   assert_equal(true, actual)
+      #   assert_equal(true, actual, 'the message')
+      #
+      #   # good
+      #   assert(actual)
+      #   assert(actual, 'the message')
+      #
+      class AssertTruthy < Cop
+        MSG = 'Prefer using `assert(%<arguments>s)` over ' \
+              '`assert_equal(true, %<arguments>s)`.'
+
+        def_node_matcher :assert_equal_with_truthy, <<~PATTERN
+          (send nil? :assert_equal true $_ $...)
+        PATTERN
+
+        def on_send(node)
+          assert_equal_with_truthy(node) do |actual, rest_receiver_arg|
+            message = rest_receiver_arg.first
+
+            arguments = [actual.source, message&.source].compact.join(', ')
+
+            add_offense(node, message: format(MSG, arguments: arguments))
+          end
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            arguments = node.arguments.reject(&:true_type?)
+            replacement = arguments.map(&:source).join(', ')
+            corrector.replace(node.loc.expression, "assert(#{replacement})")
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Minitest
+      # Check if your test uses `refute_nil` instead of `refute_equal(nil, something)`.
+      #
+      # @example
+      #   # bad
+      #   refute_equal(nil, actual)
+      #   refute_equal(nil, actual, 'the message')
+      #
+      #   # good
+      #   refute_nil(actual)
+      #   refute_nil(actual, 'the message')
+      #
+      class RefuteNil < Cop
+        MSG = 'Prefer using `refute_nil(%<arguments>s)` over ' \
+              '`refute_equal(nil, %<arguments>s)`.'
+
+        def_node_matcher :refute_equal_with_nil, <<~PATTERN
+          (send nil? :refute_equal nil $_ $...)
+        PATTERN
+
+        def on_send(node)
+          refute_equal_with_nil(node) do |actual, message|
+            message = message.first
+
+            arguments = [actual.source, message&.source].compact.join(', ')
+
+            add_offense(node, message: format(MSG, arguments: arguments))
+          end
+        end
+
+        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})")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/minitest_cops.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require_relative 'minitest/assert_empty'
+require_relative 'minitest/assert_nil'
+require_relative 'minitest/assert_includes'
+require_relative 'minitest/assert_truthy'
+require_relative 'minitest/refute_nil'

data/lib/rubocop/minitest.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module RuboCop
+  # RuboCop minitest project namespace
+  module Minitest
+    PROJECT_ROOT   = Pathname.new(__dir__).parent.parent.expand_path.freeze
+    CONFIG_DEFAULT = PROJECT_ROOT.join('config', 'default.yml').freeze
+    CONFIG         = YAML.safe_load(CONFIG_DEFAULT.read).freeze
+
+    private_constant(:CONFIG_DEFAULT, :PROJECT_ROOT)
+  end
+end

data/lib/rubocop/minitest/inject.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Minitest
+    # Because RuboCop doesn't yet support plugins, we have to monkey patch in a
+    # bit of our configuration.
+    module Inject
+      def self.defaults!
+        path = CONFIG_DEFAULT.to_s
+        hash = ConfigLoader.send(:load_yaml_configuration, path)
+        config = Config.new(hash, path)
+        puts "configuration from #{path}" if ConfigLoader.debug?
+        config = ConfigLoader.merge_with_default(config, path)
+        ConfigLoader.instance_variable_set(:@default_configuration, config)
+      end
+    end
+  end
+end

data/lib/rubocop/minitest/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Minitest
+    VERSION = '0.2.1'
+  end
+end

data/manual/cops.md

@@ -0,0 +1,10 @@
+<!-- START_COP_LIST -->
+#### Department [Minitest](cops_minitest.md)
+
+* [Minitest/AssertEmpty](cops_minitest.md#minitestassertempty)
+* [Minitest/AssertIncludes](cops_minitest.md#minitestassertincludes)
+* [Minitest/AssertNil](cops_minitest.md#minitestassertnil)
+* [Minitest/AssertTruthy](cops_minitest.md#minitestasserttruthy)
+* [Minitest/RefuteNil](cops_minitest.md#minitestrefutenil)
+
+<!-- END_COP_LIST -->

data/manual/cops_minitest.md

@@ -0,0 +1,123 @@
+# Minitest
+
+## Minitest/AssertEmpty
+
+Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
+--- | --- | --- | --- | ---
+Enabled | Yes | Yes  | 0.2 | -
+
+Check if your test uses `assert_empty` instead of `assert(actual.empty?)`.
+
+### Examples
+
+```ruby
+# bad
+assert(actual.empty?)
+assert(actual.empty?, 'the message')
+
+# good
+assert_empty(actual)
+assert_empty(actual, 'the message')
+```
+
+### References
+
+* [https://github.com/rubocop-hq/minitest-style-guide#assert-empty](https://github.com/rubocop-hq/minitest-style-guide#assert-empty)
+
+## Minitest/AssertIncludes
+
+Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
+--- | --- | --- | --- | ---
+Enabled | Yes | Yes  | 0.2 | -
+
+Check if your test uses `assert_includes`
+instead of `assert(collection.includes?(actual))`.
+
+### Examples
+
+```ruby
+# bad
+assert(collection.includes?(actual))
+assert(collection.includes?(actual), 'the message')
+
+# good
+assert_includes(collection, actual)
+assert_includes(collection, actual, 'the message')
+```
+
+### References
+
+* [https://github.com/rubocop-hq/minitest-style-guide#assert-includes](https://github.com/rubocop-hq/minitest-style-guide#assert-includes)
+
+## Minitest/AssertNil
+
+Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
+--- | --- | --- | --- | ---
+Enabled | Yes | Yes  | 0.1 | -
+
+Check if your test uses `assert_nil` instead of `assert_equal(nil, something)`.
+
+### Examples
+
+```ruby
+# bad
+assert_equal(nil, actual)
+assert_equal(nil, actual, 'the message')
+
+# good
+assert_nil(actual)
+assert_nil(actual, 'the message')
+```
+
+### References
+
+* [https://github.com/rubocop-hq/minitest-style-guide#assert-nil](https://github.com/rubocop-hq/minitest-style-guide#assert-nil)
+
+## Minitest/AssertTruthy
+
+Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
+--- | --- | --- | --- | ---
+Enabled | Yes | Yes  | 0.2 | -
+
+Check if your test uses `assert(actual)`
+instead of `assert_equal(true, actual)`.
+
+### Examples
+
+```ruby
+# bad
+assert_equal(true, actual)
+assert_equal(true, actual, 'the message')
+
+# good
+assert(actual)
+assert(actual, 'the message')
+```
+
+### References
+
+* [https://github.com/rubocop-hq/minitest-style-guide#assert-truthy](https://github.com/rubocop-hq/minitest-style-guide#assert-truthy)
+
+## Minitest/RefuteNil
+
+Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
+--- | --- | --- | --- | ---
+Enabled | Yes | Yes  | 0.2 | -
+
+Check if your test uses `refute_nil` instead of `refute_equal(nil, something)`.
+
+### Examples
+
+```ruby
+# bad
+refute_equal(nil, actual)
+refute_equal(nil, actual, 'the message')
+
+# good
+refute_nil(actual)
+refute_nil(actual, 'the message')
+```
+
+### References
+
+* [https://github.com/rubocop-hq/minitest-style-guide#refute-nil](https://github.com/rubocop-hq/minitest-style-guide#refute-nil)