nicetest 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f8b1e58e35c866d01e21b5b8e397e05c3506002d3af25681a8178e6c26d4f2e3
+  data.tar.gz: 8f032d23008336df8010de48bb4a4cf872e4416d52a092ce76e231a7a09cb934
+SHA512:
+  metadata.gz: 1cc1cd63f09d3d3c5a2abca7fcd6bf9b914eb61391efb146cb0c01c0c77139b32ee8a32d493f1cef49b69bcf8df9ebda39bda69607f84f94b39535f30ef7b0fd
+  data.tar.gz: a19a0494f63b94dd40cfa2a493d31eb0ee1eea53ab33b08fc05e775d715dfc9c3f8e0eda533e1923cbdbe984da52d6fd6c9325da67b13ed968955dbf86e5c217

checksums.yaml.gz.sig

@@ -0,0 +1,3 @@
+IU,|��W����\��1�
+
��H�'�Pz3o|��@#����צqÖ_�����h�8��,��ғf�';�%MP�P�y�*ړE"��Q��
+�i3��x��eW�ngfd��76Q��ȡ`�qXŖ�cc3�ڣ�͊L������n�0ߎ��Tqs���gIK&�o$<@���+p�$J��P��`�;����4z)��.{�;��`��Ofa�ơo����J���;��!�;-������j,�ՐX���]�Tʌs��m^

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2024 Ian Ker-Seymer
+
+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,97 @@
+# ☀️ nicetest
+
+Enhance your minitest experience with nicetest—a gem offering a CLI, pretty
+assertion diffs, pre-configured reporters, focus checks, and colorful backtrace
+filters for seamless test running.
+
+## Features
+
+- A decent CLI for running tests, which is compatible with existing minitest plugin options
+- Fancier diffs using [`super_diff`](https://github.com/mcmire/super_diff)
+- Bundled [`minitest-reporters`](https://github.com/minitest-reporters/minitest-reporters), with defaults configured
+- Bundled [`minitest-focus`](https://github.com/minitest/minitest-focus), with CI sanity check
+- A pretty backtrace filter
+
+## Usage
+
+### Take it with you
+
+`nicetest` runs well on most `minitest` suites without hassle, so you can just
+use it wherever you happen to be:
+
+```sh
+# Gem install it
+$ gem install nicetest
+
+# Go into a repo
+$ git clone https://github.com/Shopfy/liquid; cd liquid; bundle install
+
+# Run the tests
+$ nicetest --reporter doc test/integration/capture_test.rb
+Started with run options --reporter doc --seed 12874
+
+CaptureTest
+  test_increment_assign_score_by_bytes_not_characters             PASS (0.00s)
+  test_captures_block_content_in_variable                         PASS (0.00s)
+  test_capture_to_variable_from_outer_scope_if_existing           PASS (0.00s)
+  test_assigning_from_capture                                     PASS (0.00s)
+  test_capture_with_hyphen_in_variable_name                       PASS (0.00s)
+
+Finished in 0.00123s
+5 tests, 5 assertions, 0 failures, 0 errors, 0 skips
+```
+
+### Add to project
+
+
+Add to your `test_helper.rb`:
+
+```ruby
+# test/test_helper.rb
+
+require "nicetest"
+
+# whatever else you do... can probably remove some stuff
+```
+
+Then, make it easy to run:
+
+```sh
+# Add to Gemfile
+$ bundle add nicetest
+
+# Make a bin/test executable
+$ bundle binstub nicetest && mv bin/nicetest bin/test
+```
+
+You can run it now:
+
+```sh
+# Run tests
+$ bin/test
+
+# In CI
+$ bin/test --reporter doc,junit
+```
+
+### What about Rakefile?
+
+If you want to use Rake, just do this:
+
+```ruby
+# Rakefile
+
+task :test do
+  sh("bin/test")
+end
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at
+https://github.com/ianks/nicetest.
+
+## License
+
+The gem is available as open source under the terms of the [MIT
+License](https://opensource.org/licenses/MIT).

data/exe/nicetest

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "nicetest"
+
+exit(Nicetest::Cli.new(ARGV).run)

data/lib/minitest/nicetest_plugin.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+# opts.banner = "Usage: example.rb [options]"
+require "nicetest/cli"
+
+module Minitest
+  class << self
+    def plugin_nicetest_options(opts, options)
+      opts.banner = Nicetest::Cli::BANNER
+      ValidateMinitestFocus.apply!
+    end
+
+    def plugin_nicetest_init(_options)
+      Minitest.backtrace_filter = Nicetest::BacktraceFilter.new
+    end
+
+    module ValidateMinitestFocus
+      class << self
+        def apply!
+          if ENV["CI"]
+            Minitest::Test.singleton_class.prepend(ValidateMinitestFocus::NoFocus)
+          end
+        end
+      end
+
+      module NoFocus
+        def focus(name = nil)
+          location = caller_locations(1, 1).first
+          Nicetest.logger.fatal!("cannot use `focus` in CI (#{location.path}:#{location.lineno})")
+        end
+      end
+    end
+  end
+end

data/lib/minitest/reporters_plugin.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Minitest
+  module ReportersPlugin
+    MAPPING = {
+      "none" => ->(_options) { nil },
+      "default" => ->(options) { Minitest::Reporters::DefaultReporter.new(io: options[:io]) },
+      "spec" => ->(options) { Minitest::Reporters::SpecReporter.new(io: options[:io]) },
+      "doc" => ->(options) { MAPPING["spec"].call(options) },
+      "junit" => ->(options) {
+        ENV["MINITEST_REPORTERS_REPORTS_DIR"] ||= "tmp/nicetest/junit/#{Time.now.to_i}"
+        Minitest::Reporters::JUnitReporter.new(io: options[:io])
+      },
+      "progress" => ->(options) { Minitest::Reporters::ProgressReporter.new(io: options[:io]) },
+    }
+  end
+
+  class << self
+    def plugin_reporters_options(opts, options)
+      options[:reporters] = ["progress"]
+
+      vals = Minitest::ReportersPlugin::MAPPING.keys.join(",")
+      description = <<~DESC.strip
+        The reporters to use for test output as comma-seperated list.
+      DESC
+
+      opts.on("-r", "--reporter #{vals}", Array, description) do |reporters|
+        reporters = options[:reporters] + reporters if reporters == ["junit"]
+
+        is_subset = (reporters - Minitest::ReportersPlugin::MAPPING.keys).empty?
+        raise OptionParser::InvalidArgument, "Invalid reporter: #{reporters.join(", ")}" unless is_subset
+
+        options[:reporters] = reporters
+      end
+    end
+
+    def plugin_reporters_init(options)
+      return if options[:reporters].nil? || options[:reporters].empty?
+
+      require "minitest/reporters"
+
+      reporters = options[:reporters].map do |reporter|
+        ReportersPlugin::MAPPING.fetch(reporter).call(options)
+      end.compact
+
+      Minitest::Reporters.use!(reporters, ENV, Minitest.backtrace_filter) unless reporters.empty?
+    end
+  end
+end

data/lib/minitest/superdiff_plugin.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module Minitest
+  class << self
+    def plugin_superdiff_options(opts, options)
+      opts.on("--no-superdiff", "Disable superdiff") do
+        options[:no_superdiff] = true
+      end
+    end
+
+    def plugin_superdiff_init(options)
+      return if options[:no_superdiff]
+
+      require "super_diff"
+      Minitest::Assertions.prepend(SuperdiffPlugin)
+    end
+  end
+
+  module SuperdiffPlugin
+    module Helpers
+      extend self
+      def inspect_styled(obj, style, prefix: nil)
+        obj = SuperDiff.inspect_object(obj, as_lines: false)
+        SuperDiff::Core::Helpers.style(style, "#{prefix}#{obj}")
+      end
+    end
+
+    def diff(expected, actual)
+      SuperDiff::EqualityMatchers::Main.call(expected: expected, actual: actual)
+    end
+
+    def mu_pp(obj)
+      SuperDiff.inspect_object(obj, as_lines: false)
+    end
+
+    def assert_includes(collection, item, message = nil)
+      super
+    rescue Minitest::Assertion => e
+      raise if message
+
+      exception = Minitest::Assertion.new(AssertIncludesMessage.new(collection: collection, item: item))
+      exception.set_backtrace(e.backtrace)
+      raise exception
+    end
+  end
+
+  class AssertIncludesMessage
+    include SuperdiffPlugin::Helpers
+
+    def initialize(collection:, item:)
+      @collection = collection
+      @item = item
+    end
+
+    def to_s
+      return @to_s if defined?(@to_s)
+
+      content = if (diff = optional_diff)
+        collection = inspect_styled(@collection, :expected)
+        item = inspect_styled(@item, :actual)
+
+        <<~OUTPUT.strip
+          Expected #{collection} to include #{item}, but it did not.
+
+          #{diff}
+        OUTPUT
+      else
+        expected = inspect_styled(@collection, :expected, prefix: "  Collection: ")
+        actual = inspect_styled(@item, :actual, prefix: "Missing item: ")
+
+        <<~OUTPUT.strip
+          Expected collection to include item but it did not.
+
+          #{expected}
+          #{actual}
+        OUTPUT
+      end
+
+      @to_s ||= content
+    end
+
+    def optional_diff
+      case @collection
+      when Array, Set
+        collection_with_item = @collection + [@item].flatten(1)
+        basic_diff(@collection, collection_with_item)
+      end
+    end
+
+    def basic_diff(expected, actual)
+      content = SuperDiff.diff(expected, actual)
+      "\nDiff:\n\n#{content}"
+    end
+  end
+end

data/lib/nicetest/backtrace_filter.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require "pastel"
+
+module Nicetest
+  class BacktraceFilter
+    BUNDLER_REGEX = %r{/bundler/gems}
+    GEMS_DEFAULT_DIR = Regexp.escape(Gem.default_dir)
+    GEMS_PATHS = Gem.path.map { |path| Regexp.new(Regexp.escape(path)) }
+
+    attr_reader :pastel
+
+    def initialize
+      @pastel = Cli::PASTEL
+      @silence_pattern = Regexp.union([
+        /sorbet-runtime/,
+        Regexp.escape(RbConfig::CONFIG["rubylibdir"]),
+        %r{/gems/bundler-\d+\.\d+\.\d+/lib/bundler},
+        %r{/gems/minitest-\d+\.\d+\.\d+/lib/minitest},
+        %r{/gems/minitest-reporters-\d+\.\d+\.\d+/lib/minitest},
+        %r{(bin|exe)/bundle:},
+        /internal:warning/,
+      ])
+      @dim_pattern = Regexp.union([
+        GEMS_DEFAULT_DIR,
+        *GEMS_PATHS,
+        BUNDLER_REGEX,
+      ])
+    end
+
+    def filter(backtrace)
+      bt = []
+      first_line = true
+      cwd = Dir.pwd
+
+      backtrace.each do |line|
+        silenced = silence?(line)
+
+        next if silenced && !first_line
+
+        first_line = false
+
+        bt << if silenced || (dim?(line) && !line.start_with?(cwd))
+          pastel.dim(trim_prefix(line))
+        else
+          colorize_line(trim_prefix(line))
+        end
+      end
+
+      bt
+    end
+
+    def dim?(line)
+      @dim_pattern.match?(line)
+    end
+
+    def silence?(line)
+      @silence_pattern.match?(line)
+    end
+
+    def trim_prefix(line)
+      line = line.delete_prefix(Dir.pwd + "/")
+      line.sub!(ENV["HOME"], "~")
+      line
+    end
+
+    def colorize_line(line)
+      match = line.match(/(.*):(\d+):in `(.*)'/)
+
+      if match
+        file = match[1]
+        line_number = match[2]
+        method = match[3]
+
+        colored_file = pastel.cyan(file)
+        colored_line_number = pastel.green(line_number)
+        colored_method = pastel.yellow(method)
+
+        "#{colored_file}:#{colored_line_number}:in `#{colored_method}'"
+      else
+        line
+      end
+    end
+  end
+end

data/lib/nicetest/cli.rb

@@ -0,0 +1,212 @@
+# frozen_string_literal: true
+
+require "pastel"
+require "minitest"
+require "optparse"
+require "English"
+require "set"
+
+module Nicetest
+  class Cli
+    def initialize(argv)
+      @argv = argv
+      @logger = Logger.new($stderr)
+    end
+
+    def run
+      cli_options = Opts.parse!(@argv)
+      if (dir = cli_options.cd)
+        run_in_directory(dir)
+      elsif File.exist?("Gemfile") && !File.read("Gemfile").include?("nicetest")
+        run_in_directory(".")
+      else
+        run_tests
+      end
+    end
+
+    def run_tests
+      disable_autorun!
+      adjust_load_path!
+
+      args = @argv.dup
+      argv_test_files = select_file_args(args)
+      argv_test_files = glob_test_files("test") if argv_test_files.empty?
+      args -= argv_test_files
+
+      required_files = argv_test_files.flat_map do |file_or_dir|
+        require_path_or_dir(file_or_dir)
+      end
+
+      @logger.fatal!("no test files found") if required_files.compact.empty?
+
+      Minitest.run(args)
+    end
+
+    private
+
+    def fetch_dep_loadpaths(gemspec, seen = {})
+      return [] if seen[gemspec.name]
+
+      seen[gemspec.name] = true
+      load_paths = gemspec.full_require_paths
+
+      gemspec.dependencies.each do |dep|
+        dep_spec = Gem.loaded_specs[dep.name]
+        next unless dep_spec
+
+        load_paths.concat(fetch_dep_loadpaths(dep_spec, seen))
+      end
+
+      load_paths
+    end
+
+    def run_in_directory(input_dir)
+      dir = File.expand_path(input_dir)
+      dir.delete_suffix!("/") # remove trailing slash
+
+      chdir = if input_dir != "."
+        ->(&blk) do
+          @logger.info("changing directory to #{dir}")
+          Dir.chdir(dir, &blk)
+        end
+      else
+        ->(&blk) { blk.call }
+      end
+
+      loadpaths = fetch_dep_loadpaths(Gem.loaded_specs["nicetest"]).map { |path| "-I#{path}" }
+      requires = ["-rnicetest"]
+      args_with_removed_leading_path = @argv.map do |arg|
+        arg = arg.dup
+        arg.delete_prefix!(dir)
+        arg.delete_prefix!(File.expand_path(dir))
+        arg.delete_prefix!("/")
+        arg
+      end
+
+      run_proc = proc do
+        requires << "-rbundler/setup" if File.exist?("Gemfile")
+
+        cmd = [
+          RbConfig.ruby,
+          *loadpaths,
+          *requires,
+          "-e",
+          "exit(Nicetest::Cli.new(ARGV).run_tests)",
+          "--",
+          *args_with_removed_leading_path,
+        ]
+        @logger.debug("running #{cmd.join(" ")}")
+        system(*cmd)
+        $CHILD_STATUS.exitstatus
+      end
+
+      chdir.call do
+        if defined?(Bundler)
+          Bundler.with_unbundled_env(&run_proc)
+        else
+          run_proc.call
+        end
+      end
+    end
+
+    def select_file_args(args)
+      args = args.dup
+      Minitest.instance_variable_set(:@extensions, Set.new) # Avoid double-loading plugins
+      Minitest.load_plugins unless args.delete("--no-plugins") || ENV["MT_NO_PLUGINS"]
+      # this will remove all options from the args array
+      temporarily_disable_optparse_callbacks { Minitest.process_args(args) }
+      args
+    end
+
+    def glob_test_files(dir)
+      Dir.glob("#{dir}/**{,/*/**}/*_test.rb")
+    end
+
+    def require_path_or_dir(path_or_dir)
+      if path_or_dir.end_with?(".rb")
+        [try_require(path_or_dir)]
+      else
+        Dir.glob("#{path_or_dir}/**{,/*/**}/*_test.rb").map do |f|
+          try_require(f)
+        end
+      end
+    end
+
+    def try_require(path)
+      full_path = File.expand_path(path)
+      require full_path
+      true
+    rescue => e
+      bt = e.backtrace.first(10).map { |line| "\t#{PASTEL.dim(line)}" }.join("\n")
+      @logger.warn("could not require #{full_path} (#{e.class}: #{e.message})\n#{bt}")
+      nil
+    end
+
+    def disable_autorun!
+      Minitest.class_variable_set(:@@installed_at_exit, true) # rubocop:disable Style/ClassVars
+    end
+
+    def adjust_load_path!
+      $LOAD_PATH.unshift(File.expand_path("test"))
+    end
+
+    def temporarily_disable_optparse_callbacks(&blk)
+      OptionParser.class_eval do
+        def noop_callback!(*); end
+
+        original_callback = instance_method(:callback!)
+        define_method(:callback!, instance_method(:noop_callback!))
+
+        yield
+
+        define_method(:callback!, original_callback)
+        remove_method(:noop_callback!)
+      end
+    end
+
+    Opts = Struct.new(:cd) do
+      class << self
+        def parse!(argv)
+          old_officious = OptionParser::Officious.dup
+          OptionParser::Officious.clear
+
+          options = new
+          parser = OptionParser.new do |opts|
+            opts.banner = ""
+            opts.raise_unknown = false
+            opts.on("--cd=DIR", "Change directory before running tests") do |dir|
+              options[:cd] = dir
+            end
+          end
+
+          parser.parse!(argv)
+          OptionParser::Officious.replace(old_officious)
+          options
+        end
+      end
+    end
+
+    PASTEL = Pastel.new
+
+    BANNER = <<~BANNER
+      ☀️  #{PASTEL.bold.cyan("nicetest")} #{PASTEL.dim.italic(Nicetest::VERSION)}
+
+        A minimalistic test runner for Minitest.
+
+      #{PASTEL.bold("Usage")}
+
+        nicetest [options] [files or directories]
+
+      #{PASTEL.bold("Examples")}
+
+        $ nicetest
+        $ nicetest test/models --reporter spec
+        $ nicetest test/models/user_test.rb:12
+
+      #{PASTEL.bold("Nicetest Options")}
+        --cd=DIR  Change directory before running tests
+      #{PASTEL.bold("Minitest Options")}
+
+    BANNER
+  end
+end

data/lib/nicetest/logger.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require "logger"
+
+module Nicetest
+  class Logger
+    def initialize(io)
+      @pastel = Cli::PASTEL
+      @io = io
+    end
+
+    def warn(message)
+      log("warn ", message, color: :yellow)
+    end
+
+    def error(message)
+      log("error", message, color: :red)
+    end
+
+    def info(message)
+      log("info ", message, color: :cyan)
+    end
+
+    def debug(message)
+      if ENV["NICETEST_DEBUG"] == "1"
+        log("debug", message, color: :blue)
+      end
+    end
+
+    def fatal!(message)
+      error(message)
+      exit(1)
+    end
+
+    private
+
+    def log(level, message, color:)
+      @io.puts "#{target_level(level, color: color)} #{message}"
+    end
+
+    def target_level(level, color:)
+      level = @pastel.bold.send(color, level)
+      logname = @pastel.dim.italic("nicetest →")
+      "#{level} #{logname}"
+    end
+  end
+end

data/lib/nicetest/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Nicetest
+  VERSION = "0.1.0"
+end

data/lib/nicetest.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "pastel"
+require "minitest/focus"
+
+require_relative "nicetest/version"
+require_relative "nicetest/logger"
+require_relative "nicetest/cli"
+require_relative "nicetest/backtrace_filter"
+
+module Nicetest
+  class Error < StandardError; end
+
+  class << self
+    def logger
+      @logger ||= Logger.new($stderr)
+    end
+  end
+end

metadata

@@ -0,0 +1,162 @@
+--- !ruby/object:Gem::Specification
+name: nicetest
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Ian Ker-Seymer
+autorequire:
+bindir: exe
+cert_chain:
+- |
+  -----BEGIN CERTIFICATE-----
+  MIIDODCCAiCgAwIBAgIBAjANBgkqhkiG9w0BAQsFADBCMRQwEgYDVQQDDAtpLmtl
+  cnNleW1lcjEVMBMGCgmSJomT8ixkARkWBWdtYWlsMRMwEQYKCZImiZPyLGQBGRYD
+  Y29tMB4XDTI0MDQxODA1MzY0N1oXDTI1MDQxODA1MzY0N1owQjEUMBIGA1UEAwwL
+  aS5rZXJzZXltZXIxFTATBgoJkiaJk/IsZAEZFgVnbWFpbDETMBEGCgmSJomT8ixk
+  ARkWA2NvbTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAMJ2pG+er4cP
+  PasxsMIKL9/tmLL4gh80EMuF3SCS0qZoh+Oo8dkvRYxW8NXdwEIcp3cCNgE+5G+J
+  TCMOVF8S15n1Z1P7xxXiXxa/BIofKKbtatVRngm14uR/6pjdkvLXqlrWdS57bNwv
+  7LtpzYVfDHfsl/qRWaEi4jq00PNCRSWjcva8teqswjBg8KlwGtyygpezPbVSWP8Y
+  vzWZmVF7fqRBXU78Ah0+pNOhslBXDTvI3xJdN4hQ3H7rLjpD/qxKWq/8o+Qvx6cX
+  dNZ3ugH/Pr3BAsqt4JFLXin9AK7PO9GDMH5JXJrUb+hAt2VNIZqpz9VlKA6BA0jN
+  eWGea+yCZkECAwEAAaM5MDcwCQYDVR0TBAIwADALBgNVHQ8EBAMCBLAwHQYDVR0O
+  BBYEFOkrF6hsocaIMOjR/K3JBzyXCLJPMA0GCSqGSIb3DQEBCwUAA4IBAQARHgco
+  yCxWUqN+HBGewmSB7T4oq6YS2FtU62K+GuWWCTqjl5byLKMXQW8HPDja9TC1My1m
+  2r0uDshtUvUjuB/Vfe9jVMTjnPBspHZYo0MRuMPc7owJaahjkqD3l7w9aa8Ci5aC
+  YU4Aj71Sc8s7YIxgHn/yIUdCe1yu6cC0+h+Ss9r/Yjr53NNXwjGQlDmH1eHcVQGZ
+  mEoVcZO1uWNtRPPsn1gfvKLPjRe5pclXQnGviS5DiH0Du+8QMxQGBJnYz2zSMW7G
+  Lvd35BNvZkhFzs9xfykhurpkT2TiP2F3ZFn9dwLXMFe41pwrtEYLIWhYi8mUG4Ek
+  6aR8M/tqIpChVV39
+  -----END CERTIFICATE-----
+date: 2024-07-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.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-reporters
+  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: optparse
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.5.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.5.0
+- !ruby/object:Gem::Dependency
+  name: pastel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+- !ruby/object:Gem::Dependency
+  name: super_diff
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.12'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.12'
+description: Configure Minitest with common plugins and options to make it even nicer
+  to use.
+email:
+- ian.kerseymer@shopify.com
+executables:
+- nicetest
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- exe/nicetest
+- lib/minitest/nicetest_plugin.rb
+- lib/minitest/reporters_plugin.rb
+- lib/minitest/superdiff_plugin.rb
+- lib/nicetest.rb
+- lib/nicetest/backtrace_filter.rb
+- lib/nicetest/cli.rb
+- lib/nicetest/logger.rb
+- lib/nicetest/version.rb
+homepage: https://github.com/ianks/nicetest
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.9
+signing_key:
+specification_version: 4
+summary: A slightly fancier configuration for Minitest
+test_files: []