use std::{
fmt::Write,
fs,
path::{Path, PathBuf},
};
use semver::Version;
use serde::{Deserialize, Serialize};
use crate::{
detect,
errors::{ReleaseError, Result},
workspace,
};
use jj_release_changelog::ChangelogConfig;
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(default)]
pub struct Config {
pub release: ReleaseConfig,
pub bump: BumpConfig,
pub publish: PublishConfig,
pub changelog: ChangelogConfig,
pub manifest_backend: String,
pub workspace: Option<WorkspaceConfig>,
pub replacements: Vec<Replacement>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct AurConfig {
pub package: String,
#[serde(default)]
pub repo: Option<String>,
#[serde(default, alias = "required")]
pub fail_on_error: bool,
}
impl AurConfig {
#[cfg(feature = "publish-aur")]
pub(crate) fn repo_url(&self) -> String {
self.repo
.clone()
.unwrap_or_else(|| format!("ssh://aur@aur.archlinux.org/{}.git", self.package))
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CoprConfig {
pub project: String,
pub spec: PathBuf,
#[serde(default)]
pub wait: bool,
#[serde(default, alias = "required")]
pub fail_on_error: bool,
#[serde(default = "default_true")]
pub update_local: bool,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[non_exhaustive]
#[serde(default)]
pub struct ReleaseConfig {
pub trigger: String,
pub tag_prefix: String,
pub bookmark: String,
pub forge: String,
pub forge_url: String,
pub create_release: bool,
}
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
#[serde(default)]
pub struct BumpConfig {
pub force: Option<String>,
pub pre: Option<String>,
pub features_bump_patch_before_1_0: bool,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[non_exhaustive]
#[serde(default)]
pub struct PublishConfig {
pub cargo: bool,
pub cargo_flags: Vec<String>,
pub semver_checks: bool,
pub semver_checks_upgrade_major: bool, pub aur: Option<AurConfig>,
pub copr: Option<CoprConfig>,
}
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum Versioning {
#[default]
Unified,
Independent,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[non_exhaustive]
#[serde(default)]
pub struct WorkspaceMember {
pub name: String,
pub path: String,
pub publish: bool,
pub depends_on: Vec<String>,
pub tag_prefix: Option<String>,
}
impl Default for WorkspaceMember {
fn default() -> Self {
Self {
name: String::new(),
path: String::new(),
publish: true,
depends_on: vec![],
tag_prefix: None,
}
}
}
#[derive(Debug, Clone, Serialize, Deserialize, Default)]
#[non_exhaustive]
#[serde(default)]
pub struct WorkspaceConfig {
pub enabled: bool,
pub versioning: Versioning,
pub members: Vec<WorkspaceMember>,
}
impl Default for Config {
fn default() -> Self {
Self {
release: ReleaseConfig::default(),
bump: BumpConfig::default(),
publish: PublishConfig::default(),
changelog: ChangelogConfig::default(),
manifest_backend: "cargo".to_owned(),
workspace: None,
replacements: vec![],
}
}
}
impl Default for ReleaseConfig {
fn default() -> Self {
Self {
trigger: "Release: please".to_owned(),
tag_prefix: "v".to_owned(),
bookmark: "main".to_owned(),
forge: "github".to_owned(),
forge_url: String::new(),
create_release: false,
}
}
}
impl Default for PublishConfig {
fn default() -> Self {
Self {
cargo: false,
cargo_flags: vec![],
semver_checks: true,
semver_checks_upgrade_major: false,
aur: None,
copr: None,
}
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[non_exhaustive]
pub struct Replacement {
pub file: String,
pub search: String,
pub replace: String,
#[serde(default = "default_true")]
pub exactly_one: bool,
}
const fn default_true() -> bool {
true
}
pub fn load(root: &Path) -> Result<Config> {
let path = root.join("release.toml");
if !path.exists() {
return Ok(Config::default());
}
let raw = fs::read_to_string(&path)
.map_err(|e| ReleaseError::Message(format!("reading {}: {e}", path.display())))?;
toml::from_str(&raw)
.map_err(|e| ReleaseError::Message(format!("parsing {}: {e}", path.display())))
}
impl Config {
#[must_use]
pub fn tag_name(&self, version: &Version) -> String {
format!("{}{version}", self.release.tag_prefix)
}
}
#[must_use]
pub fn generate_release_toml(root: &Path, tags: &[String]) -> String {
let forge = detect::detect_forge(root).unwrap_or("github");
let language = detect::detect_language(root).unwrap_or("cargo");
let mut content = format!(
r#"# Generated by jj-release
manifest_backend = "{language}"
[release]
forge = "{forge}"
create_release = false
[publish]
cargo = false
# [bump]
# features_bump_patch_before_1_0 = true
[changelog]
enabled = true
strict = true
file = "CHANGELOG.md"
# emoji_headers = true
# link_headers = true
# layout = "per-member" # "root" (default) or "both"
# exclude_prefixes = ["chore", "ci", "test"]
# [changelog.prefix_mapping]
# security = "Security"
# doc = "Documentation"
# [[replacements]]
# file = "README.md"
# search = 'your-crate = ".*"'
# replace = 'your-crate = "{{{{version}}}}"'
# [publish.aur]
# package = "my-package"
# fail_on_error = false
# [publish.copr]
# Required: your COPR project as owner/project
# project = "your-username/my-cli-tool"
# update_local = true # bump local versions
# fail_on_error = false
# Required: path to the spec, relative to the repo root
# spec = "packaging/rust-my-cli-tool.spec"
# Optional: wait for the COPR build to finish (default: false)
# wait = true
"#
);
if let Ok(Some(ws)) = workspace::detect_workspace(root) {
let versioning = match ws.versioning {
Versioning::Independent => "independent",
Versioning::Unified => "unified",
};
let mut member_config = String::new();
for member in &ws.members {
let _ = write!(
member_config,
"\n[[workspace.members]]\nname = \"{}\"\npath = \"{}\"\n",
member.name, member.path
);
if !member.publish {
member_config.push_str("publish = false\n");
}
if !member.depends_on.is_empty() {
let deps: Vec<String> = member
.depends_on
.iter()
.map(|d| format!("\"{d}\""))
.collect();
let _ = writeln!(member_config, "depends_on = [{}]", deps.join(", "));
}
if versioning == "independent" {
let prefix = workspace::detect_tag_prefix(member, tags)
.unwrap_or_else(|| format!("{}-v", member.name));
let _ = writeln!(member_config, "tag_prefix = {prefix:?}");
}
}
let _ = write!(
content,
"\n[workspace]\nenabled = true\nversioning = \"{versioning}\"\n{member_config}"
);
}
content
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn defaults_are_sane() {
let cfg = Config::default();
assert_eq!(cfg.release.trigger, "Release: please");
assert_eq!(cfg.release.tag_prefix, "v");
assert_eq!(cfg.release.bookmark, "main");
assert!(!cfg.publish.cargo);
}
#[test]
fn tag_name_format() {
let cfg = Config::default();
let v = Version::parse("1.2.3").unwrap();
assert_eq!(cfg.tag_name(&v), "v1.2.3");
}
#[test]
fn parse_minimal_toml() {
let raw = r#"
[release]
trigger = "Ship it"
forge = "github"
[publish]
cargo = false
"#;
let cfg: Config = toml::from_str(raw).unwrap();
assert_eq!(cfg.release.trigger, "Ship it");
assert!(!cfg.publish.cargo);
assert_eq!(cfg.release.forge, "github");
assert_eq!(cfg.release.tag_prefix, "v");
}
#[test]
fn parse_forge_config() {
let raw = r#"
[release]
forge = "github"
"#;
let cfg: Config = toml::from_str(raw).unwrap();
assert_eq!(cfg.release.forge, "github");
}
#[test]
fn defaults_to_github_forge_no_release() {
let cfg = Config::default();
assert_eq!(cfg.release.forge, "github");
assert!(!cfg.release.create_release);
}
#[test]
fn member_tag_prefix_defaults_to_none() {
let m = WorkspaceMember::default();
assert!(m.tag_prefix.is_none());
}
#[test]
fn parse_member_tag_prefix() {
let raw = r#"
[workspace]
enabled = true
versioning = "independent"
[[workspace.members]]
name = "mylib"
path = "lib"
publish = true
tag_prefix = "mylib-v"
"#;
let cfg: Config = toml::from_str(raw).unwrap();
let member = &cfg.workspace.unwrap().members[0];
assert_eq!(member.tag_prefix.as_deref(), Some("mylib-v"));
}
#[test]
fn generate_release_toml_contains_forge() {
let dir = tempfile::tempdir().unwrap();
let tags: Vec<String> = ["globset-0.4.21", "grep-0.4.1", "grep-cli-0.1.12", "15.2.0"]
.map(String::from)
.to_vec();
let toml = generate_release_toml(dir.path(), &tags);
assert!(toml.contains("forge ="));
assert!(toml.contains("create_release = false"));
}
#[test]
fn generate_release_toml_detects_workspace() {
let dir = tempfile::tempdir().unwrap();
let tags: Vec<String> = ["v-0.4.21", "v-0.4.1", "v-0.1.12", "v-15.2.0"]
.map(String::from)
.to_vec();
fs::write(dir.path().join("Cargo.toml"), "[workspace]\nmembers = []\n").unwrap();
let toml = generate_release_toml(dir.path(), &tags);
assert!(toml.contains("[workspace]"));
assert!(toml.contains("enabled = true"));
}
#[test]
fn generated_toml_sets_top_level_manifest_backend() {
let dir = tempfile::tempdir().unwrap();
fs::write(dir.path().join("package.json"), "{}").unwrap();
let cfg: Config = toml::from_str(&generate_release_toml(dir.path(), &[])).unwrap();
assert_eq!(cfg.manifest_backend, "npm");
}
#[test]
fn resolves_glob_members_under_crates() {
let dir = tempfile::tempdir().unwrap();
fs::write(
dir.path().join("Cargo.toml"),
"[workspace]\nmembers = [\"crates/*\"]\nexclude = [\"crates/scratch\"]\nresolver = \"2\"\n",
).unwrap();
let crate_toml = |name: &str, extra: &str| {
format!(
"[package]\nname = \"{name}\"\nversion = \"0.1.0\"\nedition = \"2021\"\n{extra}"
)
};
for (dir_name, manifest) in [
("core", crate_toml("core", "")),
(
"cli",
crate_toml("cli", "\n[dependencies]\ncore = { path = \"../core\" }\n"),
),
("xtask", crate_toml("xtask", "publish = false\n")),
("scratch", crate_toml("scratch", "")),
] {
let d = dir.path().join("crates").join(dir_name);
fs::create_dir_all(d.join("src")).unwrap();
fs::write(d.join("Cargo.toml"), manifest).unwrap();
fs::write(d.join("src/lib.rs"), "").unwrap();
}
let mut members =
workspace::parse_workspace_members(&dir.path().join("Cargo.toml")).unwrap();
members.sort_by(|a, b| a.name.cmp(&b.name));
let names: Vec<&str> = members.iter().map(|m| m.name.as_str()).collect();
assert_eq!(names, ["cli", "core", "xtask"]); let cli = members.iter().find(|m| m.name == "cli").unwrap();
assert_eq!(cli.path, "crates/cli");
assert_eq!(cli.depends_on, ["core"]);
assert!(!members.iter().find(|m| m.name == "xtask").unwrap().publish);
}
#[test]
fn missing_changelog_file_uses_default() {
let dir = tempfile::tempdir().unwrap();
std::fs::write(
dir.path().join("release.toml"),
"[changelog]\nenabled = true\nstrict = true\n",
)
.unwrap();
let cfg = load(dir.path()).unwrap();
assert_eq!(cfg.changelog.file, "CHANGELOG.md");
}
}