Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
9 changes: 6 additions & 3 deletions src/cli.rs
Original file line number Diff line number Diff line change
Expand Up @@ -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).
Expand Down
23 changes: 19 additions & 4 deletions src/commands/generate.rs
Original file line number Diff line number Diff line change
Expand Up @@ -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)
}
Expand All @@ -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)?;
Expand Down Expand Up @@ -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,
));
};

Expand Down
14 changes: 10 additions & 4 deletions src/commands/new.rs
Original file line number Diff line number Diff line change
Expand Up @@ -27,22 +27,28 @@ 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
# external_std = false # reference `comline_std` rather than inlining std; defaults on in `lib`
# 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\"
Expand Down
248 changes: 227 additions & 21 deletions src/gen_config.rs
Original file line number Diff line number Diff line change
Expand Up @@ -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<String>,
/// Output root shared by every target unless overridden.
pub out: Option<String>,
/// Layout template shared by every target unless overridden.
Expand Down Expand Up @@ -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).
Expand All @@ -252,23 +280,76 @@ pub fn resolve(
work_dir: &Path,
ov: &Overrides,
) -> Result<Vec<ResolvedTarget>> {
let base: Vec<Target> = 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 `{}#<version> = {{}}` 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<Target> = 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<Target> = 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
Expand All @@ -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",
Expand Down Expand Up @@ -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");
Expand Down Expand Up @@ -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");
}
Expand Down
Loading
Loading