diff --git a/Cargo.lock b/Cargo.lock index 1cc6985..634d5e5 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -387,7 +387,7 @@ dependencies = [ [[package]] name = "comline-codelib-gen" version = "0.1.0" -source = "git+https://github.com/ComlineProject/generation?rev=f17c2109934a94c595925a45db4938c0720d41ed#f17c2109934a94c595925a45db4938c0720d41ed" +source = "git+https://github.com/ComlineProject/generation?rev=db4f16615de00033e860632489a63f746144ddd5#db4f16615de00033e860632489a63f746144ddd5" dependencies = [ "comline-core", "eyre", diff --git a/Cargo.toml b/Cargo.toml index e84a111..6242ae4 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -26,7 +26,7 @@ toml = "0.8" # git rev (not crates.io 0.1.0) so this and `comline-codelib-gen` share one # `comline-core` in the tree. Local dev: see .cargo/config. comline-core = { git = "https://github.com/ComlineProject/core", rev = "d8bc708bf23e4accd06a13da1d317b10596888c7" } -comline-codelib-gen = { git = "https://github.com/ComlineProject/generation", rev = "f17c2109934a94c595925a45db4938c0720d41ed" } +comline-codelib-gen = { git = "https://github.com/ComlineProject/generation", rev = "db4f16615de00033e860632489a63f746144ddd5" } [target.'cfg(unix)'.dependencies] libc = "0.2" diff --git a/src/commands/generate.rs b/src/commands/generate.rs index 05ce90b..fc2d77b 100644 --- a/src/commands/generate.rs +++ b/src/commands/generate.rs @@ -9,8 +9,10 @@ //! `compile_package` — no `.comline/` write, no version bump. `"all"` or an //! explicit list reads committed versions from the CAS chain instead. +use std::collections::HashMap; use std::path::Path; +use comline_codelib_gen::code_gen::{self, GenRequest, Mode, PackageMeta}; use comline_core::package::build::{self, cas::ObjectStore}; use comline_core::package::config::ir::frozen::FrozenUnit as ConfigUnit; use comline_core::schema::idl::constants::SCHEMA_EXTENSION; @@ -74,6 +76,10 @@ fn generate_once(work_dir: &Path, overrides: &Overrides) -> Result<()> { }) .unwrap_or_default(); + // Crate / package name for a `lib`-mode manifest — the congregation name, + // `::` flattened to `-` so it is a valid crate name. + let package_name = context.config.name.value.replace("::", "-"); + // The working-tree schemas, used for `package_versions = "latest"`. let live_schemas: Vec<(String, Vec)> = context .schema_contexts @@ -89,17 +95,18 @@ fn generate_once(work_dir: &Path, overrides: &Overrides) -> Result<()> { let mut written = 0usize; for t in &targets { - if t.mode != "code" { - return Err(miette!( - "target `{}`: mode `{}` is not supported yet (only `code`)", - t.language, - t.mode - )); - } + let mode = match t.mode.as_str() { + "code" => Mode::Code, + "lib" => Mode::Lib, + other => { + return Err(miette!( + "target `{}`: mode `{other}` is not supported yet (`code`, `lib`)", + t.language + )) + } + }; - let Some((generator, ext)) = - comline_codelib_gen::code_gen::find_generator(&t.language, &t.lang_version) - else { + let Some((generator, ext)) = code_gen::find_generator(&t.language, &t.lang_version) else { return Err(miette!( "no generator for `{}` (version `{}`)", t.language, @@ -108,7 +115,13 @@ fn generate_once(work_dir: &Path, overrides: &Overrides) -> Result<()> { }; let versions = expand_versions(&t.versions, work_dir, &live_schemas)?; - if versions.len() > 1 && !t.layout.contains("{{package_version}}") { + if mode == Mode::Lib && versions.len() > 1 { + return Err(miette!( + "target `{}`: `lib` mode does not support multiple package versions yet", + t.language + )); + } + if mode == Mode::Code && versions.len() > 1 && !t.layout.contains("{{package_version}}") { return Err(miette!( "target `{}` selects {} versions but its `layout` has no \ `{{{{package_version}}}}` — every version would write to the same paths", @@ -126,27 +139,68 @@ fn generate_once(work_dir: &Path, overrides: &Overrides) -> Result<()> { }); for gv in &versions { - for (namespace, units) in &gv.schemas { - let dest = t.dest_for(namespace, ext, &spec_version, &gv.package_version)?; + let request = GenRequest { + mode, + schemas: &gv.schemas, + package: PackageMeta { + name: package_name.clone(), + // An unbuilt working tree has no version yet; `0.0.0` keeps + // the generated manifest valid. + version: if gv.package_version.is_empty() { + "0.0.0".to_string() + } else { + gv.package_version.clone() + }, + }, + }; + let files = + generator(&request).map_err(|e| miette!("`{}` generator: {e}", t.language))?; - if let Some(parent) = dest.parent() { - std::fs::create_dir_all(parent) - .into_diagnostic() - .wrap_err_with(|| format!("failed to create `{}`", parent.display()))?; + match mode { + // One file per schema, placed by `layout`. + Mode::Code => { + let by_namespace: HashMap = files + .iter() + .map(|f| { + ( + f.path.with_extension("").to_string_lossy().into_owned(), + f.contents.as_str(), + ) + }) + .collect(); + for (namespace, _) in &gv.schemas { + let contents = by_namespace.get(namespace.as_str()).ok_or_else(|| { + miette!( + "`{}` generator produced no file for `{namespace}`", + t.language + ) + })?; + let dest = + t.dest_for(namespace, ext, &spec_version, &gv.package_version)?; + write_file(&dest, contents)?; + + let src_name = format!("{namespace}.{SCHEMA_EXTENSION}"); + let shown = dest.strip_prefix(work_dir).unwrap_or(&dest).display(); + let tag = if multi { + format!("[{}] ", gv.package_version) + } else { + String::new() + }; + ui::detail(format!(" {tag}{src_name} {} {shown}", ui::arrow())); + written += 1; + } + } + // A crate at `//`; the generator owns the layout inside it. + Mode::Lib => { + let root = t.out.join(&t.language); + for f in &files { + let dest = root.join(&f.path); + write_file(&dest, &f.contents)?; + let shown = dest.strip_prefix(work_dir).unwrap_or(&dest).display(); + ui::detail(format!(" {} {} {shown}", f.path.display(), ui::arrow())); + written += 1; + } } - std::fs::write(&dest, generator(units)) - .into_diagnostic() - .wrap_err_with(|| format!("failed to write `{}`", dest.display()))?; - - let src_name = format!("{namespace}.{SCHEMA_EXTENSION}"); - let shown = dest.strip_prefix(work_dir).unwrap_or(&dest).display(); - let tag = if multi { - format!("[{}] ", gv.package_version) - } else { - String::new() - }; - ui::detail(format!(" {tag}{src_name} {} {shown}", ui::arrow())); - written += 1; } } } @@ -155,6 +209,17 @@ fn generate_once(work_dir: &Path, overrides: &Overrides) -> Result<()> { Ok(()) } +fn write_file(dest: &Path, contents: &str) -> Result<()> { + if let Some(parent) = dest.parent() { + std::fs::create_dir_all(parent) + .into_diagnostic() + .wrap_err_with(|| format!("failed to create `{}`", parent.display()))?; + } + std::fs::write(dest, contents) + .into_diagnostic() + .wrap_err_with(|| format!("failed to write `{}`", dest.display())) +} + /// Turn a [`VersionSpec`] into the concrete list of versions to emit. /// /// `Latest` is the working tree (`live`), stamped with the last committed diff --git a/tests/cli/generate.rs b/tests/cli/generate.rs index 17094ad..2fa0667 100644 --- a/tests/cli/generate.rs +++ b/tests/cli/generate.rs @@ -176,6 +176,48 @@ fn rejects_an_unconfigured_target() { )); } +// -------- lib mode -------- + +#[test] +fn lib_mode_emits_a_crate() { + let temp = tempfile::tempdir().unwrap(); + let project = fixture_project(temp.path()); + + comline_cmd() + .current_dir(&project) + .args(["generate", "--target", "rust", "--mode", "lib"]) + .assert() + .success(); + + let crate_dir = project.join("generated/rust"); + let cargo = fs::read_to_string(crate_dir.join("Cargo.toml")).unwrap(); + assert!(cargo.contains("name = \"simple_project\"")); + assert!(cargo.contains("edition = \"2021\"")); + assert!(cargo.contains("serde = { version = \"1\"")); + + let lib = fs::read_to_string(crate_dir.join("src/lib.rs")).unwrap(); + assert!(lib.contains("pub mod main;")); + assert!(lib.contains("pub mod other;")); + + assert!(crate_dir.join("src/main.rs").exists()); + assert!(crate_dir.join("src/other.rs").exists()); + // no bare files at the target root + assert!(!crate_dir.join("main.rs").exists()); +} + +#[test] +fn dylib_mode_is_rejected() { + let temp = tempfile::tempdir().unwrap(); + let project = fixture_project(temp.path()); + + comline_cmd() + .current_dir(&project) + .args(["generate", "--target", "rust", "--mode", "dylib"]) + .assert() + .failure() + .stderr(predicate::str::contains("mode `dylib` is not supported")); +} + // -------- multi-version (package_versions) -------- /// Build twice with a schema change, so the CAS chain has 0.0.1 and 0.1.0.