From cbff9197c34fd74294f553caab27fffaf20744c8 Mon Sep 17 00:00:00 2001 From: Kinflou Date: Sun, 4 Oct 2026 09:32:52 +0800 Subject: [PATCH] fix: warn that layout is ignored in lib mode, add flatten to skip out// MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit A lib-mode target silently dropped its `layout` entirely — only `out` mattered, with `/` unconditionally appended — so setting `layout` to anything gave no error and no effect, just a confusingly nested directory. Now warns when that happens, and adds a `flatten` per-target bool so a target with `out` already to itself can skip the `//` nesting and land the crate straight into `out`. --- docs/cli.md | 23 ++++++++++++++++-- src/commands/generate.rs | 30 ++++++++++++++++++++++-- src/gen_config.rs | 28 ++++++++++++++++++++++ tests/cli/generate.rs | 50 ++++++++++++++++++++++++++++++++++++++++ 4 files changed, 127 insertions(+), 4 deletions(-) diff --git a/docs/cli.md b/docs/cli.md index af2b6e6..4944063 100644 --- a/docs/cli.md +++ b/docs/cli.md @@ -209,6 +209,24 @@ out = "src/generated" variables: `{{language}}`, `{{namespace}}` (`/`-joined), `{{ext}}`, `{{lang_version}}`, `{{spec_version}}`, `{{package_version}}`. +**`layout` only applies to `code` mode.** A `lib`-mode target ignores it +entirely (`comline generate` warns if you set one) and always writes the +crate's fixed internal shape (`Cargo.toml`, `src/lib.rs`, …) at +`//` — unless the target sets `flatten = true`, which writes it +straight into `out` instead: + +```toml +[[generate.target]] +language = "rust" +mode = "lib" +out = "../my-rust-crate/" +flatten = true # crate lands at out/ directly, not out/rust/ +``` + +`flatten` only means something for `lib`/`dylib` targets with their own `out` +— flattening a shared `out` across several `lib` targets would land two +crates in the same directory. + **Which versions.** `package_versions = "latest"` (the default) generates the working tree — no `.comline/` read. `"all"` generates every committed version in the CAS chain; `["0.3.0", "0.4.0"]` (versions or commit hashes) generates just @@ -227,8 +245,9 @@ paths — the `layout` must contain `{{package_version}}`. For `latest`, applied to **every** target (handy in CI). A flag still wins for its target. - `--watch` — regenerate on change; see [Watch mode](#watch-mode). -Currently `rust` is the only generator and `code` the only mode; other languages -or modes fail with a clear message. +Currently `rust` and `typescript` are the generators; `code` mode is +implemented for both and `lib` mode for `rust`. `dylib`, and `lib` for other +languages, fail with a clear message. ```bash comline generate diff --git a/src/commands/generate.rs b/src/commands/generate.rs index 91b5b5c..a921604 100644 --- a/src/commands/generate.rs +++ b/src/commands/generate.rs @@ -122,6 +122,26 @@ fn generate_once(work_dir: &Path, overrides: &Overrides) -> Result<()> { } }; + if mode == Mode::Lib && t.layout != gen_config::DEFAULT_LAYOUT { + let lands_at = if t.flatten { + "/".to_string() + } else { + format!("/{}/", t.language) + }; + ui::warn(format!( + "target `{}`: `layout` (`{}`) has no effect in `lib` mode — the \ + crate lands at `{lands_at}`", + t.language, t.layout, + )); + } + if mode == Mode::Code && t.flatten { + ui::warn(format!( + "target `{}`: `flatten` has no effect in `code` mode — it only \ + changes where a `lib`-mode crate lands", + t.language + )); + } + let Some((generator, ext)) = registry.find(&t.language, &t.lang_version) else { return Err(miette!( "no generator for `{}` (version `{}`)", @@ -207,9 +227,15 @@ fn generate_once(work_dir: &Path, overrides: &Overrides) -> Result<()> { written += 1; } } - // A crate at `//`; the generator owns the layout inside it. + // A crate at `//` by default, or straight into + // `out` with `flatten = true`; the generator owns the layout + // inside it either way — `layout` itself never applies here. Mode::Lib => { - let root = t.out.join(&t.language); + let root = if t.flatten { + t.out.clone() + } else { + t.out.join(&t.language) + }; for f in &files { let dest = root.join(&f.path); write_file(&dest, &f.contents)?; diff --git a/src/gen_config.rs b/src/gen_config.rs index 4ad3068..59d88ae 100644 --- a/src/gen_config.rs +++ b/src/gen_config.rs @@ -103,6 +103,13 @@ pub struct Target { pub mode: Option, pub package_versions: Option, pub default_framing: Option, + /// `lib` mode only: write the crate straight into `out` instead of + /// `//`. Target-only (no `[generate]` default, no flag/env) + /// — a shared `out` across several `lib` targets needs the per-language + /// split to avoid two crates colliding in one directory, so flattening + /// only makes sense once a target already has `out` to itself. + #[serde(default)] + pub flatten: bool, } /// A non-empty `COMLINE_GENERATE_*` env var, if set. @@ -153,6 +160,8 @@ pub struct ResolvedTarget { pub versions: VersionSpec, /// Fallback framing handed to the generator; `None` ⇒ its built-in default. pub default_framing: Option, + /// `lib` mode only — see [`Target::flatten`]. + pub flatten: bool, } /// Variables a `layout` template can reference. @@ -218,6 +227,7 @@ pub fn resolve( mode: None, package_versions: None, default_framing: None, + flatten: false, }) .collect() } else { @@ -330,6 +340,7 @@ pub fn resolve( mode, versions, default_framing, + flatten: t.flatten, }); } @@ -418,4 +429,21 @@ mod tests { let resolved = resolve(&cfg, &declared, Path::new("/x"), &Overrides::default()).unwrap(); assert_eq!(resolved[0].default_framing, None); } + + #[test] + fn flatten_defaults_to_false_and_is_target_only() { + let cfg = parse( + "[[generate.target]]\nlanguage = \"rust\"\nlang_version = \"1.70.0\"\n\ + mode = \"lib\"\nflatten = true\n", + ); + let declared = []; + let resolved = resolve(&cfg, &declared, Path::new("/x"), &Overrides::default()).unwrap(); + assert!(resolved[0].flatten); + + let cfg = parse( + "[[generate.target]]\nlanguage = \"rust\"\nlang_version = \"1.70.0\"\nmode = \"lib\"\n", + ); + let resolved = resolve(&cfg, &declared, Path::new("/x"), &Overrides::default()).unwrap(); + assert!(!resolved[0].flatten); + } } diff --git a/tests/cli/generate.rs b/tests/cli/generate.rs index d8aaff1..e299f67 100644 --- a/tests/cli/generate.rs +++ b/tests/cli/generate.rs @@ -245,6 +245,56 @@ fn lib_mode_emits_a_crate() { assert!(!crate_dir.join("main.rs").exists()); } +#[test] +fn lib_mode_flatten_skips_the_language_directory() { + let temp = tempfile::tempdir().unwrap(); + let project = fixture_project(temp.path()); + fs::write( + project.join("comline.toml"), + "[[generate.target]]\n\ + language = \"rust\"\n\ + mode = \"lib\"\n\ + out = \"crate-out\"\n\ + flatten = true\n", + ) + .unwrap(); + + comline_cmd() + .current_dir(&project) + .args(["generate"]) + .assert() + .success(); + + let crate_dir = project.join("crate-out"); + assert!(crate_dir.join("Cargo.toml").exists()); + assert!(crate_dir.join("src/lib.rs").exists()); + // not nested under an extra `rust/` + assert!(!crate_dir.join("rust").exists()); +} + +#[test] +fn lib_mode_warns_that_layout_has_no_effect() { + let temp = tempfile::tempdir().unwrap(); + let project = fixture_project(temp.path()); + fs::write( + project.join("comline.toml"), + "[[generate.target]]\n\ + language = \"rust\"\n\ + mode = \"lib\"\n\ + layout = \"{{namespace}}.{{ext}}\"\n", + ) + .unwrap(); + + comline_cmd() + .current_dir(&project) + .args(["generate"]) + .assert() + .success() + .stderr(predicate::str::contains( + "`layout` (`{{namespace}}.{{ext}}`) has no effect in `lib` mode", + )); +} + #[test] fn dylib_mode_is_rejected() { let temp = tempfile::tempdir().unwrap();