klenod-test 0.0.5

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 469fd8edab3de5dd48965dbb967cde185bc2e0b90f4081b9c7581adff7ee8287
+  data.tar.gz: e5f5c39e24cb625f210d083741749218f16dca6603901f5aa71dc3aeb8303ff1
+SHA512:
+  metadata.gz: 4de48c343c46d765d52b0883c18b82d8599bd5a8d4eb3cad2068a01752fe4a3ed950c6491f96bcf8fe6c33a3bbf109f7475a4fb2e54b6b2ec710f1fad0f38db6
+  data.tar.gz: 3ab7371fe5dd99eb681ead786a718c8b07bdd5febd073900d0763babc8a249233680ce61b5778327acfba7d836c44938ab233ea4791bd3a184cab4f4279140b6

data/README.md

@@ -0,0 +1,98 @@
+# klenod-test
+
+`klenod-test` discovers and runs application tests without choosing a test
+framework. Add its plugin to the application's build configuration:
+
+```ruby
+plugins [
+  Klenod::Test::Plugin.new,
+  Klenod::Build::Plugins::RubyPlugin.new
+]
+```
+
+The plugin finds `*.test.rb` files in deterministic order and prevents
+application modules and other tests from importing them. Tests can import normal
+application modules. `Klenod::Test::Suite` indexes each test's eager and lazy
+dependency closure without evaluating application code.
+
+The runner can run the full suite once or watch the module graph and rerun only
+tests related to a change. Install the `klenod` meta-gem and run it from an
+application directory:
+
+```sh
+bundle exec klenod test --run
+bundle exec klenod test --watch
+```
+
+Without an option, the command watches unless `CI` is set.
+
+The command searches the current directory and its parents for
+`klenod.test.rb`. The file supplies the application-specific context and test
+framework adapter:
+
+```ruby
+context do
+  path = File.expand_path("klenod.config.rb", __dir__)
+  Klenod::Build::ConfigLoader.load(path).context
+end
+
+execute do |context, test_paths|
+  # Register and run the selected test modules, then return an exit status.
+end
+
+format_error do |error, context|
+  # Optionally format collection or evaluation errors.
+end
+```
+
+The runner does not choose a testing framework. Applications provide a context
+factory and an execution callback. The same runner is also available as a Ruby
+API:
+
+```ruby
+runner = Klenod::Test::Runner.new(
+  context: -> { build_config.context },
+  execute: ->(context, test_paths) { run_tests(context, test_paths) },
+  watch: true
+)
+
+exit runner.call
+```
+
+Each batch runs in a fresh worker process. The execution callback receives that
+worker's context and sorted source-relative test paths, then returns an integer
+exit status. By default, the runner starts the current Ruby program with
+`--worker -- <test paths>`. A runner created by that program recognizes those
+arguments automatically and executes the callback instead of starting another
+worker. Pass `worker_command` and `worker_paths` explicitly when embedding the
+runner in a command with its own argument handling.
+
+## Coverage
+
+Run the complete test suite once under Covered:
+
+```sh
+bundle exec klenod coverage
+bundle exec klenod coverage --report partial --minimum 90
+```
+
+Coverage defaults to the brief report with no required minimum. Configure both
+defaults in `klenod.test.rb`:
+
+```ruby
+coverage report: :brief, minimum: 90
+```
+
+Command-line values override the configuration. Reports may be `brief`,
+`partial`, `full`, `markdown`, or `quiet`. The minimum is an overall percentage
+from 0 through 100; falling below it returns a failing status.
+
+Coverage includes evaluated application Ruby and source-mapped modules. Klenod
+maps generated execution lines back to the original Haml, Markdown, or other
+plugin source. It excludes test modules, gem and virtual modules, and generated
+wrappers for data files. Source files which no test evaluates are not synthesized
+into the report.
+
+Collection wraps the application's existing `execute` callback, so it does not
+depend on Minitest, RSpec, or another test framework. Frameworks that start
+independent subprocesses need their own subprocess coverage integration.

data/lib/klenod/test/cli.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+require "rbconfig"
+
+require "klenod/build/cli"
+
+require_relative "config"
+require_relative "coverage"
+require_relative "runner"
+
+module Klenod
+  module Test
+    module CLI
+      class Command < Samovar::Command
+        self.description = "Run and watch application tests."
+
+        options do
+          option "--run", "Run all tests once."
+          option "--watch", "Run all tests, then watch for changes."
+          option "--worker", "Run selected test files in a worker process."
+        end
+
+        split :test_paths, "Test paths passed to the worker."
+
+        def call
+          config_path = ConfigLoader.find
+          unless config_path
+            output.puts "Could not find klenod.test.rb"
+            return 1
+          end
+
+          config = ConfigLoader.load(config_path)
+          Dir.chdir(config.base_dir) do
+            Klenod::Test::Runner.new(
+              context: config.context,
+              execute: config.execute,
+              **runner_options,
+              worker_command: worker_command,
+              output:,
+              format_error: config.format_error
+            ).call
+          end
+        rescue ConfigError => error
+          output.puts error.message
+          1
+        end
+
+        private
+
+        def runner_options
+          selected = [@options[:run] && false, @options[:watch] && true].compact
+          raise ConfigError, "Choose either --run or --watch" if selected.length > 1
+
+          paths = Array(@test_paths)
+          if @options[:worker]
+            raise ConfigError, "--worker cannot be combined with --run or --watch" unless selected.empty?
+
+            {worker_paths: paths}
+          elsif paths.empty?
+            selected.empty? ? {} : {watch: selected.first}
+          else
+            raise ConfigError, "Test paths are only accepted with --worker"
+          end
+        end
+
+        def worker_command
+          [RbConfig.ruby, Gem.bin_path("klenod", "klenod"), "test"]
+        end
+      end
+
+      class CoverageCommand < Samovar::Command
+        self.description = "Run the full application test suite with coverage."
+
+        options do
+          option "--report <name>", "Coverage report: brief, partial, full, markdown, or quiet."
+          option "--minimum <percent>", "Fail below this overall coverage percentage."
+          option "--worker", "Run selected test files in a coverage worker process."
+        end
+
+        split :test_paths, "Test paths passed to the worker."
+
+        def call
+          config_path = ConfigLoader.find
+          unless config_path
+            output.puts "Could not find klenod.test.rb"
+            return 1
+          end
+
+          config = ConfigLoader.load(config_path)
+          coverage_config = coverage_config(config.coverage)
+          Dir.chdir(config.base_dir) do
+            Klenod::Test::Runner.new(
+              context: config.context,
+              execute: coverage_execute(config, coverage_config),
+              watch: false,
+              worker_paths: worker_paths,
+              spawn_empty: true,
+              worker_command: worker_command,
+              output:,
+              format_error: config.format_error
+            ).call
+          end
+        rescue ConfigError => error
+          output.puts error.message
+          1
+        end
+
+        private
+
+        def coverage_config(config)
+          CoverageConfig.build(
+            report: @options[:report] || config.report,
+            minimum: @options[:minimum] || config.minimum
+          )
+        end
+
+        def coverage_execute(config, coverage_config)
+          lambda do |context, test_paths|
+            plugin = context.graph.plugins.find { it.is_a?(Klenod::Test::Plugin) }
+            raise ArgumentError, "The Klenod context must include Klenod::Test::Plugin" unless plugin
+
+            CoverageRunner.new(context:, plugin:, config: coverage_config, output:).call do
+              config.execute.call(context, test_paths)
+            end
+          end
+        end
+
+        def worker_paths
+          paths = Array(@test_paths)
+          return paths if @options[:worker]
+
+          raise ConfigError, "Test paths are only accepted with --worker" unless paths.empty?
+
+          nil
+        end
+
+        def worker_command
+          command = [RbConfig.ruby, Gem.bin_path("klenod", "klenod"), "coverage"]
+          command.concat(["--report", @options[:report]]) if @options[:report]
+          command.concat(["--minimum", @options[:minimum]]) if @options[:minimum]
+          command
+        end
+      end
+    end
+  end
+end

data/lib/klenod/test/config.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module Klenod
+  module Test
+    class ConfigError < ArgumentError; end
+
+    COVERAGE_REPORTS = %i[brief partial full markdown quiet].freeze
+
+    CoverageConfig = Data.define(:report, :minimum) do
+      def self.build(report: :brief, minimum: nil)
+        report = report.to_s.downcase.to_sym
+        unless COVERAGE_REPORTS.include?(report)
+          raise ConfigError, "Unknown coverage report #{report.inspect}; choose one of: #{COVERAGE_REPORTS.join(", ")}"
+        end
+
+        new(report, normalize_minimum(minimum))
+      end
+
+      def self.normalize_minimum(minimum)
+        return unless minimum
+
+        value = begin
+          Float(minimum)
+        rescue ArgumentError, TypeError
+          raise ConfigError, "Coverage minimum must be a number between 0 and 100"
+        end
+        return value if value.between?(0, 100)
+
+        raise ConfigError, "Coverage minimum must be between 0 and 100"
+      end
+    end
+
+    Config = Data.define(:base_dir, :context, :execute, :format_error, :coverage)
+
+    class ConfigBuilder
+      def initialize(path)
+        @path = File.expand_path(path)
+      end
+
+      def context(&block)
+        @context = block
+      end
+
+      def execute(&block)
+        @execute = block
+      end
+
+      def format_error(&block)
+        @format_error = block
+      end
+
+      def coverage(report: :brief, minimum: nil)
+        @coverage = CoverageConfig.build(report:, minimum:)
+      end
+
+      def config
+        missing = []
+        missing << "context" unless @context
+        missing << "execute" unless @execute
+        raise ConfigError, "#{@path}: missing #{missing.join(" and ")}" unless missing.empty?
+
+        Config.new(
+          base_dir: File.dirname(@path),
+          context: @context,
+          execute: @execute,
+          format_error: @format_error,
+          coverage: @coverage || CoverageConfig.build
+        )
+      end
+    end
+
+    module ConfigLoader
+      CONFIG_FILE = "klenod.test.rb"
+
+      module_function
+
+      def find(start_dir = Dir.pwd)
+        dir = File.expand_path(start_dir)
+
+        loop do
+          path = File.join(dir, CONFIG_FILE)
+          return path if File.file?(path)
+
+          parent = File.dirname(dir)
+          return nil if parent == dir
+
+          dir = parent
+        end
+      end
+
+      def load(path)
+        builder = ConfigBuilder.new(path)
+        builder.instance_eval(File.read(path), path, 1)
+        builder.config
+      end
+    end
+  end
+end

data/lib/klenod/test/coverage.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+require "covered"
+require "covered/markdown_summary"
+require "covered/statistics"
+
+require_relative "config"
+
+module Klenod
+  module Test
+    class CoverageResult < Covered::Wrapper
+      def initialize(output, context:, plugin:)
+        super(output)
+        @modules_by_path = context.graph.mods.to_h do |module_id, mod|
+          [File.expand_path(mod.eval_path), [module_id, mod]]
+        end
+        @plugin = plugin
+      end
+
+      def each
+        return enum_for unless block_given?
+
+        super do |coverage|
+          mapped = map(coverage)
+          yield mapped if mapped
+        end
+      end
+
+      private
+
+      attr_reader :modules_by_path, :plugin
+
+      def map(coverage)
+        module_id, mod = modules_by_path[File.expand_path(coverage.path)]
+        return unless module_id&.scheme == :app
+        return if plugin.test_module_id?(module_id)
+
+        if mod.source_map
+          map_source(coverage, mod.source_map)
+        elsif module_id.extname == ".rb"
+          coverage
+        end
+      end
+
+      def map_source(coverage, source_map)
+        counts = Array.new(source_map.input.lines.count + 1)
+        input_line = nil
+
+        coverage.counts.each_with_index do |count, output_line|
+          input_line = source_map.marks_by_output_line[output_line]&.line || input_line
+          next if count.nil?
+          next unless input_line
+
+          counts[input_line] = [counts[input_line] || 0, count].max
+        end
+
+        return unless counts.any? { |count| !count.nil? }
+
+        Covered::Coverage.new(Covered::Source.for(coverage.path), counts)
+      end
+    end
+
+    class CoverageRunner
+      REPORTS = {
+        brief: Covered::BriefSummary,
+        partial: Covered::PartialSummary,
+        full: Covered::FullSummary,
+        markdown: Covered::MarkdownSummary,
+        quiet: Covered::Quiet
+      }.freeze
+
+      def initialize(context:, plugin:, config:, output: $stdout)
+        @context = context
+        @plugin = plugin
+        @config = config
+        @output = output
+      end
+
+      def call
+        policy = Covered::Policy.new
+        policy.root(context.graph.source_dir.to_s)
+        policy.start
+        status = begin
+          Integer(yield)
+        ensure
+          policy.finish
+        end
+
+        result = CoverageResult.new(policy, context:, plugin:)
+        REPORTS.fetch(config.report).new.call(result, output)
+        validate_minimum(result, status)
+      end
+
+      private
+
+      attr_reader :context, :plugin, :config, :output
+
+      def validate_minimum(result, status)
+        return status unless config.minimum
+
+        statistics = Covered::Statistics.new
+        result.each { |coverage| statistics << coverage }
+        statistics.validate!(config.minimum / 100.0)
+        status
+      rescue Covered::CoverageError => error
+        output.puts
+        output.puts error.message
+        status.zero? ? 1 : status
+      end
+    end
+  end
+end

data/lib/klenod/test/plugin.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require "klenod/build/errors"
+require "klenod/build/module_id"
+require "klenod/build/plugin"
+
+module Klenod
+  module Test
+    class ImportError < Klenod::Build::ResolveError; end
+
+    class Plugin < Klenod::Build::Plugin
+      DEFAULT_PATTERN = "**/*.test.rb"
+
+      def initialize(pattern: DEFAULT_PATTERN)
+        @pattern = pattern.to_s
+      end
+
+      attr_reader :pattern
+
+      def discover(source_dir:)
+        root = Pathname.new(source_dir).expand_path
+
+        root
+          .glob(pattern)
+          .select(&:file?)
+          .map { |path| Klenod::Build::ModuleId.new(path.relative_path_from(root).to_s.tr("\\", "/"), nil) }
+          .sort_by(&:to_s)
+      end
+
+      def test_module_id?(module_id)
+        module_id.scheme == :app && File.fnmatch?(pattern, module_id.relative_path, File::FNM_PATHNAME | File::FNM_EXTGLOB)
+      end
+
+      def finalize(module_id, result, resolved_dependencies, _dependency_records, _context)
+        imported_test = resolved_dependencies.find { |dependency| test_module_id?(dependency.module_id) }
+        return result unless imported_test
+
+        error = ImportError.new("Test file #{imported_test.module_id.path.inspect} cannot be imported")
+        raise error.with_resolution_context(dependency: imported_test.dependency, importer_id: module_id)
+      end
+    end
+  end
+end

data/lib/klenod/test/runner.rb

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+require "rbconfig"
+
+require "async/process"
+require "klenod/build"
+
+require_relative "plugin"
+require_relative "suite"
+
+module Klenod
+  module Test
+    class Runner
+      WORKER_ARGUMENT = "--worker"
+
+      def self.worker_paths_from(arguments)
+        arguments = Array(arguments)
+        return unless arguments.first == WORKER_ARGUMENT
+        raise ArgumentError, "Expected -- after #{WORKER_ARGUMENT}" unless arguments[1] == "--"
+
+        arguments.drop(2)
+      end
+
+      def initialize(
+        context:,
+        execute:,
+        watch: nil,
+        worker_paths: Runner.worker_paths_from(ARGV),
+        spawn_empty: false,
+        worker_command: [RbConfig.ruby, $PROGRAM_NAME],
+        process: Async::Process,
+        output: $stdout,
+        error_output: $stderr,
+        env: ENV,
+        format_error: nil
+      )
+        @context_factory = context
+        @execute = execute
+        @watch = watch.nil? ? !env.key?("CI") : watch
+        @worker_paths = worker_paths&.dup
+        @spawn_empty = spawn_empty
+        @worker_command = Array(worker_command)
+        @process = process
+        @output = output
+        @error_output = error_output
+        @env = env
+        @format_error = format_error || ->(error, _context) { error.full_message }
+        @last_status = 0
+        @worker_mutex = Mutex.new
+      end
+
+      def call
+        return run_worker(worker_paths) if worker_paths
+
+        context = context_factory.call
+        plugin = test_plugin(context)
+        suite = Klenod::Test::Suite.new(context:, plugin:)
+        selection = suite.collect
+        return run_in_worker(selection.test_paths) unless watch
+
+        run_watch(context, suite, selection)
+      rescue ArgumentError => error
+        error_output.puts error.message
+        1
+      end
+
+      private
+
+      attr_reader :context_factory, :execute, :watch, :worker_paths, :worker_command,
+        :spawn_empty, :process, :output, :error_output, :env, :format_error, :last_status
+
+      def run_watch(context, suite, selection)
+        watcher = build_watcher(context)
+        context.on_update do |event|
+          related = suite.update(event)
+          log_removed(related.removed_test_paths)
+          run_in_worker(related.test_paths) unless related.test_paths.empty?
+        end
+
+        begin
+          watcher.start
+          run_in_worker(selection.test_paths)
+          wait_for_changes
+        rescue Interrupt
+          output.puts
+        ensure
+          watcher.stop
+        end
+
+        last_status
+      end
+
+      def run_in_worker(test_paths)
+        @worker_mutex.synchronize do
+          clear_screen
+          report_test_paths(test_paths)
+          @last_status = (test_paths.empty? && !spawn_empty) ? 0 : worker_status(test_paths)
+          report_watch_status if watch
+          last_status
+        end
+      end
+
+      def worker_status(test_paths)
+        status = process.spawn(*worker_command, WORKER_ARGUMENT, "--", *test_paths)
+        status.success? ? 0 : (status.exitstatus || 1)
+      end
+
+      def run_worker(test_paths)
+        context = context_factory.call
+        Integer(execute.call(context, test_paths))
+      rescue => error
+        error_output.puts format_error.call(error, context)
+        1
+      end
+
+      def test_plugin(context)
+        context.graph.plugins.find do |candidate|
+          candidate.is_a?(Klenod::Test::Plugin)
+        end || raise(ArgumentError, "The Klenod context must include Klenod::Test::Plugin")
+      end
+
+      def build_watcher(context)
+        Klenod::Build::Watcher.new(source_dir: context.graph.source_dir, context:)
+      end
+
+      def wait_for_changes
+        loop { sleep }
+      end
+
+      def log_removed(paths)
+        paths.each { |path| output.puts "Removed #{path}" }
+      end
+
+      def clear_screen
+        return unless watch && output.respond_to?(:tty?) && output.tty?
+
+        output.print "\e[2J\e[H"
+      end
+
+      def report_test_paths(test_paths)
+        count = test_paths.length
+        output.puts "#{color(:run, " RUN ")} #{count} test #{(count == 1) ? "file" : "files"}"
+        output.puts
+        test_paths.each { |path| output.puts "  #{path}" }
+        output.puts
+        output.flush
+      end
+
+      def report_watch_status
+        status = last_status.zero? ? :success : :failure
+        label = last_status.zero? ? " PASS " : " FAIL "
+        output.puts
+        output.puts "#{color(status, label)} Watching for file changes..."
+        output.flush
+      end
+
+      def color(name, value)
+        return value if env.key?("NO_COLOR")
+        return value unless output.respond_to?(:tty?) && output.tty?
+
+        codes = {run: "\e[1;34m", success: "\e[1;32m", failure: "\e[1;31m"}
+        "#{codes.fetch(name)}#{value}\e[0m"
+      end
+    end
+  end
+end

data/lib/klenod/test/suite.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module Klenod
+  module Test
+    Selection = Data.define(:test_paths, :removed_test_paths) do
+      def empty?
+        test_paths.empty? && removed_test_paths.empty?
+      end
+    end
+
+    class Suite
+      def initialize(context:, plugin:)
+        @context = context
+        @plugin = plugin
+        @dependency_ids = {}
+        @failed_test_ids = Set.new
+      end
+
+      def collect
+        test_ids = discover
+        test_ids.each { |test_id| index(test_id) }
+        selection(test_ids)
+      end
+
+      def update(event)
+        previous_test_ids = @dependency_ids.keys.to_set
+        current_test_ids = discover.to_set
+        removed_test_ids = previous_test_ids - current_test_ids
+        added_test_ids = current_test_ids - previous_test_ids
+        affected_module_ids = update_module_ids(event)
+        affected_test_ids =
+          @dependency_ids.filter_map do |test_id, dependency_ids|
+            test_id if current_test_ids.include?(test_id) && dependency_ids.intersect?(affected_module_ids)
+          end
+
+        test_ids = (added_test_ids + affected_test_ids + @failed_test_ids).select { |test_id| current_test_ids.include?(test_id) }
+        removed_test_ids.each { |test_id| remove(test_id) }
+        test_ids.each { |test_id| index(test_id) }
+
+        selection(test_ids, removed_test_ids)
+      end
+
+      private
+
+      attr_reader :context, :plugin
+
+      def discover
+        plugin.discover(source_dir: context.graph.source_dir)
+      end
+
+      def index(test_id)
+        dependency_ids = Set[test_id]
+        @dependency_ids[test_id] = dependency_ids
+        collect_dependencies(test_id, dependency_ids)
+        @failed_test_ids.delete(test_id)
+      rescue
+        @failed_test_ids << test_id
+      end
+
+      def collect_dependencies(module_id, dependency_ids)
+        record = context.graph.records[module_id] || context.graph.collect_module(module_id)
+
+        record.resolved_dependencies.each do |dependency|
+          dependency_id = dependency.module_id
+          next unless dependency_ids.add?(dependency_id)
+
+          collect_dependencies(dependency_id, dependency_ids)
+        end
+      end
+
+      def remove(test_id)
+        @dependency_ids.delete(test_id)
+        @failed_test_ids.delete(test_id)
+      end
+
+      def update_module_ids(event)
+        result = event.result
+        Set.new(
+          result.changed_module_ids +
+            result.removed_module_ids +
+            result.reloaded_module_ids +
+            result.reevaluated_module_ids
+        )
+      end
+
+      def selection(test_ids, removed_test_ids = [])
+        Selection.new(
+          test_ids.map(&:relative_path).sort.freeze,
+          removed_test_ids.map(&:relative_path).sort.freeze
+        )
+      end
+    end
+  end
+end

data/lib/klenod/test/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Klenod
+  module Test
+    VERSION = "0.0.5"
+  end
+end

data/lib/klenod/test.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require_relative "test/version"
+require_relative "test/config"
+require_relative "test/plugin"
+require_relative "test/suite"
+require_relative "test/runner"
+require_relative "test/coverage"
+
+module Klenod
+  module Test
+  end
+end

metadata

@@ -0,0 +1,94 @@
+--- !ruby/object:Gem::Specification
+name: klenod-test
+version: !ruby/object:Gem::Version
+  version: 0.0.5
+platform: ruby
+authors:
+- Andrés Alin
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: klenod-build
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.0.5
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.0.5
+- !ruby/object:Gem::Dependency
+  name: async-process
+  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: covered
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.30'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.30'
+description: Framework-independent test selection, watch runs, and coverage for Klenod
+  applications.
+email:
+- andreas.alin@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/klenod/test.rb
+- lib/klenod/test/cli.rb
+- lib/klenod/test/config.rb
+- lib/klenod/test/coverage.rb
+- lib/klenod/test/plugin.rb
+- lib/klenod/test/runner.rb
+- lib/klenod/test/suite.rb
+- lib/klenod/test/version.rb
+homepage: https://github.com/aalin/klenod
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/aalin/klenod
+  source_code_uri: https://github.com/aalin/klenod/tree/main/gems/klenod-test
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 4.0.6
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.16
+specification_version: 4
+summary: Test runner for Klenod applications.
+test_files: []