diff --git a/src/cli.rs b/src/cli.rs index 8c0e7c0..f75173d 100644 --- a/src/cli.rs +++ b/src/cli.rs @@ -77,9 +77,12 @@ bumps the version, so it is safe to run in editors and pre-commit hooks.")] Validate the project (no version bump, no `.comline/` write), then write \ generated code for each target. -Targets come from `[[generate.target]]` in `comline.toml`, or — if that file \ -lists none — from `code_generation.languages` in `config.idp`. Output location \ -and layout live in `comline.toml`'s `[generate]` table. `--out` / `--layout` / \ +Every language `config.idp` declares under `code_generation.languages` is \ +generated. A `[[generate.target]]` block in `comline.toml` configures one of \ +them (where it lands, in what mode); a language with no block takes the \ +`[generate]` defaults. Narrow the set with `[generate] only` for good, or \ +`--target` for one run. Output location and layout live in `comline.toml`'s \ +`[generate]` table. `--out` / `--layout` / \ `--mode` override one target and need `--target` when several are configured. \ Defaults: out `generated`, layout `{{language}}/{{namespace}}.{{ext}}`, mode \ `code` (`lib` emits a buildable package instead; `dylib` is not built yet). diff --git a/src/commands/generate.rs b/src/commands/generate.rs index 9b5f3c8..b8cdcbc 100644 --- a/src/commands/generate.rs +++ b/src/commands/generate.rs @@ -40,7 +40,9 @@ pub fn run(work_dir: &Path, overrides: &Overrides, dry_run: bool, watching: bool ensure_project(work_dir)?; if watching { - watch::run(work_dir, "generate", || generate_once(work_dir, overrides, dry_run)) + watch::run(work_dir, "generate", || { + generate_once(work_dir, overrides, dry_run) + }) } else { generate_once(work_dir, overrides, dry_run) } @@ -56,7 +58,11 @@ fn generate_once(work_dir: &Path, overrides: &Overrides, dry_run: bool) -> Resul ui::step(format!( "Generating code{}{}", ui::at_path(work_dir), - if dry_run { " - dry run, nothing written" } else { "" }, + if dry_run { + " - dry run, nothing written" + } else { + "" + }, )); let cfg = ComlineToml::load(work_dir)?; @@ -148,11 +154,20 @@ fn generate_once(work_dir: &Path, overrides: &Overrides, dry_run: bool) -> Resul )); } + // Reached for every language the congregation declares now, not only + // for one named by a `[[generate.target]]`, so it says what to do + // about it: `only` is how a consumer whose binary can't produce a + // language says so on purpose. let Some((generator, ext)) = registry.find(&t.language, &t.lang_version) else { return Err(miette!( - "no generator for `{}` (version `{}`)", + "no generator for `{}` (version `{}`)\n \ + help: this build of comline has no {} generator. Install one that \ + does, or narrow the set in {}:\n \ + [generate]\n only = [...]", + t.language, + t.lang_version, t.language, - t.lang_version + gen_config::FILE_NAME, )); }; diff --git a/src/commands/new.rs b/src/commands/new.rs index 06bb35d..4e779f0 100644 --- a/src/commands/new.rs +++ b/src/commands/new.rs @@ -27,15 +27,18 @@ const GITIGNORE: &str = "\ "; /// Consumer-owned code-generation config. Committed. All-commented by default — -/// `comline generate` falls back to the languages declared in `config.idp` and -/// writes to `generated/{{language}}/{{namespace}}.{{ext}}`. +/// Which languages get generated always comes from `config.idp`; this file +/// only says where each lands. Everything here is commented by default, so a +/// new project writes to `generated/{{language}}/{{namespace}}.{{ext}}`. const COMLINE_TOML: &str = "\ # comline.toml — where `comline generate` writes code, and how. # -# With everything below commented out, targets come from `config.idp`'s -# `code_generation.languages` and land in `generated/`. Uncomment to change it. +# Which languages are generated comes from `config.idp`'s +# `code_generation.languages` — this file says where each one lands. +# With everything below commented out they all land in `generated/`. # # [generate] +# only = [\"rust\"] # generate just these, out of the declared languages # out = \"generated\" # output root # layout = \"{{language}}/{{namespace}}.{{ext}}\" # path under the root # mode = \"code\" # code (loose source) | lib (a buildable package); dylib not built yet @@ -43,6 +46,9 @@ const COMLINE_TOML: &str = "\ # package_versions = \"latest\" # latest | all | [\"0.3.0\", \"0.4.0\"] # default_framing = \"jsonrpc\" # wire framing for protocols with no `@framing` (else datagram) # +# One block per declared language you want to configure. A block sets that +# language's output; it does not decide which languages are generated, and +# naming one `config.idp` doesn't declare is an error. # [[generate.target]] # language = \"rust\" # out = \"src/generated\" diff --git a/src/gen_config.rs b/src/gen_config.rs index 6846500..b374c2f 100644 --- a/src/gen_config.rs +++ b/src/gen_config.rs @@ -83,6 +83,15 @@ pub struct ComlineToml { #[derive(Debug, Default, Deserialize)] #[serde(default, deny_unknown_fields)] pub struct Generate { + /// Narrow generation to these languages, out of the ones `config.idp` + /// declares. Empty (the default) means every declared language. + /// + /// The consumer's half of the split: `config.idp` says which languages + /// the *package* is for, and this says which of them *this checkout* + /// wants built. A name the congregation doesn't declare is an error + /// rather than a silent no-op, so a typo here can't quietly stop + /// generating something. + pub only: Vec, /// Output root shared by every target unless overridden. pub out: Option, /// Layout template shared by every target unless overridden. @@ -240,9 +249,28 @@ impl ResolvedTarget { /// Merge `comline.toml`, the congregation's declared languages and CLI flags /// into the concrete set of targets `generate` should emit. /// -/// The base list is `[[generate.target]]` if present, otherwise one target per -/// declared language. `--target` filters it (case-insensitive). The `--out` / -/// `--layout` / `--mode` flags apply to the single remaining target, or to the +/// **The declared languages are the set.** `config.idp`'s +/// `code_generation.languages` says which languages this package is generated +/// for - that is the package's own contract, committed alongside it - and a +/// `[[generate.target]]` block says where and how one of them lands. A block +/// used to *replace* the list outright, so adding one to redirect `rust`'s +/// output silently stopped generating every other declared language; the +/// docs described the block as settings all along ("one block per target you +/// want to pin or override"), and this is the code catching up. +/// +/// A language with no block takes the `[generate]` defaults. Several blocks +/// for one language give several targets - two `rust` blocks writing to +/// different `out` is a real thing to want. A block naming a language the +/// congregation doesn't declare is an error, not a silent no-op: that would +/// be the same footgun inverted. +/// +/// With no declared languages at all, the blocks are the set - a +/// `comline.toml`-only project with no `code_generation` in its congregation +/// still works. +/// +/// `[generate] only` narrows the declared set persistently; `--target` +/// narrows it for one run (case-insensitive). The `--out` / `--layout` / +/// `--mode` flags apply to the single remaining target, or to the /// `--target`-named one; using them with several targets and no `--target` is an /// error. `COMLINE_GENERATE_{OUT,LAYOUT,MODE}` sit just below the flags but apply /// to every target regardless (a deliberate global for CI). @@ -252,23 +280,76 @@ pub fn resolve( work_dir: &Path, ov: &Overrides, ) -> Result> { - let base: Vec = if cfg.generate.targets.is_empty() { + let declares = |language: &str| { + declared + .iter() + .any(|d| d.language.eq_ignore_ascii_case(language)) + }; + + // A block for a language nobody declared is a mistake worth naming - + // it would otherwise configure a target that is never built. + if !declared.is_empty() { + if let Some(stray) = cfg.generate.targets.iter().find(|t| !declares(&t.language)) { + return Err(miette!( + "`[[generate.target]]` names `{}`, which config.idp does not declare \ + - add `{}# = {{}}` to `code_generation.languages`, or drop \ + the block", + stray.language, + stray.language, + )); + } + } + if let Some(stray) = cfg + .generate + .only + .iter() + .find(|l| !declared.is_empty() && !declares(l)) + { + return Err(miette!( + "`[generate] only` names `{stray}`, which config.idp does not declare", + )); + } + + let base: Vec = if declared.is_empty() { + // No congregation-declared languages: the blocks are all there is. + cfg.generate.targets.clone() + } else { declared .iter() - .map(|d| Target { - language: d.language.clone(), - lang_version: Some(d.lang_version.clone()), - out: None, - layout: None, - mode: None, - package_versions: None, - default_framing: None, - external_std: None, - flatten: false, + .filter(|d| { + cfg.generate.only.is_empty() + || cfg + .generate + .only + .iter() + .any(|l| l.eq_ignore_ascii_case(&d.language)) + }) + .flat_map(|d| { + let blocks: Vec = cfg + .generate + .targets + .iter() + .filter(|t| t.language.eq_ignore_ascii_case(&d.language)) + .cloned() + .collect(); + if blocks.is_empty() { + // Declared but unconfigured: the `[generate]` defaults. + vec![Target { + language: d.language.clone(), + lang_version: Some(d.lang_version.clone()), + out: None, + layout: None, + mode: None, + package_versions: None, + default_framing: None, + external_std: None, + flatten: false, + }] + } else { + blocks + } }) .collect() - } else { - cfg.generate.targets.clone() }; let selected: Vec<&Target> = base @@ -282,6 +363,9 @@ pub fn resolve( if selected.is_empty() { return match ov.target { Some(want) => Err(miette!("no code-generation target matches `{want}`")), + None if !cfg.generate.only.is_empty() => { + Err(miette!("`[generate] only` leaves nothing to generate",)) + } None => Err(miette!( "nothing to generate: add `[[generate.target]]` to {} \ or `code_generation.languages` to config.idp", @@ -456,6 +540,124 @@ mod tests { assert_eq!(resolved[0].versions, VersionSpec::Latest); } + fn two_langs() -> [DeclaredLang; 2] { + [ + DeclaredLang { + language: "rust".into(), + lang_version: "1.70.0".into(), + }, + DeclaredLang { + language: "typescript".into(), + lang_version: "5.0".into(), + }, + ] + } + + /// The bug this rule replaced: one block existed only to redirect + /// `rust`'s output, and every other declared language silently stopped + /// being generated. + #[test] + fn a_block_configures_its_language_without_dropping_the_others() { + let cfg = parse("[[generate.target]]\nlanguage = \"rust\"\nout = \"../test-cl-rs/\"\n"); + let resolved = resolve(&cfg, &two_langs(), Path::new("/x"), &Overrides::default()).unwrap(); + + let langs: Vec<&str> = resolved.iter().map(|t| t.language.as_str()).collect(); + assert_eq!(langs, vec!["rust", "typescript"]); + assert_eq!( + resolved[0].out, + Path::new("/x/../test-cl-rs/"), + "the block's out" + ); + assert_eq!( + resolved[1].out, + Path::new("/x/generated"), + "the [generate] default" + ); + // A language with no block still gets the version its congregation declared. + assert_eq!(resolved[1].lang_version, "5.0"); + } + + #[test] + fn a_block_may_be_matched_case_insensitively() { + let cfg = parse("[[generate.target]]\nlanguage = \"Rust\"\nout = \"elsewhere\"\n"); + let resolved = resolve(&cfg, &two_langs(), Path::new("/x"), &Overrides::default()).unwrap(); + assert_eq!(resolved[0].out, Path::new("/x/elsewhere")); + } + + /// Two outputs for one language is a real thing to want, and survives + /// the declared set becoming the base. + #[test] + fn several_blocks_for_one_language_give_several_targets() { + let cfg = parse( + "[[generate.target]]\nlanguage = \"rust\"\nout = \"a\"\n\n\ + [[generate.target]]\nlanguage = \"rust\"\nout = \"b\"\n", + ); + let declared = [DeclaredLang { + language: "rust".into(), + lang_version: "1.70.0".into(), + }]; + let resolved = resolve(&cfg, &declared, Path::new("/x"), &Overrides::default()).unwrap(); + assert_eq!(resolved.len(), 2); + assert_eq!(resolved[0].out, Path::new("/x/a")); + assert_eq!(resolved[1].out, Path::new("/x/b")); + } + + /// Silently ignoring a block someone wrote would be the same footgun + /// inverted, so it names the fix instead. + #[test] + fn a_block_for_an_undeclared_language_is_an_error() { + let cfg = parse("[[generate.target]]\nlanguage = \"python\"\nlang_version = \"3.11\"\n"); + let declared = [DeclaredLang { + language: "rust".into(), + lang_version: "1.70.0".into(), + }]; + let err = resolve(&cfg, &declared, Path::new("/x"), &Overrides::default()) + .unwrap_err() + .to_string(); + assert!(err.contains("config.idp does not declare"), "{err}"); + assert!(err.contains("code_generation.languages"), "{err}"); + } + + /// A congregation with no `code_generation` at all: the blocks are all + /// there is, as they always were. + #[test] + fn blocks_stand_alone_when_nothing_is_declared() { + let cfg = parse("[[generate.target]]\nlanguage = \"rust\"\nlang_version = \"1.70.0\"\n"); + let resolved = resolve(&cfg, &[], Path::new("/x"), &Overrides::default()).unwrap(); + assert_eq!(resolved.len(), 1); + assert_eq!(resolved[0].language, "rust"); + } + + #[test] + fn only_narrows_the_declared_set() { + let cfg = parse("[generate]\nonly = [\"rust\"]\n"); + let resolved = resolve(&cfg, &two_langs(), Path::new("/x"), &Overrides::default()).unwrap(); + let langs: Vec<&str> = resolved.iter().map(|t| t.language.as_str()).collect(); + assert_eq!(langs, vec!["rust"]); + } + + /// A typo in `only` would otherwise quietly stop generating something. + #[test] + fn only_naming_an_undeclared_language_is_an_error() { + let cfg = parse("[generate]\nonly = [\"rustt\"]\n"); + let err = resolve(&cfg, &two_langs(), Path::new("/x"), &Overrides::default()) + .unwrap_err() + .to_string(); + assert!(err.contains("does not declare"), "{err}"); + } + + #[test] + fn only_still_lets_a_block_configure_what_survives() { + let cfg = parse( + "[generate]\nonly = [\"rust\"]\n\n\ + [[generate.target]]\nlanguage = \"rust\"\nout = \"here\"\n\n\ + [[generate.target]]\nlanguage = \"typescript\"\nout = \"there\"\n", + ); + let resolved = resolve(&cfg, &two_langs(), Path::new("/x"), &Overrides::default()).unwrap(); + assert_eq!(resolved.len(), 1); + assert_eq!(resolved[0].out, Path::new("/x/here")); + } + #[test] fn default_framing_section_reaches_a_declared_target() { let cfg = parse("[generate]\ndefault_framing = \"jsonrpc\"\n"); @@ -524,14 +726,18 @@ mod tests { "[[generate.target]]\nlanguage = \"rust\"\nlang_version = \"1.70.0\"\n\ mode = \"lib\"\n", ); - let off = Overrides { external_std: Some(false), ..Default::default() }; + let off = Overrides { + external_std: Some(false), + ..Default::default() + }; let resolved = resolve(&cfg, &[], Path::new("/x"), &off).unwrap(); assert!(!resolved[0].external_std, "--no-external-std"); - let cfg = parse( - "[[generate.target]]\nlanguage = \"rust\"\nlang_version = \"1.70.0\"\n", - ); - let on = Overrides { external_std: Some(true), ..Default::default() }; + let cfg = parse("[[generate.target]]\nlanguage = \"rust\"\nlang_version = \"1.70.0\"\n"); + let on = Overrides { + external_std: Some(true), + ..Default::default() + }; let resolved = resolve(&cfg, &[], Path::new("/x"), &on).unwrap(); assert!(resolved[0].external_std, "--external-std"); } diff --git a/src/ui.rs b/src/ui.rs index 4d7f085..2bafc4f 100644 --- a/src/ui.rs +++ b/src/ui.rs @@ -289,7 +289,9 @@ fn print_level(rows: &[Vec], prefix: &[String], indent: &str) { // A name with nothing below it is a file; anything else is a // directory, and gets the trailing slash that says so. - let is_dir = rows.iter().any(|r| r.len() > path.len() && r.starts_with(&path)); + let is_dir = rows + .iter() + .any(|r| r.len() > path.len() && r.starts_with(&path)); let branch = if last { elbow } else { tee }; detail(format!( "{indent}{branch}{name}{}", diff --git a/tests/cli/generate.rs b/tests/cli/generate.rs index 5f5c932..39472c9 100644 --- a/tests/cli/generate.rs +++ b/tests/cli/generate.rs @@ -17,9 +17,7 @@ fn writes_one_file_per_schema_under_the_default_layout() { .assert() .success() .stderr(predicate::str::contains("language: rust, version:")) - .stderr(predicate::str::contains( - "api.ids → generated/rust/api.rs", - )) + .stderr(predicate::str::contains("api.ids → generated/rust/api.rs")) .stderr(predicate::str::contains("Generated")); // default layout: generated/{language}/{namespace}.{ext} @@ -107,6 +105,7 @@ fn env_out_applies_in_a_multi_target_config() { // the env var does not — it applies to every target. let temp = tempfile::tempdir().unwrap(); let project = fixture_project(temp.path()); + declare_two_languages(&project); fs::write( project.join("comline.toml"), "[[generate.target]]\nlanguage = \"rust\"\nlang_version = \"1.70.0\"\n\n\ @@ -134,9 +133,7 @@ fn plain_uses_ascii_arrow() { .args(["generate", "--target", "rust", "--plain"]) .assert() .success() - .stderr(predicate::str::contains( - "api.ids -> generated/rust/api.rs", - )) + .stderr(predicate::str::contains("api.ids -> generated/rust/api.rs")) .stderr(predicate::str::contains('⚙').not()); } @@ -144,6 +141,7 @@ fn plain_uses_ascii_arrow() { fn out_flag_needs_target_when_several_are_configured() { let temp = tempfile::tempdir().unwrap(); let project = fixture_project(temp.path()); + declare_two_languages(&project); fs::write( project.join("comline.toml"), "[[generate.target]]\nlanguage = \"rust\"\nlang_version = \"1.70.0\"\n\n\ @@ -437,6 +435,19 @@ fn package_versions_all_without_a_build_errors() { .stderr(predicate::str::contains("run `comline build` first")); } +/// Declare a second language in the congregation, so a test can configure +/// two targets. A `[[generate.target]]` only configures a language +/// `config.idp` declares — it can't introduce one. +fn declare_two_languages(project: &std::path::Path) { + fs::write( + project.join("config.idp"), + "congregation simple_project\nspecification_version = 1\n\n\ + code_generation = {\n languages = {\n rust#1.70.0 = {}\n\ + \x20 python#3.11.0 = {}\n }\n}\n", + ) + .unwrap(); +} + fn add_std_reference(project: &std::path::Path) { fs::write( project.join("src/uses_std.ids"), @@ -569,7 +580,9 @@ fn the_target_line_names_the_mode() { .args(["generate", "--target", "rust"]) .assert() .success() - .stderr(predicate::str::contains("language: rust, version: 1.70.0, mode: code")); + .stderr(predicate::str::contains( + "language: rust, version: 1.70.0, mode: code", + )); comline_cmd() .current_dir(&project) @@ -598,7 +611,10 @@ fn dry_run_prints_the_tree_and_writes_nothing() { .stderr(predicate::str::contains("api.rs")) .stderr(predicate::str::contains("Would write 4 file(s)")); - assert!(!project.join("generated").exists(), "a dry run must write nothing"); + assert!( + !project.join("generated").exists(), + "a dry run must write nothing" + ); } /// `lib` mode writes the package manifest, so it can add `comline_std` to @@ -620,8 +636,14 @@ fn lib_mode_links_comline_std_instead_of_inlining_it() { let cargo = fs::read_to_string(crate_dir.join("Cargo.toml")).unwrap(); assert!(cargo.contains("comline_std = { git"), "{cargo}"); assert!(cargo.contains("rust-version = \"1.70.0\""), "{cargo}"); - assert!(!crate_dir.join("src/std.rs").exists(), "std should not be inlined"); - assert!(!crate_dir.join("src/std").exists(), "std should not be inlined"); + assert!( + !crate_dir.join("src/std.rs").exists(), + "std should not be inlined" + ); + assert!( + !crate_dir.join("src/std").exists(), + "std should not be inlined" + ); } /// `code` mode has no manifest to add a dependency to, so it keeps @@ -637,12 +659,25 @@ fn code_mode_still_inlines_std_and_the_flag_overrides_lib() { .args(["generate", "--target", "rust"]) .assert() .success(); - assert!(project.join("generated/rust/std/http.rs").exists(), "code mode inlines std"); + assert!( + project.join("generated/rust/std/http.rs").exists(), + "code mode inlines std" + ); comline_cmd() .current_dir(&project) - .args(["generate", "--target", "rust", "--mode", "lib", "--no-external-std"]) + .args([ + "generate", + "--target", + "rust", + "--mode", + "lib", + "--no-external-std", + ]) .assert() .success(); - assert!(project.join("generated/rust/src/std/http.rs").exists(), "--no-external-std inlines"); + assert!( + project.join("generated/rust/src/std/http.rs").exists(), + "--no-external-std inlines" + ); }