mighty_test 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 83c44a15f432d51e09d5c772fd11bb8e6054eaf98cbcc76e08e8f8050c1e03bd
+  data.tar.gz: 5908e6428920eb6aedcc993a24ad44587b7e6355f9002b07358c095717f865f6
+SHA512:
+  metadata.gz: 912d2cc77b7b732439f129ce082d140d15216221aa8fd8c4e0a6a9082c3129c238bb29f8841303d12dfe6c43b96f4c37f76090bada21114843b5c4db933ea9b2
+  data.tar.gz: 4d1468bc39fa04b7445b97bb58e559d798e3978067a29ad841ba82d3fbe2b6c893592231116f5fa41df3d567cbd352aea49b57fd098b0cf04db3d11bfb2f58e5

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2023 Matt Brictson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,257 @@
+# mighty_test
+
+[![Gem Version](https://img.shields.io/gem/v/mighty_test)](https://rubygems.org/gems/mighty_test)
+[![Gem Downloads](https://img.shields.io/gem/dt/mighty_test)](https://www.ruby-toolbox.com/projects/mighty_test)
+[![GitHub Workflow Status](https://img.shields.io/github/actions/workflow/status/mattbrictson/mighty_test/ci.yml)](https://github.com/mattbrictson/mighty_test/actions/workflows/ci.yml)
+[![Code Climate maintainability](https://img.shields.io/codeclimate/maintainability/mattbrictson/mighty_test)](https://codeclimate.com/github/mattbrictson/mighty_test)
+
+mighty_test (`mt`) is a TDD-friendly Minitest runner for Ruby projects. It includes a Jest-inspired interactive watch mode, focus mode, CI sharding, run by directory/file/line number, fail-fast, and color formatting.
+
+---
+
+**Quick Start**
+
+- [Install](#install)
+- [Requirements](#requirements)
+- [Usage](#usage)
+
+**Features**
+
+- ⚙️ [CI Mode](#%EF%B8%8F-ci-mode)
+- 🧑‍🔬 [Watch Mode](#-watch-mode)
+- 🔬 [Focus Mode](#-focus-mode)
+- 🛑 [Fail Fast](#-fail-fast)
+- 🚥 [Color Output](#-color-output)
+- 💬 [More Options](#-more-options)
+
+**Community**
+
+- [Support](#support)
+- [License](#license)
+- [Code of conduct](#code-of-conduct)
+- [Contribution guide](#contribution-guide)
+
+## Install
+
+The mighty_test gem provides an `mt` binary. To install it into a Ruby project, first add the gem to your Gemfile and run `bundle install`.
+
+```ruby
+gem "mighty_test"
+```
+
+Then generate a binstub:
+
+```sh
+bundle binstub mighty_test
+```
+
+Now you can run mighty_test with `bin/mt`.
+
+> [!TIP]
+> **When installing mighty_test in a Rails project, make sure to put the gem in the `:test` Gemfile group.** Although Rails has a built-in test runner (`bin/rails test`) that already provides a lot of what mighty_test offers, you can still use `bin/mt` with Rails projects for its unique `--watch` mode and CI `--shard` feature.
+
+## Requirements
+
+mighty_test requires modern versions of Minitest and Ruby.
+
+- Minitest 5.15+
+- Ruby 3.1+
+
+Support for older Ruby versions will be dropped when they reach EOL. The EOL schedule can be found here: https://endoflife.date/ruby
+
+> [!NOTE]
+> mighty_test currently assumes that your tests are stored in `test/` and are named `*_test.rb`. Watch mode expects implementation files to be in `app/` and/or `lib/`.
+
+## Usage
+
+`mt` defaults to running all tests, excluding slow tests (see the explanation of slow tests below). You can also run tests by directory, file, or line number.
+
+```sh
+# Run all tests, excluding slow tests
+bin/mt
+
+# Run all tests, slow tests included
+bin/mt --all
+
+# Run a specific test file
+bin/mt test/cli_test.rb
+
+# Run a test by line number
+bin/mt test/importer_test.rb:43
+
+# Run a directory of tests
+bin/mt test/commands
+```
+
+> [!TIP]
+> mighty_test is optimized for TDD, and excludes slow tests by default. **Slow tests** are defined as those found in `test/{e2e,feature,features,integration,system}` directories. You can run slow tests with `--all` or by specifying a slow test file or directory explicitly, like `bin/mt test/system`.
+
+## ⚙️ CI Mode
+
+If the `CI` environment variable is set, mighty_test defaults to running _all_ tests, including slow tests. This is equivalent to passing `--all`.
+
+mighty_test can also distribute test files evenly across parallel CI jobs, using the `--shard` option. The _shard_ nomenclature has been borrowed from similar features in [Jest](https://jestjs.io/docs/cli#--shard) and [Playwright](https://playwright.dev/docs/test-sharding).
+
+```sh
+# Run the 1st group of tests out of 4 total groups
+bin/mt --shard 1/4
+```
+
+In GitHub Actions, for example, you can use `--shard` with a matrix strategy to easily divide tests across N jobs.
+
+```yaml
+jobs:
+  test:
+    strategy:
+      matrix:
+        shard:
+          - "1/4"
+          - "2/4"
+          - "3/4"
+          - "4/4"
+    steps:
+      - uses: actions/checkout@v4
+      - uses: ruby/setup-ruby@v1
+        with:
+          bundler-cache: true
+      - run: bin/mt --shard ${{ matrix.shard }}
+```
+
+In CircleCI, you can use the `parallelism` setting, which automatically injects `$CIRCLE_NODE_INDEX` and `$CIRCLE_NODE_TOTAL` environment variables. Note that `$CIRCLE_NODE_INDEX` is zero-indexed, so it needs to be incremented by 1.
+
+```yaml
+jobs:
+  test:
+    parallelism: 4
+    steps:
+      - checkout
+      - ruby/install-deps
+      - run: SHARD="$((${CIRCLE_NODE_INDEX}+1))"; bin/mt --shard ${SHARD}/${CIRCLE_NODE_TOTAL}
+```
+
+> [!TIP]
+> `--shard` will shuffle tests and automatically distribute slow tests evenly across jobs.
+
+## 🧑‍🔬 Watch Mode
+
+mighty_test includes a Jest-style watch mode, which can be started with `--watch`. This is ideal for TDD.
+
+```sh
+# Start watch mode
+bin/mt --watch
+```
+
+In watch mode, mighty_test will listen for file system activity and run a test file whenever it is modified.
+
+When you modify an implementation file, mighty_test will find the corresponding test file and run it automatically. This works as long as your implementation and test files follow a standard path naming convention: e.g. `lib/commands/init.rb` is expected to have a corresponding test file named `test/commands/init_test.rb`.
+
+Watch mode also offers a menu of interactive commands:
+
+```
+> Press Enter to run all tests.
+> Press "a" to run all tests, including slow tests.
+> Press "d" to run tests for files diffed or added since the last git commit.
+> Press "h" to show this help menu.
+> Press "q" to quit.
+```
+
+## 🔬 Focus Mode
+
+You can focus a specific test by annotating the method definition with `focus`.
+
+```ruby
+class MyTest < Minitest::Test
+  focus def test_something_important
+    assert # ...
+  end
+```
+
+Now running `bin/mt` will execute only the focused test:
+
+```sh
+# Only runs MyTest#test_something_important
+bin/mt
+```
+
+In Rails projects that use the `test` syntax, `focus` must be placed on the previous line.
+
+```ruby
+class MyTest < ActiveSupport::TestCase
+  focus
+  test "something important" do
+    assert # ...
+  end
+```
+
+This functionality is provided by the [minitest-focus](https://github.com/minitest/minitest-focus) plugin, which is included with mighty_test.
+
+## 🛑 Fail Fast
+
+By default, mighty_test runs the entire test suite to completion. With the `--fail-fast` option, it will stop on the first failed test.
+
+```sh
+# Stop immediately on first test failure
+bin/mt --fail-fast
+
+# Use with watch mode for even faster TDD
+bin/mt --watch --fail-fast
+```
+
+This functionality is provided by the [minitest-fail-fast](https://github.com/teoljungberg/minitest-fail-fast) plugin, which is included with mighty_test.
+
+## 🚥 Color Output
+
+Successes, failures, errors, and skips are colored appropriately by default.
+
+```sh
+# Run tests with color output (if terminal supports it)
+bin/mt
+
+# Disable color
+bin/mt --no-rg
+```
+
+(image goes here)
+
+This functionality is provided by the [minitest-rg](https://github.com/minitest/minitest-rg) plugin, which is included with mighty_test.
+
+## 💬 More Options
+
+Minitest options are passed through to Minitest.
+
+```sh
+# Run tests with Minitest pride color output
+bin/mt --pride
+
+# Run tests with an explicit seed value for test ordering
+bin/mt --seed 4519
+
+# Run tests with detailed progress and explanation of skipped tests
+bin/mt --verbose
+
+# Show the full list of possible options
+bin/mt --help
+```
+
+If you have Minitest extensions installed, like [minitest-snapshots](https://github.com/mattbrictson/minitest-snapshots), the command line options of those extensions are supported as well.
+
+```sh
+# Update snapshots
+bin/mt -u
+```
+
+## Support
+
+If you want to report a bug, or have ideas, feedback or questions about the gem, [let me know via GitHub issues](https://github.com/mattbrictson/mighty_test/issues/new) and I will do my best to provide a helpful answer. Happy hacking!
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](LICENSE.txt).
+
+## Code of conduct
+
+Everyone interacting in this project’s codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](CODE_OF_CONDUCT.md).
+
+## Contribution guide
+
+Pull requests are welcome!

data/exe/mt

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+
+require "mighty_test"
+MightyTest::CLI.new.run

data/lib/mighty_test/cli.rb

@@ -0,0 +1,99 @@
+module MightyTest
+  class CLI
+    def initialize(file_system: FileSystem.new, env: ENV, option_parser: OptionParser.new, runner: MinitestRunner.new)
+      @file_system = file_system
+      @env = env.to_h
+      @option_parser = option_parser
+      @runner = runner
+    end
+
+    def run(argv: ARGV)
+      @path_args, @extra_args, @options = option_parser.parse(argv)
+
+      if options[:help]
+        print_help
+      elsif options[:version]
+        puts VERSION
+      elsif options[:watch]
+        watch
+      elsif path_args.grep(/.:\d+$/).any?
+        run_test_by_line_number
+      else
+        run_tests_by_path
+      end
+    rescue Exception => e # rubocop:disable Lint/RescueException
+      handle_exception(e)
+    end
+
+    private
+
+    attr_reader :file_system, :env, :path_args, :extra_args, :options, :option_parser, :runner
+
+    def print_help
+      # Minitest already prints the `-h, --help` option, so omit mighty_test's
+      puts option_parser.to_s.sub(/^\s*-h.*?\n/, "")
+      puts
+      runner.print_help_and_exit!
+    end
+
+    def watch
+      Watcher.new(extra_args:).run
+    end
+
+    def run_test_by_line_number
+      path, line = path_args.first.match(/^(.+):(\d+)$/).captures
+      test_name = TestParser.new(path).test_name_at_line(line.to_i)
+
+      if test_name
+        run_tests_and_exit!(path, flags: ["-n", "/^#{Regexp.quote(test_name)}$/"])
+      else
+        run_tests_and_exit!
+      end
+    end
+
+    def run_tests_by_path
+      test_paths = find_test_paths
+      test_paths = excluding_slow_paths(test_paths) unless path_args.any? || ci? || options[:all]
+      test_paths = Sharder.from_argv(options[:shard], env:, file_system:).shard(test_paths) if options[:shard]
+
+      run_tests_and_exit!(*test_paths)
+    end
+
+    def excluding_slow_paths(test_paths)
+      test_paths.reject { |path| file_system.slow_test_path?(path) }
+    end
+
+    def ci?
+      !env["CI"].to_s.strip.empty?
+    end
+
+    def find_test_paths
+      return file_system.find_test_paths if path_args.empty?
+
+      path_args.flat_map do |path|
+        if Dir.exist?(path)
+          file_system.find_test_paths(path)
+        elsif File.exist?(path)
+          [path]
+        else
+          raise ArgumentError, "#{path} does not exist"
+        end
+      end
+    end
+
+    def run_tests_and_exit!(*test_paths, flags: [])
+      runner.run_inline_and_exit!(*test_paths, args: extra_args + flags)
+    end
+
+    def handle_exception(e) # rubocop:disable Naming/MethodParameterName
+      case e
+      when SignalException
+        exit(128 + e.signo)
+      when Errno::EPIPE
+        # pass
+      else
+        raise e
+      end
+    end
+  end
+end

data/lib/mighty_test/console.rb

@@ -0,0 +1,58 @@
+require "io/console"
+
+module MightyTest
+  class Console
+    def initialize(stdin: $stdin, sound_player: "/usr/bin/afplay", sound_paths: SOUNDS)
+      @stdin = stdin
+      @sound_player = sound_player
+      @sound_paths = sound_paths
+    end
+
+    def clear
+      return false unless tty?
+
+      $stdout.clear_screen
+      true
+    end
+
+    def wait_for_keypress
+      return stdin.getc unless stdin.respond_to?(:raw) && tty?
+
+      stdin.raw(intr: true) { stdin.getc }
+    end
+
+    def play_sound(name, wait: false)
+      return false unless tty?
+
+      paths = sound_paths.fetch(name) { raise ArgumentError, "Unknown sound name #{name}" }
+      path = paths.find { |p| File.exist?(p) }
+      return false unless path && File.executable?(sound_player)
+
+      thread = Thread.new { system(sound_player, path) }
+      thread.join if wait
+      true
+    end
+
+    private
+
+    # rubocop:disable Layout/LineLength
+    SOUNDS = {
+      pass: %w[
+        /System/Library/PrivateFrameworks/ToneLibrary.framework/Versions/A/Resources/AlertTones/EncoreInfinitum/Milestone-EncoreInfinitum.caf
+        /System/Library/Sounds/Glass.aiff
+      ],
+      fail: %w[
+        /System/Library/PrivateFrameworks/ToneLibrary.framework/Versions/A/Resources/AlertTones/EncoreInfinitum/Rebound-EncoreInfinitum.caf
+        /System/Library/Sounds/Bottle.aiff
+      ]
+    }.freeze
+    private_constant :SOUNDS
+    # rubocop:enable Layout/LineLength
+
+    attr_reader :sound_player, :sound_paths, :stdin
+
+    def tty?
+      $stdout.respond_to?(:tty?) && $stdout.tty?
+    end
+  end
+end

data/lib/mighty_test/file_system.rb

@@ -0,0 +1,41 @@
+require "open3"
+
+module MightyTest
+  class FileSystem
+    def listen(&)
+      require "listen"
+      Listen.to(*%w[app lib test].select { |p| Dir.exist?(p) }, relative: true, &).tap(&:start)
+    end
+
+    def find_matching_test_path(path) # rubocop:disable Metrics/CyclomaticComplexity
+      return nil unless path && File.exist?(path) && !Dir.exist?(path)
+      return path if path.match?(%r{^test/.*_test.rb$})
+
+      test_path = path[%r{^(?:app|lib)/(.+)\.[^\.]+$}, 1]&.then { "test/#{_1}_test.rb" }
+      test_path if test_path && File.exist?(test_path)
+    end
+
+    def find_test_paths(directory="test")
+      glob = File.join(directory, "**/*_test.rb")
+      Dir[glob]
+    end
+
+    def slow_test_path?(path)
+      return false if path.nil?
+
+      path.match?(%r{^test/(e2e|feature|features|integration|system)/})
+    end
+
+    def find_new_and_changed_paths
+      out, _err, status = Open3.capture3(*%w[git status --porcelain=1 -uall -z --no-renames -- test app lib])
+      return [] unless status.success?
+
+      out
+        .split("\x0")
+        .filter_map { |line| line[/^.. (.+)/, 1] }
+        .uniq
+    rescue SystemCallError
+      []
+    end
+  end
+end

data/lib/mighty_test/minitest_runner.rb

@@ -0,0 +1,22 @@
+module MightyTest
+  class MinitestRunner
+    def print_help_and_exit!
+      require "minitest"
+      Minitest.run(["--help"])
+      exit
+    end
+
+    def run_inline_and_exit!(*test_files, args: [])
+      $LOAD_PATH.unshift "test"
+      ARGV.replace(Array(args))
+
+      require "minitest/focus"
+      require "minitest/rg"
+
+      test_files.flatten.each { |file| require File.expand_path(file.to_s) }
+
+      require "minitest/autorun"
+      exit
+    end
+  end
+end

data/lib/mighty_test/option_parser.rb

@@ -0,0 +1,77 @@
+require "shellwords"
+
+module MightyTest
+  class OptionParser
+    def parse(argv)
+      argv, literal_args = split(argv, "--")
+      options = parse_options!(argv)
+      minitest_flags = parse_minitest_flags!(argv) unless options[:help]
+
+      [argv + literal_args, minitest_flags || [], options]
+    end
+
+    def to_s
+      <<~USAGE
+        Usage: mt [--all]
+               mt [test file...] [test dir...]
+               mt --watch
+      USAGE
+    end
+
+    private
+
+    def parse_options!(argv)
+      options = {}
+      options[:all] = true if argv.delete("--all")
+      options[:watch] = true if argv.delete("--watch")
+      options[:version] = true if argv.delete("--version")
+      options[:help] = true if argv.delete("--help") || argv.delete("-h")
+      parse_shard(argv, options)
+      options
+    end
+
+    def parse_minitest_flags!(argv)
+      return [] if argv.grep(/\A-/).none?
+
+      require "minitest"
+      orig_argv = argv.dup
+
+      Minitest.load_plugins unless argv.delete("--no-plugins") || ENV["MT_NO_PLUGINS"]
+      minitest_options = Minitest.process_args(argv)
+
+      minitest_args = Shellwords.split(minitest_options[:args] || "")
+      remove_seed_flag(minitest_args) unless orig_argv.include?("--seed")
+
+      minitest_args
+    end
+
+    def split(array, delim)
+      delim_at = array.index(delim)
+      return [array.dup, []] if delim_at.nil?
+
+      [
+        array[0...delim_at],
+        array[(delim_at + 1)..]
+      ]
+    end
+
+    def parse_shard(argv, options)
+      argv.delete_if { |arg| options[:shard] = Regexp.last_match(1) if arg =~ /\A--shard=(.*)/ }
+
+      argv.each_with_index do |flag, i|
+        value = argv[i + 1]
+        next unless flag == "--shard"
+        raise "missing shard value" if value.nil? || value.start_with?("-")
+
+        options[:shard] = value
+        argv.slice!(i, 2)
+        break
+      end
+    end
+
+    def remove_seed_flag(parsed_argv)
+      index = parsed_argv.index("--seed")
+      parsed_argv.slice!(index, 2) if index
+    end
+  end
+end

data/lib/mighty_test/sharder.rb

@@ -0,0 +1,46 @@
+module MightyTest
+  class Sharder
+    DEFAULT_SEED = 123_456_789
+
+    def self.from_argv(value, env: ENV, file_system: FileSystem.new)
+      index, total = value.to_s.match(%r{\A(\d+)/(\d+)\z})&.captures&.map(&:to_i)
+      raise ArgumentError, "shard: value must be in the form INDEX/TOTAL (e.g. 2/8)" if total.nil?
+
+      git_sha = env.values_at("GITHUB_SHA", "CIRCLE_SHA1").find { |sha| !sha.to_s.strip.empty? }
+      seed = git_sha&.unpack1("l_")
+
+      new(index:, total:, seed:, file_system:)
+    end
+
+    attr_reader :index, :total, :seed
+
+    def initialize(index:, total:, seed: nil, file_system: FileSystem.new)
+      raise ArgumentError, "shard: total shards must be a number greater than 0" unless total > 0
+
+      valid_group = index > 0 && index <= total
+      raise ArgumentError, "shard: shard index must be > 0 and <= #{total}" unless valid_group
+
+      @index = index
+      @total = total
+      @seed = seed || DEFAULT_SEED
+      @file_system = file_system
+    end
+
+    def shard(*test_paths)
+      random = Random.new(seed)
+
+      # Shuffle slow and normal paths separately so that slow ones get evenly distributed
+      shuffled_paths = test_paths
+        .flatten
+        .partition { |path| !file_system.slow_test_path?(path) }
+        .flat_map { |paths| paths.shuffle(random:) }
+
+      slices = shuffled_paths.each_slice(total)
+      slices.filter_map { |slice| slice[index - 1] }
+    end
+
+    private
+
+    attr_reader :file_system
+  end
+end

data/lib/mighty_test/test_parser.rb

@@ -0,0 +1,33 @@
+module MightyTest
+  class TestParser
+    def initialize(test_path)
+      @path = test_path.to_s
+    end
+
+    def test_name_at_line(number)
+      method_name = nil
+      lines = File.read(path).lines
+      lines[2...number].reverse_each.find do |line|
+        method_name =
+          match_minitest_method_name(line) ||
+          match_active_support_test_string(line)&.then { "test_#{_1.gsub(/\s+/, '_')}" }
+      end
+      method_name
+    end
+
+    private
+
+    attr_reader :path
+
+    def match_minitest_method_name(line)
+      line[/^\s*(?:focus\s+)?def\s+(test_\w+)/, 1]
+    end
+
+    def match_active_support_test_string(line)
+      match = line.match(/^\s*test\s+(?:"(.+?)"|'(.+?)')\s*do\s*(?:#.*?)?$/)
+      return unless match
+
+      match.captures.compact.first
+    end
+  end
+end

data/lib/mighty_test/version.rb

@@ -0,0 +1,3 @@
+module MightyTest
+  VERSION = "0.1.0".freeze
+end

data/lib/mighty_test/watcher.rb

@@ -0,0 +1,140 @@
+module MightyTest
+  class Watcher # rubocop:disable Metrics/ClassLength
+    WATCHING_FOR_CHANGES = 'Watching for changes to source and test files. Press "h" for help or "q" to quit.'.freeze
+
+    def initialize(console: Console.new, extra_args: [], file_system: FileSystem.new, system_proc: method(:system))
+      @queue = Thread::Queue.new
+      @console = console
+      @extra_args = extra_args
+      @file_system = file_system
+      @system_proc = system_proc
+    end
+
+    def run(iterations: :indefinitely) # rubocop:disable Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+      start_file_system_listener
+      start_keypress_listener
+      puts WATCHING_FOR_CHANGES
+
+      loop_for(iterations) do
+        case await_next_event
+        in [:file_system_changed, [_, *] => paths]
+          run_matching_test_files(paths)
+        in [:keypress, "\r" | "\n"]
+          run_all_tests
+        in [:keypress, "a"]
+          run_all_tests(flags: ["--all"])
+        in [:keypress, "d"]
+          run_matching_test_files_from_git_diff
+        in [:keypress, "h"]
+          show_help
+        in [:keypress, "q"]
+          break
+        else
+          nil
+        end
+      end
+    ensure
+      puts "\nExiting."
+      file_system_listener&.stop
+      keypress_listener&.kill
+    end
+
+    private
+
+    attr_reader :console, :extra_args, :file_system, :file_system_listener, :keypress_listener, :system_proc
+
+    def show_help
+      console.clear
+      puts <<~MENU
+        `mt --watch` is watching file system activity and will automatically run
+        test files when they are added or modified. If you modify a source file,
+        mt will find and run the corresponding tests.
+
+        You can also trigger test runs with the following interactive commands.
+
+        > Press Enter to run all tests.
+        > Press "a" to run all tests, including slow tests.
+        > Press "d" to run tests for files diffed or added since the last git commit.
+        > Press "h" to show this help menu.
+        > Press "q" to quit.
+
+      MENU
+    end
+
+    def run_all_tests(flags: [])
+      console.clear
+      puts flags.any? ? "Running tests with #{flags.join(' ')}..." : "Running tests..."
+      puts
+      mt(flags:)
+    end
+
+    def run_matching_test_files(paths)
+      test_paths = paths.flat_map { |path| file_system.find_matching_test_path(path) }.compact.uniq
+      return false if test_paths.empty?
+
+      console.clear
+      puts test_paths.join("\n")
+      puts
+      mt(*test_paths)
+      true
+    end
+
+    def run_matching_test_files_from_git_diff
+      return if run_matching_test_files(file_system.find_new_and_changed_paths)
+
+      console.clear
+      puts "No affected test files detected since the last git commit."
+      puts WATCHING_FOR_CHANGES
+    end
+
+    def mt(*test_paths, flags: [])
+      command = ["mt", *extra_args, *flags]
+      command.append("--", *test_paths.flatten) if test_paths.any?
+
+      success = system_proc.call(*command)
+
+      console.play_sound(success ? :pass : :fail)
+      puts "\n#{WATCHING_FOR_CHANGES}"
+      $stdout.flush
+    rescue Interrupt
+      # Pressing ctrl-c kills the fs_event background process, so we have to manually restart it.
+      restart_file_system_listener
+    end
+
+    def start_file_system_listener
+      file_system_listener.stop if file_system_listener && !file_system_listener.stopped?
+
+      @file_system_listener = file_system.listen do |modified, added, _removed|
+        # Pause listener so that subsequent changes are queued up while we are running the tests
+        file_system_listener.pause unless file_system_listener.stopped?
+        post_event(:file_system_changed, [*modified, *added].uniq)
+      end
+    end
+    alias restart_file_system_listener start_file_system_listener
+
+    def start_keypress_listener
+      @keypress_listener = Thread.new do
+        loop do
+          key = console.wait_for_keypress
+          break if key.nil?
+
+          post_event(:keypress, key)
+        end
+      end
+      @keypress_listener.abort_on_exception = true
+    end
+
+    def loop_for(iterations, &)
+      iterations == :indefinitely ? loop(&) : iterations.times(&)
+    end
+
+    def await_next_event
+      file_system_listener.start if file_system_listener.paused?
+      @queue.pop
+    end
+
+    def post_event(*event)
+      @queue << event
+    end
+  end
+end

data/lib/mighty_test.rb

@@ -0,0 +1,11 @@
+module MightyTest
+  autoload :VERSION, "mighty_test/version"
+  autoload :CLI, "mighty_test/cli"
+  autoload :Console, "mighty_test/console"
+  autoload :FileSystem, "mighty_test/file_system"
+  autoload :MinitestRunner, "mighty_test/minitest_runner"
+  autoload :OptionParser, "mighty_test/option_parser"
+  autoload :Sharder, "mighty_test/sharder"
+  autoload :TestParser, "mighty_test/test_parser"
+  autoload :Watcher, "mighty_test/watcher"
+end

metadata

@@ -0,0 +1,132 @@
+--- !ruby/object:Gem::Specification
+name: mighty_test
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Matt Brictson
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2024-02-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: listen
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.5'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.15'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.15'
+- !ruby/object:Gem::Dependency
+  name: minitest-fail-fast
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+- !ruby/object:Gem::Dependency
+  name: minitest-focus
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+- !ruby/object:Gem::Dependency
+  name: minitest-rg
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.3'
+description:
+email:
+- opensource@mattbrictson.com
+executables:
+- mt
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- exe/mt
+- lib/mighty_test.rb
+- lib/mighty_test/cli.rb
+- lib/mighty_test/console.rb
+- lib/mighty_test/file_system.rb
+- lib/mighty_test/minitest_runner.rb
+- lib/mighty_test/option_parser.rb
+- lib/mighty_test/sharder.rb
+- lib/mighty_test/test_parser.rb
+- lib/mighty_test/version.rb
+- lib/mighty_test/watcher.rb
+homepage: https://github.com/mattbrictson/mighty_test
+licenses:
+- MIT
+metadata:
+  bug_tracker_uri: https://github.com/mattbrictson/mighty_test/issues
+  changelog_uri: https://github.com/mattbrictson/mighty_test/releases
+  source_code_uri: https://github.com/mattbrictson/mighty_test
+  homepage_uri: https://github.com/mattbrictson/mighty_test
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.1'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.5
+signing_key:
+specification_version: 4
+summary: A modern Minitest runner for TDD, with watch mode and more
+test_files: []