use super::{
artifact,
kmp_sdk::{Artifact, PreparedSdk},
maven, PublishCommand,
};
use anyhow::{bail, Context, Result};
use std::{collections::BTreeMap, fs, path::Path};
#[derive(Debug)]
pub(super) struct Dependency {
pub group: String,
pub artifact: String,
pub version: String,
}
#[derive(Debug)]
pub(super) struct Coordinates {
pub group: String,
pub artifact_base: String,
pub dependencies: Vec<Dependency>,
}
pub(super) fn publish(command: &PublishCommand, sdk: &PreparedSdk, verbose: bool) -> Result<()> {
let cwd = std::env::current_dir().context("Failed to get current directory")?;
let config = maven::load_config(&cwd)?;
let coordinates = coordinates(&config, sdk)?;
let destination = maven::destination(command, &config)?;
let client = destination.client()?;
println!(
"Publishing prebuilt KMP SDK {} {} directly to {} (Gradle not used)",
sdk.project,
sdk.version,
destination.describe()
);
let mut targets: BTreeMap<&str, Vec<&Artifact>> = BTreeMap::new();
for artifact in &sdk.artifacts {
targets.entry(&artifact.target).or_default().push(artifact);
}
for (target, artifacts) in targets {
let artifact_id = format!("{}-{}", coordinates.artifact_base, target);
artifact::coordinate(&artifact_id)
.with_context(|| format!("Invalid Maven artifactId for target {target}"))?;
let main = artifacts
.iter()
.find(|artifact| artifact.classifier.is_none())
.with_context(|| format!("KMP SDK target {target} has no main artifact"))?;
let packaging = extension(&main.path)?;
let pom = pom_xml(
&sdk.project,
target,
&coordinates.group,
&artifact_id,
&sdk.version,
packaging,
&coordinates.dependencies,
);
for artifact in artifacts {
let relative = maven::layout_path(
&coordinates.group,
&artifact_id,
&sdk.version,
artifact.classifier.as_deref(),
extension(&artifact.path)?,
);
let bytes = fs::read(&artifact.path)
.with_context(|| format!("Failed to read {}", artifact.path.display()))?;
maven::upload_with_checksum(&destination, client.as_ref(), &relative, bytes, verbose)?;
}
maven::upload_with_checksum(
&destination,
client.as_ref(),
&maven::layout_path(&coordinates.group, &artifact_id, &sdk.version, None, "pom"),
pom.into_bytes(),
verbose,
)?;
println!(" ✓ {}:{}:{}", coordinates.group, artifact_id, sdk.version);
}
println!("\n✅ Publish completed successfully!");
Ok(())
}
pub(super) fn coordinates(config: &toml::Value, sdk: &PreparedSdk) -> Result<Coordinates> {
let (project, _) = maven::project_identity(config)?;
if project != sdk.project {
bail!(
"KMP SDK project '{}' does not match '{}' in CCGO.toml",
sdk.project,
project
);
}
let group = maven::string_at(config, &["publish", "kmp", "maven", "group_id"])
.or_else(|| maven::string_at(config, &["publish", "kmp", "group_id"]))
.or_else(|| maven::string_at(config, &["publish", "android", "maven", "group_id"]))
.or_else(|| maven::string_at(config, &["project", "group_id"]))
.or_else(|| maven::string_at(config, &["package", "group_id"]))
.context(
"KMP publishing requires a Maven group id: set [publish.kmp.maven].group_id, \
[publish.android.maven].group_id, or [project].group_id in CCGO.toml",
)?;
for part in group.split('.') {
artifact::coordinate(part)
.with_context(|| format!("Invalid Maven groupId segment in '{group}'"))?;
}
let artifact_base = maven::string_at(config, &["publish", "kmp", "maven", "artifact_id"])
.or_else(|| maven::string_at(config, &["publish", "kmp", "artifact_id"]))
.filter(|value| !value.trim().is_empty())
.map(str::to_owned)
.unwrap_or_else(|| format!("{project}-kmp"));
artifact::coordinate(&artifact_base).context("Invalid Maven artifactId")?;
artifact::coordinate(&sdk.version).context("Invalid KMP SDK version")?;
Ok(Coordinates {
group: group.to_owned(),
artifact_base,
dependencies: dependencies(config)?,
})
}
fn dependencies(config: &toml::Value) -> Result<Vec<Dependency>> {
let entries = maven::value_at(config, &["publish", "kmp", "maven", "dependencies"])
.or_else(|| maven::value_at(config, &["publish", "kmp", "dependencies"]));
let Some(toml::Value::Array(entries)) = entries else {
return Ok(Vec::new());
};
entries
.iter()
.map(|entry| {
let field = |name: &str| -> Result<String> {
let value = entry
.get(name)
.and_then(|value| value.as_str())
.filter(|value| !value.trim().is_empty())
.with_context(|| {
format!("[publish.kmp.maven].dependencies entry requires {name}")
})?;
artifact::coordinate(value).with_context(|| {
format!("Invalid Maven coordinate in dependencies entry: {value}")
})?;
Ok(value.to_owned())
};
Ok(Dependency {
group: field("group")?,
artifact: field("artifact")?,
version: field("version")?,
})
})
.collect()
}
pub(super) fn extension(path: &Path) -> Result<&str> {
path.extension()
.and_then(|value| value.to_str())
.filter(|value| !value.is_empty())
.with_context(|| format!("Artifact has no extension: {}", path.display()))
}
fn pom_xml(
project: &str,
target: &str,
group: &str,
artifact: &str,
version: &str,
packaging: &str,
dependencies: &[Dependency],
) -> String {
let mut pom = String::from(
"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n\
<project xmlns=\"http://maven.apache.org/POM/4.0.0\" \
xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" \
xsi:schemaLocation=\"http://maven.apache.org/POM/4.0.0 \
https://maven.apache.org/xsd/maven-4.0.0.xsd\">\n\
\x20 <modelVersion>4.0.0</modelVersion>\n",
);
for (tag, value) in [
("groupId", group),
("artifactId", artifact),
("version", version),
("packaging", packaging),
] {
pom.push_str(&format!(" <{tag}>{}</{tag}>\n", maven::xml_escape(value)));
}
pom.push_str(&format!(
" <name>{} KMP - {}</name>\n",
maven::xml_escape(project),
maven::xml_escape(target)
));
pom.push_str(&format!(
" <description>Prebuilt {} KMP SDK ({})</description>\n",
maven::xml_escape(project),
maven::xml_escape(target)
));
if !dependencies.is_empty() {
pom.push_str(" <dependencies>\n");
for dependency in dependencies {
pom.push_str(" <dependency>\n");
for (tag, value) in [
("groupId", dependency.group.as_str()),
("artifactId", dependency.artifact.as_str()),
("version", dependency.version.as_str()),
] {
pom.push_str(&format!(
" <{tag}>{}</{tag}>\n",
maven::xml_escape(value)
));
}
pom.push_str(" <scope>compile</scope>\n");
pom.push_str(" </dependency>\n");
}
pom.push_str(" </dependencies>\n");
}
pom.push_str("</project>\n");
pom
}
#[cfg(test)]
mod tests {
use super::*;
use std::io::Write;
fn config(extra: &str) -> toml::Value {
toml::from_str(&format!(
"[project]\nname='demo'\nversion='0.0.5'\ngroup_id='com.example'\n{extra}"
))
.unwrap()
}
fn sdk() -> PreparedSdk {
let temporary = tempfile::tempdir().unwrap();
let zip_path = temporary.path().join("SDK.zip");
let mut zip = zip::ZipWriter::new(fs::File::create(&zip_path).unwrap());
for (name, bytes) in [
(
"meta/kmp/build_info.json",
br#"{"project":"demo","version":"0.0.5"}"#.as_slice(),
),
("lib/kmp/android/demo.aar", b"aar".as_slice()),
] {
zip.start_file(name, zip::write::SimpleFileOptions::default())
.unwrap();
zip.write_all(bytes).unwrap();
}
zip.finish().unwrap();
PreparedSdk::prepare(&zip_path).unwrap()
}
#[test]
fn coordinates_fall_back_from_kmp_to_android_to_project() {
let sdk = sdk();
let base = config("");
let resolved = coordinates(&base, &sdk).unwrap();
assert_eq!(resolved.group, "com.example");
assert_eq!(resolved.artifact_base, "demo-kmp");
let android = config("[publish.android.maven]\ngroup_id='com.android'\n");
let resolved = coordinates(&android, &sdk).unwrap();
assert_eq!(resolved.group, "com.android");
let kmp = config("[publish.kmp.maven]\ngroup_id='com.kmp'\nartifact_id='custom-kmp'\n");
let resolved = coordinates(&kmp, &sdk).unwrap();
assert_eq!(resolved.group, "com.kmp");
assert_eq!(resolved.artifact_base, "custom-kmp");
}
#[test]
fn rejects_mismatched_project_and_invalid_coordinates() {
let sdk = sdk();
let config: toml::Value =
toml::from_str("[project]\nname='other'\nversion='0.0.5'\ngroup_id='com.example'\n")
.unwrap();
assert!(coordinates(&config, &sdk)
.unwrap_err()
.to_string()
.contains("does not match"));
let config: toml::Value =
toml::from_str("[project]\nname='demo'\nversion='0.0.5'\ngroup_id='../bad'\n").unwrap();
assert!(coordinates(&config, &sdk).is_err());
}
#[test]
fn pom_carries_dependencies_and_escapes_values() {
let pom = pom_xml(
"demo",
"android",
"com.example",
"demo-kmp-android",
"0.0.5",
"aar",
&[Dependency {
group: "org.example".into(),
artifact: "dep".into(),
version: "1.2.3".into(),
}],
);
assert!(pom.contains("<packaging>aar</packaging>"));
assert!(pom.contains("<groupId>org.example</groupId>"));
assert!(pom.contains("<scope>compile</scope>"));
assert!(maven::xml_escape("a<b&c").contains("<"));
}
}