The IDE you know, rebuilt in Rust. IntelliJ IDEA–style keymap, tool windows and search-everywhere in a fast native app: editor, code insight, debugger, Git, terminal, database and HTTP clients for 60+ languages.
TypeScript code-editorcross-platformdapdatabase-clientdebuggerdesktop-appdeveloper-toolsgithttp-clientideintellijlsprusttauriterminal
feat(coverage): Run with Coverage and report import for Ruby (SimpleCov) (#1535)
Jacob Kjeldahl4959b430b13d
diff --git a/crates/ide-coverage/src/import.rs b/crates/ide-coverage/src/import.rsindex 669f1b8cd..e35c24c1c 100644--- a/crates/ide-coverage/src/import.rs+++ b/crates/ide-coverage/src/import.rs@@ -1,8 +1,8 @@//! "Import a report collected in CI from disk": the format is sniffed from the-//! content (lcov, Go cover profile, JaCoCo XML) and paths recorded on another+//! content (lcov, Go cover profile, JaCoCo XML, SimpleCov resultset) and paths recorded on another//! machine are mapped into the project by their longest existing suffix.-use crate::{Accumulator, CoverageSuite, goprofile, jacoco, lcov};+use crate::{Accumulator, CoverageSuite, goprofile, jacoco, lcov, simplecov};use ide_core::{IdeError, IdeResult};use std::path::{Component, Path, PathBuf};@@ -11,6 +11,7 @@ pub(crate) enum Format {Lcov,GoProfile,Jacoco,+ SimpleCov,}pub(crate) fn detect(text: &str) -> Option<Format> {@@ -18,6 +19,9 @@ pub(crate) fn detect(text: &str) -> Option<Format> {if head.starts_with('<') {return head.contains("<report").then_some(Format::Jacoco);}+ if head.starts_with('{') {+ return head.contains("\"coverage\"").then_some(Format::SimpleCov);+ }let first = head.lines().next().unwrap_or_default();if first.starts_with("mode:") {return Some(Format::GoProfile);@@ -30,6 +34,7 @@ pub fn import(path: &Path, root: &Path) -> IdeResult<CoverageSuite> {let text = std::fs::read_to_string(path)?;let mut suite = match detect(&text) {Some(Format::Lcov) => lcov::parse(&text, root).finish("lcov"),+ Some(Format::SimpleCov) => simplecov::parse(&text, root)?.finish("SimpleCov"),Some(Format::GoProfile) => {let (module, module_dir) = go_module_for(root, &text);goprofile::parse(&text, &module, &module_dir).finish("go test -cover")@@ -50,7 +55,7 @@ pub fn import(path: &Path, root: &Path) -> IdeResult<CoverageSuite> {}None => {return Err(IdeError::invalid(format!(- "{} is not an lcov tracefile, Go cover profile or JaCoCo XML report",+ "{} is not an lcov tracefile, Go cover profile, JaCoCo XML report or SimpleCov resultset",path.display())));}@@ -125,9 +130,29 @@ mod tests {Some(Format::Jacoco));assert_eq!(detect("<?xml version=\"1.0\"?><coverage/>"), None);+ assert_eq!(detect("{\"RSpec\": {\"coverage\": {}}}"), Some(Format::SimpleCov));+ assert_eq!(detect("{\"name\": \"package.json\"}"), None);assert_eq!(detect("hello"), None);}+ #[test]+ fn imports_ci_simplecov_with_foreign_paths() {+ let tmp = tempfile::tempdir().unwrap();+ let root = tmp.path().join("app");+ std::fs::create_dir_all(root.join("lib")).unwrap();+ std::fs::write(root.join("lib/a.rb"), "").unwrap();+ let report = tmp.path().join(".resultset.json");+ std::fs::write(+ &report,+ r#"{"RSpec":{"coverage":{"/home/runner/work/app/app/lib/a.rb":{"lines":[null,1,0]}}}}"#,+ )+ .unwrap();+ let suite = import(&report, &root).unwrap();+ assert_eq!(suite.runner, "SimpleCov");+ assert_eq!(suite.files[0].path.as_ref() as &Path, root.join("lib/a.rb"));+ assert_eq!((suite.files[0].lines_total, suite.files[0].lines_covered), (2, 1));+ }+#[test]fn imports_ci_lcov_with_foreign_paths() {let tmp = tempfile::tempdir().unwrap();diff --git a/crates/ide-coverage/src/lib.rs b/crates/ide-coverage/src/lib.rsindex 757812036..707f936da 100644--- a/crates/ide-coverage/src/lib.rs+++ b/crates/ide-coverage/src/lib.rs@@ -10,6 +10,7 @@//! | JS / TS (vitest, jest scripts) | the runner's `--coverage` | lcov |//! | Node.js scripts | `c8` | lcov |//! | Python (pytest, scripts) | coverage.py (`coverage run`, then `coverage lcov`) | lcov |+//! | Ruby (rspec, minitest, rake, scripts) | SimpleCov (`coverage/.resultset.json`) | SimpleCov resultset |//! | Go (`go test`) | `-coverprofile` | Go cover profile |//! | Maven / Gradle tests | JaCoCo (plugin goals / an init script) | JaCoCo XML |//!@@ -20,6 +21,7 @@ mod import;mod jacoco;mod lcov;mod plan;+mod simplecov;pub use import::import;pub use plan::prepare;@@ -83,6 +85,8 @@ pub enum CoverageReportSpec {Lcov { runner: String, path: IpcPath, base: IpcPath },/// `go test -coverprofile`; import paths under `module` map to `module_dir`.GoProfile { path: IpcPath, module: String, module_dir: IpcPath },+ /// SimpleCov's `.resultset.json`; relative paths resolve against `base`.+ SimpleCov { path: IpcPath, base: IpcPath },/// Every JaCoCo XML report (Maven `target/site/jacoco`, Gradle `build/reports/jacoco`) under `dir`.Jacoco { dir: IpcPath },/// The tool's raw data is exported to lcov by `argv` first (coverage.py: `… -m coverage lcov -o <lcov>`).@@ -185,6 +189,10 @@ pub fn collect(spec: &CoverageReportSpec) -> IdeResult<CoverageSuite> {let text = read_report(path)?;Ok(lcov::parse(&text, base).finish(runner))}+ CoverageReportSpec::SimpleCov { path, base } => {+ let text = read_report(path)?;+ Ok(simplecov::parse(&text, base)?.finish("SimpleCov"))+ }CoverageReportSpec::GoProfile { path, module, module_dir } => {let text = read_report(path)?;Ok(goprofile::parse(&text, module, module_dir).finish("go test -cover"))diff --git a/crates/ide-coverage/src/plan.rs b/crates/ide-coverage/src/plan.rsindex 2368aaaa4..5355ffd51 100644--- a/crates/ide-coverage/src/plan.rs+++ b/crates/ide-coverage/src/plan.rs@@ -67,6 +67,7 @@ pub fn prepare(root: &Path, config: &RunConfig, out: &Path) -> CoveragePrepared"gradle" | "gradlew" => gradle(config, &dir, out),"npm" | "pnpm" | "yarn" | "bun" => npm(root, config, &dir, out),"node" | "npx" | "tsx" | "ts-node" => c8(root, config, &dir, out),+ "ruby" | "bundle" | "rake" | "rspec" | "rails" => ruby(root, config, &dir, out),"deno" => unsupported("Coverage of Deno tasks is not supported yet."),"java" => unsupported("Coverage of Java applications needs the JaCoCo agent; run a Maven or Gradle test configuration with coverage.",@@ -234,6 +235,65 @@ fn c8(root: &Path, config: &RunConfig, dir: &Path, out: &Path) -> CoveragePreparready("c8", config, path(&c8), args, report)}+/// Loaded first (`ide_run::ruby_preload`) when the project never starts SimpleCov itself.+const SIMPLECOV_PRELOAD: &str = r#"# Written by OpenIDEA for Run with Coverage.+begin+ require "simplecov"+rescue LoadError+ # `bundle exec` is a Ruby process too and loads this before Bundler puts the project's gems on+ # the load path; the Ruby it starts loads bundler/setup first and finds SimpleCov.+ return+end+SimpleCov.coverage_dir(ENV.fetch("OPENIDEA_COVERAGE_DIR"))+SimpleCov.start do+ add_filter %r{^/(test|spec|features)/}+ enable_coverage :branch+end+"#;++/// Files where a project conventionally starts SimpleCov.+const SIMPLECOV_STARTERS: &[&str] =+ &[".simplecov", "spec/spec_helper.rb", "spec/rails_helper.rb", "test/test_helper.rb", "test/minitest_helper.rb"];++fn ruby(root: &Path, config: &RunConfig, dir: &Path, out: &Path) -> CoveragePrepared {+ let bundled = [dir, root].iter().any(|d| d.join("Gemfile").is_file());+ let mentions = |file: &str| {+ [dir, root].iter().any(|d| std::fs::read_to_string(d.join(file)).is_ok_and(|t| t.contains("simplecov")))+ };+ if bundled && !mentions("Gemfile.lock") && !mentions("Gemfile") {+ return missing(+ "simplecov",+ "Ruby coverage needs the simplecov gem in the project's Gemfile.",+ Some((vec![s("bundle"), s("add"), s("simplecov"), s("--group"), s("test")], dir)),+ );+ }+ let starts = |d: &Path| {+ SIMPLECOV_STARTERS.iter().any(|f| {+ std::fs::read_to_string(d.join(f))+ .is_ok_and(|t| t.contains("SimpleCov.start") || f.starts_with(".simplecov"))+ })+ };+ let mut config = config.clone();+ let resultset = if [dir, root].iter().any(|d| starts(d)) {+ // The project's own configuration decides where the report goes (default `coverage/`).+ // Drop the previous run's data: SimpleCov merges into it.+ let results = dir.join("coverage");+ let _ = std::fs::remove_file(results.join(".resultset.json"));+ results.join(".resultset.json")+ } else {+ let preload = out.join("openidea_simplecov.rb");+ if let Err(e) = std::fs::write(&preload, SIMPLECOV_PRELOAD) {+ return unsupported(format!("Cannot write the SimpleCov preload: {e}"));+ }+ config.env.insert(s("OPENIDEA_COVERAGE_DIR"), path(out));+ // `out` lives under the IDE's data directory, which may have spaces (RUBYOPT cannot take them).+ ide_run::ruby_preload::add(&mut config.env, out, "openidea_simplecov", true);+ out.join(".resultset.json")+ };+ let report = CoverageReportSpec::SimpleCov { path: resultset.into(), base: dir.to_path_buf().into() };+ ready("SimpleCov", &config, config.command.clone(), config.args.clone(), report)+}+fn python(config: &RunConfig, dir: &Path, out: &Path, py: wrap::PythonCommand) -> CoveragePrepared {if py.target.is_empty() {return unsupported("Coverage needs a Python script or module to run.");@@ -398,6 +458,74 @@ mod tests {));}+ /// `bundle exec` loads the preload before Bundler sets up the project's gems: without SimpleCov+ /// on the load path it must step aside instead of failing the launcher.+ #[test]+ fn simplecov_preload_tolerates_a_ruby_without_the_gem() {+ let dir = tempfile::tempdir().unwrap();+ let out = dir.path().join("out dir");+ std::fs::create_dir_all(&out).unwrap();+ std::fs::write(out.join("openidea_simplecov.rb"), SIMPLECOV_PRELOAD).unwrap();+ let status = std::process::Command::new("ruby")+ .args(["-e", "exit 0"])+ .env("RUBYLIB", &out)+ .env("RUBYOPT", "-ropenidea_simplecov")+ .env("OPENIDEA_COVERAGE_DIR", &out)+ .env("GEM_HOME", dir.path().join("empty gems"))+ .env("GEM_PATH", dir.path().join("empty gems"))+ .status();+ // No Ruby on this machine: nothing to check.+ let Ok(status) = status else { return };+ assert!(status.success());+ }++ #[test]+ fn ruby_runs_get_simplecov() {+ let dir = tempfile::tempdir().unwrap();+ let root = dir.path();+ // The IDE's data directory has spaces on macOS (`Application Support`).+ let out = root.join("out dir");+ std::fs::create_dir_all(&out).unwrap();+ std::fs::write(root.join("Gemfile"), "source 'https://rubygems.org'\n").unwrap();+ let config = cfg("rspec", "bundle", &["exec", "rspec"]);+ // Bundler project without the gem: install hint.+ match prepare(root, &config, &out) {+ CoveragePrepared::MissingTool { tool, install: Some(i), .. } => {+ assert_eq!(tool, "simplecov");+ assert_eq!(i.args, ["add", "simplecov", "--group", "test"]);+ }+ other => panic!("{other:?}"),+ }+ // Gem present, never started: preloaded through RUBYOPT, report in `out`.+ std::fs::write(root.join("Gemfile"), "gem 'simplecov'\n").unwrap();+ let p = prepare(root, &config, &out);+ let (l, report) = launch(&p);+ assert_eq!(+ (l.command.as_str(), l.args.as_slice()),+ ("bundle", ["exec".to_owned(), "rspec".to_owned()].as_slice())+ );+ assert!(l.env["RUBYOPT"].contains("-ropenidea_simplecov"));+ assert!(std::env::split_paths(&l.env["RUBYLIB"]).any(|d| d == out));+ assert_eq!(l.env["OPENIDEA_COVERAGE_DIR"], out.to_string_lossy());+ assert!(out.join("openidea_simplecov.rb").is_file());+ assert!(+ matches!(report, CoverageReportSpec::SimpleCov { path, .. } if (path.as_ref() as &Path).starts_with(&out))+ );+ // Started by the project: untouched environment, stale data dropped, report in `coverage/`.+ std::fs::create_dir_all(root.join("test")).unwrap();+ std::fs::create_dir_all(root.join("coverage")).unwrap();+ std::fs::write(root.join("coverage/.resultset.json"), "{}").unwrap();+ std::fs::write(root.join("test/test_helper.rb"), "require 'simplecov'\nSimpleCov.start\n").unwrap();+ let p = prepare(root, &cfg("ruby", "ruby", &["-Ilib", "test/a_test.rb"]), &out);+ let (l, report) = launch(&p);+ assert!(!l.env.contains_key("RUBYOPT"));+ assert_eq!(l.args, ["-Ilib", "test/a_test.rb"]);+ assert!(!root.join("coverage/.resultset.json").exists());+ assert!(+ matches!(report, CoverageReportSpec::SimpleCov { path, .. } if (path.as_ref() as &Path).ends_with("coverage/.resultset.json"))+ );+ }+#[test]fn unknown_commands_are_unsupported() {let dir = tempfile::tempdir().unwrap();diff --git a/crates/ide-coverage/src/simplecov.rs b/crates/ide-coverage/src/simplecov.rsnew file mode 100644index 000000000..f93c41759--- /dev/null+++ b/crates/ide-coverage/src/simplecov.rs@@ -0,0 +1,74 @@+//! SimpleCov's `coverage/.resultset.json`:+//!+//! ```json+//! { "RSpec": { "timestamp": 1, "coverage": {+//! "/abs/lib/a.rb": { "lines": [null, 1, 0],+//! "branches": { "[:if, 0, 3, 4, 3, 20]": { "[:then, 1, 4, 6, 4, 9]": 1, "[:else, 2, 6, 6, 6, 9]": 0 } } },+//! "/abs/lib/legacy.rb": [null, 1] } } }+//! ```+//!+//! `lines[i]` is line `i + 1` (`null` = not relevant), so the index is already 0-based.+//! A branch belongs to the line its condition starts on (third number of its key).++use crate::Accumulator;+use ide_core::{IdeError, IdeResult};+use serde_json::Value;+use std::path::Path;++/// Start line (1-based) of a `"[:if, 0, 3, 4, 3, 20]"` branch key.+fn start_line(key: &str) -> Option<u32> {+ key.trim_matches(['[', ']']).split(',').nth(2)?.trim().parse().ok()+}++pub(crate) fn parse(text: &str, base: &Path) -> IdeResult<Accumulator> {+ let json: Value = serde_json::from_str(text).map_err(|e| IdeError::invalid(format!("SimpleCov resultset: {e}")))?;+ let mut acc = Accumulator::default();+ // One entry per test command ("RSpec", "Minitest", …); their coverage is merged.+ for suite in json.as_object().into_iter().flat_map(|o| o.values()) {+ let Some(files) = suite.get("coverage").and_then(Value::as_object) else { continue };+ for (name, data) in files {+ let p = Path::new(name);+ let path = if p.is_absolute() { p.to_path_buf() } else { base.join(p) };+ acc.file(&path);+ let lines = data.get("lines").or(Some(data)).and_then(Value::as_array);+ for (i, hits) in lines.into_iter().flatten().enumerate() {+ if let Some(hits) = hits.as_u64() {+ acc.line(&path, i as u32, hits);+ }+ }+ for (cond, branches) in data.get("branches").and_then(Value::as_object).into_iter().flatten() {+ let Some(line) = start_line(cond) else { continue };+ for (branch, hits) in branches.as_object().into_iter().flatten() {+ acc.has_branches = true;+ acc.branch(&path, line.saturating_sub(1), format!("{cond}/{branch}"), hits.as_u64() > Some(0));+ }+ }+ }+ }+ Ok(acc)+}++#[cfg(test)]+mod tests {+ use super::*;++ #[test]+ fn reads_lines_branches_and_merges_suites() {+ let text = r#"{+ "RSpec": {"coverage": {"/p/lib/a.rb": {"lines": [null, 1, 0],+ "branches": {"[:if, 0, 2, 4, 2, 20]": {"[:then, 1, 2, 6, 2, 9]": 1, "[:else, 2, 2, 6, 2, 9]": 0}}}}},+ "Minitest": {"coverage": {"/p/lib/a.rb": {"lines": [null, 2, 3]}, "lib/old.rb": [1, null]}}+ }"#;+ let suite = parse(text, Path::new("/p")).unwrap().finish("SimpleCov");+ assert_eq!(suite.files.len(), 2);+ let a = suite.files.iter().find(|f| (f.path.as_ref() as &Path).ends_with("a.rb")).unwrap();+ assert_eq!(a.lines.iter().map(|l| (l.line, l.hits)).collect::<Vec<_>>(), [(1, 3), (2, 3)]);+ assert_eq!((a.branches_total, a.branches_covered), (2, 1));+ assert_eq!(a.lines[0].branches_total, 2);+ let old = suite.files.iter().find(|f| (f.path.as_ref() as &Path).ends_with("lib/old.rb")).unwrap();+ assert_eq!(old.path.as_ref() as &Path, Path::new("/p/lib/old.rb"));+ assert_eq!(old.lines[0].hits, 1);+ assert!(suite.has_branches);+ assert!(parse("nope", Path::new("/p")).is_err());+ }+}diff --git a/crates/ide-host/src/ops/coverage.rs b/crates/ide-host/src/ops/coverage.rsindex 007d701db..f57b538f4 100644--- a/crates/ide-host/src/ops/coverage.rs+++ b/crates/ide-host/src/ops/coverage.rs@@ -32,7 +32,7 @@ pub async fn coverage_collect(host: &Host, window: &str, report: CoverageReportSblocking(move || ide_coverage::collect(&report)).await}-/// Reads a report collected elsewhere (CI): lcov, a Go cover profile or JaCoCo XML,+/// Reads a report collected elsewhere (CI): lcov, a Go cover profile, JaCoCo XML or a SimpleCov resultset,/// with paths mapped into this project.pub async fn coverage_import(host: &Host, window: &str, path: IpcPath) -> IdeResult<CoverageSuite> {let root = host.project(window)?.root.clone();diff --git a/crates/ide-run/src/lib.rs b/crates/ide-run/src/lib.rsindex 7e85a1643..97e313423 100644--- a/crates/ide-run/src/lib.rs+++ b/crates/ide-run/src/lib.rs@@ -12,6 +12,7 @@ pub mod java_cmdline;pub mod junit;mod process;pub mod python_path;+pub mod ruby_preload;pub mod tomcat;mod utf8;pub mod which;diff --git a/crates/ide-run/src/ruby_preload.rs b/crates/ide-run/src/ruby_preload.rsnew file mode 100644index 000000000..f42937633--- /dev/null+++ b/crates/ide-run/src/ruby_preload.rs@@ -0,0 +1,61 @@+//! Loads a Ruby file into a launched process without touching the project: the directory goes on+//! `RUBYLIB` and `RUBYOPT` gets the bare feature name (`-ropenidea_hook`).+//!+//! `RUBYOPT` is split at spaces with no quoting, so an absolute path in it (`-r/…/Application+//! Support/…/hook.rb`, where the IDE keeps its data) makes Ruby fail with `invalid switch in RUBYOPT`.+//! `RUBYLIB` is a path list and takes spaces.+use std::collections::BTreeMap;+use std::path::{Path, PathBuf};++/// Makes `feature` (a file `<dir>/<feature>.rb`) load first in every Ruby the process starts.+/// `inherit`: the process also sees the IDE's own environment, whose `RUBYLIB` / `RUBYOPT` stay.+pub fn add(env: &mut BTreeMap<String, String>, dir: &Path, feature: &str, inherit: bool) {+ let mut inherited = if inherit { crate::system_env() } else { BTreeMap::new() };+ let mut existing = |name: &str| env.get(name).cloned().or_else(|| inherited.remove(name)).filter(|v| !v.is_empty());++ let mut dirs: Vec<PathBuf> = vec![dir.to_path_buf()];+ if let Some(lib) = existing("RUBYLIB") {+ for d in std::env::split_paths(&lib) {+ if !dirs.contains(&d) {+ dirs.push(d);+ }+ }+ }+ let rubyopt = existing("RUBYOPT");+ if let Ok(joined) = std::env::join_paths(dirs) {+ env.insert("RUBYLIB".into(), joined.to_string_lossy().into_owned());+ }+ let option = format!("-r{feature}");+ let value = match rubyopt {+ Some(e) if e.split_whitespace().any(|o| o == option) => e,+ Some(e) => format!("{e} {option}"),+ None => option,+ };+ env.insert("RUBYOPT".into(), value);+}++#[cfg(test)]+mod tests {+ use super::*;++ #[test]+ fn a_directory_with_spaces_goes_on_rubylib_not_into_rubyopt() {+ let dir = Path::new("/Users/me/Library/Application Support/ide/ruby");+ let mut env = BTreeMap::new();+ add(&mut env, dir, "openidea_hook", false);+ assert_eq!(env["RUBYLIB"], dir.to_string_lossy());+ assert_eq!(env["RUBYOPT"], "-ropenidea_hook");+ assert!(!env["RUBYOPT"].contains(' '));+ }++ #[test]+ fn keeps_existing_settings_and_adds_once() {+ // Path lists use the platform's separator (`;` on Windows).+ let list = |dirs: &[&str]| std::env::join_paths(dirs).unwrap().to_string_lossy().into_owned();+ let mut env = BTreeMap::from([("RUBYLIB".into(), list(&["/a", "/b"])), ("RUBYOPT".into(), "-w".into())]);+ add(&mut env, Path::new("/hook"), "h", false);+ add(&mut env, Path::new("/hook"), "h", false);+ assert_eq!(env["RUBYLIB"], list(&["/hook", "/a", "/b"]));+ assert_eq!(env["RUBYOPT"], "-w -rh");+ }+}diff --git a/src/bindings.ts b/src/bindings.tsindex 39dfd5848..ffe154510 100644--- a/src/bindings.ts+++ b/src/bindings.ts@@ -2426,6 +2426,8 @@ export type CoverageReportSpec ={ kind: "lcov"; runner: string; path: IpcPath; base: IpcPath } |/** `go test -coverprofile`; import paths under `module` map to `module_dir`. */{ kind: "goProfile"; path: IpcPath; module: string; moduleDir: IpcPath } |+/** SimpleCov's `.resultset.json`; relative paths resolve against `base`. */+{ kind: "simpleCov"; path: IpcPath; base: IpcPath } |/** Every JaCoCo XML report (Maven `target/site/jacoco`, Gradle `build/reports/jacoco`) under `dir`. */{ kind: "jacoco"; dir: IpcPath } |/** The tool's raw data is exported to lcov by `argv` first (coverage.py: `… -m coverage lcov -o <lcov>`). */diff --git a/src/features/coverage/coverage.test.ts b/src/features/coverage/coverage.test.tsindex 22257cc20..dff972c7b 100644--- a/src/features/coverage/coverage.test.ts+++ b/src/features/coverage/coverage.test.ts@@ -57,6 +57,9 @@ describe("coverageSupports", () => {expect(coverageSupports(cfg("pnpm", ["run", "dev"]))).toBe(false);expect(coverageSupports(cfg("/v/bin/python3", ["-m", "pytest"]))).toBe(true);expect(coverageSupports(cfg("uv", ["run", "pytest"]))).toBe(true);+ expect(coverageSupports(cfg("/v/bin/ruby", ["-Ilib", "test/a_test.rb"]))).toBe(true);+ expect(coverageSupports(cfg("bundle", ["exec", "rspec"], { isTest: true }))).toBe(true);+ expect(coverageSupports(cfg("bundle", ["exec", "rake", "db:migrate"]))).toBe(false);expect(coverageSupports(cfg("make", ["test"]))).toBe(false);});});diff --git a/src/features/coverage/model.ts b/src/features/coverage/model.tsindex e36d8ceac..472537edd 100644--- a/src/features/coverage/model.ts+++ b/src/features/coverage/model.ts@@ -16,7 +16,7 @@ const runsJvmTests = (args: readonly string[]) =>/*** Whether a coverage runner is known for `config` (cheap; the backend decides for real):* cargo test / run / nextest, go test, Maven / Gradle tests, package.json test scripts,- * Node.js programs and Python.+ * Node.js programs, Python and Ruby (scripts, rspec, test rake tasks).*/export function coverageSupports(config: Pick<RunConfig, "command" | "args" | "kind" | "isTest">): boolean {const program = programName(config.command);@@ -43,6 +43,13 @@ export function coverageSupports(config: Pick<RunConfig, "command" | "args" | "kcase "tsx":case "ts-node":return true;+ case "ruby":+ case "rspec":+ return true;+ case "bundle":+ case "rake":+ case "rails":+ return config.isTest;}return (config.kind === "python" ||diff --git a/src/features/coverage/reports.tsx b/src/features/coverage/reports.tsxindex e0dee7503..c672ace10 100644--- a/src/features/coverage/reports.tsx+++ b/src/features/coverage/reports.tsx@@ -1,6 +1,6 @@/*** Coverage reports collected elsewhere: "Import a report collected in CI from- * disk" (lcov, JaCoCo XML, Go cover profile) and "Manage Coverage Reports"+ * disk" (lcov, JaCoCo XML, Go cover profile, SimpleCov) and "Manage Coverage Reports"* (choose the shown suite, delete suites and remembered imports).*/import { useMemo, useState } from "react";@@ -35,7 +35,7 @@ async function pickReport(): Promise<string | null> {filters: [{name: "Coverage reports (lcov, JaCoCo XML, Go cover profile)",- extensions: ["info", "lcov", "xml", "out", "txt", "cov", "coverprofile"],+ extensions: ["info", "lcov", "xml", "out", "txt", "cov", "coverprofile", "json"],},{ name: "All files", extensions: ["*"] },],