{"id":48881111,"url":"https://github.com/cargo-runner/cargo-runner","last_synced_at":"2026-04-16T03:02:01.425Z","repository":{"id":232256434,"uuid":"783776325","full_name":"cargo-runner/cargo-runner","owner":"cargo-runner","description":"A sophisticated scope-based runnable detection tool for Rust that supports multiple build systems (Cargo, Bazel, Rustc) and provides intelligent command generation for tests, benchmarks, binaries, and doc tests.","archived":false,"fork":false,"pushed_at":"2025-08-15T08:52:49.000Z","size":1645,"stargazers_count":0,"open_issues_count":0,"forks_count":0,"subscribers_count":1,"default_branch":"main","last_synced_at":"2025-08-15T10:13:31.990Z","etag":null,"topics":["clap-rs","cli","js","rust","typescript","vscode","vscode-extension","wasm","wit-bindgen"],"latest_commit_sha":null,"homepage":"","language":"Rust","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"mit","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/cargo-runner.png","metadata":{"files":{"readme":"README.md","changelog":"CHANGELOG.md","contributing":null,"funding":null,"license":"LICENSE","code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null,"zenodo":null}},"created_at":"2024-04-08T14:48:37.000Z","updated_at":"2025-08-15T08:52:52.000Z","dependencies_parsed_at":null,"dependency_job_id":"4735a8bb-7b84-498d-a751-f2b1d05ebd5a","html_url":"https://github.com/cargo-runner/cargo-runner","commit_stats":null,"previous_names":["codeitlikemiley/rx","cargo-runner/core","cargo-runner/cargo-runner"],"tags_count":0,"template":false,"template_full_name":null,"purl":"pkg:github/cargo-runner/cargo-runner","repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/cargo-runner%2Fcargo-runner","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/cargo-runner%2Fcargo-runner/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/cargo-runner%2Fcargo-runner/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/cargo-runner%2Fcargo-runner/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/cargo-runner","download_url":"https://codeload.github.com/cargo-runner/cargo-runner/tar.gz/refs/heads/main","sbom_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/cargo-runner%2Fcargo-runner/sbom","scorecard":null,"host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":286080680,"owners_count":31861800,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2026-04-15T15:24:51.572Z","status":"ssl_error","status_checked_at":"2026-04-15T15:24:39.138Z","response_time":63,"last_error":"SSL_read: unexpected eof while reading","robots_txt_status":"success","robots_txt_updated_at":"2025-07-24T06:49:26.215Z","robots_txt_url":"https://github.com/robots.txt","online":false,"can_crawl_api":true,"host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["clap-rs","cli","js","rust","typescript","vscode","vscode-extension","wasm","wit-bindgen"],"created_at":"2026-04-16T03:02:00.659Z","updated_at":"2026-04-16T03:02:01.418Z","avatar_url":"https://github.com/cargo-runner.png","language":"Rust","funding_links":[],"categories":[],"sub_categories":[],"readme":"# Cargo Runner\n\nThe core build engine for the `cargo-runner` project. Handles command generation, build-system detection, framework dispatch, and per-function override resolution for Cargo, Bazel, Rustc, single-file-script targets, and custom frameworks like Dioxus, Leptos, and Tauri.\n\n---\n\n## Installation\n\nThe recommended way to install is via `cargo-binstall` to download pre-compiled binaries directly from GitHub Releases:\n\n```bash\ncargo binstall cargo-runner-cli\n```\n\nAlternatively, you can build from source:\n\n```bash\ncargo install cargo-runner-cli\n```\n\n---\n\n## Build System \u0026 Framework Detection\n\n`UnifiedRunner` uses a Plugin Registry to allow overrides (framework overlays) before falling back to generic build-system detection:\n\n```\n┌─ Framework Overlays (highest priority) ───────────────────────┐\n│  Dioxus.toml in ancestor dirs    →  DioxusOverlayPlugin       │\n│  \"leptos\" in Cargo.toml          →  LeptosOverlayPlugin       │\n└───────────────────────────────────────────────────────────────┘\n         │ (no plugin claimed the path)\n         ▼\n┌─ Build system detection ──────────────────────────────────────┐\n│  MODULE.bazel present            →  BazelRunner               │\n│  Cargo.toml present              →  CargoRunner               │\n│  (none)                          →  RustcPrimaryPlugin        │\n└───────────────────────────────────────────────────────────────┘\n```\n\n### Framework vs Bazel — design boundary\n\nFramework-managed projects (Dioxus, Leptos, Tauri) **always use their native CLI**, never Bazel. These frameworks orchestrate WASM compilation, asset bundling, hot-reload dev servers, and platform-specific builds internally — capabilities that Bazel cannot replicate.\n\nBazel support targets **pure Rust projects**: API servers, CLI tools, libraries, and monorepos with shared dependency graphs.\n\n| Framework | CLI | Bazel support? |\n|-----------|-----|----------------|\n| Dioxus | `dx serve / dx build` | ❌ Not supported — use `dx` |\n| Leptos | `cargo leptos watch / build` | ❌ Not supported — use `cargo-leptos` |\n| Tauri | `cargo tauri dev / build` | ❌ Not supported — use Tauri CLI |\n| Pure Rust (lib, bin, tests) | `cargo` or `bazel` | ✅ Fully supported |\n\n---\n\n## Implicit Execution \u0026 Target Inference\n\nWhen running `cargo runner run` without explicit file arguments, the runner intelligently infers what to execute based on Cargo's `default-run` settings and standard Rust project conventions.\n\nIt uses these exact filesystem layout patterns to automatically detect binaries, tests, benchmarks, and libraries—both for resolving implicitly executed targets and for generating underlying Bazel rules:\n\n| Rust Source Path | Inferred Target Kind | Notes / Bazel Mapping |\n|------------------|----------------------|-----------------------|\n| `src/main.rs` | Project Binary | The default entry point, maps to `rust_binary` |\n| `src/lib.rs` | Library \u0026 Doc Tests | Maps to `rust_library` and `rust_doc_test` |\n| `src/bin/*.rs` | Additional Binary | Scaffolded/detected only if `fn main()` is present |\n| `src/bin/*/main.rs` | Directory Binary | Scaffolded/detected only if `fn main()` is present |\n| `tests/*.rs` | Integration Test | Automatically maps to `rust_test_suite` |\n| `examples/*.rs` | Example Binary | Scaffolded/detected only if `fn main()` is present |\n| `benches/*.rs` | Benchmark | Scaffolded/detected only if `fn main()` is present |\n| `build.rs` | Build Script | Maps to `cargo_build_script` internally |\n\n**Priority:** Explicit `Cargo.toml` definitions (`[[bin]]`, `[[test]]`, `[[bench]]`, `[[example]]`) always take priority over the filesystem conventions above.\n\n**`fn main()` heuristic**: Files in `src/bin/` and `examples/` are only detected as runnable binaries if they actually contain a `fn main()` function — helper modules are silently skipped.\n\n---\n\n## Scoped Execution\n\n`cargo runner run \u003cpath\u003e` detects the surrounding project context and automatically builds the correct compilation and execution command. To preview any command without executing it, simply append `--dry-run`.\n\nIt evaluates the environment in this specific priority:\n\n### 1. Standalone Rust Files (`rustc`)\n\nIf a Rust file sits outside of any framework or build system (no `Cargo.toml`, no Bazel), Cargo Runner transparently falls back to `rustc`.\n\n```bash\ncargo runner run standalone.rs\n# Generates: rustc standalone.rs -o /tmp/... \u0026\u0026 /tmp/...\n```\n\n### 2. Single-file Scripts\n\nCargo Runner recognizes single-file Rust scripts explicitly via their shebangs and a `fn main()` entry point.\n\n**Cargo Nightly Script Example (`-Zscript`):**\n```rust\n#!/usr/bin/env -S cargo +nightly -Zscript\n---cargo\n[package]\nedition = \"2021\"\n---\nfn main() { println!(\"nightly cargo script!\"); }\n```\n```bash\ncargo runner run my_script.rs\n# Generates: cargo +nightly -Zscript my_script.rs\n```\n\n**Rust-Script Example:**\n```rust\n#!/usr/bin/env rust-script\n//! ```cargo\n//! [dependencies]\n//! anyhow = \"1\"\n//! ```\nfn main() { println!(\"rust-script execution!\"); }\n```\n```bash\ncargo runner run my_rust_script.rs\n# Generates: rust-script my_rust_script.rs\n```\n\n### 3. Cargo Projects \u0026 Workspaces\n\nInside a standard Cargo project or massively scaled virtual Workspace, execution paths are mapped intelligently:\n\n```bash\ncargo runner run src/main.rs\n# Generates: cargo run --bin my_app\n\ncargo runner run tests/integration.rs\n# Generates: cargo test --test integration\n```\n\n| What you cursor into | Cargo generates |\n|---------------------|-----------------|\n| `#[test] fn test_add()` | `cargo test test_add --exact` |\n| `mod tests { }` block | `cargo test tests::` |\n| `/// ``` doctest` | `cargo test --doc add` |\n| `fn main()` binary | `cargo run --bin name` |\n| Benchmark function | `cargo bench name` |\n\n### 4. Bazel Projects\n\nIn a Bazel workspace, the runner maps standard Rust layout conventions to their exact Bazel targets so you don't have to think about `//:labels`:\n\n```bash\ncargo runner run src/main.rs\n# Generates: bazel run //:my_app\n\ncargo runner run src/lib.rs:25 \n# Generates: bazel test //:unit_tests --test_arg=\"tests::add\"\n```\n\n| What you cursor into | Bazel generates |\n|---------------------|-----------------|\n| `#[test] fn test_add()` | `bazel test //:unit_tests --test_arg=\"test_add\"` |\n| `mod tests { }` block | `bazel test //:unit_tests --test_arg=\"tests::\"` |\n| `/// ``` doctest` | `bazel test //:doc_tests` |\n| `fn main()` binary | `bazel run //:name` |\n| Benchmark function | `bazel run //:bench_name -c opt` |\n\n### 5. Dioxus and Leptos (Custom Frameworks)\n\nWhen working inside a frontend framework, `cargo-runner` hands off execution to the native CLI orchestrator required to run the WebAssembly bundling and hot-reloading dev servers.\n\n```bash\ncargo runner run src/main.rs\n```\n\n- **Dioxus:** Automatically invokes `dx serve` or `dx build`.\n- **Leptos:** Automatically invokes `cargo leptos watch` or `cargo leptos build`.\n- **Tauri:** Automatically invokes the `cargo tauri` developer environment.\n\n---\n\n## Tooling \u0026 Debugging Commands\n\nBeyond executing files, Cargo Runner provides powerful introspection commands. You can pass raw module paths (like `runners::unified_runner::tests`) or standard file paths to these utilities.\n\n### Previewing Commands (`--dry-run`)\nIf you aren't sure what command Cargo Runner will synthesize for a specific file or framework, use `--dry-run`. It will print the exact internal `Command` structure without spawning it:\n```bash\ncargo runner run src/main.rs --dry-run\n```\n\n### Exploring Targets (`runnables`)\nUse `runnables` to list all valid execution targets. You can filter by `--bin`, `--test`, `--bench`, or substring matches:\n```bash\n# List all targets in a specific file\ncargo runner runnables src/lib.rs\n\n# Search the entire workspace for binaries\ncargo runner runnables --bin\n\n# Find a specific module block or test\ncargo runner runnables runners::unified_runner::tests --exact\n```\n\n### Inspecting Context (`context`)\nIf you need deep JSON introspection for IDE integration (or debugging why a file resolved a certain way), the `context` command reveals exactly how Cargo Runner interpreted the environment:\n```bash\ncargo runner context src/main.rs --json\n```\nWhen the input is not an existing file, `cargo runner` scans the current workspace members, matches the runnable `module_path`, and resolves the owning file automatically.\n\n---\n\n## Bazel — One-Command Workflow\n\n\u003e **Goal**: Use a Bazel-managed Rust workspace as if it were plain Cargo — no manual Bazel bookkeeping.\n\n### `cargo runner init --bazel`\n\nThis is the **single entry point** for all Bazel scaffolding. It handles both initial setup and subsequent syncs.\n\n#### First run — scaffolds the workspace\n\n```bash\ncargo runner init --bazel\n```\n\nGenerates:\n- `MODULE.bazel` — bzlmod dependency graph via `crate.from_cargo()`\n- `.bazelversion` — pins Bazel 7.4.1\n- `.bazelrc` — build flags + shared disk/repo caches\n- `BUILD.bazel` — targets for each crate (see below)\n- `Cargo.lock` — required by `crate_universe`\n- `.cargo-runner.json` — framework defaults\n\nThen runs:\n1. `bazel sync` — downloads toolchain + resolves crate deps\n2. `bazel build --nobuild //...` — validates all BUILD files without compiling\n\n#### Re-run — idempotent sync\n\n```bash\ncargo runner init --bazel   # safe to re-run anytime\n```\n\nRe-scans source files, adds missing targets, skips existing ones. The single command replaces the old `build-sync` workflow.\n\n#### Workspace support\n\nFor Cargo workspaces, `init --bazel` automatically:\n- Parses `[workspace] members` (supports explicit lists and globs)\n- Generates per-member `BUILD.bazel` files\n- Creates a unified `MODULE.bazel` at the root\n\n### Doctests\n\nLibrary crates (`src/lib.rs`) automatically get a `rust_doc_test` target:\n\n```python\nrust_doc_test(\n    name = \"doc_tests\",\n    crate = \":my_lib\",\n)\n```\n\nDoctests use Bazel natively. There is **no cargo fallback** — if it's a Bazel project, everything goes through Bazel.\n\n### BUILD.bazel safety model\n\n`build-sync` only modifies lines inside a **managed block** — anything outside the fences is left untouched:\n\n```python\n# Hand-authored rules above are NEVER touched\n\n# BEGIN cargo-runner-managed — do not edit this block manually\nrust_library(...)\nrust_test(...)\nrust_doc_test(...)\n# END cargo-runner-managed\n```\n\nDeduplication is name-aware and content-aware:\n- Exact name matches are skipped\n- Any existing `rust_doc_test(` rule (regardless of name) prevents duplicate doc test targets\n\n### Other commands\n\n| Command | What it does |\n|---------|-------------|\n| `cargo runner add \u003ccrate\u003e [--features f] [--dev]` | `cargo add` + `cargo update` + `bazel sync` + `gen_rust_project` in one shot |\n| `cargo runner sync [--crate \u003cname\u003e] [--skip-ide]` | Sync Bazel crate-universe after any `Cargo.toml` edit |\n| `cargo runner build-sync [--crate \u003cname\u003e] [--dry-run]` | Update `BUILD.bazel` targets (also runs as part of `init --bazel`) |\n| `cargo runner clean` | Context-aware clean: `bazel clean` (Bazel) or `cargo clean` (Cargo) |\n| `cargo runner watch` | Context-aware file watcher: `ibazel` (Bazel) or `cargo watch` (Cargo) |\n| `cargo runner run \u003cfile\\|module::path\u003e[:\u003cline\u003e]` | Scope-based execution: detects build system and runs the target at the given line or module path |\n| `cargo runner runnables [file\\|module::path[:line]] [--bin] [--test] [--bench] [--doc] [--name QUERY] [--symbol SYMBOL] [--exact]` | List runnable items for a file, module path, or entire workspace |\n| `cargo runner context [file\\|module::path[:line]] --json` | Emit machine-readable project/file context for TMP and other tooling |\n\n---\n\n## Configuration Reference\n\nConfiguration lives in `.cargo-runner.json` at your crate root.\n\n### Top-level shape\n\n```json\n{\n  \"bazel\": { ... },\n  \"cargo\": { ... },\n  \"overrides\": [ ... ]\n}\n```\n\n### Bazel project config (`\"bazel\"`)\n\nUsed at the project level to configure how Bazel commands are built.\n\n```json\n{\n  \"bazel\": {\n    \"workspace\": \"my_workspace\",\n    \"test_framework\": {\n      \"command\": \"bazel\",\n      \"subcommand\": \"test\",\n      \"target\": \"{target}\",\n      \"args\": [\"--test_output\", \"streamed\"],\n      \"test_args\": [\"--nocapture\", \"{test_filter}\"]\n    },\n    \"binary_framework\": {\n      \"command\": \"bazel\",\n      \"subcommand\": \"run\",\n      \"target\": \"{target}\"\n    },\n    \"benchmark_framework\": {\n      \"command\": \"bazel\",\n      \"subcommand\": \"test\",\n      \"target\": \"{target}\",\n      \"args\": [\"--test_output\", \"streamed\", \"--test_arg\", \"--bench\"],\n      \"test_args\": [\"{bench_filter}\"]\n    }\n  }\n}\n```\n\nSupported template placeholders: `{target}`, `{test_filter}`, `{bench_filter}`, `{file_name}`.\n\n### Per-function overrides (`\"overrides\"`)\n\nThe `overrides` array lets you customize commands for specific functions, tests, or files. Each entry has a `\"match\"` key and a command-type block.\n\n#### Cargo override\n\n```json\n{\n  \"match\": {\n    \"function_name\": \"my_slow_test\",\n    \"package\": \"server\"\n  },\n  \"cargo\": {\n    \"extra_args\": [\"--test-threads=1\"],\n    \"extra_env\": { \"RUST_BACKTRACE\": \"1\", \"RUSTFLAGS\": \"-Awarnings\" }\n  }\n}\n```\n\n**Note on Cargo Environments**: Overrides correctly inject environment variables into `cargo` commands contextually. Due to accurate `FileType` contextual propagation, `RUSTFLAGS` or other systemic flags apply perfectly onto `cargo run`/`cargo test` invocations without mistakenly triggering standalone `rustc` fallbacks.\n\n#### Bazel override\n\nThe `\"bazel\"` block inside an override is a **flat `BazelOverride`** — fields are promoted from the framework level directly to the override. You no longer need to nest `test_framework.test_args`.\n\n```json\n{\n  \"match\": {\n    \"function_name\": \"it_works_too\",\n    \"module_path\": \"tests\",\n    \"package\": \"frontend\"\n  },\n  \"bazel\": {\n    \"test_args\": [\"--nocapture\"]\n  }\n}\n```\n\nAll `BazelOverride` fields:\n\n| Field | Type | Description |\n|-------|------|-------------|\n| `command` | `string` | Override the Bazel binary (e.g. `\"bazelisk\"`). Display/tooling only — not yet applied at runtime. |\n| `subcommand` | `string` | Override the subcommand (`\"test\"`, `\"run\"`, `\"build\"`). |\n| `target` | `string` | Override the target label. |\n| `args` | `string[]` | Replace the base args block (after subcommand + target). |\n| `extra_args` | `string[]` | Append verbatim args after the base args. |\n| `test_args` | `string[]` | Inject as `--test_arg \u003cvalue\u003e` pairs. |\n| `exec_args` | `string[]` | Append after `--` separator (for `bazel run`). |\n| `extra_env` | `object` | Merge extra environment variables. |\n\n\u003e **Migration note**: The previous nested form `\"bazel\": { \"test_framework\": { \"test_args\": [...] } }` inside overrides **is no longer valid**. Update to the flat shape above.\n\n### Override CLI\n\nUse `cargo runner override` to create overrides from the command line instead of editing JSON manually.\n\n#### Named flags\n\n```bash\ncargo runner override \u003cfilepath\u003e --command \u003ccmd\u003e --subcommand \u003csub\u003e --channel \u003cch\u003e\n```\n\n| Flag | What it sets |\n|------|-------------|\n| `--command` | The command binary (`dx`, `cargo`, `bazel`) |\n| `--subcommand` | The subcommand (`serve`, `run`, `build`, `watch`) |\n| `--channel` | Rust toolchain channel (`nightly`, `stable`) |\n\n#### Token syntax (after `--`)\n\n```bash\ncargo runner override \u003cfilepath\u003e -- \u003ctokens...\u003e\n```\n\n| Token | Effect |\n|-------|--------|\n| `@cmd.sub` | Set command + subcommand (e.g., `@dx.run`) |\n| `+channel` | Set Rust toolchain channel (e.g., `+nightly`) |\n| `KEY=value` | Set environment variable (e.g., `RUST_LOG=debug`, `RUSTFLAGS=\"-Awarnings\"`) |\n| `/args...` | Test binary args (like `--` in `cargo test`) |\n| `-command` | Remove the command override |\n| `-env` | Remove all env overrides |\n| `-` | Remove the entire override |\n| other | Appended as `extra_args` |\n\n\u003e **Environment Variables**: Overrides like `KEY=value` reliably populate the `extra_env` record. For Bazel targets, these are accurately transformed strictly into `--action_env=KEY=value` (and `--test_env=KEY=value` for valid subcommands). For Cargo, these correctly attach to the `Command` execution environment across nested workspace crates.\n\n#### Dioxus examples\n\n```bash\n# Default: dx serve — override to dx run\ncargo runner override src/main.rs --command dx --subcommand run\n\n# Same using token syntax\ncargo runner override src/main.rs -- @dx.run\n\n# Add --release flag\ncargo runner override src/main.rs -- @dx.serve --release\n\n# Add env vars\ncargo runner override src/main.rs -- @dx.serve RUST_LOG=debug\n```\n\n#### Leptos examples\n\n```bash\n# Default: cargo leptos serve — override to cargo leptos watch\ncargo runner override src/main.rs --subcommand watch\n\n# Same using token syntax (all three forms are equivalent)\ncargo runner override src/main.rs -- @cargo.watch\ncargo runner override src/main.rs -- @cargo.leptos.watch\n\n# Add --release\ncargo runner override src/main.rs --subcommand build -- --release\n```\n\n\u003e **Note**: For Leptos, you only set `--subcommand` (not `--command`) because the command is always `cargo` — the runner constructs `cargo leptos \u003csubcommand\u003e` automatically.\n\n#### Test binary args (ignored tests, etc.)\n\nThe `/` token passes arguments directly to the test binary (after `--` in `cargo test`):\n\n```bash\n# Run all tests including ignored ones\ncargo runner override src/lib.rs -- /--include-ignored\n\n# Run only ignored tests\ncargo runner override src/lib.rs -- /--ignored\n\n# Add multiple test binary args\ncargo runner override src/lib.rs -- /--include-ignored --nocapture\n```\n\nKey distinction:\n- `-- extra_args` → cargo-level flags (before `--`)\n- `/ test_args` → test binary flags (after `--`)\n\n#### Workspace-wide test binary args\n\nTo apply test binary args to **all tests in the workspace**, set `extra_test_binary_args` at the top-level `cargo` config in `.cargo-runner.json`:\n\n```json\n{\n  \"cargo\": {\n    \"extra_test_binary_args\": [\"--include-ignored\"]\n  }\n}\n```\n\nThis applies globally without needing per-file overrides.\n\n#### Remove an override\n\n```bash\ncargo runner override src/main.rs -- -\n```\n\n---\n\n## Waz Integration\n\nIf you use `waz`, the same lookup model is available there too:\n\n```bash\nwaz run src/main.rs:25\nwaz run runners::unified_runner::tests\nwaz runnables\nwaz runnables runners::unified_runner::tests\n```\n\n`waz run` is the non-interactive path; it reuses the same project and\nmodule-path resolution so you can skip the TUI when you already know what you\nwant to run.\n\n`waz runnables` is the companion listing command when you want to inspect the\navailable run targets first, either for the whole workspace or for a specific\nmodule path.\n\n`--bin`, `--test`, `--bench`, and `--doc` narrow the result set by runnable\nkind. `--name` does a case-insensitive, punctuation-insensitive substring\nmatch against the label, module path, and function name. Add `--exact` to\nrequire the normalized name to match exactly instead of by substring, so\n`foo bar`, `foo_bar`, and `FooBar` still collapse to the same search key but\n`foo` will no longer match `foobar` when `--exact` is present.\n\n`--symbol` filters symbol-like targets, such as doc-tested structs, enums,\nunions, module test groups, and binary names. It can be combined with `--name`\nand the kind filters.\n\n`cargo runner run` accepts the same selector styles:\n\n- bare function or method name: `cargo runner run test_helper`\n- full module path plus function: `cargo runner run runners::unified_runner::tests::test_helper`\n- doc-test symbol: `cargo runner run Users`\n\n---\n\n## License\n\nMIT or Apache-2.0, at your option.\n","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fcargo-runner%2Fcargo-runner","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fcargo-runner%2Fcargo-runner","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fcargo-runner%2Fcargo-runner/lists"}