test-map 0.2.1 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cd8d77a4693229a3bdc64882a2771830090f7b04ae977df9eec5386e3ffc16e3
-  data.tar.gz: dc04407d47b77d1b5a6418072c8e380a327417a82fe27a21f31e1020d7b6b2aa
+  metadata.gz: 502e7e183acdd6b0f2576ad014d920a1c00b4233f08cdfaf57243ed4814b1c1b
+  data.tar.gz: 4d50c652f8ffa46c485ab2da15c5ddd5da022cd856aac394375679f07ea083b8
 SHA512:
-  metadata.gz: d80247e944cecd9b3c06b48b63bae9052589f97713496f674dc9ad23524ebfe6e8bb0720d38a90d0ba9b0874cb33c6a9422d6cd9bf3c49c2f8db252c26dde011
-  data.tar.gz: 1690f86016ea54148386896023ba40e22210e2559c8d7dd175c7b728c458a9e2abdfdaa7f3a73997cbb4da446186e51033313a35df8c3e7e158a1a8cd8359f5a
+  metadata.gz: 60480addcb32f9528c65895488190f4a7c01623b437e9818ff81e85f081b4e884e8fc3afb5684b4105b2eb52010ae1f1e182e2fbae0574a690c2404b86af3314
+  data.tar.gz: 61ce5a7bb1bd602f018e6e64b141bdfddbf52bbd61c72794796823d04b8b0a225f1748a6d66afe1d0540bfd85e31d34ed3cc3dd9c368ad543a2ecacfe0f898a5

data/CHANGELOG.md

@@ -6,6 +6,17 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](http://keepachangelog.com/)
 and this project adheres to [Semantic Versioning](http://semver.org/).
 
+## 0.4.0 - 2026-03-07
+
+Extend reporting and cache handling for minitest and rspec. Add caches at
+processing and profiling events. Optimize execution by reducing excessive
+calls and calculations.
+
+## 0.3.0 - 2026-03-01
+
+Introduce test cache and remove changes runner. Removed `test:changes` Rake
+task as it is no longer needed.
+
 ## 0.2.0 - 2024-10-25
 
 Provide explicit Test Task via Rake for Minitest, Rspec, and Rails. Extend

data/README.md

@@ -4,12 +4,10 @@
 Track associated files of executed tests to optimize test execution on file
 changes.
 
-Test-Map results in a file that maps test files to the files they depend on.
-You can use this file to run only the tests that are affected by a file change.
-This is useful when you have a large test suite and want to optimize the time
-spent running tests. Submit a change request and only run tests that depend on
-what you changed. Optimizing in such way, the time spent waiting for CI to
-verify can be reduced to seconds.
+Test-Map records which source files each test touches and caches their
+checksums. On subsequent runs, tests whose dependencies haven't changed are
+automatically skipped. This is useful when you have a large test suite and want
+to optimize the time spent running tests locally or in CI.
 
 ## Usage
 
@@ -19,59 +17,89 @@ Add test-map to your Gemfile.
 $ bundle add test-map
 ```
 
-### Minitest
-
-Include test-map in your test helper. Typically you want to include it
-conditionally so it only generates the test map when needed.
+Require test-map in your test helper or spec helper.
 
 ```ruby
 # filename: test/test_helper.rb
-
-# Include test-map after minitest has been required
-require 'test_map' if ENV['TEST_MAP']
+require 'test_map'
 ```
 
-Run your tests with the `TEST_MAP` environment variable set.
+## Example Run
+
+Running the testsuite, test-map creates a mapping of tests to their code files,
+as well as a test-file result cache. Running the testsuite again, all
+successfully run tests are cached and skipped. Chaning a file, **only tests
+that need to be run are executed**.
 
 ```sh
-$ TEST_MAP=1 bundle exec ruby -Itest test/models/user_test.rb
-# or
-$ TEST_MAP=1 bundle exec rake test
+# Running the testsuite for the first time, all tests are executed and mapped
+ > be rake
+Run options: --seed 10112
+
+# Running:
+
+.......................................................
+
+Finished in 0.042190s, 1303.6402 runs/s, 1730.2861 assertions/s.
+55 runs, 73 assertions, 0 failures, 0 errors, 0 skips, 0 cached
+
+# Running again without changes, all tests are cached and skipped
+ > be rake
+Run options: --seed 40581
+
+# Running:
+
+CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC
+
+Finished in 0.007902s, 6960.1126 runs/s, 0.0000 assertions/s.
+55 runs, 0 assertions, 0 failures, 0 errors, 0 skips, 55 cached
+
+# Change a file and rerun the testsuite
+ > be rake
+Run options: --seed 47682
+
+# Running:
+
+CCCCCCCCCC...CCCCCCCCCCCC.....CCCCCCCCCCCCCCCCCCCCCCCCC
+
+Finished in 0.014029s, 3920.3764 runs/s, 570.2366 assertions/s.
+55 runs, 8 assertions, 0 failures, 0 errors, 0 skips, 47 cached
 ```
 
-Using the a dedicated rake task you can connect a file watcher and trigger
-tests on file changes.
+### Minitest
+
+Include test-map in your test helper.
 
 ```ruby
-# filename: Rakefile
-require 'test_map/test_task'
+# filename: test/test_helper.rb
 
-TestMap::TestTask.create
+# Include test-map after minitest has been required
+require 'test_map'
 ```
 
-Using [entr](https://eradman.com/entrproject/) as example file watcher.
+Run your tests. On the first run test-map records file dependencies into
+`.test-map.yml` and checksums into `.test-cache.yml`. On subsequent runs,
+tests whose source files haven't changed are automatically skipped.
 
 ```sh
-# find all ruby files | watch them, postpone first execution, clear screen
-#   with every run and on file change run test suite for the changed file
-#   (placeholder /_).
-$ find . -name "*.rb" | entr -cp bundle exec rake test:changes /_
+$ bundle exec ruby -Itest test/models/user_test.rb
+# or
+$ bundle exec rake test
 ```
 
 ### Rspec
 
-Include test-map in your test helper. Typically you want to include it
-conditionally so it only generates the test map when needed.
+Include test-map in your spec helper.
 
 ```ruby
 # filename: spec/spec_helper.rb
-require 'test_map' if ENV['TEST_MAP']
+require 'test_map'
 ```
 
-Run your tests with the `TEST_MAP` environment variable set.
+Run your tests. Caching works the same as with Minitest.
 
 ```sh
-$ TEST_MAP=1 bundle exec rspec
+$ bundle exec rspec
 ```
 
 ## Configuration
@@ -83,6 +111,7 @@ TestMap::Config.configure do |config|
   config[:logger] = Logger.new($stdout) # default logs to dev/null
   config[:merge] = false # merge results (e.g. with multiple testsuites)
   config[:out_file] = 'my-test-map.yml' # default is .test-map.yml
+  config[:cache_file] = 'my-test-cache.yml' # default is .test-cache.yml
   # defaults to [%r{^(vendor)/}] }
   config[:exclude_patterns] = [%r{^(vendor|other_libraries)/}]
   # register a custom rule to match new files; must implement `call(file)`;
@@ -93,14 +122,6 @@ end
 
 ## Development
 
-Open list of features:
-
-- [x] Configure file exclude list (e.g. test files are not needed).
-- [ ] Auto-handle packs, packs with subdirectories.
-- [x] Demonstrate usage with file watchers.
-- [ ] Demonstrate CI pipelines with GitHub actions and GitLab CI.
-- [x] Merge results.
-
 ```sh
 $ bundle install # install dependencies
 $ bundle exec rake # run testsuite

data/lib/test_map/cache.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require 'digest'
+require 'yaml'
+
+module TestMap
+  # Cache tracks file checksums to skip unchanged tests.
+  class Cache
+    GLOBAL_FILES = %w[Gemfile.lock .ruby-version].freeze
+
+    def initialize(cache_file, map_file, root: Dir.pwd)
+      @cache_file = cache_file
+      @map_file = map_file
+      @root = root
+      @global_files_changed = nil
+      @current_checksums = {}
+      @file_exists_cache = {}
+    end
+
+    def fresh?(test_file)
+      return false unless cached_checksums
+      return false if global_files_changed?
+
+      files_to_check = [test_file].concat(source_files_for(test_file))
+      files_to_check.all? { |f| file_exist?(f) && current_checksum(f) == cached_checksums[f] }
+    end
+
+    def write(results)
+      all_files = collect_tracked_files(results)
+      checksums = all_files.each_with_object({}) do |file, hash|
+        hash[file] = current_checksum(file) if file_exist?(file)
+      end
+      File.write(@cache_file, checksums.sort.to_h.to_yaml)
+    end
+
+    private
+
+    def cached_checksums
+      @cached_checksums ||= File.exist?(@cache_file) && YAML.safe_load_file(@cache_file)
+    end
+
+    def global_files_changed?
+      return @global_files_changed unless @global_files_changed.nil?
+
+      @global_files_changed = GLOBAL_FILES.any? do |f|
+        file_exist?(f) && current_checksum(f) != cached_checksums[f]
+      end
+    end
+
+    def inverted_map = @inverted_map ||= build_inverted_map
+
+    def build_inverted_map
+      return {} unless File.exist?(@map_file)
+
+      map = YAML.safe_load_file(@map_file)
+      inverted = Hash.new { |h, k| h[k] = [] }
+      map.each do |source, tests|
+        tests.each { |t| inverted[t] << source }
+      end
+      inverted
+    end
+
+    def source_files_for(test_file)
+      inverted_map[test_file] || []
+    end
+
+    def current_checksum(file)
+      @current_checksums[file] ||= Digest::SHA256.file(File.join(@root, file)).hexdigest
+    end
+
+    def file_exist?(file)
+      return @file_exists_cache[file] if @file_exists_cache.key?(file)
+
+      @file_exists_cache[file] = File.exist?(File.join(@root, file))
+    end
+
+    def collect_tracked_files(results)
+      sources = results.keys
+      tests = results.values.flatten.uniq
+      all = (sources + tests + GLOBAL_FILES).uniq
+      all.select { |f| file_exist?(f) }
+    end
+  end
+end

data/lib/test_map/config.rb

@@ -11,6 +11,7 @@ module TestMap
 
     def self.default_config
       { logger: Logger.new('/dev/null'), out_file: '.test-map.yml',
+        cache_file: '.test-cache.yml',
         exclude_patterns: [%r{^(vendor)/}], natural_mapping: nil,
         skip_files: [%r{^(test/)}], merge: false }
     end

data/lib/test_map/event.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module TestMap
+  # Publish/subscribe event bus. No overhead when no subscribers.
+  #
+  # Topics use `type.action` format, e.g. `cache.create`, `map.create`.
+  #
+  # Block form measures elapsed time and passes it to subscribers:
+  #   Event.publish('cache.create') { write_cache }
+  #
+  # Fire-and-forget form for simple notifications:
+  #   Event.publish('cache.found', test_file:)
+  module Event
+    @subscribers = {}
+
+    class << self
+      def subscribe(topic, &block)
+        (@subscribers[topic] ||= []) << block
+      end
+
+      def publish(topic, **payload, &block)
+        listeners = @subscribers[topic]
+        return notify(listeners, topic, **payload) unless block
+        return yield unless listeners
+
+        publish_with_timing(listeners, topic, **payload, &block)
+      end
+
+      def reset
+        @subscribers = {}
+      end
+
+      private
+
+      def notify(listeners, topic, **payload)
+        listeners&.each { |cb| cb.call(topic, **payload) }
+      end
+
+      def publish_with_timing(listeners, topic, **payload)
+        start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        result = yield
+        elapsed = Process.clock_gettime(Process::CLOCK_MONOTONIC) - start
+        listeners.each { |cb| cb.call(topic, elapsed:, **payload) }
+        result
+      end
+    end
+  end
+end

data/lib/test_map/file_recorder.rb

@@ -26,8 +26,9 @@ module TestMap
     def results
       raise NotTracedError.default unless @trace
 
-      @files.filter { _1.start_with? Dir.pwd }
-            .map { _1.sub("#{Dir.pwd}/", '') }
+      cwd = "#{Dir.pwd}/"
+      @files.filter { _1.start_with? cwd }
+            .map { _1.sub(cwd, '') }
             .then { Filter.call _1 }
     end
   end

data/lib/test_map/plugins/minitest/cache_reporter.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module TestMap
+  module Plugins
+    module Minitest
+      # Reporter that tracks cached test count and appends it to the summary.
+      class CacheReporter < ::Minitest::StatisticsReporter
+        attr_accessor :cached, :composite
+
+        def initialize(io = $stdout, options = {}, composite: nil)
+          super(io, options)
+          self.cached = 0
+          self.composite = composite
+        end
+
+        def record(result)
+          super
+          self.cached += 1 if result.failure.is_a?(TestMap::CachedSkip)
+        end
+
+        def report
+          super
+          return unless composite
+
+          summary_reporter = composite.reporters.find { |r| r.is_a?(::Minitest::SummaryReporter) }
+          return unless summary_reporter
+
+          summary_reporter.results.reject! { |r| r.failure.is_a?(TestMap::CachedSkip) }
+          summary_reporter.skips -= cached if summary_reporter.skips
+          patch_summary(summary_reporter)
+        end
+
+        private
+
+        def patch_summary(summary_reporter)
+          cached_count = cached
+          original_summary = summary_reporter.method(:summary)
+
+          summary_reporter.define_singleton_method(:summary) do
+            "#{original_summary.call}, #{cached_count} cached"
+          end
+        end
+      end
+    end
+  end
+end
+
+module Minitest # :nodoc:
+  def self.plugin_test_map_cache_init(options)
+    cache_reporter = TestMap::Plugins::Minitest::CacheReporter.new(options[:io], options, composite: reporter)
+    reporter.reporters.unshift(cache_reporter)
+  end
+end

data/lib/test_map/plugins/minitest.rb

@@ -1,27 +1,85 @@
 # frozen_string_literal: true
 
+module TestMap
+  # CachedSkip is raised to skip tests whose files haven't changed.
+  # Subclasses Minitest::Skip so Minitest treats it as a skip, but the
+  # custom reporter can distinguish it and show `C` instead of `S`.
+  class CachedSkip < Minitest::Skip
+    def initialize(msg = 'test-map: cached')
+      super
+    end
+
+    def result_label
+      'Cached'
+    end
+  end
+end
+
+require_relative 'minitest/cache_reporter'
+
 module TestMap
   module Plugins
     # Minitest plugin for TestMap.
     module Minitest
       def self.included(_base)
         TestMap.logger.info 'Registering hooks for Minitest'
-        ::Minitest.after_run do
-          TestMap.reporter.write "#{Dir.pwd}/#{Config.config[:out_file]}"
+        TestMap.suite_passed = true
+
+        ::Minitest.after_run { write_results }
+        install_cache_reporter
+      end
+
+      def self.install_cache_reporter
+        ::Minitest.extensions << 'test_map_cache'
+      end
+
+      def self.write_results
+        out_file = "#{Dir.pwd}/#{Config.config[:out_file]}"
+        reporter_results = TestMap.reporter.results
+
+        # All tests were cache-skipped, existing files are still valid
+        return if reporter_results.empty?
+
+        full_results = merge_results(out_file, reporter_results)
+        File.write(out_file, full_results.to_yaml)
+        TestMap.cache.write(full_results) if TestMap.suite_passed
+      end
+
+      # Merge with existing map to preserve mappings for cache-skipped tests
+      def self.merge_results(out_file, reporter_results)
+        if File.exist?(out_file)
+          TestMap.reporter.merge(reporter_results, YAML.safe_load_file(out_file))
+        else
+          reporter_results
         end
       end
 
-      def after_setup
-        @recorder = FileRecorder.new.tap(&:trace)
+      def before_setup
+        test_file = resolve_test_file
+        raise TestMap::CachedSkip if test_file && TestMap.cache.fresh?(test_file)
 
+        @recorder = FileRecorder.new.tap(&:trace)
         super
       end
 
       def before_teardown
         super
 
+        return unless @recorder
+
         @recorder.stop
         TestMap.reporter.add @recorder.results
+
+        TestMap.suite_passed = false if !passed? && !skipped?
+      end
+
+      private
+
+      def resolve_test_file
+        file = method(name).source_location&.first
+        return unless file
+
+        file.sub("#{Dir.pwd}/", '')
       end
     end
   end

data/lib/test_map/plugins/rspec/cache_formatter.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require 'rspec/core/formatters/progress_formatter'
+
+module TestMap
+  module Plugins
+    module RSpec
+      # Formatter that shows `C` for cached tests instead of `*` (pending).
+      # Extends ProgressFormatter so it can serve as the default formatter.
+      # Adjusts the summary to show cached count and filters cached tests
+      # from the pending output.
+      class CacheFormatter < ::RSpec::Core::Formatters::ProgressFormatter
+        CACHED_MESSAGE = 'test-map: cached'
+
+        ::RSpec::Core::Formatters.register self,
+                                           :example_passed, :example_pending, :example_failed,
+                                           :start_dump, :dump_summary, :dump_pending
+
+        def initialize(output)
+          super
+          @cached_count = 0
+        end
+
+        def example_pending(notification)
+          if cached?(notification.example)
+            @cached_count += 1
+            output.print ::RSpec::Core::Formatters::ConsoleCodes.wrap('c', :cyan)
+          else
+            super
+          end
+        end
+
+        def dump_pending(notification)
+          examples = notification.pending_examples
+          cached = examples.select { |ex| cached?(ex) }
+          return if examples.size == cached.size
+
+          cached.each { |ex| examples.delete(ex) }
+          super
+          cached.each { |ex| examples.push(ex) }
+        end
+
+        def dump_summary(summary)
+          if @cached_count.positive?
+            cached_count = @cached_count
+            original_totals_line = summary.method(:totals_line)
+            summary.define_singleton_method(:totals_line) do
+              "#{original_totals_line.call}, #{cached_count} cached"
+            end
+          end
+          super
+        end
+
+        private
+
+        def cached?(example)
+          example.execution_result.pending_message == CACHED_MESSAGE
+        end
+      end
+    end
+  end
+end

data/lib/test_map/plugins/rspec.rb

@@ -1,16 +1,57 @@
 # frozen_string_literal: true
 
+require_relative 'rspec/cache_formatter'
+
 TestMap.logger.info 'Loading RSpec plugin'
+TestMap.suite_passed = true
+
+module TestMap
+  module Plugins
+    # RSpec integration for TestMap.
+    module RSpec
+      def self.write_results
+        out_file = "#{Dir.pwd}/#{Config.config[:out_file]}"
+        reporter_results = TestMap.reporter.results
+
+        # All tests were cache-skipped, existing files are still valid
+        return if reporter_results.empty?
+
+        full_results = merge_results(out_file, reporter_results)
+        File.write(out_file, full_results.to_yaml)
+        TestMap.cache.write(full_results) if TestMap.suite_passed
+      end
+
+      # Merge with existing map to preserve mappings for cache-skipped tests
+      def self.merge_results(out_file, reporter_results)
+        if File.exist?(out_file)
+          TestMap.reporter.merge(reporter_results, YAML.safe_load_file(out_file))
+        else
+          reporter_results
+        end
+      end
+    end
+  end
+end
 
 RSpec.configure do |config|
-  config.around(:example) do |example|
-    # path = example.metadata[:example_group][:file_path]
-    recorder = TestMap::FileRecorder.new
-    recorder.trace { example.run }
-    TestMap.reporter.add recorder.results
+  config.default_formatter = TestMap::Plugins::RSpec::CacheFormatter
+
+  config.before(:context) do
+    test_file = self.class.metadata[:file_path].sub("#{Dir.pwd}/", '').sub(%r{^\./}, '')
+    skip TestMap::Plugins::RSpec::CacheFormatter::CACHED_MESSAGE if TestMap.cache.fresh?(test_file)
   end
 
-  config.after(:suite) do
-    TestMap.reporter.write "#{Dir.pwd}/#{TestMap::Config.config[:out_file]}"
+  config.around(:example) do |example|
+    if example.metadata[:skip]
+      example.run
+    else
+      recorder = TestMap::FileRecorder.new
+      recorder.trace { example.run }
+      TestMap.reporter.add recorder.results
+
+      TestMap.suite_passed = false if example.exception && !example.skipped?
+    end
   end
+
+  config.after(:suite) { TestMap::Plugins::RSpec.write_results }
 end

data/lib/test_map/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module TestMap
-  VERSION = '0.2.1'
+  VERSION = '0.4.0'
 end

data/lib/test_map.rb

@@ -8,11 +8,24 @@ require_relative 'test_map/report'
 require_relative 'test_map/file_recorder'
 require_relative 'test_map/natural_mapping'
 require_relative 'test_map/mapping'
+require_relative 'test_map/cache'
+require_relative 'test_map/event'
 
 # TestMap records associated files to test execution.
 module TestMap
   def self.reporter = @reporter ||= Report.new
   def self.logger = Config.config[:logger]
+
+  def self.cache
+    @cache ||= Cache.new(
+      "#{Dir.pwd}/#{Config[:cache_file]}",
+      "#{Dir.pwd}/#{Config[:out_file]}"
+    )
+  end
+
+  class << self
+    attr_accessor :suite_passed
+  end
 end
 
 # Load plugins for supported test frameworks.

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: test-map
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.4.0
 platform: ruby
 authors:
 - Christoph Lipautz
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-10-28 00:00:00.000000000 Z
+date: 2026-03-07 00:00:00.000000000 Z
 dependencies: []
 description: |
   Track files that are covered by test files to execute only the necessary
@@ -25,16 +25,19 @@ files:
 - LICENSE.txt
 - README.md
 - lib/test_map.rb
+- lib/test_map/cache.rb
 - lib/test_map/config.rb
 - lib/test_map/errors.rb
+- lib/test_map/event.rb
 - lib/test_map/file_recorder.rb
 - lib/test_map/filter.rb
 - lib/test_map/mapping.rb
 - lib/test_map/natural_mapping.rb
 - lib/test_map/plugins/minitest.rb
+- lib/test_map/plugins/minitest/cache_reporter.rb
 - lib/test_map/plugins/rspec.rb
+- lib/test_map/plugins/rspec/cache_formatter.rb
 - lib/test_map/report.rb
-- lib/test_map/test_task.rb
 - lib/test_map/version.rb
 homepage: https://github.com/unused/test-map
 licenses: []
@@ -43,7 +46,7 @@ metadata:
   source_code_uri: https://github.com/unused/test-map
   changelog_uri: https://github.com/unused/test-map/main/blob/main/CHANGELOG.md
   rubygems_mfa_required: 'true'
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -51,15 +54,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 3.0.0
+      version: 3.2.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.16
-signing_key: 
+rubygems_version: 3.4.10
+signing_key:
 specification_version: 4
 summary: Track associated files of tests.
 test_files: []

data/lib/test_map/test_task.rb

@@ -1,73 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'mapping'
-require 'rake/testtask'
-require 'minitest'
-require 'minitest/unit'
-
-module TestMap
-  # TestTask is a rake helper class.
-  class TestTask < Rake::TaskLib
-    # Error for unknown test task adapter.
-    class UnknownAdapterError < StandardError; end
-
-    def initialize(name) # rubocop:disable Lint/MissingSuper
-      @name = name
-    end
-
-    # Adapter for rspec test task
-    class RailsTestTask
-      attr_accessor :files
-
-      def call = Rails::TestUnit::Runner.run_from_rake('test', files)
-    end
-
-    # Adapter for minitest test task.
-    class MinitestTask < Minitest::TestTask
-      def call = ruby(make_test_cmd, verbose: false)
-
-      def files=(test_files)
-        self.test_globs = test_files
-      end
-    end
-
-    # Adapter for rspec test task
-    class RSpecTask
-      attr_accessor :files
-
-      def call = `rspec #{files.join(' ')}`
-    end
-
-    def self.create(name = :test) = new(name).define
-
-    def define
-      namespace @name do
-        desc 'Run tests for changed files'
-        task :changes do
-          out_file = "#{Dir.pwd}/.test-map.yml"
-          args = defined?(Rails) ? ENV['TEST']&.split : ARGV[1..]
-          test_files = Mapping.new(out_file).lookup(*args)
-
-          # puts "Running tests #{test_files.join(' ')}"
-          test_task.files = test_files
-          test_task.call
-        end
-      end
-    end
-
-    def test_task = @test_task ||= build_test_task
-
-    def build_test_task
-      if defined?(Rails)
-        return RailsTestTask.new
-      elsif defined?(Minitest)
-        require 'minitest/test_task'
-        return MinitestTask.new
-      elsif defined?(RSpec)
-        return RSpecTask.new
-      end
-
-      raise UnknownAdapterError, 'No test task adapter found'
-    end
-  end
-end