rubocop-minitest 0.15.0 → 0.17.0

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

@@ -19,6 +19,18 @@ module RuboCop
         extend MinitestCopRule
 
         define_rule :refute, target_method: :empty?
+
+        remove_method :on_send
+        def on_send(node)
+          return unless node.method?(:refute)
+          return unless (arguments = peel_redundant_parentheses_from(node.arguments))
+          return unless arguments.first.respond_to?(:method?) && arguments.first.method?(:empty?)
+          return unless arguments.first.arguments.empty?
+
+          add_offense(node, message: offense_message(arguments)) do |corrector|
+            autocorrect(corrector, node, arguments)
+          end
+        end
       end
     end
   end

data/lib/rubocop/minitest/assert_offense.rb

@@ -0,0 +1,183 @@
+# frozen_string_literal: true
+
+# Laziness copied from rubocop source code
+require 'rubocop/rspec/expect_offense'
+require 'rubocop/cop/legacy/corrector'
+
+module RuboCop
+  module Minitest
+    # Mixin for `assert_offense` and `assert_no_offenses`
+    #
+    # This mixin makes it easier to specify strict offense assertions
+    # in a declarative and visual fashion. Just type out the code that
+    # should generate a offense, annotate code by writing '^'s
+    # underneath each character that should be highlighted, and follow
+    # the carets with a string (separated by a space) that is the
+    # message of the offense. You can include multiple offenses in
+    # one code snippet.
+    #
+    # @example Usage
+    #
+    #   assert_offense(<<~RUBY)
+    #     class FooTest < Minitest::Test
+    #       def test_do_something
+    #         assert_equal(nil, somestuff)
+    #         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer using `assert_nil(somestuff)` over `assert_equal(nil, somestuff)`.
+    #       end
+    #     end
+    #   RUBY
+    #
+    # Auto-correction can be tested using `assert_correction` after
+    # `assert_offense`.
+    #
+    # @example `assert_offense` and `assert_correction`
+    #
+    #   assert_offense(<<~RUBY)
+    #     class FooTest < Minitest::Test
+    #       def test_do_something
+    #         assert_equal(nil, somestuff)
+    #         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer using `assert_nil(somestuff)` over `assert_equal(nil, somestuff)`.
+    #       end
+    #     end
+    #   RUBY
+    #
+    #   assert_correction(<<~RUBY)
+    #     class FooTest < Minitest::Test
+    #       def test_do_something
+    #         assert_nil(somestuff)
+    #       end
+    #     end
+    #   RUBY
+    #
+    # If you do not want to specify an offense then use the
+    # companion method `assert_no_offenses`. This method is a much
+    # simpler assertion since it just inspects the source and checks
+    # that there were no offenses. The `assert_offense` method has
+    # to do more work by parsing out lines that contain carets.
+    #
+    # If the code produces an offense that could not be auto-corrected, you can
+    # use `assert_no_corrections` after `assert_offense`.
+    #
+    # @example `assert_offense` and `assert_no_corrections`
+    #
+    #   assert_offense(<<~RUBY)
+    #     class FooTest < Minitest::Test
+    #       def test_do_something
+    #         assert_equal(nil, somestuff)
+    #         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer using `assert_nil(somestuff)` over `assert_equal(nil, somestuff)`.
+    #       end
+    #     end
+    #   RUBY
+    #
+    #   assert_no_corrections
+    module AssertOffense
+      private
+
+      def setup
+        cop_name = self.class.to_s.delete_suffix('Test')
+
+        @cop = RuboCop::Cop::Minitest.const_get(cop_name).new
+      end
+
+      def assert_no_offenses(source, file = nil)
+        setup_assertion
+
+        offenses = inspect_source(source, @cop, file)
+
+        expected_annotations = RuboCop::RSpec::ExpectOffense::AnnotatedSource.parse(source)
+        actual_annotations = expected_annotations.with_offense_annotations(offenses)
+
+        assert_equal(source, actual_annotations.to_s)
+      end
+
+      def assert_offense(source, file = nil)
+        setup_assertion
+
+        @cop.instance_variable_get(:@options)[:auto_correct] = true
+
+        expected_annotations = RuboCop::RSpec::ExpectOffense::AnnotatedSource.parse(source)
+        if expected_annotations.plain_source == source
+          raise 'Use `assert_no_offenses` to assert that no offenses are found'
+        end
+
+        @processed_source = parse_source!(expected_annotations.plain_source, file)
+
+        offenses = _investigate(@cop, @processed_source)
+
+        actual_annotations = expected_annotations.with_offense_annotations(offenses)
+
+        assert_equal(expected_annotations.to_s, actual_annotations.to_s)
+      end
+
+      def _investigate(cop, processed_source)
+        team = RuboCop::Cop::Team.new([cop], nil, raise_error: true)
+        report = team.investigate(processed_source)
+        @last_corrector = report.correctors.first || RuboCop::Cop::Corrector.new(processed_source)
+        report.offenses
+      end
+
+      def assert_correction(correction, loop: true)
+        raise '`assert_correction` must follow `assert_offense`' unless @processed_source
+
+        iteration = 0
+        new_source = loop do
+          iteration += 1
+
+          corrected_source = @last_corrector.rewrite
+
+          break corrected_source unless loop
+          break corrected_source if @last_corrector.empty? || corrected_source == @processed_source.buffer.source
+
+          if iteration > RuboCop::Runner::MAX_ITERATIONS
+            raise RuboCop::Runner::InfiniteCorrectionLoop.new(@processed_source.path, [])
+          end
+
+          # Prepare for next loop
+          @processed_source = parse_source!(corrected_source, @processed_source.path)
+
+          _investigate(@cop, @processed_source)
+        end
+
+        assert_equal(correction, new_source)
+      end
+
+      def setup_assertion
+        RuboCop::Formatter::DisabledConfigFormatter.config_to_allow_offenses = {}
+        RuboCop::Formatter::DisabledConfigFormatter.detected_styles = {}
+      end
+
+      def inspect_source(source, cop, file = nil)
+        processed_source = parse_source!(source, file)
+        raise 'Error parsing example code' unless processed_source.valid_syntax?
+
+        _investigate(cop, processed_source)
+      end
+
+      def investigate(cop, processed_source)
+        needed = Hash.new { |h, k| h[k] = [] }
+        Array(cop.class.joining_forces).each { |force| needed[force] << cop }
+        forces = needed.map do |force_class, joining_cops|
+          force_class.new(joining_cops)
+        end
+
+        commissioner = RuboCop::Cop::Commissioner.new([cop], forces, raise_error: true)
+        commissioner.investigate(processed_source)
+        commissioner
+      end
+
+      def parse_source!(source, file = nil)
+        if file.respond_to?(:write)
+          file.write(source)
+          file.rewind
+          file = file.path
+        end
+
+        RuboCop::ProcessedSource.new(source, ruby_version, file)
+      end
+
+      def ruby_version
+        2.5
+      end
+    end
+  end
+end

data/lib/rubocop/minitest/support.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+# Require this file to load code that supports testing using Minitest.
+
+require 'rubocop'
+require 'minitest/autorun'
+require 'minitest/pride'
+require_relative 'assert_offense'
+
+Minitest::Test.include RuboCop::Minitest::AssertOffense

data/lib/rubocop/minitest/version.rb

@@ -4,7 +4,7 @@ module RuboCop
   module Minitest
     # This module holds the RuboCop Minitest version information.
     module Version
-      STRING = '0.15.0'
+      STRING = '0.17.0'
 
       def self.document_version
         STRING.match('\d+\.\d+').to_s

data/relnotes/v0.15.1.md

@@ -0,0 +1,5 @@
+### Bug fixes
+
+* [#143](https://github.com/rubocop/rubocop-minitest/issues/143): Fix an error for `Minitest/LiteralAsActualArgumentTest` when expected and actual arguments are literals. ([@koic][])
+
+[@koic]: https://github.com/koic

data/relnotes/v0.15.2.md

@@ -0,0 +1,5 @@
+### Bug fixes
+
+* [#145](https://github.com/rubocop/rubocop-minitest/pull/145): Mark `Minitest/AssertEmptyLiteral` as safe auto-correction. ([@koic][])
+
+[@koic]: https://github.com/koic

data/relnotes/v0.16.0.md

@@ -0,0 +1,11 @@
+### New features
+
+* [#147](https://github.com/rubocop/rubocop-minitest/issues/147): Add `EnforcedStyle` config parameter for `Minitest/GlobalExpectations`. ([@gi][])
+
+### Bug fixes
+
+* [#142](https://github.com/rubocop/rubocop-minitest/issues/142): Fix `Minitest/GlobalExpectations` autocorrect when receiver is lambda. ([@gi][])
+* [#150](https://github.com/rubocop/rubocop-minitest/issues/150): Fix a false positive for `Minitest/AssertEmpty` and `RefuteEmpty` cops when using `empty` method with any arguments. ([@koic][])
+
+[@gi]: https://github.com/gi
+[@koic]: https://github.com/koic

data/relnotes/v0.17.0.md

@@ -0,0 +1,5 @@
+### New features
+
+* [#155](https://github.com/rubocop/rubocop-minitest/issues/155): Provide `assert_offense`, `assert_correction`, and `assert_no_offenses` testing APIs for custom Minitest cop development. ([@koic][])
+
+[@koic]: https://github.com/koic

data/rubocop-minitest.gemspec

@@ -22,7 +22,8 @@ Gem::Specification.new do |spec|
     'changelog_uri' => 'https://github.com/rubocop/rubocop-minitest/blob/master/CHANGELOG.md',
     'source_code_uri' => 'https://github.com/rubocop/rubocop-minitest',
     'documentation_uri' => "https://docs.rubocop.org/rubocop-minitest/#{RuboCop::Minitest::Version.document_version}",
-    'bug_tracker_uri' => 'https://github.com/rubocop/rubocop-minitest/issues'
+    'bug_tracker_uri' => 'https://github.com/rubocop/rubocop-minitest/issues',
+    'rubygems_mfa_required' => 'true'
   }
 
   # Specify which files should be added to the gem when it is released.

data/tasks/changelog.rake

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+autoload :Changelog, "#{__dir__}/changelog"
+
+namespace :changelog do
+  %i[new fix change].each do |type|
+    desc "Create a Changelog entry (#{type})"
+    task type, [:id] do |_task, args|
+      ref_type = :pull if args[:id]
+      path = Changelog::Entry.new(type: type, ref_id: args[:id], ref_type: ref_type).write
+      cmd = "git add #{path}"
+      system cmd
+      puts "Entry '#{path}' created and added to git index"
+    end
+  end
+
+  desc 'Merge entries and delete them'
+  task :merge do
+    raise 'No entries!' unless Changelog.pending?
+
+    Changelog.new.merge!.and_delete!
+    cmd = "git commit -a -m 'Update Changelog'"
+    puts cmd
+    system cmd
+  end
+
+  task :check_clean do
+    next unless Changelog.pending?
+
+    puts '*** Pending changelog entries!'
+    puts 'Do `bundle exec rake changelog:merge`'
+    exit(1)
+  end
+end

data/tasks/changelog.rb

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+if RUBY_VERSION < '2.6'
+  puts 'Changelog utilities available only for Ruby 2.6+'
+  exit(1)
+end
+
+# Changelog utility
+class Changelog
+  ENTRIES_PATH = 'changelog/'
+  FIRST_HEADER = /#{Regexp.escape("## master (unreleased)\n")}/m.freeze
+  ENTRIES_PATH_TEMPLATE = "#{ENTRIES_PATH}%<type>s_%<name>s.md"
+  TYPE_REGEXP = /#{Regexp.escape(ENTRIES_PATH)}([a-z]+)_/.freeze
+  TYPE_TO_HEADER = { new: 'New features', fix: 'Bug fixes', change: 'Changes' }.freeze
+  HEADER = /### (.*)/.freeze
+  PATH = 'CHANGELOG.md'
+  REF_URL = 'https://github.com/rubocop/rubocop-minitest'
+  MAX_LENGTH = 40
+  CONTRIBUTOR = '[@%<user>s]: https://github.com/%<user>s'
+  SIGNATURE = Regexp.new(format(Regexp.escape('[@%<user>s][]'), user: '([\w-]+)'))
+  EOF = "\n"
+
+  # New entry
+  Entry = Struct.new(:type, :body, :ref_type, :ref_id, :user, keyword_init: true) do
+    def initialize(type:, body: last_commit_title, ref_type: nil, ref_id: nil, user: github_user)
+      id, body = extract_id(body)
+      ref_id ||= id || 'x'
+      ref_type ||= id ? :issues : :pull
+      super
+    end
+
+    def write
+      Dir.mkdir(ENTRIES_PATH) unless Dir.exist?(ENTRIES_PATH)
+      File.write(path, content)
+      path
+    end
+
+    def path
+      format(ENTRIES_PATH_TEMPLATE, type: type, name: str_to_filename(body))
+    end
+
+    def content
+      period = '.' unless body.end_with? '.'
+      "* #{ref}: #{body}#{period} ([@#{user}][])\n"
+    end
+
+    def ref
+      "[##{ref_id}](#{REF_URL}/#{ref_type}/#{ref_id})"
+    end
+
+    def last_commit_title
+      `git log -1 --pretty=%B`.lines.first.chomp
+    end
+
+    def extract_id(body)
+      /^\[Fix(?:es)? #(\d+)\] (.*)/.match(body)&.captures || [nil, body]
+    end
+
+    def str_to_filename(str)
+      str
+        .downcase
+        .split
+        .each { |s| s.gsub!(/\W/, '') }
+        .reject(&:empty?)
+        .inject do |result, word|
+        s = "#{result}_#{word}"
+        return result if s.length > MAX_LENGTH
+
+        s
+      end
+    end
+
+    def github_user
+      user = `git config --global credential.username`.chomp
+      warn 'Set your username with `git config --global credential.username "myusernamehere"`' if user.empty?
+
+      user
+    end
+  end
+  attr_reader :header, :rest
+
+  def initialize(content: File.read(PATH), entries: Changelog.read_entries)
+    require 'strscan'
+
+    parse(content)
+    @entries = entries
+  end
+
+  def and_delete!
+    @entries.each_key { |path| File.delete(path) }
+  end
+
+  def merge!
+    File.write(PATH, merge_content)
+    self
+  end
+
+  def unreleased_content
+    entry_map = parse_entries(@entries)
+    merged_map = merge_entries(entry_map)
+    merged_map.flat_map { |header, things| ["### #{header}\n", *things, ''] }.join("\n")
+  end
+
+  def merge_content
+    merged_content = [@header, unreleased_content, @rest.chomp, *new_contributor_lines].join("\n")
+
+    merged_content << EOF
+  end
+
+  def self.pending?
+    entry_paths.any?
+  end
+
+  def self.entry_paths
+    Dir["#{ENTRIES_PATH}*"]
+  end
+
+  def self.read_entries
+    entry_paths.to_h { |path| [path, File.read(path)] }
+  end
+
+  def new_contributor_lines
+    contributors
+      .map { |user| format(CONTRIBUTOR, user: user) }
+      .reject { |line| @rest.include?(line) }
+  end
+
+  def contributors
+    contributors = @entries.values.flat_map do |entry|
+      entry.match(/\. \((?<contributors>.+)\)\n/)[:contributors].split(',')
+    end
+
+    contributors.join.scan(SIGNATURE).flatten
+  end
+
+  private
+
+  def merge_entries(entry_map)
+    all = @unreleased.merge(entry_map) { |_k, v1, v2| v1.concat(v2) }
+    canonical = TYPE_TO_HEADER.values.to_h { |v| [v, nil] }
+    canonical.merge(all).compact
+  end
+
+  def parse(content)
+    ss = StringScanner.new(content)
+    @header = ss.scan_until(FIRST_HEADER)
+    @unreleased = parse_release(ss.scan_until(/\n(?=## )/m))
+    @rest = ss.rest
+  end
+
+  # @return [Hash<type, Array<String>]]
+  def parse_release(unreleased)
+    unreleased.lines.map(&:chomp).reject(&:empty?).slice_before(HEADER).to_h do |header, *entries|
+      [HEADER.match(header)[1], entries]
+    end
+  end
+
+  def parse_entries(path_content_map)
+    changes = Hash.new { |h, k| h[k] = [] }
+    path_content_map.each do |path, content|
+      header = TYPE_TO_HEADER.fetch(TYPE_REGEXP.match(path)[1].to_sym)
+      changes[header].concat(content.lines.map(&:chomp))
+    end
+    changes
+  end
+end

data/tasks/cops_documentation.rake

@@ -10,24 +10,14 @@ YARD::Rake::YardocTask.new(:yard_for_generate_documentation) do |task|
   task.options = ['--no-output']
 end
 
-desc 'Generate docs of all cops departments'
-task generate_cops_documentation: :yard_for_generate_documentation do
+task update_cops_documentation: :yard_for_generate_documentation do
   deps = ['Minitest']
   CopsDocumentationGenerator.new(departments: deps).call
 end
 
-desc 'Verify that documentation is up to date'
-task verify_cops_documentation: :generate_cops_documentation do
-  # Do not print diff and yield whether exit code was zero
-  sh('git diff --quiet docs') do |outcome, _|
-    exit if outcome
-
-    # Output diff before raising error
-    sh('GIT_PAGER=cat git diff docs')
-
-    warn 'The docs directory is out of sync. Run `rake generate_cops_documentation` and commit the results.'
-    exit!
-  end
+desc 'Generate docs of all cops departments (obsolete)'
+task :generate_cops_documentation do
+  puts 'Updating the documentation is now done automatically!'
 end
 
 desc 'Syntax check for the documentation comments'

data/tasks/cut_release.rake

@@ -4,9 +4,8 @@ require 'bump'
 
 namespace :cut_release do
   %w[major minor patch pre].each do |release_type|
-    desc "Cut a new #{release_type} release, create release notes " \
-         'and update documents.'
-    task release_type do
+    desc "Cut a new #{release_type} release, create release notes and update documents."
+    task release_type => 'changelog:check_clean' do
       run(release_type)
     end
   end
@@ -50,12 +49,25 @@ namespace :cut_release do
     version.split('.').take(2).join('.')
   end
 
+  # Replace `<<next>>` (and variations) with version being cut.
+  def update_cop_versions(_old_version, new_version)
+    update_file('config/default.yml') do |default|
+      default.gsub(/['"]?<<\s*next\s*>>['"]?/i,
+                   "'#{version_sans_patch(new_version)}'")
+    end
+  end
+
   def new_version_changes
     changelog = File.read('CHANGELOG.md')
     _, _, new_changes, _older_changes = changelog.split(/^## .*$/, 4)
     new_changes
   end
 
+  def update_file(path)
+    content = File.read(path)
+    File.write(path, yield(content))
+  end
+
   def user_links(text)
     names = text.scan(/\[@(\S+)\]\[\]/).map(&:first).uniq
     names.map { |name| "[@#{name}]: https://github.com/#{name}" }
@@ -67,6 +79,9 @@ namespace :cut_release do
     Bump::Bump.run(release_type, commit: false, bundle: false, tag: false)
     new_version = Bump::Bump.current
 
+    update_cop_versions(old_version, new_version)
+    Rake::Task['update_cops_documentation'].invoke
+
     add_header_to_changelog(new_version)
     create_release_notes(new_version)
     update_antora_yml(new_version)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rubocop-minitest
 version: !ruby/object:Gem::Version
-  version: 0.15.0
+  version: 0.17.0
 platform: ruby
 authors:
 - Bozhidar Batsov
@@ -10,7 +10,7 @@ authors:
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-08-09 00:00:00.000000000 Z
+date: 2021-11-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rubocop
@@ -60,9 +60,11 @@ files:
 - ".github/ISSUE_TEMPLATE/bug_report.md"
 - ".github/ISSUE_TEMPLATE/feature_request.md"
 - ".github/PULL_REQUEST_TEMPLATE.md"
+- ".github/workflows/spell_checking.yml"
 - ".gitignore"
 - ".rubocop.yml"
 - ".rubocop_todo.yml"
+- ".yardopts"
 - CHANGELOG.md
 - CONTRIBUTING.md
 - Gemfile
@@ -71,6 +73,7 @@ files:
 - Rakefile
 - bin/console
 - bin/setup
+- codespell.txt
 - config/default.yml
 - docs/antora.yml
 - docs/modules/ROOT/nav.adoc
@@ -127,7 +130,9 @@ files:
 - lib/rubocop/cop/mixin/minitest_exploration_helpers.rb
 - lib/rubocop/cop/mixin/nil_assertion_handleable.rb
 - lib/rubocop/minitest.rb
+- lib/rubocop/minitest/assert_offense.rb
 - lib/rubocop/minitest/inject.rb
+- lib/rubocop/minitest/support.rb
 - lib/rubocop/minitest/version.rb
 - mkdocs.yml
 - readthedocs.yml
@@ -143,6 +148,10 @@ files:
 - relnotes/v0.13.0.md
 - relnotes/v0.14.0.md
 - relnotes/v0.15.0.md
+- relnotes/v0.15.1.md
+- relnotes/v0.15.2.md
+- relnotes/v0.16.0.md
+- relnotes/v0.17.0.md
 - relnotes/v0.2.0.md
 - relnotes/v0.2.1.md
 - relnotes/v0.3.0.md
@@ -158,6 +167,8 @@ files:
 - relnotes/v0.8.1.md
 - relnotes/v0.9.0.md
 - rubocop-minitest.gemspec
+- tasks/changelog.rake
+- tasks/changelog.rb
 - tasks/cops_documentation.rake
 - tasks/cut_release.rake
 homepage:
@@ -167,8 +178,9 @@ metadata:
   homepage_uri: https://docs.rubocop.org/rubocop-minitest/
   changelog_uri: https://github.com/rubocop/rubocop-minitest/blob/master/CHANGELOG.md
   source_code_uri: https://github.com/rubocop/rubocop-minitest
-  documentation_uri: https://docs.rubocop.org/rubocop-minitest/0.15
+  documentation_uri: https://docs.rubocop.org/rubocop-minitest/0.17
   bug_tracker_uri: https://github.com/rubocop/rubocop-minitest/issues
+  rubygems_mfa_required: 'true'
 post_install_message:
 rdoc_options: []
 require_paths:
@@ -184,7 +196,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.18
+rubygems_version: 3.3.0.dev
 signing_key:
 specification_version: 4
 summary: Automatic Minitest code style checking tool.