From 85d3e8ffa9be339ade15dd0804170b4244a15195 Mon Sep 17 00:00:00 2001 From: Kinflou Date: Tue, 13 Oct 2026 04:00:15 +0800 Subject: [PATCH 1/2] fix: a target block configures a language, it doesn't replace the set A congregation declaring `rust#1.70.0` and `typescript#5.0` generated rust only, said nothing about typescript, and exited 0. One line did it: let base = if cfg.generate.targets.is_empty() { declared } else { targets }; An all-or-nothing switch. The moment one `[[generate.target]]` block existed - and the reported case had exactly one, there only to redirect rust's output to a sibling directory - every declared language without its own block was dropped. Silently: no warning, no mention in the output, nothing. This contradicted the documentation, which already described the intended behaviour: the guide introduces the block as "one block per target you want to pin or override" and `lang_version` as "defaults to what config.idp declared". A block is described throughout as *settings for a language*, never as the thing that decides whether that language is generated. The code had diverged from its own docs. It also conflated two files with different owners. `config.idp` is committed and says which languages the package is generated for; `comline.toml` is consumer-owned and says where and how each one lands. Deciding *whether* is the congregation's call. So the declared set is the base, and blocks configure it by language (case-insensitively). A language with no block takes the `[generate]` defaults. Several blocks for one language still give several outputs. A block naming a language the congregation doesn't declare is an error that names the fix - silently ignoring a block someone wrote would be the same footgun inverted. With nothing declared at all, the blocks are the set, so a `comline.toml`-only project still works. `[generate] only = ["rust"]` narrows persistently, for a checkout that wants fewer languages than the package offers; `--target` still narrows per run. A name the congregation doesn't declare is an error there too, so a typo can't quietly stop generating something. That makes the declared set reachable on every run, so the missing-generator error now says what to do about it: this build has no such generator, install one that does or narrow with `only`. The `gen-*` Cargo features are optional, so a binary lacking one is a normal build - but declaring a language means meaning it, and `only` is the way to say otherwise on purpose. No existing `gen_config` test combined a declared language with a block, so none encoded the old behaviour and none needed changing. Two integration tests configured a `python` block against a fixture declaring only rust; they now declare it, which is what a block requires. --- src/cli.rs | 9 +- src/commands/generate.rs | 13 ++- src/commands/new.rs | 14 ++- src/gen_config.rs | 207 ++++++++++++++++++++++++++++++++++++--- tests/cli/generate.rs | 15 +++ 5 files changed, 233 insertions(+), 25 deletions(-) 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..81d2e0c 100644 --- a/src/commands/generate.rs +++ b/src/commands/generate.rs @@ -148,11 +148,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.lang_version, + t.language, + 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..faa6264 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,65 @@ 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 +352,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 +529,108 @@ 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"); diff --git a/tests/cli/generate.rs b/tests/cli/generate.rs index 5f5c932..a271849 100644 --- a/tests/cli/generate.rs +++ b/tests/cli/generate.rs @@ -107,6 +107,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\ @@ -144,6 +145,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 +439,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"), From 81833874d27d7c11a797ac8de365ac5f30959fb5 Mon Sep 17 00:00:00 2001 From: Kinflou Date: Tue, 13 Oct 2026 04:10:37 +0800 Subject: [PATCH 2/2] style: run rustfmt over the lib-mode and target-resolution changes The `lib` mode work (#58) landed unformatted, turning CI's Lint job red on main; this branch added more of the same. `cargo fmt --all` over the four files it touched, no behaviour change. --- src/commands/generate.rs | 10 ++++-- src/gen_config.rs | 77 ++++++++++++++++++++++++++++------------ src/ui.rs | 4 ++- tests/cli/generate.rs | 46 +++++++++++++++++------- 4 files changed, 98 insertions(+), 39 deletions(-) diff --git a/src/commands/generate.rs b/src/commands/generate.rs index 81d2e0c..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)?; diff --git a/src/gen_config.rs b/src/gen_config.rs index faa6264..b374c2f 100644 --- a/src/gen_config.rs +++ b/src/gen_config.rs @@ -281,7 +281,9 @@ pub fn resolve( ov: &Overrides, ) -> Result> { let declares = |language: &str| { - declared.iter().any(|d| d.language.eq_ignore_ascii_case(language)) + declared + .iter() + .any(|d| d.language.eq_ignore_ascii_case(language)) }; // A block for a language nobody declared is a mistake worth naming - @@ -297,7 +299,12 @@ pub fn resolve( )); } } - if let Some(stray) = cfg.generate.only.iter().find(|l| !declared.is_empty() && !declares(l)) { + 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", )); @@ -311,7 +318,11 @@ pub fn resolve( .iter() .filter(|d| { cfg.generate.only.is_empty() - || cfg.generate.only.iter().any(|l| l.eq_ignore_ascii_case(&d.language)) + || cfg + .generate + .only + .iter() + .any(|l| l.eq_ignore_ascii_case(&d.language)) }) .flat_map(|d| { let blocks: Vec = cfg @@ -352,9 +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 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", @@ -531,8 +542,14 @@ mod tests { fn two_langs() -> [DeclaredLang; 2] { [ - DeclaredLang { language: "rust".into(), lang_version: "1.70.0".into() }, - DeclaredLang { language: "typescript".into(), lang_version: "5.0".into() }, + DeclaredLang { + language: "rust".into(), + lang_version: "1.70.0".into(), + }, + DeclaredLang { + language: "typescript".into(), + lang_version: "5.0".into(), + }, ] } @@ -541,15 +558,21 @@ mod tests { /// 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 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"); + 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"); } @@ -569,7 +592,10 @@ mod tests { "[[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 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")); @@ -581,7 +607,10 @@ mod tests { #[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 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(); @@ -593,9 +622,7 @@ mod tests { /// 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 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"); @@ -699,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 a271849..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} @@ -135,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()); } @@ -584,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) @@ -613,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 @@ -635,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 @@ -652,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" + ); }