rspec-sprint 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f16ad949645afe84a5a8ba614a5a6e2e40f609fa76f73c2e0af72557830dbd9d
+  data.tar.gz: 8503cde0dabd4c8cccefee9d53ef55b996e2724ad21ebcb6f4f4d6b9b6eec747
+SHA512:
+  metadata.gz: 021d7debd206e0d543a97c71692eed732b0f3bc280e13e3262c19936ee790012d3b93588f3de91f1741f19fa26ac36da322e2fd1ad87ef81f215098231f00a66
+  data.tar.gz: 0d93b9cb8eb129e2cc6451d8ad2607efcbd0a1a6108549d4c5f8a566c4fd69db39b481d1b40293462ed94bd0396b49da6a2cf573b9e38eb3c6357c22c73a9e43

data/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 yasu551
+
+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,98 @@
+# rspec-sprint
+
+> Diagnose your RSpec/Rails test-suite slowness and get the top repo-specific fixes — diagnosis **plus** prescription, not just numbers.
+
+`rspec-sprint doctor` runs your suite once (via [test-prof](https://test-prof.evilmartians.io/)'s FactoryProf and RSpec's JSON formatter in a single run), interprets the output against opinionated heuristics, and asserts the top few things to fix in *your* repo:
+
+```
+$ bundle exec rspec-sprint doctor
+factory が suite の 47% (local実測)。最上位は :user（420回, うち直接生成は 30回 = カスケード）。
+  → 不要 association を trait へ退避 / build_stubbed / let_it_be / FactoryDefault
+...
+```
+
+## Installation
+
+Add to your `Gemfile` (development/test group):
+
+```ruby
+group :development, :test do
+  gem "rspec-sprint"
+  gem "test-prof"
+end
+```
+
+Then run `bundle install`.
+
+**Prerequisite:** Add to your `spec/spec_helper.rb`:
+
+```ruby
+require "test_prof"
+```
+
+## Usage
+
+Run the doctor command to diagnose your suite and get prescriptions ranked by ROI:
+
+```
+$ bundle exec rspec-sprint doctor
+```
+
+To target a subset of specs (faster feedback during investigation):
+
+```
+$ bundle exec rspec-sprint doctor -- spec/models
+```
+
+Snapshot comparison (coming in v0.2.0):
+
+```
+$ bundle exec rspec-sprint doctor --no-snapshot
+```
+
+The command exits 0 whether or not findings are reported, so it is safe to run in CI as an advisory step.
+
+## Why not just test-prof?
+
+test-prof gives you the **instruments** (FactoryProf, EventProf, TagProf). `rspec-sprint` is the **judgment layer** on top: it reads those instruments, ranks the bottlenecks by ROI, and tells you which one to fix first and how. It does not reimplement any profiler.
+
+Concretely, rspec-sprint applies three opinionated heuristics to your numbers:
+
+- **factory_dominance** — factory time exceeds 30% of total suite time
+- **path_group_skew** — one spec directory accounts for a disproportionate share of slowness
+- **slow_examples_concentration** — a handful of examples dominate the tail
+
+For each finding it emits a ranked prescription (e.g. "retire unused associations to a trait, switch to `build_stubbed`") rather than leaving interpretation to you.
+
+Even when test-prof is not installed, FactoryBot is absent, or the suite fails partway through, `rspec-sprint doctor` degrades gracefully and tells you what it could and could not measure.
+
+## Compatibility
+
+| Component | Version |
+|-----------|---------|
+| Ruby      | >= 3.0  |
+| RSpec     | ~> 3.13 |
+| test-prof | >= 1.0  |
+| Rails     | optional (not required) |
+
+## Status
+
+v0.1.0 — install-day tested, dogfood confirmed.
+
+**Dogfood result (SonicGarden/aegis, 2026-06-18):**
+
+```
+$ bundle exec rspec-sprint doctor -- spec/models spec/policies
+
+1. path group spec/models が suite 時間の 92% (local実測)
+   → spec/models を別CIジョブに分離し fast suite から切り出す（候補）
+
+2. factory が suite の 44%。最上位は :tenant（689回）
+   → 不要な association を trait へ退避 / build_stubbed / let_it_be
+```
+
+Both findings are repo-specific with concrete numbers — not generic advice.
+
+## License
+
+MIT

data/exe/rspec-sprint

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "rspec_sprint/cli"
+
+RspecSprint::CLI.start(ARGV)

data/lib/rspec_sprint/cli.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "thor"
+require_relative "collector"
+require_relative "doctor"
+
+module RspecSprint
+  class CLI < Thor
+    def self.exit_on_failure?
+      true
+    end
+
+    desc "doctor [-- RSPEC_ARGS]", "Run your suite once and assert the top things to fix"
+    long_desc <<~DESC
+      Runs your RSpec suite a single time with FactoryProf (test-prof) + RSpec's
+      JSON formatter, then prints the top repo-specific bottlenecks and how to fix
+      them. Forward args to rspec after `--`, e.g.
+
+        bundle exec rspec-sprint doctor -- spec/models --tag focus
+
+      Requires test-prof in your bundle and `require "test_prof"` in your spec
+      helper for factory diagnosis (Rule①); without it, the other rules still run.
+    DESC
+    def doctor(*rspec_args)
+      result = Collector.new(rspec_args: rspec_args).run
+      puts Doctor.diagnose(result)
+    end
+
+    default_command :doctor
+  end
+end

data/lib/rspec_sprint/collector.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require "open3"
+require "fileutils"
+
+module RspecSprint
+  # Runs the host project's RSpec suite ONCE with FactoryProf JSON enabled and
+  # RSpec's JSON formatter writing to a dedicated file (so the host's own
+  # formatter on stdout is not clobbered — design D10③). Returns a Result that
+  # downstream code (Diagnosis) and degraded-path handling read.
+  #
+  # The pure pieces (build_command, factory_prof_path_from) are split out so
+  # most behavior is unit-testable without spawning a real rspec process.
+  class Collector
+    DEFAULT_OUT = "tmp/rspec_sprint/rspec.json"
+    FPROF_LOG = /Profile results to JSON:\s*(\S+)/
+
+    Result = Struct.new(
+      :rspec_json_path, :factory_prof_path, :exit_status, :stdout, :stderr,
+      keyword_init: true
+    ) do
+      def rspec_json?
+        !rspec_json_path.nil? && File.exist?(rspec_json_path) && !File.zero?(rspec_json_path)
+      end
+
+      def factory_prof?
+        !factory_prof_path.nil? && File.exist?(factory_prof_path)
+      end
+
+      def suite_red?
+        !exit_status.nil? && exit_status != 0
+      end
+    end
+
+    # Pure: the env + argv used to run rspec. FPROF=json makes test-prof write
+    # its FactoryProf JSON; --format json --out writes rspec's JSON to its own
+    # file without replacing the host's stdout formatter.
+    def self.build_command(out_path:, rspec_args: [])
+      env = { "FPROF" => "json" }
+      argv = ["bundle", "exec", "rspec", "--format", "json", "--out", out_path, *rspec_args]
+      [env, argv]
+    end
+
+    # Pure: pull the FactoryProf output path test-prof logs to stdout. nil means
+    # test-prof never ran (not required in the host's boot) — Rule① will be skipped.
+    def self.factory_prof_path_from(stdout)
+      match = stdout.to_s.match(FPROF_LOG)
+      match && match[1]
+    end
+
+    def initialize(rspec_args: [], out_path: DEFAULT_OUT, dir: ".")
+      @rspec_args = rspec_args
+      @out_path = out_path
+      @dir = dir
+    end
+
+    def run
+      FileUtils.mkdir_p(File.dirname(File.join(@dir, @out_path)))
+      env, argv = self.class.build_command(out_path: @out_path, rspec_args: @rspec_args)
+      stdout, stderr, status = Open3.capture3(env, *argv, chdir: @dir)
+      Result.new(
+        rspec_json_path: File.join(@dir, @out_path),
+        factory_prof_path: resolve_factory_prof_path(stdout),
+        exit_status: status.exitstatus,
+        stdout: stdout,
+        stderr: stderr
+      )
+    end
+
+    private
+
+    def resolve_factory_prof_path(stdout)
+      rel = self.class.factory_prof_path_from(stdout)
+      rel && File.join(@dir, rel)
+    end
+  end
+end

data/lib/rspec_sprint/diagnosis.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative "normalizer"
+require_relative "ranker"
+require_relative "formatter"
+
+module RspecSprint
+  # Pure pipeline: profiler JSON files -> normalized snapshot -> ranked findings
+  # -> rendered report. Decoupled from how the JSON was produced (a live run, a
+  # fixture, or a CI artifact), per design D3.
+  module Diagnosis
+    module_function
+
+    def from_files(rspec_json:, factory_prof_json: nil)
+      snapshot = Normalizer.new(rspec_json: rspec_json, factory_prof_json: factory_prof_json).call
+      Formatter.format(Ranker.call(snapshot))
+    end
+  end
+end

data/lib/rspec_sprint/doctor.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require_relative "diagnosis"
+
+module RspecSprint
+  # Turns a Collector::Result into a human report, handling the degraded paths
+  # (design D4 / D10④): distinguish "the suite never produced readable output"
+  # (diagnosis impossible) from "the suite ran but had failures" (still
+  # diagnosable, with a warning), and from "test-prof wasn't active" (skip
+  # Rule① with a one-line setup hint).
+  module Doctor
+    module_function
+
+    def diagnose(result)
+      return diagnosis_impossible(result) unless result.rspec_json?
+
+      sections = []
+      sections << suite_red_warning(result) if result.suite_red?
+      sections << factory_prof_missing_hint unless result.factory_prof?
+      sections << Diagnosis.from_files(
+        rspec_json: result.rspec_json_path,
+        factory_prof_json: result.factory_prof? ? result.factory_prof_path : nil
+      )
+      sections.join("\n\n")
+    end
+
+    def diagnosis_impossible(result)
+      "診断不可: rspec の出力（JSON）が読めませんでした（exit #{result.exit_status}）。" \
+        "suite はブートしましたか？ `bundle exec rspec` を直接実行してエラーを確認してください。"
+    end
+
+    def suite_red_warning(result)
+      "注意: suite に失敗があります（exit #{result.exit_status}）。" \
+        "全 example が走り切っていない場合、以下の数値は不安定なことがあります。"
+    end
+
+    def factory_prof_missing_hint
+      "注意: FactoryProf の出力がありません（test-prof 未導入、または spec_helper で require 忘れ）。" \
+        "factory 関連の診断（Rule①）をスキップしました。\n" \
+        '設定: Gemfile の development/test グループに test-prof を追加し、spec_helper で `require "test_prof"` してください。'
+    end
+  end
+end

data/lib/rspec_sprint/finding.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module RspecSprint
+  # One diagnosis + prescription. `score` is the ROI/severity used by the Ranker
+  # to order findings (higher = more dominant). A rule returns a Finding when it
+  # fires, or nil when it is below threshold (signal-gated output, design D8).
+  Finding = Struct.new(
+    :rule_id, :score, :headline, :prescriptions, :expected_saving, :doc_url,
+    keyword_init: true
+  )
+end

data/lib/rspec_sprint/formatter.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module RspecSprint
+  # Renders ranked findings as a terminal report. Asserts the top few; when no
+  # rule fired it says so explicitly rather than padding with generic advice
+  # (design D8).
+  module Formatter
+    module_function
+
+    def format(findings)
+      return no_bottleneck if findings.empty?
+
+      lines = ["rspec-sprint doctor — 上位#{findings.size}件 (信号があった項目のみ):", ""]
+      findings.each_with_index do |f, i|
+        lines << "#{i + 1}. #{f.headline}"
+        f.prescriptions.each { |p| lines << "   → #{p}" }
+        lines << "   想定削減: #{f.expected_saving}" if f.expected_saving
+        lines << "   参考: #{f.doc_url}" if f.doc_url
+        lines << ""
+      end
+      lines.join("\n")
+    end
+
+    def no_bottleneck
+      "支配的なボトルネックは検出されませんでした（各指標は閾値以下＝該当なし）。" \
+        "生の数値は --verbose で出せますが、いま無理に直すべき箇所はありません。"
+    end
+  end
+end

data/lib/rspec_sprint/normalizer.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+require "json"
+
+module RspecSprint
+  # Turns raw profiler JSON (rspec's JSON formatter + test-prof's FactoryProf
+  # JSON) into one normalized Snapshot. Input is FILE PATHS (decoupled from the
+  # live run) so golden fixtures and a future artifact-ingest mode feed the same
+  # code (design doc D3).
+  class Normalizer
+    # One factory's profile. top_level_ratio is the cascade signal: low ratio
+    # means the factory is built mostly via associations, not directly.
+    Factory = Struct.new(:name, :total_count, :top_level_count, :total_time, keyword_init: true) do
+      def top_level_ratio
+        return 0.0 if total_count.nil? || total_count.zero?
+
+        top_level_count.to_f / total_count
+      end
+    end
+
+    Example = Struct.new(:full_description, :file_path, :run_time, :status, keyword_init: true)
+
+    Snapshot = Struct.new(
+      :suite_duration, :factory_time, :factories,
+      :examples, :example_count, :failure_count,
+      keyword_init: true
+    ) do
+      # Share of example-run wall time spent building factories (top-level, so
+      # cascade time is not double-counted). Denominator = summary.duration (D7).
+      def factory_time_ratio
+        return 0.0 if suite_duration.nil? || suite_duration.zero?
+
+        factory_time / suite_duration
+      end
+
+      def slow_examples
+        (examples || []).sort_by { |e| -e.run_time }
+      end
+
+      # run_time summed by the first path segment under spec/ (Rule② data).
+      # Deliberately "path group", not RSpec metadata `type:` — see design D10⑦.
+      def path_group_durations
+        (examples || []).each_with_object(Hash.new(0.0)) do |ex, acc|
+          acc[path_group(ex.file_path)] += ex.run_time
+        end
+      end
+
+      private
+
+      def path_group(file_path)
+        segments = file_path.to_s.sub(%r{\A\./}, "").split("/")
+        idx = segments.index("spec")
+        (idx && segments[idx + 1] && !segments[idx + 1].end_with?("_spec.rb") ? segments[idx + 1] : "(root)")
+      end
+    end
+
+    def initialize(rspec_json:, factory_prof_json: nil)
+      @rspec_json = rspec_json
+      @factory_prof_json = factory_prof_json
+    end
+
+    def call
+      rspec = JSON.parse(File.read(@rspec_json))
+      summary = rspec.fetch("summary", {})
+      Snapshot.new(
+        suite_duration: summary.fetch("duration"),
+        factory_time: top_level_factory_time,
+        factories: build_factories,
+        examples: build_examples(rspec.fetch("examples", [])),
+        example_count: summary.fetch("example_count", 0),
+        failure_count: summary.fetch("failure_count", 0)
+      )
+    end
+
+    private
+
+    def build_examples(raw)
+      raw.map do |e|
+        Example.new(
+          full_description: e["full_description"],
+          file_path: e["file_path"],
+          run_time: e.fetch("run_time", 0.0),
+          status: e["status"]
+        )
+      end
+    end
+
+    # FactoryProf `stats`, already sorted by total_count desc by test-prof.
+    def factory_stats
+      return [] unless @factory_prof_json && File.exist?(@factory_prof_json)
+
+      JSON.parse(File.read(@factory_prof_json)).fetch("stats", [])
+    end
+
+    def build_factories
+      factory_stats.map do |s|
+        Factory.new(
+          name: s.fetch("name"),
+          total_count: s.fetch("total_count", 0),
+          top_level_count: s.fetch("top_level_count", 0),
+          total_time: s.fetch("total_time", 0.0)
+        )
+      end
+    end
+
+    # Sum of per-stat top_level_time. test-prof's top-level total_time
+    # ("00:00.077") is a formatted STRING, so we never read that; we sum the
+    # per-stat raw floats instead (design doc Verification Findings ②).
+    def top_level_factory_time
+      factory_stats.sum { |s| s.fetch("top_level_time", 0.0) }
+    end
+  end
+end

data/lib/rspec_sprint/ranker.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative "rules"
+
+module RspecSprint
+  # Runs every rule against a snapshot, drops the ones that didn't fire
+  # (signal-gated, design D8), and returns the strongest few by score.
+  module Ranker
+    RULES = %i[factory_dominance path_group_skew slow_examples_concentration].freeze
+    MAX_FINDINGS = 3
+
+    module_function
+
+    def call(snapshot)
+      RULES
+        .map { |rule| Rules.public_send(rule, snapshot) }
+        .compact
+        .sort_by { |finding| -finding.score }
+        .first(MAX_FINDINGS)
+    end
+  end
+end

data/lib/rspec_sprint/rules.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+require_relative "finding"
+
+module RspecSprint
+  # The judgment layer — the gem's moat. Each rule is a plain method (design D1):
+  # it reads a normalized Snapshot and returns a Finding when its signal exceeds
+  # a threshold, or nil otherwise. Thresholds and prescription wording are the
+  # opinionated, tunable heart of the tool (premise #3).
+  module Rules
+    # --- Tunable thresholds (the opinionated knobs) ---------------------------
+    FACTORY_DOMINANCE_THRESHOLD = 0.30 # fires when factory_time_ratio exceeds this
+    CASCADE_RATIO = 0.5                # top_level_ratio below this = built mostly via association
+
+    # Defaults (tune freely — these are the gem's IP):
+    PATH_GROUP_SKEW_THRESHOLD = 0.50            # one path group eating MORE than this share of suite time
+    SLOW_EXAMPLE_TOP_N = 5                       # "a few" = this many slowest examples
+    SLOW_EXAMPLE_CONCENTRATION_THRESHOLD = 0.30 # top-N eating more than this share of suite time
+    SLOW_EXAMPLE_MIN_EXAMPLES = 10              # below this the "top-N" isn't a minority — skip (D8: no signal)
+
+    module_function
+
+    # Rule ①: factory build time dominates the suite.
+    def factory_dominance(snapshot)
+      ratio = snapshot.factory_time_ratio
+      return nil if ratio < FACTORY_DOMINANCE_THRESHOLD
+
+      pct = (ratio * 100).round
+      top = (snapshot.factories || []).max_by(&:total_count)
+      cascade = top && top.top_level_ratio < CASCADE_RATIO
+
+      Finding.new(
+        rule_id: :factory_dominance,
+        score: ratio,
+        headline: headline_for(pct, top, cascade),
+        prescriptions: [
+          "不要な association をデフォルト factory から外し trait へ退避",
+          "永続化が不要な spec は build_stubbed / build に置換",
+          "全 spec で使う共有データは let_it_be / FactoryDefault 化"
+        ],
+        expected_saving: "factory time の一部（目安 suite の #{(pct * 0.3).round}–#{pct}%、local実測）",
+        doc_url: "https://test-prof.evilmartians.io/guide/profilers/factory_prof"
+      )
+    end
+
+    # Rule ②: one "path group" (spec/system, spec/requests, ...) dominates the
+    # suite's wall time. NOTE: call it a path group, not RSpec `type:` — they can
+    # diverge (design D10⑦). Do NOT assert "split your system specs"; offer it as
+    # a candidate.
+    #
+    # Data available on `snapshot`:
+    #   snapshot.path_group_durations  # => { "system" => 1.5, "models" => 0.3, ... } seconds
+    #   snapshot.suite_duration        # => total example-run wall time (the denominator)
+    #
+    # Return a Finding when the biggest group's share exceeds
+    # PATH_GROUP_SKEW_THRESHOLD, else nil. Score = that share (0.0..1.0).
+    #
+    def path_group_skew(snapshot)
+      total = snapshot.suite_duration.to_f
+      return nil if total.zero?
+
+      # Drop "(root)" — specs directly under spec/ aren't a coherent group you'd
+      # split into a CI job (dogfooding finding; cf. Codex #8 path-group risk).
+      candidates = (snapshot.path_group_durations || {}).reject { |g, _| g == "(root)" }
+      group, time = candidates.max_by { |_, t| t }
+      return nil if group.nil?
+
+      share = time / total
+      return nil unless share > PATH_GROUP_SKEW_THRESHOLD
+
+      pct = (share * 100).round
+      Finding.new(
+        rule_id: :path_group_skew,
+        score: share,
+        headline: "path group spec/#{group} が suite 時間の #{pct}% (local実測)",
+        prescriptions: [
+          "spec/#{group} を別CIジョブに分離し fast suite から切り出す（候補）",
+          "ロジックを下位レイヤ(model/request/service)へ寄せ #{group} spec 本数を減らせるか検討",
+          "runtime ログで #{group} を shard 分割"
+        ],
+        expected_saving: "spec/#{group} を分離すれば fast suite から最大 #{pct}% 相当を外せる（local実測）",
+        doc_url: "https://test-prof.evilmartians.io/guide/profilers/tag_prof"
+      )
+    end
+
+    # Rule ③: a few slow examples concentrate most of the suite time.
+    #
+    # Data available on `snapshot`:
+    #   snapshot.slow_examples   # => [Example(full_description, file_path, run_time, status)] slow-first
+    #   snapshot.suite_duration  # => denominator
+    #
+    # Return a Finding when the top-10 examples' summed run_time / suite_duration
+    # exceeds SLOW_EXAMPLE_CONCENTRATION_THRESHOLD, naming the worst few. Score =
+    # that concentration.
+    #
+    def slow_examples_concentration(snapshot)
+      total = snapshot.suite_duration.to_f
+      return nil if total.zero?
+
+      examples = snapshot.slow_examples || []
+      count = snapshot.example_count || examples.size
+      return nil if count < SLOW_EXAMPLE_MIN_EXAMPLES # tiny suite: top-N isn't a minority (D8)
+
+      top = examples.first(SLOW_EXAMPLE_TOP_N)
+      return nil if top.empty?
+
+      concentration = top.sum(&:run_time) / total
+      return nil unless concentration > SLOW_EXAMPLE_CONCENTRATION_THRESHOLD
+
+      pct = (concentration * 100).round
+      worst = top.first
+      Finding.new(
+        rule_id: :slow_examples_concentration,
+        score: concentration,
+        headline: "上位#{top.size}例が suite 時間の #{pct}% (local実測)。最遅: \"#{worst.full_description}\" (#{(worst.run_time * 1000).round}ms)",
+        prescriptions: [
+          "最遅例に EVENT_PROF='sql.active_record' / TEST_STACK_PROF を当てて原因特定",
+          "重い setup (let! / before(:each)) を let_it_be / build_stubbed へ",
+          "外部I/O・sleep・実ブラウザ依存を切り出す"
+        ],
+        expected_saving: "上位例を半減できれば最大 #{(pct * 0.5).round}% 相当（local実測）",
+        doc_url: "https://test-prof.evilmartians.io/guide/profilers/event_prof"
+      )
+    end
+
+    def headline_for(pct, top, cascade)
+      base = "factory が suite の #{pct}% (local実測)"
+      return base unless top
+
+      if cascade
+        "#{base}。最上位は :#{top.name}（#{top.total_count}回, うち直接生成 #{top.top_level_count}回 = カスケード）"
+      else
+        "#{base}。最上位は :#{top.name}（#{top.total_count}回）"
+      end
+    end
+  end
+end

data/lib/rspec_sprint/version.rb

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

data/lib/rspec_sprint.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require_relative "rspec_sprint/version"
+
+# rspec-sprint: diagnose RSpec/Rails test-suite slowness and assert the top
+# repo-specific things to fix. Wraps test-prof + rspec JSON; it does not
+# reimplement profilers.
+module RspecSprint
+  class Error < StandardError; end
+end

metadata

@@ -0,0 +1,88 @@
+--- !ruby/object:Gem::Specification
+name: rspec-sprint
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- yasu551
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: test-prof
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.0'
+description: |
+  rspec-sprint doctor runs your suite once (via test-prof's FactoryProf + rspec's
+  JSON formatter), interprets the output against opinionated heuristics, and asserts
+  the top few things to fix — diagnosis plus concrete prescription, not just numbers.
+  It wraps existing profilers; it does not reimplement them.
+executables:
+- rspec-sprint
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- exe/rspec-sprint
+- lib/rspec_sprint.rb
+- lib/rspec_sprint/cli.rb
+- lib/rspec_sprint/collector.rb
+- lib/rspec_sprint/diagnosis.rb
+- lib/rspec_sprint/doctor.rb
+- lib/rspec_sprint/finding.rb
+- lib/rspec_sprint/formatter.rb
+- lib/rspec_sprint/normalizer.rb
+- lib/rspec_sprint/ranker.rb
+- lib/rspec_sprint/rules.rb
+- lib/rspec_sprint/version.rb
+homepage: https://github.com/yasu551/rspec-sprint
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/yasu551/rspec-sprint
+  changelog_uri: https://github.com/yasu551/rspec-sprint/blob/main/CHANGELOG.md
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.10
+specification_version: 4
+summary: Diagnose RSpec/Rails test-suite slowness and assert the top repo-specific
+  fixes.
+test_files: []