conformance-kit 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 45e9d40d8ce04df0a8aae9f4f0bd8da57e2f0f649c2549f1649f7d9d5ed7adc2
+  data.tar.gz: df75fb6611c183f7d93d52f95755022f6154afd63cd60a541346e779107e317b
+SHA512:
+  metadata.gz: ea8d19b3ca7a5dfdb2a4cd5d5a9e12c350c105ffa7af381319f7d31efc5a10ae8e6e8c35b5ef2f8cb0e70f23f2dcdaa417e8bf96617c9ac51280d176d106272d
+  data.tar.gz: aea92dfbc96c976dd0a4a31d556d8d111764c31ddfa14dab32f7f5123aad84272ca59f4251302d160f635af1289de41a357fdae78f474db6ca16a3dc13d2f1e8

data/CHANGELOG.md

@@ -0,0 +1,11 @@
+# Changelog
+
+## Unreleased
+
+- Shared examples (`require "conformance_kit/rspec"`): `"thread-safe under contention"`, `"fiber-safe under an Async reactor"`, `"a boot-finalized configuration"` and `"runs inside a non-main Ractor"` (Ruby 4.0+, tagged `:ractor`).
+- The same checks as Minitest assertions (`require "conformance_kit/minitest"`): `assert_thread_safe`, `assert_fiber_safe`, `assert_boot_finalized`, `assert_runs_in_ractor`.
+- `ConformanceKit::Store.fetch(key) { init }`: per-Ractor lazy storage (`Ractor.store_if_absent` on 3.4+, a Mutex-guarded fallback below).
+- `conformance-audit`: reports unshareable constants and class/module ivars under a namespace; `.conformance.yml` `main_only:` allowlist with a required `reason:`; `--strict` exits 1.
+- `config/rubocop.yml` (rubocop-thread_safety) and `config/rubocop_spinel.yml` (report-only Spinel probe).
+- Reusable workflows: `ractor.yml` (Ruby 4.0 Ractor examples + `conformance-audit --strict`) and `probes.yml` (report-only rubocop_spinel, spinel-compat, roundhouse).
+- Gem skeleton: release kit, labels kit, CI on Ruby 3.2, 3.4 and 4.0.

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 mhenrixon
+
+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,200 @@
+# conformance-kit
+
+Concurrency conformance for the zoolutions gems. A gem that adopts it is held to explicit tiers, each with a mechanical gate:
+
+| Tier | Meaning | Gate |
+|---|---|---|
+| 1 thread-safe | no unguarded shared mutable state on the request/broadcast path | `config/rubocop.yml` (rubocop-thread_safety) + `"thread-safe under contention"` |
+| 2 fiber-safe | correct under a fiber scheduler (Falcon/Async): request state fiber-local, no `Thread.main[]` misuse | `"fiber-safe under an Async reactor"` |
+| 3 Ractor-clean | the gem adds no Ractor blocker beyond its dependencies': config shareable after boot, per-Ractor caches, no locks in constants | `"a boot-finalized configuration"`, `conformance-audit --strict`, the Ruby 4.0 `"runs inside a non-main Ractor"` canary (`ractor.yml`) |
+| 4 compiler-probed | Spinel/Roundhouse readiness is measured, never gated | `probes.yml` (report-only) |
+
+Background, the finalize-at-boot pattern and the settled decisions: [zoolutions/phlex-reactive#363](https://github.com/zoolutions/phlex-reactive/issues/363).
+
+**A development dependency only.** Nothing here becomes a runtime dependency of your gem, and the kit adds none to your bundle: `async`, `minitest`, `rubocop-thread_safety` and `rubocop_spinel` are used only when you already have them. Ruby 3.2+; Ractor-only behaviour is gated on the running Ruby, never on a version floor.
+
+```ruby
+# Gemfile
+group :development, :test do
+  gem "conformance-kit", github: "zoolutions/conformance-kit"
+  gem "rubocop-thread_safety", ">= 0.8", require: false # for config/rubocop.yml
+  gem "async", require: false                 # optional: runs the fiber example
+end
+```
+
+## Shared examples (RSpec)
+
+```ruby
+# spec/spec_helper.rb
+require "conformance_kit/rspec"
+```
+
+Each example calls `subject_call`, a callable for the operation under test:
+
+```ruby
+RSpec.describe MyGem::Cache do
+  let(:subject_call) { -> { MyGem::Cache.for(:key) } }
+
+  it_behaves_like "thread-safe under contention", threads: 8, iterations: 50, consistent: :identical
+  it_behaves_like "fiber-safe under an Async reactor", fibers: 8, iterations: 50
+end
+
+RSpec.describe MyGem do
+  it_behaves_like "a boot-finalized configuration",
+                  readers: [MyGem.method(:colors), MyGem.method(:adapters)],
+                  finalize: -> { MyGem.finalize! }
+end
+
+RSpec.describe MyGem::Token do
+  let(:subject_call) { ->(payload) { MyGem::Token.verify(MyGem::Token.sign(payload)) } }
+
+  it_behaves_like "runs inside a non-main Ractor", inputs: [{ id: 1 }]
+end
+```
+
+| Example | Options | Fails when | Skipped when |
+|---|---|---|---|
+| `"thread-safe under contention"` | `threads:` (8), `iterations:` (50), `consistent:` | a call raises, or the results disagree | — |
+| `"fiber-safe under an Async reactor"` | `fibers:` (8), `iterations:` (50), `consistent:` | a call raises inside an `Async` task, or the results disagree | `async` is not loadable |
+| `"a boot-finalized configuration"` | `readers:`, `finalize:` | a reader returns a value that is not `Ractor.shareable?` (or raises) | no `Ractor` (TruffleRuby, JRuby) |
+| `"runs inside a non-main Ractor"` (tagged `:ractor`) | `inputs:` ([]) | the block raises inside `Ractor.new`, captures outer variables, or returns something else than on the main Ractor | below Ruby 4.0 (`Ractor#value`) |
+
+- `consistent:` is opt-in: `:identical` (every result is the same object, e.g. a memoized cache), `:equal` (all `==`), or a callable that receives every result and returns truthy.
+- `readers:` takes `Method` objects (reported as `Owner.reader`), a `{ "name" => callable }` Hash, or bare callables (reported by source location).
+- The Ractor block must be capture-free: pass values through `inputs:`, reach everything else through constants. Before 4.0 a non-main Ractor cannot autoload, so load what it touches first.
+
+Failures name the culprit, e.g.
+
+```
+a boot-finalized configuration: 1 of 2 readers returned a value that is not Ractor-shareable:
+  MyGem.colors returned Hash: [:primary] is an Array that is not frozen: freeze it at boot (Ractor.make_shareable)
+```
+
+## Assertions (Minitest)
+
+```ruby
+require "minitest/autorun" # the kit never loads Minitest itself
+require "conformance_kit/minitest"
+
+class CacheTest < Minitest::Test
+  include ConformanceKit::Minitest
+
+  def test_thread_safe = assert_thread_safe(threads: 8, iterations: 50, consistent: :identical) { MyGem::Cache.for(:key) }
+  def test_fiber_safe = assert_fiber_safe(fibers: 8) { MyGem::Cache.for(:key) }
+  def test_boot_finalized = assert_boot_finalized(readers: [MyGem.method(:colors)], finalize: -> { MyGem.finalize! })
+  def test_ractor = assert_runs_in_ractor(inputs: [2]) { |n| MyGem.double(n) }
+end
+```
+
+Same checks, same options and messages; skips use `skip` with the reason. Works on Minitest 5 and 6.
+
+## `ConformanceKit::Store`
+
+Per-Ractor lazy storage, the home for caches that must not live in a class ivar or a constant:
+
+```ruby
+def self.cache = ConformanceKit::Store.fetch(:my_gem_cache) { {} }
+```
+
+On Ruby 3.4+ this is `Ractor.store_if_absent` (atomic, one value per Ractor). Below 3.4 the main Ractor (and an engine without `Ractor`) uses one Mutex-guarded Hash, and a non-main Ractor keeps its own values in Ractor-local storage, unlocked: two threads of that one Ractor can race to build a value, as with `||=`. Keys are Symbols; prefix them with your gem's name.
+
+## `conformance-audit`
+
+```bash
+bundle exec conformance-audit --require ./lib/my_gem --namespace MyGem --strict
+```
+
+Requires the files, walks every loaded module under the namespaces (`--require` and `--namespace` repeat), and reports each public constant and class/module instance variable whose value is not `Ractor.shareable?`, with the path to the offending object and the fix:
+
+```
+conformance-audit: 2 findings in MyGem (1 allowlisted main-only; 14 modules audited, 0 unloaded autoloads skipped)
+  MyGem::LOCK (constant) Thread::Mutex: a Thread::Mutex is main-only: keep per-Ractor state in ConformanceKit::Store, or allowlist it main_only
+  MyGem::Config.@colors (module ivar) Hash: [:primary] is an Array that is not frozen: freeze it at boot (Ractor.make_shareable)
+```
+
+Limits, so a green run means what it says:
+
+- Unloaded autoload constants are skipped and listed, never loaded mid-walk: require (or eager-load) everything the audit should see. The header counts the modules audited and the autoloads skipped.
+- `private_constant`s are invisible to it (Ruby has no public way to enumerate them). `config/rubocop.yml` and the boot-finalized example are the gates for those.
+
+| Exit | Meaning |
+|---|---|
+| 0 | no unallowlisted findings; or findings without `--strict` (report only); or no `Ractor` on this engine |
+| 1 | unallowlisted findings under `--strict` |
+| 2 | usage error, a namespace that is not defined or not a module, a file that cannot be required, or an invalid allowlist |
+
+### `.conformance.yml`
+
+State that is deliberately main-only, read from `.conformance.yml` in the working directory (or `--allowlist PATH`). Every entry needs a `reason:`; an entry without one is an error (exit 2).
+
+```yaml
+main_only:
+  - name: MyGem::Registry.@lock     # class/module ivar: Owner.@ivar
+    reason: guards boot-time registration; no non-main Ractor ever registers
+  - name: MyGem::LOCK               # constant: Owner::NAME
+    reason: ...
+```
+
+Entries inside the audited namespaces that no longer turn up are listed as stale.
+
+## RuboCop
+
+```yaml
+# .rubocop.yml
+inherit_gem:
+  conformance-kit: config/rubocop.yml
+```
+
+Turns on the six `rubocop-thread_safety` cops (`ClassAndModuleAttributes`, `ClassInstanceVariable`, `MutableClassInstanceVariable` with `EnforcedStyle: literals`, `NewThread`, `DirChdir`, `RackMiddlewareInstanceVariable`) plus `LazySynchronizationPrimitive` (which needs rubocop-thread_safety 0.8+). Exclude a file or line only with a comment saying why it is safe.
+
+`config/rubocop_spinel.yml` runs only `Spinel/Unsupported` (rubocop_spinel). It is for the report-only probe, never your lint: it flags `class << self`.
+
+## Reusable workflows
+
+```yaml
+# .github/workflows/main.yml
+jobs:
+  ractor:
+    uses: zoolutions/conformance-kit/.github/workflows/ractor.yml@main
+    with:
+      require: ./lib/my_gem
+      namespace: MyGem
+
+  probes:
+    uses: zoolutions/conformance-kit/.github/workflows/probes.yml@main
+    with:
+      gem-name: my_gem
+```
+
+**`ractor.yml`** (the Tier 3 gate): the Ractor examples, then `conformance-audit --strict`.
+
+| Input | Default | |
+|---|---|---|
+| `require` | required | files the audit requires (space-separated) |
+| `namespace` | required | constants to audit (space-separated) |
+| `ruby-version` | `4.0` | |
+| `allowlist` | `.conformance.yml` | skipped when the default file is absent |
+| `test-command` | `bundle exec rspec --tag ractor` | Minitest gems pass their own |
+| `audit` | `true` | `false` runs only the examples |
+| `working-directory` | `.` | |
+
+**`probes.yml`** (Tier 4, report-only): `rubocop_spinel`, `spinel-compat probe <gem-name> --dir .` and, when `roundhouse-app` is set, `roundhouse check`. Every probe step continues on error; the reports go to the run summary and an artifact. It never fails a build.
+
+| Input | Default | |
+|---|---|---|
+| `gem-name` | required | the gem spinel-compat probes from the checkout |
+| `ruby-version` | `4.0` | |
+| `paths` | `lib` | what rubocop_spinel inspects (space-separated) |
+| `roundhouse-app` | `""` | a Rails app directory (e.g. `spec/dummy`); empty skips it |
+| `roundhouse-version` | `v2026.9.18` | the rubys/roundhouse release to install |
+| `roundhouse-sha256` | SHA-256 of that release's `roundhouse-x86_64-unknown-linux-musl.tar.xz` | checked before the binary runs; change it with `roundhouse-version` |
+| `artifact-name` | `conformance-probes` | |
+| `working-directory` | `.` | |
+
+## Development
+
+```bash
+bundle exec rake   # rspec + rubocop; CI runs Ruby 3.2, 3.4 and 4.0
+```
+
+Every check is proven both ways against `spec/fixtures/`: a violating fixture it must catch and a conforming one it must pass. The kit audits itself (`.conformance.yml`) and calls its own workflows in CI.

data/config/rubocop.yml

@@ -0,0 +1,35 @@
+# conformance-kit's Tier 1 RuboCop gate. In a consuming gem's .rubocop.yml:
+#
+#   inherit_gem:
+#     conformance-kit: config/rubocop.yml
+#
+# and add `gem "rubocop-thread_safety", require: false` to its Gemfile (the kit
+# never adds dependencies for you). Exclude a file or line only with a comment
+# saying why it is safe, e.g. a Mutex created at load and only used on the main
+# Ractor, or the specs that start threads on purpose.
+plugins:
+  - rubocop-thread_safety
+
+# The six cops of the epic's Tier 1, on whatever the consumer's NewCops is.
+ThreadSafety/ClassAndModuleAttributes:
+  Enabled: true
+
+ThreadSafety/ClassInstanceVariable:
+  Enabled: true
+
+ThreadSafety/MutableClassInstanceVariable:
+  Enabled: true
+  EnforcedStyle: literals
+
+ThreadSafety/NewThread:
+  Enabled: true
+
+ThreadSafety/DirChdir:
+  Enabled: true
+
+ThreadSafety/RackMiddlewareInstanceVariable:
+  Enabled: true
+
+# `@mutex ||= Mutex.new` is itself a race: two threads can build two locks.
+ThreadSafety/LazySynchronizationPrimitive:
+  Enabled: true

data/config/rubocop_spinel.yml

@@ -0,0 +1,16 @@
+# conformance-kit's report-only Spinel probe (Tier 4): only the Spinel cops,
+# never a gate. Run by .github/workflows/probes.yml as
+#
+#   rubocop --config <conformance-kit>/config/rubocop_spinel.yml lib
+#
+# It flags `class << self`, which every zoolutions gem uses: read the report,
+# don't chase it.
+plugins:
+  - rubocop_spinel
+
+AllCops:
+  DisabledByDefault: true
+  SuggestExtensions: false
+
+Spinel/Unsupported:
+  Enabled: true

data/exe/conformance-audit

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative "../lib/conformance_kit/audit"
+
+exit ConformanceKit::Audit::CLI.run(ARGV)

data/lib/conformance_kit/audit/allowlist.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require "yaml"
+
+module ConformanceKit
+  class Audit
+    class AllowlistError < StandardError; end
+
+    # `.conformance.yml`: state that is deliberately main-only, each entry with
+    # the reason it is safe.
+    #
+    #   main_only:
+    #     - name: MyGem::Registry.@lock      # a class/module ivar: Owner.@ivar
+    #       reason: guards boot-time registration; never touched by a non-main Ractor
+    #     - name: MyGem::LOCK                # a constant: Owner::NAME
+    #       reason: ...
+    class Allowlist
+      def self.empty = new([])
+
+      def self.load(path)
+        data = YAML.safe_load_file(path) || {}
+        raise AllowlistError, "#{path}: expected a mapping with a main_only: list" unless data.is_a?(Hash)
+
+        new(data.fetch("main_only", []) || [], source: path)
+      rescue Psych::Exception => e
+        raise AllowlistError, "#{path}: #{e.message}"
+      end
+
+      attr_reader :entries
+
+      def initialize(entries, source: "the allowlist")
+        raise AllowlistError, "#{source}: main_only: must be a list" unless entries.is_a?(Array)
+
+        @entries = entries.map { validate(_1, source) }
+      end
+
+      def names = entries.map { _1["name"] }
+      def include?(name) = names.include?(name)
+      def reason_for(name) = entries.find { _1["name"] == name }&.fetch("reason")
+
+      private
+
+      def validate(entry, source)
+        unless entry.is_a?(Hash)
+          raise AllowlistError,
+                "#{source}: each main_only entry needs a name: and a reason:, got #{entry.inspect}"
+        end
+
+        name = entry["name"]
+        raise AllowlistError, "#{source}: a main_only entry has no name: (#{entry.inspect})" if blank?(name)
+        if blank?(entry["reason"])
+          raise AllowlistError,
+                "#{source}: #{name} has no reason: (say why it is safe main-only)"
+        end
+
+        entry
+      end
+
+      def blank?(value) = !value.is_a?(String) || value.strip.empty?
+    end
+  end
+end

data/lib/conformance_kit/audit/cli.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require "optparse"
+
+module ConformanceKit
+  class Audit
+    # `conformance-audit --require FILE --namespace CONST [--strict] [--allowlist PATH]`
+    #
+    # Exit codes: 0 clean (or report-only, or no Ractor on this engine),
+    # 1 unallowlisted findings under --strict, 2 usage or allowlist error.
+    class CLI
+      DEFAULT_ALLOWLIST = ".conformance.yml"
+      USAGE_ERROR = 2
+
+      def self.run(argv, out: $stdout, err: $stderr) = new(out, err).run(argv)
+
+      def initialize(out, err)
+        @out = out
+        @err = err
+      end
+
+      def run(argv)
+        options = parse(argv)
+        return unavailable unless defined?(::Ractor)
+
+        options[:requires].each { require File.expand_path(_1) }
+        options[:namespaces].each { check_namespace(_1) }
+        audit = Audit.new(namespaces: options[:namespaces], allowlist: allowlist(options[:allowlist]))
+        report(audit, options[:strict])
+      rescue OptionParser::ParseError, AllowlistError, LoadError, NameError, ArgumentError => e
+        @err.puts "conformance-audit: #{e.message}"
+        USAGE_ERROR
+      end
+
+      private
+
+      def parse(argv)
+        options = { requires: [], namespaces: [], strict: false, allowlist: nil }
+        parser(options).parse!(argv.dup)
+        raise OptionParser::MissingArgument, "--namespace (the constant to audit)" if options[:namespaces].empty?
+
+        options
+      end
+
+      def parser(options)
+        OptionParser.new do |o|
+          o.banner = "Usage: conformance-audit --require FILE --namespace CONST [--strict] [--allowlist PATH]"
+          o.on("--require FILE", "Require FILE before auditing (repeatable)") { options[:requires] << _1 }
+          o.on("--namespace CONST", "Audit CONST and everything under it (repeatable)") do |name|
+            options[:namespaces] << name.delete_prefix("::")
+          end
+          o.on("--strict", "Exit 1 on any unallowlisted finding") { options[:strict] = true }
+          o.on("--allowlist PATH", "main_only: allowlist (default: #{DEFAULT_ALLOWLIST} if present)") do |path|
+            options[:allowlist] = path
+          end
+        end
+      end
+
+      def check_namespace(name)
+        value = Object.const_get(name)
+        raise ArgumentError, "--namespace #{name} is a #{value.class}, not a module" unless value.is_a?(Module)
+      end
+
+      def allowlist(path)
+        return Allowlist.load(path) if path
+        return Allowlist.load(DEFAULT_ALLOWLIST) if File.exist?(DEFAULT_ALLOWLIST)
+
+        Allowlist.empty
+      rescue Errno::ENOENT
+        raise AllowlistError, "allowlist #{path} does not exist"
+      end
+
+      def unavailable
+        @out.puts "conformance-audit: Ractor is unavailable on #{RUBY_ENGINE} #{RUBY_VERSION}; nothing to audit."
+        0
+      end
+
+      def report(audit, strict)
+        findings = audit.findings
+        allowlisted = audit.allowlisted
+        @out.puts "conformance-audit: #{findings.size} findings in #{audit.namespaces.join(', ')} " \
+                  "(#{allowlisted.size} allowlisted main-only; #{audit.modules_audited} modules audited, " \
+                  "#{audit.skipped_autoloads.size} unloaded autoloads skipped)"
+        findings.each { @out.puts "  #{_1}" }
+        section("allowlisted main-only:", allowlisted.map { "#{_1.name} — #{audit.allowlist.reason_for(_1.name)}" })
+        section("stale allowlist entries (no longer found):", audit.stale)
+        section("unloaded autoloads, not audited (require or eager-load them):", audit.skipped_autoloads)
+        return 0 if findings.empty?
+        return 1 if strict
+
+        @out.puts "report only: --strict fails on these"
+        0
+      end
+
+      def section(title, lines)
+        return if lines.empty?
+
+        @out.puts title
+        lines.each { @out.puts "  #{_1}" }
+      end
+    end
+  end
+end

data/lib/conformance_kit/audit.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require "conformance_kit"
+require_relative "audit/allowlist"
+require_relative "audit/cli"
+
+module ConformanceKit
+  # Walks every loaded module under the given namespaces and reports each
+  # constant and class/module instance variable whose value is not
+  # Ractor-shareable. Unloaded autoload constants are skipped: require (or
+  # eager-load) everything the audit should see.
+  class Audit
+    Finding = Data.define(:name, :kind, :value_class, :path, :reason) do
+      def to_s
+        where = path.empty? ? "" : " #{path} is"
+        "#{name} (#{kind}) #{value_class}:#{where} #{reason}"
+      end
+    end
+
+    attr_reader :namespaces, :allowlist
+
+    def initialize(namespaces:, allowlist: Allowlist.empty)
+      @namespaces = namespaces
+      @allowlist = allowlist
+    end
+
+    def findings = partitioned.first
+    def allowlisted = partitioned.last
+
+    def modules_audited = audited_modules.size
+
+    # Constants declared with `autoload` but never loaded: not audited.
+    def skipped_autoloads
+      audited_modules.flat_map do |mod, name|
+        constants_of(mod).select { autoload?(mod, _1) }.map { "#{name}::#{_1}" }
+      end
+    end
+
+    # Allowlisted names inside the audited namespaces that no longer turn up.
+    def stale
+      found = scan.map(&:name)
+      @allowlist.names.select { in_namespace?(_1) && !found.include?(_1) }
+    end
+
+    private
+
+    def partitioned
+      @partitioned ||= scan.partition { !@allowlist.include?(_1.name) }
+    end
+
+    def scan
+      @scan ||= audited_modules.flat_map { |mod, name| constant_findings(mod, name) + ivar_findings(mod, name) }
+                               .sort_by(&:name)
+    end
+
+    def audited_modules
+      @audited_modules ||= ObjectSpace.each_object(Module).filter_map do |mod|
+        next if mod.singleton_class?
+
+        name = ::Module.instance_method(:name).bind_call(mod) # a class may override .name
+        [mod, name] if name && in_namespace?(name)
+      end
+    end
+
+    def in_namespace?(name)
+      namespaces.any? { |namespace| name == namespace || name.start_with?("#{namespace}::", "#{namespace}.") }
+    end
+
+    def constant_findings(mod, name)
+      constants_of(mod).filter_map do |constant|
+        next if autoload?(mod, constant)
+
+        finding("#{name}::#{constant}", "constant", core(::Module, :const_get, mod, constant, false))
+      end
+    end
+
+    def ivar_findings(mod, name)
+      core(::Kernel, :instance_variables, mod).filter_map do |ivar|
+        kind = mod.is_a?(Class) ? "class ivar" : "module ivar"
+        finding("#{name}.#{ivar}", kind, core(::Kernel, :instance_variable_get, mod, ivar))
+      end
+    end
+
+    # The core reflection methods, bound directly: a module may override its own
+    # `.constants` or `.instance_variables` and hide state from the audit.
+    def core(owner, method, receiver, *) = owner.instance_method(method).bind_call(receiver, *)
+    def constants_of(mod) = core(::Module, :constants, mod, false)
+    def autoload?(mod, constant) = core(::Module, :autoload?, mod, constant)
+
+    def finding(name, kind, value)
+      culprit = Shareability.culprit(value)
+      return nil unless culprit
+
+      Finding.new(name: name, kind: kind, value_class: value.class.name, path: culprit.path, reason: culprit.reason)
+    end
+  end
+end

data/lib/conformance_kit/checks/boot_finalized.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module ConformanceKit
+  module Checks
+    # "a boot-finalized configuration": after `finalize`, every reader returns a
+    # Ractor-shareable value. Readers are `Method` objects (named
+    # `Owner.reader`), a `{ "name" => callable }` Hash, or bare callables (named
+    # by source location).
+    module BootFinalized
+      NAME = "a boot-finalized configuration"
+
+      class << self
+        def call(readers:, finalize: nil)
+          raise ArgumentError, "readers: is empty, so #{NAME} would check nothing" if readers.nil? || readers.empty?
+
+          unless Shareability.available?
+            return Result.skip("#{NAME} needs Ractor.shareable?, which #{RUBY_ENGINE} #{RUBY_VERSION} lacks")
+          end
+
+          finalize&.call
+          named = name_readers(readers)
+          offenses = named.filter_map { |name, reader| offense(name, reader) }
+          return Result.pass if offenses.empty?
+
+          Result.fail("#{NAME}: #{offenses.size} of #{named.size} readers returned a value " \
+                      "that is not Ractor-shareable:\n#{offenses.map { "  #{_1}" }.join("\n")}")
+        end
+
+        private
+
+        def offense(name, reader)
+          value = reader.call
+          culprit = Shareability.culprit(value)
+          return nil unless culprit
+
+          where = culprit.path.empty? ? "it is" : "#{culprit.path} is"
+          "#{name} returned #{value.class}: #{where} #{culprit.reason}"
+        rescue StandardError => e
+          "#{name} raised #{e.class}: #{e.message}"
+        end
+
+        def name_readers(readers)
+          return readers.map { |name, reader| [name.to_s, reader] } if readers.is_a?(::Hash)
+
+          Array(readers).map { |reader| [reader_name(reader), reader] }
+        end
+
+        def reader_name(reader)
+          case reader
+          when ::Method
+            receiver = reader.receiver
+            receiver.is_a?(::Module) ? "#{receiver.name}.#{reader.name}" : "#{receiver.class.name}##{reader.name}"
+          when ::Proc
+            file, line = reader.source_location
+            "the reader at #{file}:#{line}"
+          else reader.inspect
+          end
+        end
+      end
+    end
+  end
+end

data/lib/conformance_kit/checks/consistency.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module ConformanceKit
+  module Checks
+    # The outcome reporting shared by the thread and fiber checks: exceptions,
+    # and the `consistent:` option.
+    module Consistency
+      MODES = %i[identical equal].freeze
+      # How many distinct results a failure report tells apart before it stops counting.
+      DIAGNOSED = 10
+
+      class << self
+        def validate_counts!(**counts)
+          counts.each do |name, count|
+            next if count.is_a?(Integer) && count.positive?
+
+            raise ArgumentError, "#{name}: must be a positive Integer (got #{count.inspect}); " \
+                                 "zero would pass without a single call"
+          end
+        end
+
+        def validate!(consistent)
+          return if consistent.nil? || consistent.respond_to?(:call) || MODES.include?(consistent)
+
+          raise ArgumentError, "consistent: must be :identical, :equal or a callable taking every result, " \
+                               "got #{consistent.inspect}"
+        end
+
+        # nil when consistent, a failure description otherwise.
+        def problem(results, consistent)
+          case consistent
+          when nil then nil
+          when :identical then distinct(results.uniq(&:__id__), consistent)
+          when :equal then distinct(uniq_by_equality(results), consistent)
+          else "the `consistent:` check returned false for #{results.size} results" unless consistent.call(results)
+          end
+        end
+
+        def raised(errors, total, unit)
+          first = errors.first
+          where = first.backtrace ? " (#{first.backtrace.first})" : ""
+          "#{errors.size} of #{total} #{unit} raised; first: #{first.class}: #{first.message}#{where}"
+        end
+
+        private
+
+        # Array#uniq compares with eql?/hash (1 and 1.0 differ); :equal promises ==. Stops past
+        # DIAGNOSED distinct values, so N different results cost O(N) == calls, not O(N²).
+        def uniq_by_equality(results)
+          results.each_with_object([]) do |result, seen|
+            next if seen.any? { |s| s == result }
+
+            seen << result
+            break seen if seen.size > DIAGNOSED
+          end
+        end
+
+        def distinct(unique, mode)
+          return nil if unique.size <= 1
+
+          count = unique.size > DIAGNOSED ? "more than #{DIAGNOSED}" : unique.size
+          classes = unique.group_by { _1.class.name }.map { |name, all| "#{name} ×#{all.size}" }.join(", ")
+          "returned #{count} distinct results (#{classes}), so the `consistent: #{mode.inspect}` check failed"
+        end
+      end
+    end
+  end
+end

data/lib/conformance_kit/checks/fiber_reactor.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module ConformanceKit
+  module Checks
+    # "fiber-safe under an Async reactor": `fibers` Async tasks, each making
+    # `iterations` calls. Needs the `async` gem, which is never a dependency of
+    # the kit: skipped with a reason when it cannot be loaded.
+    module FiberReactor
+      NAME = "fiber-safe under an Async reactor"
+
+      class << self
+        def call(fibers: 8, iterations: 50, consistent: nil, loader: -> { require "async" }, &subject)
+          Consistency.validate_counts!(fibers: fibers, iterations: iterations)
+          Consistency.validate!(consistent)
+          begin
+            loader.call
+          rescue LoadError => e
+            return Result.skip("#{NAME} needs the async gem, which is not loadable (#{e.message}): " \
+                               "add `gem \"async\"` to the Gemfile's test group to run it")
+          end
+
+          verdict(run(fibers, iterations, subject), fibers, iterations, consistent)
+        end
+
+        private
+
+        def run(fibers, iterations, subject)
+          Async do |task|
+            tasks = Array.new(fibers) do
+              task.async do
+                Array.new(iterations) { subject.call }
+              rescue StandardError => e
+                e
+              end
+            end
+            tasks.map(&:wait)
+          end.wait
+        end
+
+        def verdict(outcomes, fibers, iterations, consistent)
+          errors = outcomes.grep(Exception)
+          return Result.fail("#{NAME}: #{Consistency.raised(errors, fibers, 'fibers')}") if errors.any?
+
+          problem = Consistency.problem(outcomes.flatten(1), consistent)
+          problem ? Result.fail("#{NAME}: #{fibers} fibers × #{iterations} calls #{problem}") : Result.pass
+        end
+      end
+    end
+  end
+end

data/lib/conformance_kit/checks/ractor_canary.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module ConformanceKit
+  module Checks
+    # "runs inside a non-main Ractor": runs a capture-free block on the main
+    # Ractor and inside `Ractor.new(*inputs)`, and compares the two results.
+    # Ruby 4.0+ only (`Ractor#value`); skipped with a reason below.
+    module RactorCanary
+      NAME = "runs inside a non-main Ractor"
+
+      class << self
+        def call(inputs: [], &block)
+          return Result.skip(unavailable) unless available?
+
+          ractor = ::Ractor.new(*inputs, &block) # copies the inputs before the main run can mutate them
+          expected = block.call(*inputs)
+          actual = ractor.value
+          return Result.pass if actual == expected
+
+          Result.fail("#{NAME}: returned #{actual.inspect} inside the Ractor " \
+                      "but #{expected.inspect} on the main Ractor")
+        rescue ::Ractor::RemoteError => e
+          cause = e.cause || e
+          Result.fail("#{NAME}: raised #{cause.class} inside the Ractor: #{cause.message}")
+        rescue ::Ractor::IsolationError, ::ArgumentError => e
+          raise unless e.message.include?("isolate")
+
+          Result.fail("#{NAME}: the block must be capture-free (pass values through inputs:): #{e.message}")
+        end
+
+        private
+
+        def available? = defined?(::Ractor) && ::Ractor.method_defined?(:value)
+
+        def unavailable
+          "#{NAME} needs Ruby 4.0+ (Ractor#value); running #{RUBY_ENGINE} #{RUBY_VERSION}"
+        end
+      end
+    end
+  end
+end

data/lib/conformance_kit/checks/thread_contention.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module ConformanceKit
+  module Checks
+    # "thread-safe under contention": `threads` threads released together, each
+    # making `iterations` calls. Fails on any exception, or when the results
+    # disagree under `consistent:`.
+    module ThreadContention
+      NAME = "thread-safe under contention"
+
+      class << self
+        def call(threads: 8, iterations: 50, consistent: nil, &subject)
+          Consistency.validate_counts!(threads: threads, iterations: iterations)
+          Consistency.validate!(consistent)
+          outcomes = run(threads, iterations, subject)
+          errors = outcomes.grep(Exception)
+          return Result.fail("#{NAME}: #{Consistency.raised(errors, threads, 'threads')}") if errors.any?
+
+          problem = Consistency.problem(outcomes.flatten(1), consistent)
+          problem ? Result.fail("#{NAME}: #{threads} threads × #{iterations} calls #{problem}") : Result.pass
+        end
+
+        private
+
+        def run(threads, iterations, subject)
+          start = Queue.new
+          workers = Array.new(threads) do
+            Thread.new do # rubocop:disable ThreadSafety/NewThread -- contention is the point of the check
+              start.pop
+              Array.new(iterations) { subject.call }
+            rescue StandardError => e
+              e
+            end
+          end
+          threads.times { start << true }
+          workers.map(&:value)
+        end
+      end
+    end
+  end
+end

data/lib/conformance_kit/minitest.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require "conformance_kit"
+
+module ConformanceKit
+  # The Minitest front end: the same four checks as assertions.
+  #
+  #   class CacheTest < Minitest::Test
+  #     include ConformanceKit::Minitest
+  #
+  #     def test_cache_is_thread_safe
+  #       assert_thread_safe(threads: 8, iterations: 50, consistent: :identical) { MyGem.cache_for(:key) }
+  #     end
+  #   end
+  #
+  # Uses only `assert` and `skip`, so it works on Minitest 5 and 6.
+  module Minitest
+    def assert_thread_safe(threads: 8, iterations: 50, consistent: nil, &)
+      conformance_enforce(Checks::ThreadContention.call(
+                            threads: threads, iterations: iterations, consistent: consistent, &
+                          ))
+    end
+
+    def assert_fiber_safe(fibers: 8, iterations: 50, consistent: nil, &)
+      conformance_enforce(Checks::FiberReactor.call(fibers: fibers, iterations: iterations, consistent: consistent, &))
+    end
+
+    def assert_boot_finalized(readers:, finalize: nil)
+      conformance_enforce(Checks::BootFinalized.call(readers: readers, finalize: finalize))
+    end
+
+    def assert_runs_in_ractor(inputs: [], &)
+      conformance_enforce(Checks::RactorCanary.call(inputs: inputs, &))
+    end
+
+    private
+
+    def conformance_enforce(result)
+      skip(result.message) if result.skipped?
+      assert(result.passed?, result.message)
+    end
+  end
+end

data/lib/conformance_kit/result.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module ConformanceKit
+  # What a check returns; the RSpec and Minitest front ends turn it into a
+  # pass, a failure or a skip.
+  Result = Data.define(:status, :message) do
+    def self.pass(message = "ok") = new(status: :passed, message: message)
+    def self.fail(message) = new(status: :failed, message: message)
+    def self.skip(message) = new(status: :skipped, message: message)
+
+    def passed? = status == :passed
+    def failed? = status == :failed
+    def skipped? = status == :skipped
+  end
+end

data/lib/conformance_kit/rspec.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require "rspec/core"
+require "conformance_kit"
+
+module ConformanceKit
+  # The RSpec front end: `require "conformance_kit/rspec"` registers four shared
+  # examples. Each example group defines `subject_call`, a callable for the
+  # operation under test (not needed by "a boot-finalized configuration").
+  #
+  #   let(:subject_call) { -> { MyGem.cache_for(:key) } }
+  #   it_behaves_like "thread-safe under contention", threads: 8, iterations: 50, consistent: :identical
+  module RSpec
+    class << self
+      def register!
+        register_thread_example
+        register_fiber_example
+        register_boot_example
+        register_ractor_example
+      end
+
+      def enforce(example, result)
+        return if result.passed?
+        return example.skip(result.message) if result.skipped?
+
+        raise failure_class, result.message
+      end
+
+      private
+
+      def failure_class
+        return RuntimeError unless defined?(::RSpec::Expectations::ExpectationNotMetError)
+
+        ::RSpec::Expectations::ExpectationNotMetError
+      end
+
+      def register_thread_example
+        ::RSpec.shared_examples "thread-safe under contention" do |threads: 8, iterations: 50, consistent: nil|
+          it "survives #{threads} threads × #{iterations} calls" do
+            options = { threads: threads, iterations: iterations, consistent: consistent }
+            ConformanceKit::RSpec.enforce(self, Checks::ThreadContention.call(**options, &subject_call))
+          end
+        end
+      end
+
+      def register_fiber_example
+        ::RSpec.shared_examples "fiber-safe under an Async reactor" do |fibers: 8, iterations: 50, consistent: nil|
+          it "survives #{fibers} fibers × #{iterations} calls in one reactor" do
+            options = { fibers: fibers, iterations: iterations, consistent: consistent }
+            ConformanceKit::RSpec.enforce(self, Checks::FiberReactor.call(**options, &subject_call))
+          end
+        end
+      end
+
+      def register_boot_example
+        ::RSpec.shared_examples "a boot-finalized configuration" do |readers:, finalize: nil|
+          it "returns a Ractor-shareable value from every reader after finalize" do
+            ConformanceKit::RSpec.enforce(self, Checks::BootFinalized.call(readers: readers, finalize: finalize))
+          end
+        end
+      end
+
+      def register_ractor_example
+        ::RSpec.shared_examples "runs inside a non-main Ractor" do |inputs: []|
+          it "returns the main Ractor's result from inside Ractor.new", :ractor do
+            ConformanceKit::RSpec.enforce(self, Checks::RactorCanary.call(inputs: inputs, &subject_call))
+          end
+        end
+      end
+    end
+  end
+end
+
+ConformanceKit::RSpec.register!

data/lib/conformance_kit/shareability.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+module ConformanceKit
+  # Finds WHY a value is not Ractor-shareable: the first offending object on a
+  # depth-first walk (followed as deep as it goes), the path to it, and the fix.
+  # Works on any value, BasicObject included: it only calls core methods.
+  module Shareability
+    Culprit = Data.define(:path, :object_class, :reason)
+
+    LOCKS = %w[Thread::Mutex Monitor Thread::Queue Thread::SizedQueue Thread::ConditionVariable].freeze
+    MAX_DEPTH = 32
+
+    class << self
+      def available? = defined?(::Ractor) ? ::Ractor.respond_to?(:shareable?) : false
+
+      # nil when the value is shareable, a Culprit otherwise.
+      def culprit(value)
+        return nil if ::Ractor.shareable?(value)
+
+        find(value, "", {}, 0)
+      end
+
+      private
+
+      def find(value, path, seen, depth)
+        return nil if ::Ractor.shareable?(value) || seen.key?(value.__id__)
+        return blame(value, path) if intrinsic?(value) || depth >= MAX_DEPTH
+
+        seen[value.__id__] = true
+        # Freezing an unfrozen container would not fix a lock or a Proc inside it.
+        return intrinsic_below(value, path, seen, depth) || blame(value, path) unless frozen?(value)
+
+        children(value).each do |child_path, child|
+          found = find(child, path + child_path, seen, depth + 1)
+          return found if found
+        end
+        blame(value, path)
+      end
+
+      def intrinsic?(value) = callable?(value) || lock?(value) || concurrent?(value)
+
+      # The first never-shareable object (lock, Proc, Concurrent::*) under value.
+      def intrinsic_below(value, path, seen, depth)
+        return nil if depth >= MAX_DEPTH
+
+        children(value).each do |child_path, child|
+          next if ::Ractor.shareable?(child) || seen.key?(child.__id__)
+          return blame(child, path + child_path) if intrinsic?(child)
+
+          seen[child.__id__] = true
+          found = intrinsic_below(child, path + child_path, seen, depth + 1)
+          return found if found
+        end
+        nil
+      end
+
+      def children(value)
+        pairs = core(:instance_variables, value).map { |ivar| [".#{ivar}", core(:instance_variable_get, value, ivar)] }
+        case value
+        when ::Hash then pairs + hash_children(value)
+        when ::Array then pairs + value.each_with_index.map { |v, i| ["[#{i}]", v] }
+        when ::Struct, ::Data then pairs + value.to_h.map { |k, v| [".#{k}", v] }
+        when ::Range then pairs + [[".begin", value.begin], [".end", value.end]]
+        else pairs
+        end
+      end
+
+      def hash_children(hash)
+        pairs = hash.flat_map { |k, v| [["{key #{label(k)}}", k], ["[#{label(k)}]", v]] }
+        return pairs + [[".default_proc", hash.default_proc]] if hash.default_proc
+
+        hash.default.nil? ? pairs : pairs + [[".default", hash.default]]
+      end
+
+      def blame(value, path)
+        Culprit.new(path: path, object_class: class_name(value), reason: reason(value))
+      end
+
+      def reason(value)
+        name = class_name(value)
+        if callable?(value)
+          "#{article(name)} #{name} is never shareable: use Ractor.shareable_proc (Ruby 4.0) " \
+            "or Ractor.make_shareable on a capture-free proc"
+        elsif lock?(value) || concurrent?(value)
+          "#{article(name)} #{name} is main-only: keep per-Ractor state in ConformanceKit::Store, " \
+            "or allowlist it main_only"
+        elsif !frozen?(value)
+          "#{article(name)} #{name} that is not frozen: freeze it at boot (Ractor.make_shareable)"
+        else
+          "#{article(name)} #{name} that is frozen but not shareable (an extension object, or unshareable internals)"
+        end
+      end
+
+      def article(name) = name.match?(/\A[AEIOU]/) ? "an" : "a"
+
+      # Module#=== rather than value.is_a?, which a BasicObject lacks.
+      def callable?(value)
+        [::Proc, ::Method, ::UnboundMethod].any? { _1 === value } # rubocop:disable Style/CaseEquality
+      end
+
+      def frozen?(value) = core(:frozen?, value)
+      def core(method, value, *) = ::Kernel.instance_method(method).bind_call(value, *)
+
+      # A key's #inspect is consumer code: never let it abort the walk.
+      def label(key)
+        key.inspect
+      rescue StandardError
+        "#<#{class_name(key)}>"
+      end
+
+      def lock?(value) = LOCKS.include?(class_name(value))
+      def concurrent?(value) = class_name(value).start_with?("Concurrent::")
+      def class_name(value) = ::Kernel.instance_method(:class).bind_call(value).name || "anonymous class"
+    end
+  end
+end

data/lib/conformance_kit/store.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module ConformanceKit
+  # Per-Ractor lazy storage: `Store.fetch(:my_gem_cache) { {} }`.
+  #
+  # On Ruby 3.4+ this is `Ractor.store_if_absent`, atomic and per-Ractor. Below
+  # 3.4 (and on engines without Ractor) the main Ractor uses one Hash guarded by
+  # a Mutex, created at load (never lazily, so there is no check-then-set race);
+  # it is the kit's one allowlisted main-only state (.conformance.yml). A
+  # non-main Ractor on 3.2/3.3 cannot read it, so it keeps its own values in
+  # Ractor-local storage instead (not locked: one Ractor's threads may race to
+  # build a value, as with any `||=`).
+  module Store
+    # rubocop:disable ThreadSafety/MutableClassInstanceVariable -- main-only fallback, guarded by @fallback_lock
+    @fallback_lock = Mutex.new
+    @fallback_values = {}
+    # rubocop:enable ThreadSafety/MutableClassInstanceVariable
+
+    class << self
+      def fetch(key, &init)
+        raise ArgumentError, "ConformanceKit::Store.fetch(#{key.inspect}) needs an initializer block" unless init
+        return ::Ractor.store_if_absent(key, &init) if native?
+        return ractor_local(key, &init) unless main_ractor?
+
+        @fallback_lock.synchronize do
+          @fallback_values.fetch(key) { @fallback_values[key] = init.call }
+        end
+      end
+
+      private
+
+      def main_ractor? = !defined?(::Ractor) || ::Ractor.current == ::Ractor.main
+
+      # Boxed, so a nil or false value is cached rather than rebuilt on every fetch.
+      def ractor_local(key)
+        (::Ractor.current[:"conformance_kit_store/#{key}"] ||= [yield]).first
+      end
+
+      public
+
+      def native?
+        defined?(::Ractor) ? ::Ractor.respond_to?(:store_if_absent) : false
+      end
+    end
+  end
+end

data/lib/conformance_kit/version.rb

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

data/lib/conformance_kit.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require_relative "conformance_kit/version"
+require_relative "conformance_kit/result"
+require_relative "conformance_kit/store"
+require_relative "conformance_kit/shareability"
+require_relative "conformance_kit/checks/consistency"
+require_relative "conformance_kit/checks/thread_contention"
+require_relative "conformance_kit/checks/fiber_reactor"
+require_relative "conformance_kit/checks/boot_finalized"
+require_relative "conformance_kit/checks/ractor_canary"
+
+# Concurrency conformance for the zoolutions gems. See README.md for the tiers.
+module ConformanceKit
+end

metadata

@@ -0,0 +1,68 @@
+--- !ruby/object:Gem::Specification
+name: conformance-kit
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- mhenrixon
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: Shared RSpec examples, a per-Ractor storage shim, a class-state audit,
+  RuboCop configs and reusable CI workflows that hold a gem to explicit thread-safe,
+  fiber-safe and Ractor-clean tiers.
+email:
+- mikael@mhenrixon.com
+executables:
+- conformance-audit
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- config/rubocop.yml
+- config/rubocop_spinel.yml
+- exe/conformance-audit
+- lib/conformance_kit.rb
+- lib/conformance_kit/audit.rb
+- lib/conformance_kit/audit/allowlist.rb
+- lib/conformance_kit/audit/cli.rb
+- lib/conformance_kit/checks/boot_finalized.rb
+- lib/conformance_kit/checks/consistency.rb
+- lib/conformance_kit/checks/fiber_reactor.rb
+- lib/conformance_kit/checks/ractor_canary.rb
+- lib/conformance_kit/checks/thread_contention.rb
+- lib/conformance_kit/minitest.rb
+- lib/conformance_kit/result.rb
+- lib/conformance_kit/rspec.rb
+- lib/conformance_kit/shareability.rb
+- lib/conformance_kit/store.rb
+- lib/conformance_kit/version.rb
+homepage: https://github.com/zoolutions/conformance-kit
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/zoolutions/conformance-kit
+  changelog_uri: https://github.com/zoolutions/conformance-kit/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.2'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.19
+specification_version: 4
+summary: 'Concurrency conformance gates for Ruby gems: threads, fibers, Ractors and
+  compiler probes.'
+test_files: []