use std::collections::{BTreeMap, BTreeSet};
use clap::Args;
use semver::Version;
use serde_json::json;
use super::add;
use super::changelog;
use super::ci;
use super::config::{
enforce_tool_version, load_config, require_config, tag_managed_ids, LoadedConfig,
};
use super::git::{BlobKind, Commit, Git, Op};
use super::github::{self, Look};
use super::handoff;
use super::preconditions::{self, PendingRelease, TagEvaluation};
use super::repository;
use super::tags::{self, Advertised};
use super::template::load_template_body;
use super::CliError;
use super::{deliver_out, say_err, say_out};
const DEFAULT_SINGLE: &str = "v{{ version }}";
const DEFAULT_MULTI: &str = "{{ package }}/v{{ version }}";
#[derive(Debug, Args)]
pub(super) struct ReleaseArgs {
#[arg(long, value_name = "REF")]
from: Option<String>,
}
#[derive(Debug)]
struct PlannedTag {
package: String,
version: Version,
changelog: String,
name: String,
commit: Commit,
resumed: bool,
}
#[derive(Clone, Copy)]
enum Progress {
Tagged,
Pushed,
PushUnverified,
Released,
}
#[derive(Clone, Copy)]
struct HaveRemote(bool);
#[derive(Clone, Copy)]
struct HaveToken(bool);
#[derive(Debug)]
enum ReleaseDecision {
NothingToRelease,
Refused(CliError),
Proceed(ReleasePlan),
}
#[derive(Debug)]
struct ReleasePlan {
planned: Vec<PlannedTag>,
advertised: Advertised,
owner: String,
repo_name: String,
remote: String,
}
struct ReleaseReadiness {
had_planned_before_resume: bool,
resumable: Vec<ExistingTag>,
have_remote: HaveRemote,
have_token: HaveToken,
remote: Option<String>,
token: Option<String>,
planned: Vec<PlannedTag>,
advertised: Advertised,
preflight_error: Option<CliError>,
skip_ci_error: Option<CliError>,
worktree_dirty: bool,
owner: Option<String>,
repo_name: Option<String>,
}
fn decide_release(readiness: ReleaseReadiness) -> ReleaseDecision {
if !readiness.had_planned_before_resume {
if !readiness.resumable.is_empty() {
if let Err(err) = refuse_without_a_look(readiness.have_remote, readiness.have_token) {
return ReleaseDecision::Refused(err);
}
}
if readiness.remote.is_none() || readiness.token.is_none() {
return ReleaseDecision::NothingToRelease;
}
}
if let Some(err) = readiness.preflight_error {
return ReleaseDecision::Refused(err);
}
if readiness.planned.is_empty() {
return ReleaseDecision::NothingToRelease;
}
if let Some(err) = readiness.skip_ci_error {
return ReleaseDecision::Refused(err);
}
if readiness.worktree_dirty {
return ReleaseDecision::Refused(CliError::new(
"working tree is dirty; commit or stash before releasing",
));
}
let (Some(owner), Some(repo_name), Some(remote)) =
(readiness.owner, readiness.repo_name, readiness.remote)
else {
return ReleaseDecision::Refused(CliError::new(
"internal error: release plan missing GitHub coordinates",
));
};
ReleaseDecision::Proceed(ReleasePlan {
planned: readiness.planned,
advertised: readiness.advertised,
owner,
repo_name,
remote,
})
}
fn apply_decision(
decision: ReleaseDecision,
git: &Git,
token: Option<String>,
) -> Result<(), CliError> {
match decision {
ReleaseDecision::NothingToRelease => {
say_out("nothing to release");
Ok(())
}
ReleaseDecision::Refused(err) => Err(err),
ReleaseDecision::Proceed(plan) => {
let token = token
.ok_or_else(|| CliError::new("`oakum release` needs GITHUB_TOKEN or GH_TOKEN"))?;
let client = github::Client::new(token)?;
act(
git,
&client,
&plan.owner,
&plan.repo_name,
&plan.remote,
&plan.planned,
&plan.advertised,
)
}
}
}
fn refuse_without_a_look(remote: HaveRemote, token: HaveToken) -> Result<(), CliError> {
let absent: Vec<&str> = [
(!remote.0).then_some("this repository has no remote"),
(!token.0).then_some("GITHUB_TOKEN and GH_TOKEN are both unset"),
]
.into_iter()
.flatten()
.collect();
if absent.is_empty() {
return Ok(());
}
Err(CliError::unverified(format!(
"unverified: a tagged version has no local plan, and {}, so oakum could \
not ask GitHub whether it is missing its release",
absent.join(", and ")
)))
}
struct ExistingTag {
item: PendingRelease,
name: String,
commit: Commit,
}
fn existing_tags(
repo: &repository::Repository,
git: &Git,
evaluation: &TagEvaluation,
) -> Result<Vec<ExistingTag>, CliError> {
let template = tag_template(repo)?;
let mut found = Vec::new();
for item in evaluation.current() {
let name = render_tag(&template, &item)?;
if let Some(commit) = local_tag_commit(git, &name)? {
found.push(ExistingTag { item, name, commit });
}
}
Ok(found)
}
pub(super) fn run(args: &ReleaseArgs) -> Result<(), CliError> {
let repo = repository::discover().map_err(CliError::from_boxed)?;
let config = load_config(&repo).map_err(CliError::from_boxed)?;
require_config(&config)?;
enforce_tool_version(&config).map_err(CliError::from_boxed)?;
let git = Git::at_repository(&repo).map_err(CliError::from_boxed)?;
let evaluation = preconditions::evaluate(&git, &repo, args.from.as_deref())?;
let pending = evaluation.pending();
let planned_before_resume = if pending.is_empty() {
Vec::new()
} else {
plan_tags(&repo, &git, &pending)?
};
let resumable = existing_tags(&repo, &git, &evaluation)?;
let remote = tags::first_remote(&git)?;
refuse_unread_tags(&repo, &git, &pending, remote.as_deref())?;
let token = github::token();
let have_remote = HaveRemote(remote.is_some());
let have_token = HaveToken(token.is_some());
let slug = match (remote.as_ref(), token.as_ref()) {
(Some(remote), Some(_)) => Some(ci::repository_slug_from(&git, remote)),
_ => None,
};
let (owner, repo_name) = match &slug {
Some(Ok((owner, repo_name))) => (Some(owner.clone()), Some(repo_name.clone())),
_ => (None, None),
};
let had_planned_before_resume = !planned_before_resume.is_empty();
let worktree_dirty = worktree_is_dirty(&git)?;
if had_planned_before_resume && worktree_dirty {
return Err(CliError::new(
"working tree is dirty; commit or stash before releasing",
));
}
let mut planned = planned_before_resume;
planned.extend(resume_candidates(&repo, &resumable, &planned)?);
let (planned, advertised, preflight_error) = if planned.is_empty() {
(planned, Advertised::default(), None)
} else if remote.is_none() {
(
planned,
Advertised::default(),
Some(CliError::unverified(
"unverified: this repository has no remotes to push tags to",
)),
)
} else if token.is_none() {
(
planned,
Advertised::default(),
Some(CliError::new(
"`oakum release` needs GITHUB_TOKEN or GH_TOKEN",
)),
)
} else if let Some(Err(err)) = slug {
(planned, Advertised::default(), Some(unverified_look(&err)))
} else {
let remote = remote.clone().expect("checked above");
let token = token.clone().expect("checked above");
let owner = owner.clone().expect("slug succeeded");
let repo_name = repo_name.clone().expect("slug succeeded");
let client = github::Client::new(token)?;
match preflight(&git, &client, &owner, &repo_name, &remote, planned) {
Ok((planned, advertised)) => (planned, advertised, None),
Err(err) => (Vec::new(), Advertised::default(), Some(err)),
}
};
let skip_ci_error = refuse_skip_ci(&git, &planned).err();
let readiness = ReleaseReadiness {
had_planned_before_resume,
resumable,
have_remote,
have_token,
remote,
token: token.clone(),
planned,
advertised,
preflight_error,
skip_ci_error,
worktree_dirty,
owner,
repo_name,
};
apply_decision(decide_release(readiness), &git, token)
}
fn plan_tags(
repo: &repository::Repository,
git: &Git,
items: &[PendingRelease],
) -> Result<Vec<PlannedTag>, CliError> {
let config = load_config(repo).map_err(CliError::from_boxed)?;
let workspace = add::discover_workspace(repo).map_err(CliError::from_boxed)?;
config.validate_workspace_selection(&workspace)?;
let bare_candidates = tag_managed_ids(&workspace, &config);
let template = tag_template_for(repo, &config, bare_candidates.len())?;
let head = git.head()?;
let mut rendered = Vec::new();
let mut names = BTreeSet::new();
for item in items {
let name = render_tag(&template, item)?;
if !names.insert(name.clone()) {
return Err(CliError::new(format!(
"tag-format rendered `{name}` for more than one package"
)));
}
valid_tag_name(git, &name)?;
rendered.push((item, name));
}
let mut planned = Vec::new();
for (item, name) in rendered {
readable_for_package(&workspace, item, &name, |id| bare_candidates.contains(id))?;
planned.push(PlannedTag {
package: item.id().name.clone(),
version: item.version().clone(),
changelog: changelog_path_for(&workspace, item)?,
name,
commit: head.clone(),
resumed: false,
});
}
Ok(planned)
}
fn resume_candidates(
repo: &repository::Repository,
resumable: &[ExistingTag],
already: &[PlannedTag],
) -> Result<Vec<PlannedTag>, CliError> {
let config = load_config(repo).map_err(CliError::from_boxed)?;
let planned: BTreeSet<&str> = already.iter().map(|tag| tag.name.as_str()).collect();
let workspace = add::discover_workspace(repo).map_err(CliError::from_boxed)?;
config.validate_workspace_selection(&workspace)?;
let bare_candidates = tag_managed_ids(&workspace, &config);
let mut extra = Vec::new();
for candidate in resumable {
if planned.contains(candidate.name.as_str()) {
continue;
}
readable_for_package(&workspace, &candidate.item, &candidate.name, |id| {
bare_candidates.contains(id)
})?;
extra.push(PlannedTag {
package: candidate.item.id().name.clone(),
version: candidate.item.version().clone(),
changelog: changelog_path_for(&workspace, &candidate.item)?,
name: candidate.name.clone(),
commit: candidate.commit.clone(),
resumed: true,
});
}
Ok(extra)
}
fn tag_template(repo: &repository::Repository) -> Result<String, CliError> {
let config = load_config(repo).map_err(CliError::from_boxed)?;
let workspace = add::discover_workspace(repo).map_err(CliError::from_boxed)?;
config.validate_workspace_selection(&workspace)?;
tag_template_for(repo, &config, tag_managed_ids(&workspace, &config).len())
}
pub(super) const fn default_tag_template(managed_count: usize) -> &'static str {
if managed_count <= 1 {
DEFAULT_SINGLE
} else {
DEFAULT_MULTI
}
}
fn tag_template_for(
repo: &repository::Repository,
config: &LoadedConfig,
managed_count: usize,
) -> Result<String, CliError> {
let default = default_tag_template(managed_count);
match config.tag_format() {
Some(source) => {
load_template_body(repo.dir(), repo.path(), source).map_err(CliError::from_boxed)
}
None => Ok(default.to_owned()),
}
}
fn render_tag(template: &str, item: &PendingRelease) -> Result<String, CliError> {
render_tag_for(template, &item.id().name, item.version())
}
fn tag_context(package: &str, version: &Version) -> serde_json::Value {
json!({
"package": package,
"version": version.to_string(),
})
}
fn render_tag_for(template: &str, package: &str, version: &Version) -> Result<String, CliError> {
let rendered = oakum::template::render("tag-format", template, tag_context(package, version))
.map_err(|err| CliError::new(err.to_string()))?;
let rendered = rendered.trim();
if rendered.is_empty() {
return Err(CliError::new("tag-format rendered an empty string"));
}
if rendered.chars().any(char::is_whitespace) {
return Err(CliError::new(format!(
"tag-format rendered whitespace: {rendered:?}"
)));
}
Ok(rendered.to_owned())
}
fn changelog_path_for(
workspace: &oakum::plan::Workspace,
item: &PendingRelease,
) -> Result<String, CliError> {
let package = workspace.get(item.id()).ok_or_else(|| {
CliError::new(format!(
"{} is planned for release but not in the workspace",
item.id().name
))
})?;
Ok(changelog::changelog_repo_path(package))
}
struct OwedRelease<'a> {
tag: &'a PlannedTag,
body: String,
notice: Option<String>,
}
fn load_release_bodies<'a>(
git: &Git,
planned: &'a [PlannedTag],
) -> Result<Vec<OwedRelease<'a>>, CliError> {
planned
.iter()
.map(|tag| {
let (body, notice) = release_body(git, tag)?.resolve(tag);
Ok(OwedRelease { tag, body, notice })
})
.collect()
}
enum BodySource {
Section(String),
NoChangelog,
Symlink { target: String },
EmptySection,
NoHeading,
}
impl BodySource {
fn resolve(self, tag: &PlannedTag) -> (String, Option<String>) {
let (path, at) = (tag.changelog.as_str(), tag.commit.as_str());
let remedy = match &self {
Self::NoHeading => " (run `oakum version` before releasing, or add the section)",
_ => "",
};
let why = match self {
Self::Section(section) => return (format!("{section}\n"), None),
Self::NoChangelog => format!("no {path} at {at}"),
Self::Symlink { target } => format!("{path} at {at} is a symlink to `{target}`"),
Self::EmptySection => format!("{path} has an empty {} section", tag.version),
Self::NoHeading => format!("{path} has no `## {}` heading", tag.version),
};
(
format!("{} {}\n", tag.package, tag.version),
Some(format!("release body: {why}; using the title{remedy}")),
)
}
}
fn release_body(git: &Git, tag: &PlannedTag) -> Result<BodySource, CliError> {
let path = tag.changelog.as_str();
let commit = &tag.commit;
let read_failed = |err: CliError| {
CliError::new(format!(
"could not read {path} at {} for the release body: {}; no tag was created",
commit.as_str(),
err.detail()
))
};
match git.blob_kind(commit, path).map_err(read_failed)? {
BlobKind::Absent => return Ok(BodySource::NoChangelog),
BlobKind::Symlink(target) => return Ok(BodySource::Symlink { target }),
BlobKind::Other => {}
}
let text = git
.raw_text(Op::BlobText { commit, path })
.map_err(read_failed)?;
Ok(match changelog::version_section(&text, &tag.version) {
Some(section) if !section.is_empty() => BodySource::Section(section),
Some(_) => BodySource::EmptySection,
None => BodySource::NoHeading,
})
}
fn readable_for_package(
workspace: &oakum::plan::Workspace,
item: &PendingRelease,
name: &str,
bare_candidate: impl Fn(&oakum::plan::PackageId) -> bool,
) -> Result<(), CliError> {
match oakum::tags::resolve_commit_tags(&[name], workspace, bare_candidate) {
Ok(map) => match map.get(item.id()) {
Some(version) if version == item.version() => Ok(()),
Some(version) => Err(CliError::new(format!(
"tag-format rendered `{name}` as {} {version}, not {} {}",
item.id().name,
item.id().name,
item.version()
))),
None => Err(CliError::new(format!(
"tag-format rendered `{name}`, which is not a readable tag for {}",
item.id().name
))),
},
Err(_) => Err(CliError::new(format!(
"tag-format rendered `{name}`, which later check would treat as leftover"
))),
}
}
fn refuse_unread_tags(
repo: &repository::Repository,
git: &Git,
pending: &[PendingRelease],
remote: Option<&str>,
) -> Result<(), CliError> {
let config = load_config(repo).map_err(CliError::from_boxed)?;
let workspace = add::discover_workspace(repo).map_err(CliError::from_boxed)?;
config.validate_workspace_selection(&workspace)?;
let bare_candidates = tag_managed_ids(&workspace, &config);
let template = tag_template_for(repo, &config, bare_candidates.len())?;
let listed = tags::all_tag_objects(git)?;
let reachable = tags::reachable_tag_names(git)?;
let local_names: BTreeSet<&str> = listed.iter().map(|(name, _)| name.as_str()).collect();
let pending_ids: BTreeSet<_> = pending.iter().map(PendingRelease::id).collect();
let local_resolved = resolve_tag_names(
listed.iter().map(|(name, _)| name.as_str()),
&workspace,
|id| bare_candidates.contains(id),
);
let mut advertised = None;
for package in workspace
.packages()
.filter(|package| bare_candidates.contains(package.id()))
{
if pending_ids.contains(package.id()) {
continue;
}
refuse_unread_for_package(
&mut UnreadTagScan {
git,
template: &template,
listed: &listed,
reachable: &reachable,
local_names: &local_names,
local_resolved: &local_resolved,
workspace: &workspace,
bare_candidates: &bare_candidates,
remote,
advertised: &mut advertised,
},
package,
)?;
}
Ok(())
}
struct UnreadTagScan<'a> {
git: &'a Git,
template: &'a str,
listed: &'a [(String, String)],
reachable: &'a BTreeSet<String>,
local_names: &'a BTreeSet<&'a str>,
local_resolved: &'a ResolvedTags,
workspace: &'a oakum::plan::Workspace,
bare_candidates: &'a BTreeSet<oakum::plan::PackageId>,
remote: Option<&'a str>,
advertised: &'a mut Option<(tags::Advertised, ResolvedTags)>,
}
fn refuse_unread_for_package(
ctx: &mut UnreadTagScan<'_>,
package: &oakum::plan::Package,
) -> Result<(), CliError> {
let package_name = &package.id().name;
let version = package.version();
let rendered = render_tag_for(ctx.template, package_name, version)?;
if let Some((_, object)) = ctx.listed.iter().find(|(name, _)| *name == rendered) {
if ctx.reachable.contains(&rendered) {
return Ok(());
}
return Err(match local_tag_commit(ctx.git, &rendered)? {
Some(commit) => CliError::unverified(format!(
"unverified: tag `{rendered}` for {package_name} {version} points at \
`{}` on history unreachable from HEAD, so the release scan never \
read it; merge that history or move the tag",
commit.as_str()
)),
None => CliError::unverified(format!(
"unverified: tag `{rendered}` for {package_name} {version} names \
object `{object}`, which cannot be read; the repository is corrupt \
where the release state would be"
)),
});
}
if let Some(err) = scan_resolved_tags(
ctx.local_resolved,
package.id(),
version,
|name| ctx.reachable.contains(name),
|name| {
CliError::unverified(format!(
"unverified: tag-format renders `{rendered}` for {package_name} \
{version}, but the tag that exists for that version is \
`{name}`; the resume asks only about `{rendered}`, so \
reconcile the tag-format with the existing tags"
))
},
|name| {
CliError::unverified(format!(
"unverified: tag `{name}` looks like a version but could not \
be attributed to a package, and it sits outside reachable \
history, so its release state was never read; reconcile or \
delete the tag"
))
},
) {
return Err(err);
}
let Some(remote) = ctx.remote else {
return Ok(());
};
if ctx.advertised.is_none() {
let commits = tags::remote_tag_commits(ctx.git, remote)?;
let remote_resolved = resolve_tag_names(
commits.tag_names().map(str::to_owned),
ctx.workspace,
|id| ctx.bare_candidates.contains(id),
);
*ctx.advertised = Some((commits, remote_resolved));
}
let (advertised_map, remote_resolved) = ctx.advertised.as_ref().expect("consulted above");
if advertised_map.contains_tag(&rendered) {
return Err(CliError::unverified(format!(
"unverified: tag `{rendered}` for {package_name} {version} exists on \
remote {remote:?} but not locally, so the release scan never read it; \
run `git fetch {remote} tag {rendered}` and rerun"
)));
}
if let Some(err) = scan_resolved_tags(
remote_resolved,
package.id(),
version,
|name| ctx.local_names.contains(name),
|name| {
CliError::unverified(format!(
"unverified: remote {remote:?} has tag `{name}`, which names \
{package_name} {version}, but the tag-format renders \
`{rendered}`; the release scan never read it — fetch it \
(`git fetch {remote} tag {name}`) or reconcile the tag-format"
))
},
|name| {
CliError::unverified(format!(
"unverified: remote {remote:?} has tag `{name}`, which looks \
like a version but could not be attributed to a package; the \
release scan never read it — fetch it (`git fetch {remote} \
tag {name}`) or reconcile the tag names"
))
},
) {
return Err(err);
}
Ok(())
}
type ResolvedTags = Vec<(
String,
Result<BTreeMap<oakum::plan::PackageId, Version>, ()>,
)>;
fn resolve_tag_names(
names: impl IntoIterator<Item = impl Into<String>>,
workspace: &oakum::plan::Workspace,
bare_candidate: impl Fn(&oakum::plan::PackageId) -> bool,
) -> ResolvedTags {
names
.into_iter()
.map(|name| {
let name = name.into();
let resolved = oakum::tags::resolve_commit_tags(&[&name], workspace, &bare_candidate)
.map_err(|_| ());
(name, resolved)
})
.collect()
}
fn scan_resolved_tags(
tags: &ResolvedTags,
package_id: &oakum::plan::PackageId,
version: &Version,
excuse: impl Fn(&str) -> bool,
on_mismatch: impl Fn(&str) -> CliError,
on_unattributable: impl Fn(&str) -> CliError,
) -> Option<CliError> {
for (name, resolved) in tags {
match resolved {
Ok(map) if map.get(package_id) == Some(version) => {
return Some(on_mismatch(name));
}
Ok(_) => {}
Err(()) if excuse(name) => {}
Err(()) => return Some(on_unattributable(name)),
}
}
None
}
fn valid_tag_name(git: &Git, name: &str) -> Result<(), CliError> {
if name.starts_with('-') {
return Err(CliError::new(format!(
"tag-format rendered an invalid git ref: {name:?}"
)));
}
if git.predicate(Op::ValidRefName { reference: name })? {
return Ok(());
}
Err(CliError::new(format!(
"tag-format rendered an invalid git ref: {name:?}"
)))
}
fn preflight(
git: &Git,
client: &github::Client,
owner: &str,
name: &str,
remote: &str,
planned: Vec<PlannedTag>,
) -> Result<(Vec<PlannedTag>, Advertised), CliError> {
let mut owed = Vec::new();
for tag in planned {
match client.release_for_tag(owner, name, &tag.name)? {
Look::Empty => owed.push(tag),
Look::Found(_) if tag.resumed => {}
Look::Found(release) => {
return Err(CliError::new(format!(
"GitHub already has a release for `{}` ({})",
tag.name, release.html_url
)));
}
}
}
if owed.is_empty() {
return Ok((owed, Advertised::default()));
}
let advertised = tags::remote_tag_commits(git, remote)?;
for tag in &owed {
if !advertised.points_at(&tag.name, &tag.commit) {
if let Some(existing) = advertised.get(&tag.name) {
return Err(CliError::new(format!(
"remote {remote:?} already has tag `{}` at `{}`, not `{}`",
tag.name,
existing.as_str(),
tag.commit.as_str()
)));
}
}
if let Some(existing) = local_tag_commit(git, &tag.name)? {
if existing != tag.commit {
return Err(CliError::new(format!(
"local tag `{}` points at `{}`, not `{}`",
tag.name,
existing.as_str(),
tag.commit.as_str()
)));
}
}
}
Ok((owed, advertised))
}
fn act(
git: &Git,
client: &github::Client,
owner: &str,
name: &str,
remote: &str,
planned: &[PlannedTag],
advertised: &Advertised,
) -> Result<(), CliError> {
let owed = load_release_bodies(git, planned)?;
let mut completed = Vec::new();
let mut handoff = handoff::Handoff::open(
client,
owner,
name,
git,
planned.iter().map(|tag| &tag.commit),
)?;
for (index, release) in owed.iter().enumerate() {
let tag = release.tag;
let released = |completed: &[String], err: &CliError| {
partial_failure(completed, Some(Progress::Released), planned, index, err)
};
match release_one(git, client, owner, name, remote, release, advertised) {
Ok(did_push) => {
match handoff.confirm_push(&tag.name, &tag.commit, did_push) {
Ok(None) => {}
Ok(Some(run)) => {
if !run.html_url.is_empty() {
if let Err(err) = deliver_out(&run.html_url) {
return Err(released(
&completed,
&CliError::undelivered(
format!(
"downstream run {} found, but its URL",
run.html_url
),
&err,
),
));
}
}
let commit_recurs = planned[index + 1..]
.iter()
.any(|later| later.commit == tag.commit);
if commit_recurs {
if let Err(err) = handoff.absorb_before_next(&tag.commit) {
return Err(released(&completed, &err));
}
}
}
Err(err) => {
return Err(released(&completed, &err));
}
}
let line = format!("{} {} {}", tag.package, tag.version, tag.name);
if let Err(err) = deliver_out(&line) {
return Err(released(
&completed,
&CliError::undelivered(
format!("{} released, but the line saying so", tag.name),
&err,
),
));
}
completed.push(tag.name.clone());
}
Err((progress, err)) => {
return Err(partial_failure(&completed, progress, planned, index, &err));
}
}
}
Ok(())
}
fn release_one(
git: &Git,
client: &github::Client,
owner: &str,
name: &str,
remote: &str,
release: &OwedRelease<'_>,
advertised: &Advertised,
) -> Result<bool, (Option<Progress>, CliError)> {
let tag = release.tag;
let mut progress = None;
let remote_has_it = advertised.points_at(&tag.name, &tag.commit);
if local_tag_commit(git, &tag.name)
.map_err(|err| (progress, err))?
.is_none()
&& !remote_has_it
{
git.run(Op::AnnotatedTag {
name: &tag.name,
commit: &tag.commit,
})
.map_err(|err| (progress, err))?;
progress = Some(Progress::Tagged);
}
let did_push = !remote_has_it;
if did_push {
git.run(Op::PushTag {
remote,
tag: &tag.name,
})
.map_err(|err| push_outcome(git, remote, tag, progress, err))?;
}
progress = Some(Progress::Pushed);
let title = format!("{} {}", tag.package, tag.version);
if let Some(notice) = &release.notice {
say_err(notice);
}
let body = release.body.as_str();
let created = client
.create_release(owner, name, &tag.name, &title, body)
.map_err(|err| (progress, CliError::from(err)))?;
progress = Some(Progress::Released);
deliver_out(&created.html_url).map_err(|err| {
(
progress,
CliError::undelivered(
format!("release {} created, but its URL", created.html_url),
&err,
),
)
})?;
Ok(did_push)
}
fn push_outcome(
git: &Git,
remote: &str,
tag: &PlannedTag,
progress: Option<Progress>,
err: CliError,
) -> (Option<Progress>, CliError) {
match tags::remote_tag_commits(git, remote) {
Ok(advertised) if advertised.points_at(&tag.name, &tag.commit) => {
(Some(Progress::Pushed), err)
}
Ok(_) => (progress, err),
Err(reread) => {
let reread = reread.detail();
(
Some(Progress::PushUnverified),
CliError::unverified(format!(
"unverified: {err}; the re-read that would settle whether \
the tag landed failed too ({reread})"
)),
)
}
}
}
fn partial_failure(
completed: &[String],
progress: Option<Progress>,
planned: &[PlannedTag],
index: usize,
err: &CliError,
) -> CliError {
let current = &planned[index].name;
let remaining = if matches!(progress, Some(Progress::Released)) {
&planned[index + 1..]
} else {
&planned[index..]
};
let mut detail = String::from("release stopped; tags are not deleted.\n");
if completed.is_empty() && progress.is_none() {
detail.push_str("completed: none\n");
} else {
detail.push_str("completed:\n");
for name in completed {
detail.push_str(" ");
detail.push_str(name);
detail.push('\n');
}
if let Some(progress) = progress {
let stage = match progress {
Progress::Tagged => "tagged",
Progress::Pushed => "pushed",
Progress::PushUnverified => "tagged; whether the push landed is unverified",
Progress::Released => "released",
};
detail.push_str(" ");
detail.push_str(current);
detail.push_str(" (");
detail.push_str(stage);
detail.push_str(")\n");
}
}
if remaining.is_empty() {
detail.push_str("remaining: none\n");
} else {
detail.push_str("remaining:\n");
for tag in remaining {
detail.push_str(" ");
detail.push_str(&tag.name);
detail.push('\n');
}
}
detail.push_str(&err.detail());
err.recast(detail)
}
fn worktree_is_dirty(git: &Git) -> Result<bool, CliError> {
Ok(!git.text(Op::WorktreeStatus)?.is_empty())
}
fn refuse_skip_ci(git: &Git, planned: &[PlannedTag]) -> Result<(), CliError> {
let mut read: BTreeSet<&str> = BTreeSet::new();
for tag in planned {
if !read.insert(tag.commit.as_str()) {
continue;
}
let commit = git.commit_text(tag.commit.as_str())?;
if skip_ci(&commit.message, &commit.skip_checks) {
return Err(CliError::new(format!(
"tag `{}` would be pushed at a commit whose message carries a \
skip-ci annotation, which GitHub honours for tag pushes: the \
release workflow would never start. Land a new commit without \
the annotation (an empty one works), re-cut the tag at a \
clean commit, or start the downstream workflow by hand",
tag.name
)));
}
}
Ok(())
}
fn unverified_look(err: &CliError) -> CliError {
CliError::unverified(format!(
"unverified: {err}, so oakum could not ask GitHub whether these tags \
are released"
))
}
fn skip_ci(message: &str, trailers: &str) -> bool {
let lower = message.to_ascii_lowercase();
[
"[skip ci]",
"[ci skip]",
"[no ci]",
"[skip actions]",
"[actions skip]",
]
.iter()
.any(|needle| lower.contains(needle))
|| trailers
.lines()
.any(|value| value.trim().eq_ignore_ascii_case("true"))
}
fn local_tag_commit(git: &Git, name: &str) -> Result<Option<Commit>, CliError> {
git.tag_commit(name)
}
#[cfg(test)]
mod tests {
use super::{
decide_release, refuse_skip_ci, refuse_without_a_look, skip_ci, unverified_look,
valid_tag_name, worktree_is_dirty, Advertised, BodySource, Commit, ExistingTag, Git,
HaveRemote, HaveToken, PendingRelease, PlannedTag, ReleaseDecision, ReleaseReadiness,
Version,
};
use crate::cli::git::Reply;
use crate::cli::CliError;
#[test]
fn the_schema_names_every_variable_tag_format_renders_with() {
crate::cli::schema_names_every_variable(
"tag-format",
super::tag_context("demo", &Version::new(1, 2, 3)),
);
}
#[test]
fn decide_nothing_when_no_work_and_no_credentials() {
let decision = decide_release(ReleaseReadiness {
had_planned_before_resume: false,
resumable: Vec::new(),
have_remote: HaveRemote(false),
have_token: HaveToken(false),
remote: None,
token: None,
planned: Vec::new(),
advertised: Advertised::default(),
preflight_error: None,
skip_ci_error: None,
worktree_dirty: false,
owner: None,
repo_name: None,
});
assert!(matches!(decision, ReleaseDecision::NothingToRelease));
}
#[test]
fn decide_refuses_a_dirty_worktree_before_proceeding() {
let decision = decide_release(ReleaseReadiness {
had_planned_before_resume: true,
resumable: Vec::new(),
have_remote: HaveRemote(true),
have_token: HaveToken(true),
remote: Some(String::from("origin")),
token: Some(String::from("token")),
planned: vec![planned_tag("v0.1.1")],
advertised: Advertised::default(),
preflight_error: None,
skip_ci_error: None,
worktree_dirty: true,
owner: Some(String::from("oakoss")),
repo_name: Some(String::from("oakum")),
});
let ReleaseDecision::Refused(err) = decision else {
panic!("expected refusal, got {decision:?}");
};
assert!(err.to_string().contains("dirty"), "{err}");
}
#[test]
fn decide_refuses_on_preflight_error() {
let decision = decide_release(ReleaseReadiness {
had_planned_before_resume: true,
resumable: Vec::new(),
have_remote: HaveRemote(true),
have_token: HaveToken(true),
remote: Some(String::from("origin")),
token: Some(String::from("token")),
planned: vec![planned_tag("v0.1.1")],
advertised: Advertised::default(),
preflight_error: Some(CliError::new(
"`oakum release` needs GITHUB_TOKEN or GH_TOKEN",
)),
skip_ci_error: None,
worktree_dirty: false,
owner: Some(String::from("oakoss")),
repo_name: Some(String::from("oakum")),
});
let ReleaseDecision::Refused(err) = decision else {
panic!("expected refusal, got {decision:?}");
};
assert!(err.to_string().contains("GITHUB_TOKEN"), "{err}");
}
#[test]
fn decide_proceeds_when_readiness_is_complete() {
let decision = decide_release(ReleaseReadiness {
had_planned_before_resume: true,
resumable: Vec::new(),
have_remote: HaveRemote(true),
have_token: HaveToken(true),
remote: Some(String::from("origin")),
token: Some(String::from("token")),
planned: vec![planned_tag("v0.1.1")],
advertised: Advertised::default(),
preflight_error: None,
skip_ci_error: None,
worktree_dirty: false,
owner: Some(String::from("oakoss")),
repo_name: Some(String::from("oakum")),
});
assert!(matches!(decision, ReleaseDecision::Proceed(_)));
}
#[test]
fn decide_nothing_when_credentials_exist_but_there_is_no_work() {
let decision = decide_release(ReleaseReadiness {
had_planned_before_resume: false,
resumable: Vec::new(),
have_remote: HaveRemote(true),
have_token: HaveToken(true),
remote: Some(String::from("origin")),
token: Some(String::from("token")),
planned: Vec::new(),
advertised: Advertised::default(),
preflight_error: None,
skip_ci_error: None,
worktree_dirty: false,
owner: Some(String::from("oakoss")),
repo_name: Some(String::from("oakum")),
});
assert!(matches!(decision, ReleaseDecision::NothingToRelease));
}
#[test]
fn decide_refuses_a_resume_look_without_credentials() {
let decision = decide_release(ReleaseReadiness {
had_planned_before_resume: false,
resumable: vec![resumable_tag("v0.1.0")],
have_remote: HaveRemote(true),
have_token: HaveToken(false),
remote: Some(String::from("origin")),
token: None,
planned: Vec::new(),
advertised: Advertised::default(),
preflight_error: None,
skip_ci_error: None,
worktree_dirty: false,
owner: None,
repo_name: None,
});
let ReleaseDecision::Refused(err) = decision else {
panic!("expected refusal, got {decision:?}");
};
assert!(err.to_string().contains("GITHUB_TOKEN"), "{err}");
assert!(err.to_string().starts_with("unverified:"), "{err}");
}
#[test]
fn decide_refuses_on_skip_ci_error() {
let decision = decide_release(ReleaseReadiness {
had_planned_before_resume: true,
resumable: Vec::new(),
have_remote: HaveRemote(true),
have_token: HaveToken(true),
remote: Some(String::from("origin")),
token: Some(String::from("token")),
planned: vec![planned_tag("v0.1.1")],
advertised: Advertised::default(),
preflight_error: None,
skip_ci_error: Some(CliError::new(
"refusing to release: HEAD commit is marked skip-ci",
)),
worktree_dirty: false,
owner: Some(String::from("oakoss")),
repo_name: Some(String::from("oakum")),
});
let ReleaseDecision::Refused(err) = decision else {
panic!("expected refusal, got {decision:?}");
};
assert!(err.to_string().contains("skip-ci"), "{err}");
}
#[test]
fn decide_refuses_when_github_coordinates_are_missing() {
let decision = decide_release(ReleaseReadiness {
had_planned_before_resume: true,
resumable: Vec::new(),
have_remote: HaveRemote(true),
have_token: HaveToken(true),
remote: None,
token: Some(String::from("token")),
planned: vec![planned_tag("v0.1.1")],
advertised: Advertised::default(),
preflight_error: None,
skip_ci_error: None,
worktree_dirty: false,
owner: None,
repo_name: None,
});
let ReleaseDecision::Refused(err) = decision else {
panic!("expected refusal, got {decision:?}");
};
assert!(err.to_string().contains("GitHub coordinates"), "{err}");
}
fn planned_tag(name: &str) -> PlannedTag {
let commit = Git::answering([("rev-parse HEAD", Reply::said("cafe"))])
.head()
.expect("minted");
PlannedTag {
package: String::from("demo"),
version: Version::new(0, 1, 1),
changelog: String::from("CHANGELOG.md"),
name: String::from(name),
commit,
resumed: false,
}
}
fn resumable_tag(name: &str) -> ExistingTag {
let commit = Git::answering([("rev-parse HEAD", Reply::said("cafe"))])
.head()
.expect("minted");
ExistingTag {
item: PendingRelease::new(
oakum::plan::PackageId::new(oakum::plan::Ecosystem::Cargo, "demo"),
Version::new(0, 1, 0),
),
name: String::from(name),
commit,
}
}
#[test]
fn a_look_needs_both_a_remote_and_a_token() {
refuse_without_a_look(HaveRemote(true), HaveToken(true)).expect("both present");
let no_remote = refuse_without_a_look(HaveRemote(false), HaveToken(true))
.expect_err("a missing remote refuses");
assert!(no_remote
.to_string()
.contains("this repository has no remote"));
assert!(!no_remote.to_string().contains("GITHUB_TOKEN"));
let no_token = refuse_without_a_look(HaveRemote(true), HaveToken(false))
.expect_err("a missing token refuses");
assert!(no_token.to_string().contains("GITHUB_TOKEN and GH_TOKEN"));
assert!(!no_token.to_string().contains("has no remote"));
let neither = refuse_without_a_look(HaveRemote(false), HaveToken(false))
.expect_err("neither present refuses")
.to_string();
assert!(
neither.contains("this repository has no remote"),
"{neither}"
);
assert!(neither.contains("GITHUB_TOKEN and GH_TOKEN"), "{neither}");
}
#[test]
fn a_slug_failure_on_the_release_path_is_unverified() {
let err = unverified_look(&CliError::new("git `origin` `x` is not a github.com URL"));
assert!(matches!(err, CliError::Unverified { .. }), "{err:?}");
assert!(err.to_string().starts_with("unverified:"), "{err}");
assert!(err.to_string().contains("is not a github.com URL"), "{err}");
}
const STATUS: &str = "status --porcelain";
#[test]
fn a_dirty_worktree_stops_the_release_and_a_clean_one_does_not() {
let clean = Git::answering([(STATUS, Reply::said(""))]);
assert!(!worktree_is_dirty(&clean).expect("a clean worktree"));
assert_eq!(clean.asked().len(), 1, "{:?}", clean.asked());
let dirty = Git::answering([(STATUS, Reply::said(" M crates/oakum/src/lib.rs"))]);
assert!(worktree_is_dirty(&dirty).expect("a dirty worktree"));
}
#[test]
fn a_skip_ci_commit_in_the_push_set_stops_the_release() {
let cafe = Git::answering([("rev-parse HEAD", Reply::said("cafe"))])
.head()
.expect("minted");
let planned = |commit: &Commit| PlannedTag {
package: String::from("demo"),
version: Version::new(0, 1, 1),
changelog: String::from("CHANGELOG.md"),
name: String::from("v0.1.1"),
commit: commit.clone(),
resumed: false,
};
let marked = Git::answering([("log -1", Reply::said("fix: typo [skip ci]\u{0}\n"))]);
let err = refuse_skip_ci(&marked, &[planned(&cafe)]).expect_err("a skip-ci commit stops");
assert!(err.to_string().contains("skip-ci"), "{err}");
assert!(err.to_string().contains("v0.1.1"), "{err}");
let plain = Git::answering([("log -1", Reply::said("fix: typo\u{0}\n"))]);
refuse_skip_ci(&plain, &[planned(&cafe)]).expect("an unmarked commit releases");
assert_eq!(plain.asked().len(), 1, "{:?}", plain.asked());
let shared = Git::answering([("log -1", Reply::said("fix: typo\u{0}\n"))]);
refuse_skip_ci(&shared, &[planned(&cafe), planned(&cafe)]).expect("shared commit");
assert_eq!(shared.asked().len(), 1, "{:?}", shared.asked());
let trailer = Git::answering([("log -1", Reply::said("chore: release\u{0}true\n"))]);
let err =
refuse_skip_ci(&trailer, &[planned(&cafe)]).expect_err("a skip-checks trailer stops");
assert!(err.to_string().contains("skip-ci"), "{err}");
}
#[test]
fn skip_ci_matches_github_annotations_and_trailers() {
assert!(skip_ci("fix: typo [skip ci]", ""));
assert!(skip_ci("[CI SKIP] docs", ""));
assert!(skip_ci("chore: [no ci]", ""));
assert!(skip_ci("[skip actions]\nmore", ""));
assert!(skip_ci("[actions skip]", ""));
assert!(!skip_ci("fix: do not skip", ""));
assert!(!skip_ci("skip ci without brackets", ""));
assert!(!skip_ci("docs: explain the skip-checks:true trailer", ""));
assert!(skip_ci("fix: typo", "true"));
assert!(skip_ci("fix: typo", "True"));
assert!(skip_ci("fix: typo", " true "));
assert!(skip_ci("fix: typo", "false\ntrue"));
assert!(!skip_ci("fix: typo", "false"));
assert!(!skip_ci("fix: typo", "truely"));
assert!(!skip_ci("fix: typo", ""));
}
#[test]
fn valid_tag_name_rejects_git_ref_hazards() {
let git = Git::at(".");
assert!(valid_tag_name(&git, "v0.1.1").is_ok());
assert!(valid_tag_name(&git, "pkg/v0.1.1").is_ok());
assert!(valid_tag_name(&git, "foo..bar").is_err());
assert!(valid_tag_name(&git, "foo.lock").is_err());
assert!(valid_tag_name(&git, "foo@{bar}").is_err());
assert!(valid_tag_name(&git, "-v0.1.1").is_err());
assert!(valid_tag_name(&git, "--delete").is_err());
}
#[test]
fn body_source_renders_each_fallback_once() {
let tag = planned_tag("v0.1.1");
assert_eq!(
BodySource::Section(String::from("- a fix")).resolve(&tag),
(String::from("- a fix\n"), None)
);
for (source, expected) in [
(
BodySource::NoChangelog,
"release body: no CHANGELOG.md at cafe; using the title",
),
(
BodySource::Symlink {
target: String::from("real.md"),
},
"release body: CHANGELOG.md at cafe is a symlink to `real.md`; using the title",
),
(
BodySource::EmptySection,
"release body: CHANGELOG.md has an empty 0.1.1 section; using the title",
),
(
BodySource::NoHeading,
"release body: CHANGELOG.md has no `## 0.1.1` heading; using the title (run `oakum version` before releasing, or add the section)",
),
] {
let (body, notice) = source.resolve(&tag);
assert_eq!(body, "demo 0.1.1\n");
assert_eq!(notice.as_deref(), Some(expected));
}
}
}