use std::{fs, path::Path};
use semver::Version;
use serde::{Deserialize, Serialize};
use crate::errors::{ReleaseError, Result};
#[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>,
}
#[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>,
}
#[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, }
#[derive(Debug, Clone, Serialize, Deserialize)]
#[non_exhaustive]
#[serde(default)]
pub struct ChangelogConfig {
pub enabled: bool,
pub file: String,
pub require_tag: bool,
}
#[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,
}
}
}
impl Default for ChangelogConfig {
fn default() -> Self {
Self {
enabled: true,
file: "CHANGELOG.md".to_owned(),
require_tag: true,
}
}
}
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,
}
}
}
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)
}
}
#[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"));
}
}